@bonsae/nrg 0.1.0

package/build/server/index.cjs

@@ -0,0 +1,910 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/server/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfigNode: () => ConfigNode,
+  IONode: () => IONode,
+  Node: () => Node,
+  SchemaType: () => SchemaType,
+  defineSchema: () => defineSchema,
+  registerType: () => registerType,
+  registerTypes: () => registerTypes
+});
+module.exports = __toCommonJS(index_exports);
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+
+// 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, validator3]) => {
+      if (validator3 instanceof RegExp) {
+        this.ajv.addFormat(name, validator3);
+      } else {
+        this.ajv.addFormat(name, { validate: validator3 });
+      }
+    });
+  }
+  /**
+   * 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 validator3 = this.ajv.compile(schema);
+    return validator3;
+  }
+  /**
+   * Validate data against a schema and return a structured result
+   */
+  validate(data, schema, options) {
+    const validator3 = this.createValidator(schema, options?.cacheKey);
+    const valid = validator3(data);
+    if (!valid) {
+      const errorMessage = this.formatErrors(validator3.errors);
+      if (options?.throwOnError) {
+        throw new ValidationError(errorMessage, validator3.errors || []);
+      }
+      return {
+        valid: false,
+        errors: validator3.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);
+  }
+};
+var validator = new Validator();
+
+// src/core/server/validator.ts
+var NodeRedValidator = class extends Validator {
+  constructor(RED) {
+    super({
+      customKeywords: [
+        { keyword: "skip-validation", schemaType: "boolean", valid: true },
+        {
+          keyword: "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)
+      }
+    });
+  }
+};
+var validator2 = void 0;
+function initValidator(RED) {
+  validator2 = new NodeRedValidator(RED);
+}
+
+// src/core/server/nodes/utils.ts
+function setupContext(context, store) {
+  return {
+    get: (key) => new Promise(
+      (resolve, reject) => context.get(
+        key,
+        store,
+        (error, value) => error ? reject(error) : resolve(value)
+      )
+    ),
+    set: (key, value) => new Promise(
+      (resolve, reject) => context.set(
+        key,
+        value,
+        store,
+        (error) => error ? reject(error) : resolve()
+      )
+    ),
+    keys: () => new Promise(
+      (resolve, reject) => context.keys(store, (error, k) => error ? reject(error) : resolve(k))
+    )
+  };
+}
+function setupConfigProxy(RED, config) {
+  const SKIP_PROPS = /* @__PURE__ */ new Set(["id", "_id", "_users"]);
+  const createProxy = (obj) => {
+    return new Proxy(obj, {
+      get(target, prop) {
+        if (typeof prop === "symbol") {
+          return target[prop];
+        }
+        if (SKIP_PROPS.has(prop)) {
+          return target[prop];
+        }
+        const value = target[prop];
+        if (typeof value === "string" && value.length > 0) {
+          const node = RED.nodes.getNode(value)?._node;
+          return node || value;
+        }
+        if (Array.isArray(value)) {
+          return value.map((item) => {
+            if (typeof item === "string") {
+              const node = RED.nodes.getNode(item)?._node;
+              return node || item;
+            }
+            if (item && typeof item === "object") {
+              return createProxy(item);
+            }
+            return item;
+          });
+        }
+        if (value && typeof value === "object") {
+          return createProxy(value);
+        }
+        return value;
+      }
+    });
+  };
+  return createProxy(config);
+}
+
+// src/core/server/nodes/node.ts
+var Node = class {
+  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");
+    const prefix = this.type.replace(/-./g, (x) => x[1].toUpperCase());
+    const properties = this.settingsSchema.properties;
+    const settings = {};
+    for (const key of Object.keys(properties)) {
+      const settingKey = prefix + key.charAt(0).toUpperCase() + key.slice(1);
+      const value = RED.settings[settingKey];
+      if (value !== void 0) {
+        settings[key] = value;
+      }
+    }
+    for (const [key, prop] of Object.entries(properties)) {
+      if (settings[key] === void 0) {
+        const defaultValue = prop.default ?? prop._default;
+        if (defaultValue !== void 0) {
+          settings[key] = defaultValue;
+        }
+      }
+    }
+    validator2.validate(settings, this.settingsSchema, {
+      cacheKey: this.settingsSchema.$id || `${this.type}:settings`,
+      throwOnError: true
+    });
+    this._cachedSettings = settings;
+    RED.log.info("Settings are valid");
+  }
+  RED;
+  node;
+  context;
+  config;
+  timers = /* @__PURE__ */ new Set();
+  intervals = /* @__PURE__ */ new Set();
+  constructor(RED, node, config, credentials) {
+    this.RED = RED;
+    this.node = node;
+    const constructor = this.constructor;
+    if (constructor.configSchema) {
+      this.log("Validating configs");
+      const configResult = validator2.validate(
+        config,
+        constructor.configSchema,
+        {
+          cacheKey: constructor.configSchema.$id || `${constructor.type}:configs-schema`,
+          throwOnError: false
+        }
+      );
+      if (!configResult.valid && configResult.errors?.length) {
+        this.warn(
+          `Config validation errors: ${configResult.errors.map((e) => `${e.instancePath} ${e.message}`).join("; ")}`
+        );
+      }
+    }
+    this.config = setupConfigProxy(RED, config);
+    if (constructor.credentialsSchema && credentials) {
+      this.log("Validating credentials");
+      const credResult = validator2.validate(
+        credentials,
+        constructor.credentialsSchema,
+        {
+          cacheKey: constructor.credentialsSchema.$id || `${constructor.type}:credentials-schema`,
+          throwOnError: false
+        }
+      );
+      if (!credResult.valid && credResult.errors?.length) {
+        this.warn(
+          `Credentials validation errors: ${credResult.errors.map((e) => `${e.instancePath} ${e.message}`).join("; ")}`
+        );
+      }
+    }
+  }
+  i18n(key, substitutions) {
+    const nodeType = this.constructor.type;
+    return this.RED._(`${nodeType}.${key}`, substitutions);
+  }
+  setTimeout(fn, ms) {
+    const timer = setTimeout(() => {
+      this.timers.delete(timer);
+      fn();
+    }, ms);
+    this.timers.add(timer);
+    return timer;
+  }
+  setInterval(fn, ms) {
+    const interval = setInterval(fn, ms);
+    this.intervals.add(interval);
+    return interval;
+  }
+  clearTimeout(timer) {
+    clearTimeout(timer);
+    this.timers.delete(timer);
+  }
+  clearInterval(interval) {
+    clearInterval(interval);
+    this.intervals.delete(interval);
+  }
+  // NOTE: typing msg isnt necessary in this case
+  resolveTypedInput(typedInput, msg) {
+    return new Promise((resolve, reject) => {
+      this.RED.util.evaluateNodeProperty(
+        typedInput.value,
+        typedInput.type,
+        this.node,
+        msg,
+        (error, result) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          if (typedInput.type === "node" && result) {
+            resolve(result._node ?? result);
+            return;
+          }
+          resolve(result);
+        }
+      );
+    });
+  }
+  // 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);
+  }
+  log(msg) {
+    this.node.log(msg);
+  }
+  warn(message) {
+    this.node.warn(message);
+  }
+  error(message, msg) {
+    this.node.error(message, msg);
+  }
+  get id() {
+    return this.node.id;
+  }
+  get name() {
+    return this.node.name;
+  }
+  get z() {
+    return this.node.z;
+  }
+  get credentials() {
+    return this.node.credentials;
+  }
+  get settings() {
+    const constructor = this.constructor;
+    return constructor._cachedSettings ?? {};
+  }
+};
+
+// src/core/server/nodes/io-node.ts
+var IONode = class extends Node {
+  static align;
+  static color;
+  static labelStyle;
+  static paletteLabel;
+  static inputs = 0;
+  static outputs = 0;
+  static inputLabels;
+  static outputLabels;
+  static inputSchema;
+  static outputsSchema;
+  static validateInput = false;
+  static validateOutput = false;
+  _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();
+    const fn = (scope, store) => {
+      const target = scope === "global" ? context.global : scope === "flow" ? context.flow : context;
+      return setupContext(target, store);
+    };
+    fn.node = setupContext(context);
+    fn.flow = setupContext(context.flow);
+    fn.global = setupContext(context.global);
+    this.context = fn;
+  }
+  // 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) {
+    const NodeClass = this.constructor;
+    const shouldValidateInput = this.config.validateInput ?? NodeClass.validateInput;
+    if (shouldValidateInput && NodeClass.inputSchema) {
+      this.log("Validating input");
+      validator2.validate(msg, NodeClass.inputSchema, {
+        cacheKey: NodeClass.inputSchema.$id || `${NodeClass.type}:input-schema`,
+        throwOnError: true
+      });
+      this.log("Input is valid");
+    }
+    this._send = send;
+    try {
+      await Promise.resolve(this.input(msg));
+    } finally {
+      this._send = void 0;
+    }
+  }
+  send(msg) {
+    const NodeClass = this.constructor;
+    const shouldValidateOutput = this.config.validateOutput ?? NodeClass.validateOutput;
+    if (shouldValidateOutput && NodeClass.outputsSchema) {
+      this.log("Validating output");
+      const schemas = NodeClass.outputsSchema;
+      if (Array.isArray(schemas)) {
+        const msgs = msg;
+        for (let i = 0; i < schemas.length; i++) {
+          if (msgs[i] == null) continue;
+          validator2.validate(msgs[i], schemas[i], {
+            cacheKey: schemas[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;
+          validator2.validate(msg[i], schemas, {
+            cacheKey: schemas.$id || `${NodeClass.type}:output-schema`,
+            throwOnError: true
+          });
+        }
+      } else {
+        validator2.validate(msg, schemas, {
+          cacheKey: schemas.$id || `${NodeClass.type}:output-schema`,
+          throwOnError: true
+        });
+      }
+      this.log("Output is valid");
+    }
+    if (this._send) {
+      this._send(msg);
+    } else {
+      this.node.send(msg);
+    }
+  }
+  status(status) {
+    this.node.status(status);
+  }
+  updateWires(wires) {
+    this.node.updateWires(wires);
+  }
+  receive(msg) {
+    this.node.receive(msg);
+  }
+  get x() {
+    return this.node.x;
+  }
+  get y() {
+    return this.node.y;
+  }
+  get g() {
+    return this.node.g;
+  }
+  get wires() {
+    return this.node.wires;
+  }
+  get credentials() {
+    return this.node.credentials;
+  }
+};
+
+// src/core/server/nodes/config-node.ts
+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();
+    const fn = (scope, store) => {
+      const target = scope === "global" ? context.global : context;
+      return setupContext(target, store);
+    };
+    fn.node = setupContext(context);
+    fn.global = setupContext(context.global);
+    this.context = fn;
+  }
+  get userIds() {
+    return this.config._users;
+  }
+  get users() {
+    return this.userIds.map((id) => this.RED.nodes.getNode(id)?._node).filter((node) => node != null);
+  }
+  getUser(index) {
+    const id = this.userIds[index];
+    if (!id) return void 0;
+    return this.RED.nodes.getNode(id)?._node;
+  }
+  get credentials() {
+    return this.node.credentials;
+  }
+};
+
+// src/core/constants.ts
+var TYPED_INPUT_TYPES = [
+  "msg",
+  "flow",
+  "global",
+  "str",
+  "num",
+  "bool",
+  "json",
+  "bin",
+  "re",
+  "jsonata",
+  "date",
+  "env",
+  "node",
+  "cred"
+];
+
+// src/core/server/schemas/type.ts
+var import_typebox = require("@sinclair/typebox");
+var import_rules = require("ajv/dist/compile/rules");
+function NodeRef(nodeClass, options) {
+  return {
+    ...SchemaType.String({
+      description: options?.description || `Reference to ${nodeClass.type}`,
+      format: "node-id"
+    }),
+    "node-type": nodeClass.type,
+    ...options,
+    [import_typebox.Kind]: "NodeRef"
+  };
+}
+function TypedInput(options) {
+  return {
+    ...TypedInputSchema,
+    ...options,
+    [import_typebox.Kind]: "TypedInput"
+  };
+}
+var SchemaType = Object.assign({}, import_typebox.Type, {
+  NodeRef,
+  TypedInput
+});
+function markNonValidatable(schema) {
+  const type = schema.type;
+  const hasInvalidType = type !== void 0 && (Array.isArray(type) ? !type.every(import_rules.isJSONType) : !(0, import_rules.isJSONType)(type));
+  if (hasInvalidType) {
+    schema["skip-validation"] = true;
+    if (schema.default !== void 0) {
+      schema._default = schema.default;
+      delete schema.default;
+    }
+    delete schema.type;
+  }
+  if (schema.properties) {
+    for (const prop of Object.values(schema.properties)) {
+      markNonValidatable(prop);
+    }
+  }
+  if (schema.items) {
+    markNonValidatable(schema.items);
+  }
+  if (schema.anyOf) {
+    schema.anyOf.forEach((s) => markNonValidatable(s));
+  }
+  if (schema.allOf) {
+    schema.allOf.forEach((s) => markNonValidatable(s));
+  }
+  if (schema.oneOf) {
+    schema.oneOf.forEach((s) => markNonValidatable(s));
+  }
+  return schema;
+}
+function defineSchema(properties, options) {
+  const schema = SchemaType.Object(properties, options);
+  return markNonValidatable(schema);
+}
+
+// src/core/server/schemas/base.ts
+var NodeConfigSchema = SchemaType.Object({
+  id: SchemaType.String(),
+  type: SchemaType.String(),
+  name: SchemaType.String(),
+  z: SchemaType.Optional(SchemaType.String())
+});
+var ConfigNodeConfigSchema = SchemaType.Object({
+  ...NodeConfigSchema.properties,
+  _users: SchemaType.Array(SchemaType.String())
+});
+var IONodeConfigSchema = SchemaType.Object({
+  ...NodeConfigSchema.properties,
+  wires: SchemaType.Array(
+    SchemaType.Array(SchemaType.String(), { default: [] }),
+    {
+      default: [[]]
+    }
+  ),
+  x: SchemaType.Number(),
+  y: SchemaType.Number(),
+  g: SchemaType.Optional(SchemaType.String())
+});
+var TypedInputSchema = SchemaType.Object(
+  {
+    value: SchemaType.Union(
+      [
+        SchemaType.String(),
+        SchemaType.Number(),
+        SchemaType.Boolean(),
+        SchemaType.Null()
+      ],
+      {
+        description: "The actual value entered or selected.",
+        default: ""
+      }
+    ),
+    type: SchemaType.Union(
+      TYPED_INPUT_TYPES.map((type) => SchemaType.Literal(type)),
+      {
+        description: "The type of the value (string, number, message property, etc.)",
+        default: "str"
+      }
+    )
+  },
+  {
+    description: "Represents a Node-RED TypedInput value and its type.",
+    default: {
+      type: "str",
+      value: ""
+    }
+  }
+);
+
+// src/core/server/index.ts
+var MIME = {
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml"
+};
+var _nrgResourcesRegistered = false;
+function serveNrgResources(RED) {
+  if (_nrgResourcesRegistered) return;
+  _nrgResourcesRegistered = true;
+  const clientDir = import_path.default.resolve(__dirname, "./resources");
+  if (!import_fs.default.existsSync(clientDir)) return;
+  const httpAdmin = RED.httpAdmin;
+  if (!httpAdmin) return;
+  httpAdmin.use(function(req, res, next) {
+    const prefix = "/nrg/assets/";
+    if (!req.path.startsWith(prefix)) return next();
+    const reqPath = req.path.slice(prefix.length).replace(/\.\./g, "");
+    const filePath = import_path.default.resolve(clientDir, reqPath);
+    if (!filePath.startsWith(clientDir)) return next();
+    if (!import_fs.default.existsSync(filePath) || !import_fs.default.statSync(filePath).isFile())
+      return next();
+    const ext = import_path.default.extname(filePath);
+    res.setHeader("Content-Type", MIME[ext] ?? "application/octet-stream");
+    import_fs.default.createReadStream(filePath).pipe(res);
+  });
+}
+async function registerType(RED, NodeClass) {
+  const NC = NodeClass;
+  RED.log.debug(`Registering Type: ${NC.type}`);
+  if (!(NC.prototype instanceof Node)) {
+    throw new Error(`${NC.name} must extend IONode or ConfigNode classes`);
+  }
+  if (!NC.type) {
+    throw new Error("type must be provided when registering the node");
+  }
+  if (NC.color && !/^#[0-9A-Fa-f]{6}$/.test(NC.color)) {
+    throw new Error(
+      `Invalid color for ${NodeClass.type}: ${NC.color} color must be in hex format`
+    );
+  }
+  if (NC.inputs !== void 0 && (!Number.isInteger(NC.inputs) || NC.inputs != 0 && NC.inputs != 1)) {
+    throw new Error(
+      `Invalid number of inputs for ${NodeClass.type}: inputs must be 0 or 1`
+    );
+  }
+  if (NC.outputs !== void 0 && (!Number.isInteger(NC.outputs) || NC.outputs < 0)) {
+    throw new Error(
+      `Invalid number of outputs for ${NodeClass.type}: outputs must be a positive integer`
+    );
+  }
+  RED.nodes.registerType(
+    NC.type,
+    function(config) {
+      RED.nodes.createNode(this, config);
+      const node = new NC(RED, this, config, this.credentials);
+      this._node = node;
+      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));
+            done();
+            this.log("Input processed");
+          } catch (error) {
+            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("Unknown error during input handling"));
+            }
+          }
+        }
+      );
+      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);
+    serveNrgResources(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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigNode,
+  IONode,
+  Node,
+  SchemaType,
+  defineSchema,
+  registerType,
+  registerTypes
+});