@bonsae/nrg 0.25.1 → 0.26.1

package/test/server/integration/index.js

@@ -1,10 +1,1222 @@
 // src/test/server/integration/runtime.ts
 import http from "http";
 import os from "os";
-import fs from "fs";
+import fs2 from "fs";
+import path2 from "path";
+import { createRequire as createRequire2 } from "module";
+
+// src/core/errors.ts
+var NrgError = class _NrgError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NrgError";
+    Object.setPrototypeOf(this, _NrgError.prototype);
+  }
+};
+
+// src/core/server/typed-input.ts
+var TypedInput = class {
+  constructor(RED, node, input) {
+    this.RED = RED;
+    this.node = node;
+    this.input = input;
+  }
+  resolvers = {
+    // evaluateNodeProperty returns the node ID string for "node" type —
+    // resolve it to the actual node instance via RED.nodes.getNode,
+    // then surface the NRG wrapper if available.
+    node: (raw) => {
+      if (typeof raw === "string") {
+        const node = this.RED.nodes.getNode(raw);
+        return node?._node ?? node ?? raw;
+      }
+      return raw?._node ?? raw;
+    }
+  };
+  get type() {
+    return this.input.type;
+  }
+  get value() {
+    return this.input.value;
+  }
+  resolve(msg) {
+    return new Promise((resolve, reject) => {
+      this.RED.util.evaluateNodeProperty(
+        this.input.value,
+        this.input.type,
+        this.node,
+        msg,
+        (err, raw) => {
+          if (err) return reject(err);
+          const post = this.resolvers[this.input.type];
+          resolve(post ? post(raw) : raw);
+        }
+      );
+    });
+  }
+};
+
+// src/core/server/nodes/proxy.ts
+function setupConfigProxy(opts) {
+  const { RED, node, config, schema } = opts;
+  const SKIP_PROPS = /* @__PURE__ */ new Set(["id", "_id", "_users"]);
+  const nodeRefProps = /* @__PURE__ */ new Set();
+  const typedInputProps = /* @__PURE__ */ new Set();
+  if (schema?.properties) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      const s = propSchema;
+      if (s?.["x-nrg-node-type"]) nodeRefProps.add(key);
+      if (s?.["x-nrg-typed-input"]) typedInputProps.add(key);
+    }
+  }
+  const cache = /* @__PURE__ */ new WeakMap();
+  const createProxy = (obj) => {
+    const cached = cache.get(obj);
+    if (cached) return cached;
+    if (Array.isArray(obj)) {
+      const mapped = obj.map(
+        (item) => item && typeof item === "object" ? createProxy(item) : item
+      );
+      cache.set(obj, mapped);
+      return mapped;
+    }
+    const proxy = 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 && nodeRefProps.has(prop)) {
+          return RED.nodes.getNode(value)?._node ?? value;
+        }
+        if (typedInputProps.has(prop) && value && typeof value === "object" && "type" in value && "value" in value) {
+          let ref = cache.get(value);
+          if (!ref) {
+            ref = new TypedInput(RED, node, value);
+            cache.set(value, ref);
+          }
+          return ref;
+        }
+        if (value && typeof value === "object") {
+          return createProxy(value);
+        }
+        return value;
+      },
+      set(_target, prop) {
+        throw new NrgError(
+          `Cannot set property '${String(prop)}' on read-only node config`
+        );
+      }
+    });
+    cache.set(obj, proxy);
+    return proxy;
+  };
+  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.for("nrg.wireHandlers");
+
+// src/core/server/nodes/node.ts
+var cachedSettingsMap = /* @__PURE__ */ new WeakMap();
+var Node = class _Node {
+  static type;
+  static category;
+  static configSchema;
+  static credentialsSchema;
+  static settingsSchema;
+  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;
+        }
+      }
+    }
+    RED.validator.validate(settings, this.settingsSchema, {
+      cacheKey: this.settingsSchema.$id || `${this.type}:settings`,
+      throwOnError: true
+    });
+    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;
+          }
+        );
+        createdPromise.catch(() => {
+        });
+        node[WIRE_HANDLERS](this, createdPromise);
+      },
+      {
+        credentials: NodeClass.credentialsSchema ? getCredentialsFromSchema(NodeClass.credentialsSchema) : {},
+        settings: _Node.#buildSettings(this)
+      }
+    );
+    NodeClass.validateSettings(RED);
+    try {
+      await Promise.resolve(NodeClass.registered?.(RED));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      RED.log.error(
+        `Error during registered hook for ${NodeClass.type}: ${message}`
+      );
+    }
+  }
+  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 = this.RED.validator.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,
+      node,
+      config,
+      schema: constructor.configSchema
+    });
+    if (constructor.credentialsSchema && credentials) {
+      this.log("Validating credentials");
+      const credResult = this.RED.validator.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("; ")}`
+        );
+      }
+    }
+  }
+  [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);
+  }
+  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);
+  }
+  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 cachedSettingsMap.get(constructor) ?? {};
+  }
+};
+
+// src/core/server/nodes/io-node.ts
+import { Kind } from "@sinclair/typebox";
+
+// src/core/server/nodes/context.ts
+var updateLocks = /* @__PURE__ */ new WeakMap();
+function setupContext(context, store) {
+  const get = (key) => new Promise(
+    (resolve, reject) => context.get(
+      key,
+      store,
+      (error, value) => error ? reject(error) : resolve(value)
+    )
+  );
+  const set = (key, value) => new Promise(
+    (resolve, reject) => context.set(
+      key,
+      value,
+      store,
+      (error) => error ? reject(error) : resolve()
+    )
+  );
+  const keys = () => new Promise(
+    (resolve, reject) => context.keys(store, (error, k) => error ? reject(error) : resolve(k))
+  );
+  const nativeUpdate = context.update;
+  const nativeIncrement = context.increment;
+  const update = (key, fn) => {
+    if (nativeUpdate) {
+      return new Promise(
+        (resolve, reject) => nativeUpdate(
+          key,
+          fn,
+          store,
+          (error, value) => error ? reject(error) : resolve(value)
+        )
+      );
+    }
+    let chains = updateLocks.get(context);
+    if (!chains) updateLocks.set(context, chains = /* @__PURE__ */ new Map());
+    const lockKey = JSON.stringify([store ?? null, key]);
+    const task = async () => {
+      const next = await fn(await get(key));
+      await set(key, next);
+      return next;
+    };
+    const run = (chains.get(lockKey) ?? Promise.resolve()).then(task, task);
+    chains.set(
+      lockKey,
+      run.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+    return run;
+  };
+  const increment = (key, by = 1) => {
+    if (nativeIncrement) {
+      return new Promise(
+        (resolve, reject) => nativeIncrement(
+          key,
+          by,
+          store,
+          (error, value) => error ? reject(error) : resolve(value)
+        )
+      );
+    }
+    return update(
+      key,
+      (current) => typeof current === "number" ? current + by : by
+    );
+  };
+  return { get, set, keys, update, increment };
+}
+
+// src/core/server/nodes/io-node.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function isSchemaLike(obj) {
+  return obj != null && typeof obj === "object" && Kind in obj;
+}
+var RETURN_PROPERTY_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var INPUT_KEY = "input";
+var IONode = class _IONode extends Node {
+  static align;
+  static color;
+  static inputSchema;
+  // outputsSchema accepts any schema shape: the raw sent value (per port) is
+  // validated, and results are frequently non-objects.
+  static outputsSchema;
+  static validateInput = false;
+  static validateOutput = false;
+  static get inputs() {
+    return this.inputSchema ? 1 : 0;
+  }
+  static get outputs() {
+    const s = this.outputsSchema;
+    if (!s) return 0;
+    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.`
+        );
+      }
+      if (key === "error" || key === "complete" || key === "status") {
+        throw new NrgError(
+          `outputsSchema record key "${key}" in ${this.type} is reserved for built-in ports. Use a different name (e.g. "failed" instead of "error").`
+        );
+      }
+    }
+    return keys.length;
+  }
+  /**
+   * The names of the base output ports when `outputsSchema` is a record of
+   * named ports (`{ success, failure }`), in declaration order — otherwise
+   * `undefined` (a single schema or a positional array). Resolved here, where
+   * TypeBox's `Kind` symbol is intact, so the editor reads the names directly
+   * instead of guessing them from a serialized (symbol-stripped) schema.
+   */
+  static get outputPortNames() {
+    const s = this.outputsSchema;
+    if (!s || Array.isArray(s) || isSchemaLike(s)) return void 0;
+    return Object.keys(s);
+  }
+  /**
+   * Per-`input()`-invocation context, scoped via AsyncLocalStorage. One store
+   * per class, shared by every instance: each `.run()` isolates one input()
+   * call (and everything it `await`s, including detached `.then`/timer
+   * continuations it schedules) into its own session, so concurrent inputs on a
+   * node never clobber each other's context and a deferred send keeps the
+   * context of the input that scheduled it. Real Node-RED never awaits an async
+   * input handler before delivering the next message, so two inputs can be in
+   * flight at once. `getStore()` is `undefined` only for a send made entirely
+   * outside any `input()` (e.g. a timer set up in `created()`): it carries no
+   * inherited context and delivers via `node.send`. Server-only — this is part
+   * of the node runtime and is never imported in a browser.
+   */
+  static #invocation = new AsyncLocalStorage();
+  context;
+  constructor(RED, node, config, credentials) {
+    super(RED, node, config, credentials);
+    const context = node.context();
+    const resolve = (scope, store) => {
+      const target = scope === "global" ? context.global : scope === "flow" ? context.flow : context;
+      return setupContext(target, store);
+    };
+    this.context = Object.assign(resolve, {
+      node: setupContext(context),
+      flow: setupContext(context.flow),
+      global: setupContext(context.global)
+    });
+    const outputReturnProperties = this.config.outputReturnProperties;
+    if (outputReturnProperties) {
+      for (const [port, key] of Object.entries(outputReturnProperties)) {
+        if (typeof key === "string" && key.trim() && !RETURN_PROPERTY_PATTERN.test(key.trim())) {
+          throw new NrgError(
+            `Invalid return property "${key}" for output port ${port} in ${this.constructor.type} \u2014 it must be a valid JavaScript identifier (letters, digits, _, $; not starting with a digit)`
+          );
+        }
+      }
+    }
+  }
+  [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");
+          const result = await this.#input(msg, send);
+          this.#sendToPort("complete", {
+            ...msg,
+            ...result !== void 0 ? { output: result } : {},
+            complete: {
+              source: this.#nodeSource()
+            },
+            [INPUT_KEY]: msg
+          });
+          done();
+          nodeRedNode.log("Input processed");
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : "Unknown error during input handling";
+          const errorData = error && typeof error === "object" ? { ...error } : {};
+          this.#sendToPort("error", {
+            ...msg,
+            error: {
+              ...errorData,
+              name: error?.name ?? "Error",
+              message: errorMsg,
+              source: this.#nodeSource()
+            },
+            [INPUT_KEY]: msg
+          });
+          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) {
+    return void 0;
+  }
+  async #input(msg, send) {
+    const NodeClass = this.constructor;
+    const shouldValidateInput = this.config.validateInput ?? NodeClass.validateInput;
+    if (shouldValidateInput && NodeClass.inputSchema) {
+      this.log("Validating input");
+      this.RED.validator.validate(msg, NodeClass.inputSchema, {
+        cacheKey: NodeClass.inputSchema.$id || `${NodeClass.type}:input-schema`,
+        throwOnError: true
+      });
+      this.log("Input is valid");
+    }
+    return await _IONode.#invocation.run(
+      { inputMsg: msg, send },
+      () => Promise.resolve(this.input(msg))
+    );
+  }
+  send(msg) {
+    const multi = this.baseOutputs > 1 && Array.isArray(msg);
+    const values = multi ? msg.slice(0, this.baseOutputs) : [msg];
+    const out = values.map((m, port) => {
+      if (m == null) return m;
+      this.#validatePort(m, port);
+      return this.#wrapOutgoing(m, this.#resolveContextMode(port), port);
+    });
+    this.#deliver(out);
+  }
+  #deliver(out) {
+    const send = _IONode.#invocation.getStore()?.send;
+    if (send) {
+      send(out);
+    } else {
+      this.node.send(out);
+    }
+  }
+  /**
+   * Per-port output validation. A port validates when its flow-author flag
+   * (`config.validateOutputs[port]`) — or the node's static `validateOutput`
+   * fallback — is on and a schema exists for that port.
+   */
+  #validatePort(value, port) {
+    const NodeClass = this.constructor;
+    const configured = this.config.validateOutputs?.[port];
+    if (!(configured ?? NodeClass.validateOutput)) return;
+    const schema = this.#outputSchemaForPort(port);
+    if (!schema) return;
+    this.log("Validating output");
+    this.RED.validator.validate(value, schema, {
+      cacheKey: schema.$id || `${NodeClass.type}:output-schema:${port}`,
+      throwOnError: true
+    });
+    this.log("Output is valid");
+  }
+  /** Resolves the output schema for a base-output port: array → `[port]`,
+   * record → the port-th value, single schema → itself. */
+  #outputSchemaForPort(port) {
+    const raw = this.constructor.outputsSchema;
+    if (!raw) return void 0;
+    if (Array.isArray(raw)) return raw[port];
+    if (isSchemaLike(raw)) return raw;
+    return Object.values(raw)[port];
+  }
+  /**
+   * The return key for an output port — `"output"` unless a custom one is set
+   * via `outputReturnProperties[port]` (author default and/or flow-author
+   * override, only possible when the node declares `outputReturnProperties`).
+   * `this.send(x)` always means "x is the value at this port's return key",
+   * never "x is the whole outgoing message".
+   */
+  #returnPropertyKey(port) {
+    const configured = this.config.outputReturnProperties?.[port];
+    if (typeof configured === "string" && configured.trim()) {
+      return configured.trim();
+    }
+    return "output";
+  }
+  /**
+   * Resolves the context mode for a base-output port from the flow author's
+   * per-port config (`config.outputContextModes[port]`, written by the editor
+   * when the node declares `outputContextModes`), falling back to `"carry"`.
+   */
+  #resolveContextMode(port) {
+    return this.config.outputContextModes?.[port] ?? "carry";
+  }
+  /**
+   * Merges a sent value into the incoming message at the returnProperty key so
+   * upstream message properties propagate. A fresh base is built per call so
+   * multi-port sends never share an object.
+   */
+  #wrapOutgoing(value, mode, port) {
+    const key = this.#returnPropertyKey(port);
+    const input = _IONode.#invocation.getStore()?.inputMsg ?? {};
+    if (mode === "reset") {
+      return { [key]: value };
+    }
+    if (mode === "trace") {
+      return { ...input, [key]: value, [INPUT_KEY]: input };
+    }
+    return { ...input, [key]: value };
+  }
+  // --- Built-in port management ---
+  get baseOutputs() {
+    return this.constructor.outputs ?? 0;
+  }
+  get totalOutputs() {
+    let count = this.baseOutputs;
+    if (this.config.errorPort) count++;
+    if (this.config.completePort) count++;
+    if (this.config.statusPort) count++;
+    return count;
+  }
+  /**
+   * Send a message to a specific output port by index or name.
+   * Custom named ports are resolved from `outputsSchema` when it is a record.
+   * Numeric indices refer to the base output ports (0-based).
+   *
+   * Built-in ports (`"error"`, `"complete"`, `"status"`) are managed by the
+   * framework and cannot be sent to directly. Use `this.status()` for status,
+   * throw an error or call `this.error()` for the error port, and the complete
+   * port is sent automatically on successful input processing.
+   */
+  sendToPort(port, msg) {
+    if (port === "error" || port === "complete" || port === "status") {
+      throw new NrgError(
+        `sendToPort("${port}") is not allowed. Built-in ports are managed by the framework.`
+      );
+    }
+    const portIndex = typeof port === "number" ? port : this.#getNamedPortIndex(port);
+    const mode = this.#resolveContextMode(portIndex ?? 0);
+    this.#sendToPort(
+      port,
+      msg == null ? msg : this.#wrapOutgoing(msg, mode, portIndex ?? 0)
+    );
+  }
+  #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 = new Array(this.totalOutputs);
+    out[portIndex] = msg;
+    this.node.send(out);
+  }
+  #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) {
+    if (name === "error") {
+      return this.config.errorPort ? this.baseOutputs : null;
+    }
+    let idx = this.baseOutputs;
+    if (this.config.errorPort) idx++;
+    if (name === "complete") {
+      return this.config.completePort ? idx : null;
+    }
+    if (this.config.completePort) idx++;
+    return this.config.statusPort ? idx : null;
+  }
+  #nodeSource() {
+    return {
+      id: this.id,
+      type: this.constructor.type,
+      name: this.name
+    };
+  }
+  status(status) {
+    this.node.status(status);
+    this.#sendToPort("status", {
+      status,
+      source: this.#nodeSource()
+    });
+  }
+  error(message, msg) {
+    super.error(message, msg);
+    if (msg) {
+      this.#sendToPort("error", {
+        ...msg,
+        error: {
+          message,
+          source: this.#nodeSource()
+        },
+        [INPUT_KEY]: msg
+      });
+    }
+  }
+  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/validator.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import addErrors from "ajv-errors";
+var Validator = class {
+  ajv;
+  constructor(options) {
+    const { customKeywords, customFormats, ...ajvOptions } = options || {};
+    this.ajv = new Ajv({
+      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
+    });
+    addFormats(this.ajv);
+    addErrors(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) {
+  if (RED.validator) return;
+  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
 import path from "path";
+import fs from "fs";
 import { createRequire } from "module";
-import { registerTypes } from "@bonsae/nrg-runtime/server";
+function serveFile(filePath) {
+  return (_req, res, next) => {
+    if (!fs.existsSync(filePath)) return next();
+    res.setHeader("Content-Type", "application/javascript");
+    fs.createReadStream(filePath).pipe(res);
+  };
+}
+function initAssetsRoutes(router) {
+  const resourcesDir = path.resolve(__dirname, "./resources");
+  if (!fs.existsSync(resourcesDir)) return;
+  const _require = createRequire(path.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(path.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
+var _initialized = false;
+function initRoutes(RED) {
+  if (_initialized) return;
+  _initialized = true;
+  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",
+  "flow",
+  "global",
+  "str",
+  "num",
+  "bool",
+  "json",
+  "bin",
+  "re",
+  "jsonata",
+  "date",
+  "env",
+  "node",
+  "cred"
+];
+
+// src/core/server/schemas/type.ts
+import { Type as BaseType, Kind as Kind2 } from "@sinclair/typebox";
+import { isJSONType } from "ajv/dist/compile/rules.js";
+function NodeRef(nodeClass, options) {
+  return {
+    ...BaseType.String({
+      description: options?.description || `Reference to ${nodeClass.type}`,
+      format: "node-id"
+    }),
+    "x-nrg-node-type": nodeClass.type,
+    ...options,
+    [Kind2]: "NodeRef"
+  };
+}
+function TypedInput2(options) {
+  return {
+    ...TypedInputSchema,
+    "x-nrg-typed-input": true,
+    ...options,
+    [Kind2]: "TypedInput"
+  };
+}
+function NrgString(options) {
+  return BaseType.String(options);
+}
+function OutputReturnProperties(options) {
+  return BaseType.Record(
+    BaseType.Number(),
+    BaseType.String({ pattern: "^[A-Za-z_$][A-Za-z0-9_$]*$" }),
+    {
+      description: "Per-port return property, keyed by output port index. A missing entry falls back to `output`.",
+      default: {},
+      ...options
+    }
+  );
+}
+function OutputContextModes(options) {
+  return BaseType.Record(
+    BaseType.Number(),
+    BaseType.Union([
+      BaseType.Literal("carry"),
+      BaseType.Literal("trace"),
+      BaseType.Literal("reset")
+    ]),
+    {
+      description: "Per-port context mode, keyed by output port index. A missing entry falls back to `carry`.",
+      default: {},
+      ...options
+    }
+  );
+}
+var SchemaType = Object.assign({}, BaseType, {
+  String: NrgString,
+  NodeRef,
+  TypedInput: TypedInput2,
+  OutputReturnProperties,
+  OutputContextModes
+});
+
+// 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: ""
+    }
+  }
+);
+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.Union([
+    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())
+    }),
+    SchemaType.String()
+  ]),
+  source: NodeSourceSchema
+});
 
 // src/test/server/integration/recorder.ts
 var Recorder = class {
@@ -79,7 +1291,6 @@ var Recorder = class {
 };
 
 // src/test/server/integration/flow.ts
-import { setupContext } from "@bonsae/nrg-runtime/internal/server";
 var seq = 0;
 function genId(prefix) {
   seq += 1;
@@ -88,7 +1299,7 @@ function genId(prefix) {
 function tick() {
   return new Promise((resolve) => setImmediate(resolve));
 }
-var NodeRef = class {
+var NodeRef2 = class {
   id;
   type;
   isConfig;
@@ -179,7 +1390,7 @@ var Flow = class {
   /** Add any node — regular or config (detected via `category === "config"`). */
   addNode(Cls, config = {}, opts = {}) {
     const isConfig = Cls.category === "config";
-    const ref = new NodeRef(this, Cls.type, isConfig, config, opts);
+    const ref = new NodeRef2(this, Cls.type, isConfig, config, opts);
     this.#nodes.push(ref);
     return ref;
   }
@@ -231,7 +1442,7 @@ var Flow = class {
   #serializeConfig(config) {
     const out = {};
     for (const [key, value] of Object.entries(config)) {
-      out[key] = value instanceof NodeRef ? value.id : value;
+      out[key] = value instanceof NodeRef2 ? value.id : value;
     }
     return out;
   }
@@ -270,7 +1481,7 @@ var Flow = class {
 
 // src/test/server/integration/runtime.ts
 function requireNodeRed() {
-  const req = createRequire(path.join(process.cwd(), "package.json"));
+  const req = createRequire2(path2.join(process.cwd(), "package.json"));
   let entry;
   try {
     entry = req.resolve("node-red");
@@ -288,7 +1499,7 @@ function headlessSettings(userDir, overrides) {
     disableEditor: true,
     httpNodeRoot: false,
     userDir,
-    flowFile: path.join(userDir, "flows.json"),
+    flowFile: path2.join(userDir, "flows.json"),
     credentialSecret: "nrg-integration-test",
     logging: { console: { level: "fatal", metrics: false, audit: false } },
     functionGlobalContext: {},
@@ -297,7 +1508,7 @@ function headlessSettings(userDir, overrides) {
 }
 async function startRuntime(options) {
   const RED = requireNodeRed();
-  const userDir = fs.mkdtempSync(path.join(os.tmpdir(), "nrg-integration-"));
+  const userDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "nrg-integration-"));
   const server = http.createServer();
   await new Promise(
     (resolve) => server.listen(0, "127.0.0.1", () => resolve())
@@ -338,14 +1549,14 @@ var Runtime = class {
     }
     await new Promise((resolve) => this.#server.close(() => resolve()));
     try {
-      fs.rmSync(this.#userDir, { recursive: true, force: true });
+      fs2.rmSync(this.#userDir, { recursive: true, force: true });
     } catch {
     }
   }
 };
 export {
   Flow,
-  NodeRef,
+  NodeRef2 as NodeRef,
   Runtime,
   startRuntime
 };