@bonsae/nrg 0.26.1 → 0.26.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.26.1",
+  "version": "0.26.3",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",

package/test/server/integration/config.js

@@ -1,3 +1,9 @@
+import { fileURLToPath as __nrgFileURLToPath } from "url";
+import { dirname as __nrgDirname } from "path";
+var __filename = __nrgFileURLToPath(import.meta.url);
+var __dirname = __nrgDirname(__filename);
+
+
 // src/test/server/integration/config.ts
 import path from "path";
 var defaultConfig = {

package/test/server/integration/index.js

@@ -1,373 +1,89 @@
+import { fileURLToPath as __nrgFileURLToPath } from "url";
+import { dirname as __nrgDirname } from "path";
+var __filename = __nrgFileURLToPath(import.meta.url);
+var __dirname = __nrgDirname(__filename);
+
+
 // src/test/server/integration/runtime.ts
 import http from "http";
 import os from "os";
-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);
-  }
-};
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { registerTypes } from "@bonsae/nrg/server";
 
-// src/core/server/typed-input.ts
-var TypedInput = class {
-  constructor(RED, node, input) {
-    this.RED = RED;
-    this.node = node;
-    this.input = input;
+// src/test/server/integration/recorder.ts
+var Recorder = class {
+  #sent = /* @__PURE__ */ new Map();
+  #received = /* @__PURE__ */ new Map();
+  #waiters = [];
+  recordSent(id, port, msg) {
+    this.#push("sent", id, { port, msg });
   }
-  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;
+  recordReceived(id, msg) {
+    if (!id) return;
+    this.#push("received", id, { port: 0, msg });
   }
-  get value() {
-    return this.input.value;
+  /** Snapshot of all messages on a channel for a node (optionally one port). */
+  snapshot(channel, id, port) {
+    return this.#filter(channel, id, port).map((c) => c.msg);
   }
-  resolve(msg) {
+  /** Resolve the message at `index` on a channel, awaiting it if not yet seen. */
+  next(channel, id, port, index, timeoutMs) {
+    const existing = this.#filter(channel, id, port);
+    if (existing.length > index) return Promise.resolve(existing[index].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);
+      const waiter = {
+        channel,
+        id,
+        port,
+        index,
+        settle: (msg) => {
+          clearTimeout(timer);
+          resolve(msg);
         }
-        return value;
-      },
-      set(_target, prop) {
-        throw new NrgError(
-          `Cannot set property '${String(prop)}' on read-only node config`
+      };
+      const timer = setTimeout(() => {
+        this.#waiters = this.#waiters.filter((w) => w !== waiter);
+        const where = port === void 0 ? "" : ` on port ${port}`;
+        reject(
+          new Error(
+            `Timed out after ${timeoutMs}ms waiting for ${channel} message #${index} from node ${id}${where}`
+          )
         );
-      }
-    });
-    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
+      }, timeoutMs);
+      this.#waiters.push(waiter);
     });
-    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;
+  clear() {
+    this.#sent.clear();
+    this.#received.clear();
+    this.#waiters = [];
   }
-  /**
-   * 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}`
-      );
-    }
+  #map(channel) {
+    return channel === "sent" ? this.#sent : this.#received;
   }
-  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("; ")}`
-        );
-      }
-    }
+  #filter(channel, id, port) {
+    const list = this.#map(channel).get(id) ?? [];
+    return port === void 0 ? list : list.filter((c) => c.port === port);
   }
-  [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"));
-          }
-        }
+  #push(channel, id, captured) {
+    const map = this.#map(channel);
+    const list = map.get(id) ?? [];
+    list.push(captured);
+    map.set(id, list);
+    for (let i = this.#waiters.length - 1; i >= 0; i--) {
+      const w = this.#waiters[i];
+      if (w.channel !== channel || w.id !== id) continue;
+      const filtered = this.#filter(channel, id, w.port);
+      if (filtered.length > w.index) {
+        this.#waiters.splice(i, 1);
+        w.settle(filtered[w.index].msg);
       }
-    );
-  }
-  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) {
@@ -439,857 +155,6 @@ function setupContext(context, store) {
   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";
-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 {
-  #sent = /* @__PURE__ */ new Map();
-  #received = /* @__PURE__ */ new Map();
-  #waiters = [];
-  recordSent(id, port, msg) {
-    this.#push("sent", id, { port, msg });
-  }
-  recordReceived(id, msg) {
-    if (!id) return;
-    this.#push("received", id, { port: 0, msg });
-  }
-  /** Snapshot of all messages on a channel for a node (optionally one port). */
-  snapshot(channel, id, port) {
-    return this.#filter(channel, id, port).map((c) => c.msg);
-  }
-  /** Resolve the message at `index` on a channel, awaiting it if not yet seen. */
-  next(channel, id, port, index, timeoutMs) {
-    const existing = this.#filter(channel, id, port);
-    if (existing.length > index) return Promise.resolve(existing[index].msg);
-    return new Promise((resolve, reject) => {
-      const waiter = {
-        channel,
-        id,
-        port,
-        index,
-        settle: (msg) => {
-          clearTimeout(timer);
-          resolve(msg);
-        }
-      };
-      const timer = setTimeout(() => {
-        this.#waiters = this.#waiters.filter((w) => w !== waiter);
-        const where = port === void 0 ? "" : ` on port ${port}`;
-        reject(
-          new Error(
-            `Timed out after ${timeoutMs}ms waiting for ${channel} message #${index} from node ${id}${where}`
-          )
-        );
-      }, timeoutMs);
-      this.#waiters.push(waiter);
-    });
-  }
-  clear() {
-    this.#sent.clear();
-    this.#received.clear();
-    this.#waiters = [];
-  }
-  #map(channel) {
-    return channel === "sent" ? this.#sent : this.#received;
-  }
-  #filter(channel, id, port) {
-    const list = this.#map(channel).get(id) ?? [];
-    return port === void 0 ? list : list.filter((c) => c.port === port);
-  }
-  #push(channel, id, captured) {
-    const map = this.#map(channel);
-    const list = map.get(id) ?? [];
-    list.push(captured);
-    map.set(id, list);
-    for (let i = this.#waiters.length - 1; i >= 0; i--) {
-      const w = this.#waiters[i];
-      if (w.channel !== channel || w.id !== id) continue;
-      const filtered = this.#filter(channel, id, w.port);
-      if (filtered.length > w.index) {
-        this.#waiters.splice(i, 1);
-        w.settle(filtered[w.index].msg);
-      }
-    }
-  }
-};
-
 // src/test/server/integration/flow.ts
 var seq = 0;
 function genId(prefix) {
@@ -1299,7 +164,7 @@ function genId(prefix) {
 function tick() {
   return new Promise((resolve) => setImmediate(resolve));
 }
-var NodeRef2 = class {
+var NodeRef = class {
   id;
   type;
   isConfig;
@@ -1390,7 +255,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 NodeRef2(this, Cls.type, isConfig, config, opts);
+    const ref = new NodeRef(this, Cls.type, isConfig, config, opts);
     this.#nodes.push(ref);
     return ref;
   }
@@ -1442,7 +307,7 @@ var Flow = class {
   #serializeConfig(config) {
     const out = {};
     for (const [key, value] of Object.entries(config)) {
-      out[key] = value instanceof NodeRef2 ? value.id : value;
+      out[key] = value instanceof NodeRef ? value.id : value;
     }
     return out;
   }
@@ -1481,7 +346,7 @@ var Flow = class {
 
 // src/test/server/integration/runtime.ts
 function requireNodeRed() {
-  const req = createRequire2(path2.join(process.cwd(), "package.json"));
+  const req = createRequire(path.join(process.cwd(), "package.json"));
   let entry;
   try {
     entry = req.resolve("node-red");
@@ -1499,7 +364,7 @@ function headlessSettings(userDir, overrides) {
     disableEditor: true,
     httpNodeRoot: false,
     userDir,
-    flowFile: path2.join(userDir, "flows.json"),
+    flowFile: path.join(userDir, "flows.json"),
     credentialSecret: "nrg-integration-test",
     logging: { console: { level: "fatal", metrics: false, audit: false } },
     functionGlobalContext: {},
@@ -1508,7 +373,7 @@ function headlessSettings(userDir, overrides) {
 }
 async function startRuntime(options) {
   const RED = requireNodeRed();
-  const userDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "nrg-integration-"));
+  const userDir = fs.mkdtempSync(path.join(os.tmpdir(), "nrg-integration-"));
   const server = http.createServer();
   await new Promise(
     (resolve) => server.listen(0, "127.0.0.1", () => resolve())
@@ -1549,14 +414,14 @@ var Runtime = class {
     }
     await new Promise((resolve) => this.#server.close(() => resolve()));
     try {
-      fs2.rmSync(this.#userDir, { recursive: true, force: true });
+      fs.rmSync(this.#userDir, { recursive: true, force: true });
     } catch {
     }
   }
 };
 export {
   Flow,
-  NodeRef2 as NodeRef,
+  NodeRef,
   Runtime,
   startRuntime
 };

package/test/server/unit/config.js

@@ -1,3 +1,9 @@
+import { fileURLToPath as __nrgFileURLToPath } from "url";
+import { dirname as __nrgDirname } from "path";
+var __filename = __nrgFileURLToPath(import.meta.url);
+var __dirname = __nrgDirname(__filename);
+
+
 // src/test/server/unit/config.ts
 import path from "path";
 var defaultConfig = {

package/test/server/unit/index.js

@@ -1,3 +1,9 @@
+import { fileURLToPath as __nrgFileURLToPath } from "url";
+import { dirname as __nrgDirname } from "path";
+var __filename = __nrgFileURLToPath(import.meta.url);
+var __dirname = __nrgDirname(__filename);
+
+
 // src/test/server/unit/index.ts
 import { vi as vi2 } from "vitest";