@bonsae/nrg-runtime 0.31.0 → 0.33.0

package/{server/index.cjs → index.cjs}

@@ -27,18 +27,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/core/server/index.ts
-var index_exports = {};
-__export(index_exports, {
-  CompletePortSchema: () => CompletePortSchema,
+// src/sdk/lib/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
   ConfigNode: () => ConfigNode,
-  ErrorPortSchema: () => ErrorPortSchema,
   IONode: () => IONode,
+  Kind: () => import_typebox3.Kind,
   Node: () => Node,
-  NodeSourceSchema: () => NodeSourceSchema,
   NrgError: () => NrgError,
   SchemaType: () => SchemaType,
-  StatusPortSchema: () => StatusPortSchema,
   defineConfigNode: () => defineConfigNode,
   defineIONode: () => defineIONode,
   defineModule: () => defineModule,
@@ -46,9 +43,14 @@ __export(index_exports, {
   registerType: () => registerType,
   registerTypes: () => registerTypes
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(runtime_exports);
 
-// src/core/shared/errors.ts
+// src/sdk/lib/server/nodes/symbols.ts
+var NRG_WIRE_HANDLERS = Symbol.for("nrg.wireHandlers");
+var NRG_NODE = Symbol.for("nrg.node");
+var NRG_CONFIG_NODE = Symbol.for("nrg.configNode");
+
+// src/sdk/lib/shared/errors.ts
 var NrgError = class _NrgError extends Error {
   constructor(message) {
     super(message);
@@ -57,1426 +59,1525 @@ var NrgError = class _NrgError extends Error {
   }
 };
 
-// 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/sdk/lib/server/module.ts
+function defineModule(definition) {
+  for (const NodeClass of definition.nodes) {
+    if (!NodeClass[NRG_NODE]) {
+      const name = NodeClass?.name || String(NodeClass);
+      throw new NrgError(
+        `defineModule: "${name}" is not an nrg node class \u2014 extend IONode/ConfigNode or use defineIONode/defineConfigNode.`
       );
-    });
+    }
   }
-};
+  return definition;
+}
 
-// 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);
-    }
+// src/sdk/lib/shared/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 {
+  // Coercing instance (coerceTypes + useDefaults): mutates the validated object.
+  // Used for the config plane, where `this.config.<field>` must read as its typed
+  // value (the proxy returns whatever coercion left on the raw config).
+  ajv;
+  // Non-mutating instance (no coercion, no defaults): a pure predicate. Used for
+  // message/form validation so a validated msg/form is never silently rewritten.
+  pureAjv;
+  // `$id` → the schema object (and owner label) that first claimed it, recorded
+  // by reserveSchemaId() at node registration. AJV caches compiled validators by
+  // `$id`, so two *different* schemas sharing one `$id` is a silent bug — this
+  // registry makes the collision fail loudly.
+  registeredSchemaIds = /* @__PURE__ */ new Map();
+  constructor(options) {
+    const { customKeywords, customFormats, ...ajvOptions } = options || {};
+    this.ajv = this.buildAjv(ajvOptions, true, customKeywords, customFormats);
+    this.pureAjv = this.buildAjv(
+      ajvOptions,
+      false,
+      customKeywords,
+      customFormats
+    );
   }
-  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 (nodeRefProps.has(prop)) {
-          if (typeof value !== "string" || value.length === 0) return void 0;
-          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;
+  buildAjv(ajvOptions, mutate, customKeywords, customFormats) {
+    const ajv = new import_ajv.default({
+      allErrors: true,
+      code: {
+        source: false
       },
-      set(_target, prop) {
-        throw new NrgError(
-          `Cannot set property '${String(prop)}' on read-only node config`
-        );
-      }
+      // coerceTypes + useDefaults both WRITE into the validated object; gate them
+      // on `mutate` so the pure instance leaves data untouched.
+      coerceTypes: mutate,
+      removeAdditional: false,
+      strict: false,
+      strictSchema: false,
+      useDefaults: mutate,
+      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
     });
-    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;
-    const isPassword = property.format === "password";
-    if (!isPassword) {
-      console.warn(
-        `[nrg] credential "${key}" has no format:"password" \u2014 it is stored as a visible (cleartext-in-editor) credential. Add { format: "password" } to mask it.`
-      );
-    }
-    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: isPassword ? "password" : "text",
-      value: property.default ?? void 0
-    };
+    (0, import_ajv_formats.default)(ajv);
+    (0, import_ajv_errors.default)(ajv);
+    this.addCustomKeywords(ajv, customKeywords || []);
+    this.addCustomFormats(ajv, customFormats || {});
+    return ajv;
   }
-  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;
-        }
+  /**
+   * Add custom keywords to the given ajv instance
+   */
+  addCustomKeywords(ajv, keywords) {
+    if (!keywords) return;
+    keywords.forEach((keyword) => {
+      ajv.addKeyword(keyword);
+    });
+  }
+  /**
+   * Add custom formats to the given ajv instance
+   */
+  addCustomFormats(ajv, formats) {
+    if (!formats) return;
+    Object.entries(formats).forEach(([name, validator]) => {
+      if (validator instanceof RegExp) {
+        ajv.addFormat(name, validator);
+      } else {
+        ajv.addFormat(name, { validate: validator });
       }
-    }
-    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
-      };
+  /**
+   * Compile (and cache) a validator for a schema, using AJV's own registry as the
+   * cache — keyed by the schema's `$id`. `defineSchema` requires a unique `$id`,
+   * so `getSchema($id)` returns the previously compiled validator and `compile`
+   * registers it on first use. We never write `$id` (no mutation of the caller's
+   * schema). A schema without `$id` (rare — an ad-hoc `SchemaType.Object`) simply
+   * compiles fresh each call.
+   *
+   * @param schema - JSON Schema to validate against
+   * @param mutate - `true` (default) uses the coercing instance; `false` uses the
+   *   non-mutating (pure-predicate) instance. Each AJV keeps its own registry.
+   */
+  createValidator(schema, mutate = true) {
+    const ajv = mutate ? this.ajv : this.pureAjv;
+    if (schema.$id) {
+      const cached = ajv.getSchema(schema.$id);
+      if (cached) return cached;
     }
-    return settings;
+    return ajv.compile(schema);
   }
   /**
-   * Registers this node class with Node-RED. Handles instance creation,
-   * event handler wiring, settings validation, and the user's registered() hook.
+   * Reserve a schema's `$id` at registration so a collision fails loudly.
+   * {@link createValidator} caches compiled validators by `$id`, so if two
+   * *different* schemas share one `$id` the second would silently validate
+   * against the first. Reserving the same schema object again (a re-deploy, or
+   * one schema reused across roles) is idempotent. A schema without `$id` is a
+   * no-op here. Convention: `"<node-type>:<role>"`.
+   *
+   * @param schema - the schema being registered (its `$id` is the key)
+   * @param owner - human-readable origin (e.g. `"my-node.config"`) for the error
+   * @throws NrgError when `$id` is already held by a different schema object.
    */
-  static async register(RED) {
-    const NodeClass = this;
-    if (NodeClass.color && !/^#[0-9A-Fa-f]{6}$/.test(NodeClass.color)) {
+  reserveSchemaId(schema, owner) {
+    const id = schema.$id;
+    if (!id) return;
+    const existing = this.registeredSchemaIds.get(id);
+    if (existing && existing.schema !== schema) {
       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(() => {
-          this.status({ fill: "red", shape: "ring", text: "created() failed" });
-        });
-        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}`
+        `Duplicate schema $id "${id}": declared by both ${existing.owner} and ${owner}. $id is the AJV compile-cache key and must be unique \u2014 a collision makes one schema validate against another. Convention: "<node-type>:<role>".`
       );
     }
+    this.registeredSchemaIds.set(id, { schema, owner });
   }
-  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("; ")}`
-        );
+  /**
+   * Validate data against a schema and return a structured result
+   */
+  validate(data, schema, options) {
+    const validator = this.createValidator(schema, options?.mutate ?? true);
+    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
+      };
     }
-    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"));
-          }
-        }
-      }
-    );
+    return {
+      valid: true,
+      data
+    };
   }
-  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");
+  /**
+   * 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
+    });
   }
-  i18n(key, substitutions) {
-    const nodeType = this.constructor.type;
-    return this.RED._(`${nodeType}.${key}`, substitutions);
+  /**
+   * 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
+    }));
   }
-  setTimeout(fn, ms) {
-    const timer = setTimeout(() => {
-      this.timers.delete(timer);
-      fn();
-    }, ms);
-    this.timers.add(timer);
-    return timer;
+  /**
+   * Add a schema to both validator instances for cross-schema `$ref` reference.
+   */
+  addSchema(schema, key) {
+    this.ajv.addSchema(schema, key);
+    this.pureAjv.addSchema(schema, key);
+    return this;
   }
-  setInterval(fn, ms) {
-    const interval = setInterval(fn, ms);
-    this.intervals.add(interval);
-    return interval;
+  /**
+   * Remove a schema from both validator instances.
+   */
+  removeSchema(key) {
+    this.ajv.removeSchema(key);
+    this.pureAjv.removeSchema(key);
+    return this;
   }
-  clearTimeout(timer) {
-    clearTimeout(timer);
-    this.timers.delete(timer);
+};
+var ValidationError = class _ValidationError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
   }
-  clearInterval(interval) {
-    clearInterval(interval);
-    this.intervals.delete(interval);
+};
+
+// src/sdk/lib/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-_]+$/
+      }
+    })
+  };
+  Object.defineProperty(RED, "_nrg", {
+    value: nrg,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(RED, "validator", {
+    get: () => nrg.validator,
+    enumerable: false,
+    configurable: false
+  });
+}
+
+// src/sdk/lib/server/api/assets.ts
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_module = require("module");
+var CLIENT_ASSET = true ? "nrg.229bba2d.js" : "nrg.js";
+function serveFile(filePath) {
+  return (_req, res, next) => {
+    if (!import_fs.default.existsSync(filePath)) return next();
+    res.setHeader("Content-Type", "application/javascript");
+    import_fs.default.createReadStream(filePath).pipe(res);
+  };
+}
+function initAssetsRoutes(router) {
+  const resourcesDir = import_path.default.resolve(__dirname, "./resources");
+  if (!import_fs.default.existsSync(resourcesDir)) return;
+  const _require = (0, import_module.createRequire)(import_path.default.join(__dirname, "package.json"));
+  const vueFile = process.env.NODE_ENV !== "production" ? _require.resolve("vue/dist/vue.esm-browser.js") : _require.resolve("vue/dist/vue.esm-browser.prod.js");
+  router.get(
+    `/nrg/assets/${CLIENT_ASSET}`,
+    serveFile(import_path.default.join(resourcesDir, CLIENT_ASSET))
+  );
+  router.get("/nrg/assets/vue.esm-browser.prod.js", serveFile(vueFile));
+}
+
+// src/sdk/lib/server/api/routes.ts
+var _initialized = false;
+function initRoutes(RED) {
+  if (_initialized) return;
+  _initialized = true;
+  initAssetsRoutes(RED.httpAdmin);
+}
+
+// src/sdk/lib/shared/schemas/factories.ts
+var import_typebox2 = require("@sinclair/typebox");
+
+// src/sdk/lib/shared/constants.ts
+var TYPED_INPUT_TYPES = [
+  "msg",
+  "flow",
+  "global",
+  "str",
+  "num",
+  "bool",
+  "json",
+  "bin",
+  "re",
+  "jsonata",
+  "date",
+  "env",
+  "node",
+  "cred"
+];
+
+// src/sdk/lib/shared/schemas/base.ts
+var import_typebox = require("@sinclair/typebox");
+var TypedInputSchema = import_typebox.Type.Object(
+  {
+    value: import_typebox.Type.Union(
+      [
+        import_typebox.Type.String(),
+        import_typebox.Type.Number(),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Null()
+      ],
+      {
+        description: "The actual value entered or selected.",
+        default: ""
+      }
+    ),
+    type: import_typebox.Type.Union(
+      TYPED_INPUT_TYPES.map((type) => import_typebox.Type.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: ""
+    }
   }
-  on(event, callback) {
-    this.node.on(event, callback);
+);
+
+// src/sdk/lib/shared/schemas/factories.ts
+var JSON_TYPES = /* @__PURE__ */ new Set([
+  "null",
+  "boolean",
+  "object",
+  "array",
+  "number",
+  "integer",
+  "string"
+]);
+function isJSONType(value) {
+  return typeof value === "string" && JSON_TYPES.has(value);
+}
+function NodeRef(type, options) {
+  return {
+    ...import_typebox2.Type.String({
+      description: options?.description || `Reference to ${type}`
+    }),
+    // `...options` first so user options (description, x-nrg-form, …) apply, but
+    // the framework keys below win — a caller can't clobber `format`/
+    // `x-nrg-node-type`/`Kind` and silently break NodeRef resolution.
+    ...options,
+    format: "node-id",
+    "x-nrg-node-type": type,
+    [import_typebox2.Kind]: "NodeRef"
+  };
+}
+function TypedInput(options) {
+  const opts = options ?? {};
+  const restrictedTypes = opts["x-nrg-form"]?.typedInputTypes;
+  if (restrictedTypes && restrictedTypes.length === 0) {
+    throw new Error(
+      "SchemaType.TypedInput: typedInputTypes must list at least one type."
+    );
   }
-  log(msg) {
-    this.node.log(msg);
+  const explicitType = opts.default?.type;
+  if (restrictedTypes && explicitType !== void 0 && !restrictedTypes.includes(explicitType)) {
+    throw new Error(
+      `SchemaType.TypedInput: default type "${explicitType}" is not one of its typedInputTypes [${restrictedTypes.join(", ")}].`
+    );
   }
-  warn(message) {
-    this.node.warn(message);
+  const defaultType = explicitType ?? (restrictedTypes ? restrictedTypes.includes("str") ? "str" : restrictedTypes[0] : "str");
+  return {
+    ...TypedInputSchema,
+    // `...options` first; the framework keys below win (see NodeRef).
+    ...options,
+    default: {
+      ...TypedInputSchema.default,
+      ...opts.default,
+      type: defaultType
+    },
+    "x-nrg-typed-input": true,
+    [import_typebox2.Kind]: "TypedInput"
+  };
+}
+function NrgString(options) {
+  return import_typebox2.Type.String(options);
+}
+function OutputReturnProperties(options) {
+  return import_typebox2.Type.Record(
+    import_typebox2.Type.Number(),
+    import_typebox2.Type.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 import_typebox2.Type.Record(
+    import_typebox2.Type.Number(),
+    import_typebox2.Type.Union([
+      import_typebox2.Type.Literal("carry"),
+      import_typebox2.Type.Literal("trace"),
+      import_typebox2.Type.Literal("reset")
+    ]),
+    {
+      description: "Per-port context mode, keyed by output port index. A missing entry falls back to `carry`.",
+      default: {},
+      ...options
+    }
+  );
+}
+function NrgUnsafe(options) {
+  return import_typebox2.Type.Unsafe(options);
+}
+var NRG_SCHEMA_TYPES_FACTORIES = {
+  String: NrgString,
+  Unsafe: NrgUnsafe,
+  NodeRef,
+  TypedInput,
+  OutputReturnProperties,
+  OutputContextModes
+};
+var SchemaType = Object.assign(
+  {},
+  import_typebox2.Type,
+  NRG_SCHEMA_TYPES_FACTORIES
+);
+function markNonValidatable(schema) {
+  const type = schema.type;
+  const hasInvalidType = type !== void 0 && (Array.isArray(type) ? !type.every(isJSONType) : !isJSONType(type));
+  if (hasInvalidType) {
+    schema["x-nrg-skip-validation"] = true;
+    if (schema.default !== void 0) {
+      schema._default = schema.default;
+      delete schema.default;
+    }
+    delete schema.type;
   }
-  error(message, msg) {
-    this.node.error(message, msg);
+  if (schema.properties) {
+    for (const prop of Object.values(schema.properties)) {
+      markNonValidatable(prop);
+    }
   }
-  get id() {
-    return this.node.id;
+  if (schema.patternProperties) {
+    for (const prop of Object.values(schema.patternProperties)) {
+      markNonValidatable(prop);
+    }
   }
-  get name() {
-    return this.node.name;
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    markNonValidatable(schema.additionalProperties);
   }
-  get z() {
-    return this.node.z;
+  if (schema.items) {
+    markNonValidatable(schema.items);
   }
-  get credentials() {
-    return this.node.credentials;
+  if (schema.anyOf) {
+    schema.anyOf.forEach((s) => markNonValidatable(s));
   }
-  get settings() {
-    const constructor = this.constructor;
-    return cachedSettingsMap.get(constructor) ?? {};
+  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/nodes/io-node.ts
-var import_typebox = require("@sinclair/typebox");
+// src/sdk/lib/shared/schemas/index.ts
+var import_typebox3 = require("@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 previous = chains.get(lockKey) ?? Promise.resolve();
-    const run = previous.then(task, task);
-    const settled = run.then(
-      () => void 0,
-      () => void 0
-    );
-    chains.set(lockKey, settled);
-    void settled.then(() => {
-      if (chains.get(lockKey) === settled) chains.delete(lockKey);
-    });
-    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
+// src/sdk/lib/server/registration.ts
+async function registerType(RED, NodeClass) {
+  RED.log.debug(`Registering Type: ${NodeClass.type}`);
+  if (!NodeClass[NRG_NODE]) {
+    throw new NrgError(
+      `${NodeClass.name} must extend IONode or ConfigNode classes`
     );
-  };
-  return { get, set, keys, update, increment };
-}
-
-// src/core/server/nodes/io-node.ts
-var import_node_async_hooks = require("node:async_hooks");
-function isSchemaLike(obj) {
-  return obj != null && typeof obj === "object" && import_typebox.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;
-  // A single boolean applies to every output port; a boolean[] sets the
-  // per-port default by base-output index (missing entries default to 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;
+  if (!NodeClass.type) {
+    throw new NrgError("type must be provided when registering the node");
   }
-  /**
-   * 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);
+  await NodeClass.register(RED);
+  RED.log.debug(`Type registered: ${NodeClass.type}`);
+}
+function collectNodeSchemas(NodeClass) {
+  const found = [];
+  const add = (role, schema) => {
+    if (schema && typeof schema === "object") {
+      found.push({ role, schema });
+    }
+  };
+  add("config", NodeClass.configSchema);
+  add("credentials", NodeClass.credentialsSchema);
+  add("settings", NodeClass.settingsSchema);
+  add("input", NodeClass.inputSchema);
+  const outputs = NodeClass.outputsSchema;
+  if (Array.isArray(outputs)) {
+    outputs.forEach((schema, i) => add(`output[${i}]`, schema));
+  } else if (outputs && typeof outputs === "object" && !(import_typebox3.Kind in outputs)) {
+    for (const [port, schema] of Object.entries(outputs)) {
+      add(`output.${port}`, schema);
+    }
+  } else {
+    add("output", outputs);
   }
-  /**
-   * 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 import_node_async_hooks.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)`
+  return found;
+}
+function checkSchemaIds(RED, nodes) {
+  for (const NodeClass of nodes) {
+    for (const { role, schema } of collectNodeSchemas(NodeClass)) {
+      const owner = `${NodeClass.type}.${role}`;
+      const id = schema.$id;
+      if (typeof id !== "string" || id.length === 0) {
+        const props = schema.properties;
+        if (props && Object.keys(props).length > 0) {
+          RED.log.warn(
+            `[nrg] ${owner} schema has properties but no $id \u2014 it recompiles on every validation and cannot be $ref'd. Build it with defineSchema(props, { $id: "${NodeClass.type}:${role}" }).`
           );
         }
+        continue;
       }
+      RED.validator.reserveSchemaId(schema, owner);
     }
   }
-  [WIRE_HANDLERS](nodeRedNode, createdPromise) {
-    super[WIRE_HANDLERS](nodeRedNode, createdPromise);
-    const NC = this.constructor;
-    nodeRedNode.on(
-      "input",
-      async (msg, send, done) => {
-        try {
-          await createdPromise;
-        } catch (initError) {
-          done(
-            initError instanceof Error ? initError : new Error(String(initError))
-          );
-          return;
-        }
-        const store = { inputMsg: msg, send };
-        try {
-          nodeRedNode.log("Calling input");
-          const result = await this.#input(msg, store);
-          if (this.config.completePort) {
-            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";
-          if (this.config.errorPort && !store.errorEmitted) {
-            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));
-          }
+}
+function registerTypes(nodes) {
+  const fn = Object.assign(
+    async function(RED) {
+      initValidator(RED);
+      initRoutes(RED);
+      try {
+        checkSchemaIds(RED, nodes);
+        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;
       }
-    );
-  }
-  input(msg) {
-    return void 0;
+    },
+    { nodes }
+  );
+  return fn;
+}
+
+// src/sdk/lib/server/typed-input.ts
+var TypedInput2 = class {
+  constructor(RED, node, input) {
+    this.RED = RED;
+    this.node = node;
+    this.input = input;
   }
-  async #input(msg, store) {
-    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");
+  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;
     }
-    return await _IONode.#invocation.run(
-      store,
-      () => Promise.resolve(this.input(msg))
-    );
+  };
+  get type() {
+    return this.input.type;
   }
-  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);
+  get value() {
+    return this.input.value;
   }
-  #deliver(out) {
-    const send = _IONode.#invocation.getStore()?.send;
-    if (send) {
-      send(out);
-    } else {
-      this.node.send(out);
-    }
+  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);
+        }
+      );
+    });
   }
-  /**
-   * 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. The static fallback is
-   * a single boolean (all ports) or a boolean[] (per-port, by base index).
-   */
-  #validatePort(value, port) {
-    const NodeClass = this.constructor;
-    const staticFlag = NodeClass.validateOutput;
-    const staticForPort = Array.isArray(staticFlag) ? staticFlag[port] ?? false : staticFlag;
-    const configured = this.config.validateOutputs?.[port];
-    if (!(configured ?? staticForPort)) 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
+};
+
+// src/sdk/lib/server/nodes/proxy.ts
+function setupConfigProxy(opts) {
+  const { RED, node, config, schema } = opts;
+  const SKIP_PROPS = /* @__PURE__ */ new Set(["id", "_id", "_users"]);
+  const proxyCache = /* @__PURE__ */ new WeakMap();
+  const typedInputCache = /* @__PURE__ */ new WeakMap();
+  const createProxy = (obj, subSchema) => {
+    const cached = proxyCache.get(obj);
+    if (cached) return cached;
+    const schemaForProp = (target, prop) => Array.isArray(target) ? subSchema?.items : subSchema?.properties?.[prop];
+    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];
+        const fieldSchema = schemaForProp(target, prop);
+        if (fieldSchema?.["x-nrg-node-type"]) {
+          if (typeof value !== "string" || value.length === 0) return void 0;
+          const resolved = RED.nodes.getNode(value)?._node;
+          const ctor = resolved?.constructor;
+          if (ctor?.[NRG_NODE] && !resolved[NRG_CONFIG_NODE]) {
+            throw new NrgError(
+              `Config field "${String(prop)}" references "${value}", which is not an nrg config node.`
+            );
+          }
+          return resolved ?? value;
+        }
+        if (fieldSchema?.["x-nrg-typed-input"] && value && typeof value === "object" && "type" in value && "value" in value) {
+          let ref = typedInputCache.get(value);
+          if (!ref) {
+            ref = new TypedInput2(RED, node, value);
+            typedInputCache.set(value, ref);
+          }
+          return ref;
+        }
+        if (value && typeof value === "object") {
+          return createProxy(value, fieldSchema);
+        }
+        return value;
+      },
+      set(_target, prop) {
+        throw new NrgError(
+          `Cannot set property '${String(prop)}' on read-only node config`
+        );
+      },
+      deleteProperty(_target, prop) {
+        throw new NrgError(
+          `Cannot delete property '${String(prop)}' on read-only node config`
+        );
+      }
     });
-    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();
+    proxyCache.set(obj, proxy);
+    return proxy;
+  };
+  return createProxy(config, schema);
+}
+
+// src/sdk/lib/shared/schemas/utils.ts
+function getCredentialsFromSchema(schema) {
+  if (!schema?.properties) return void 0;
+  const result = {};
+  for (const [key, value] of Object.entries(schema.properties)) {
+    const property = value;
+    const isPassword = property.format === "password";
+    if (!isPassword) {
+      console.warn(
+        `[nrg] credential "${key}" has no format:"password" \u2014 it is stored as a visible (cleartext-in-editor) credential. Add { format: "password" } to mask it.`
+      );
     }
-    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";
+    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: isPassword ? "password" : "text",
+      value: property.default ?? void 0
+    };
   }
+  return result;
+}
+
+// src/sdk/lib/server/nodes/node.ts
+var cachedSettingsMap = /* @__PURE__ */ new WeakMap();
+var Node = class _Node {
   /**
-   * 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.
+   * Runtime NRG-node brand — inherited by every subclass (IONode/ConfigNode and
+   * factory-built classes) and checked by `defineModule` at runtime. See
+   * symbols.ts for why it's a `Symbol.for()` runtime key, not a compile-time brand.
    */
-  #wrapOutgoing(value, mode, port) {
-    const key = this.#returnPropertyKey(port);
-    const input = _IONode.#invocation.getStore()?.inputMsg ?? {};
-    if (mode === "reset") {
-      return { [key]: value };
+  static [NRG_NODE] = true;
+  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;
+      }
     }
-    if (mode === "trace") {
-      return { ...input, [key]: value, [INPUT_KEY]: input };
+    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;
+        }
+      }
     }
-    return { ...input, [key]: value };
-  }
-  // --- Built-in port management ---
-  get baseOutputs() {
-    return this.constructor.outputs ?? 0;
+    RED.validator.validate(settings, this.settingsSchema, {
+      throwOnError: true
+    });
+    cachedSettingsMap.set(this, settings);
+    RED.log.info("Settings are valid");
   }
-  get totalOutputs() {
-    let count = this.baseOutputs;
-    if (this.config.errorPort) count++;
-    if (this.config.completePort) count++;
-    if (this.config.statusPort) count++;
-    return count;
+  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;
   }
   /**
-   * 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.
+   * Registers this node class with Node-RED. Handles instance creation,
+   * event handler wiring, settings validation, and the user's registered() hook.
    */
-  sendToPort(port, msg) {
-    if (port === "error" || port === "complete" || port === "status") {
+  static async register(RED) {
+    const NodeClass = this;
+    if (NodeClass.color && !/^#[0-9A-Fa-f]{6}$/.test(NodeClass.color)) {
       throw new NrgError(
-        `sendToPort("${port}") is not allowed. Built-in ports are managed by the framework.`
+        `Invalid color "${NodeClass.color}" for ${NodeClass.type}: must be a 6-digit hex color like "#a6bbcf" (shorthand "#abc" is not accepted).`
       );
     }
-    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)
+    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(() => {
+          this.status({ fill: "red", shape: "ring", text: "created() failed" });
+        });
+        node[NRG_WIRE_HANDLERS](this, createdPromise);
+      },
+      {
+        credentials: NodeClass.credentialsSchema ? getCredentialsFromSchema(NodeClass.credentialsSchema) : {},
+        settings: _Node.#buildSettings(this)
+      }
     );
-  }
-  #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;
+    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}`
+      );
     }
-    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;
+  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,
+        {
+          // Coercing (default): the proxy at (this).config wraps this same object,
+          // so `this.config.<field>` must read as its coerced/typed value.
+          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,
+        {
+          throwOnError: false
+        }
+      );
+      if (!credResult.valid && credResult.errors?.length) {
+        this.warn(
+          `Credentials validation errors: ${credResult.errors.map((e) => `${e.instancePath} ${e.message}`).join("; ")}`
+        );
+      }
     }
-    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()
-    });
+  [NRG_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"));
+          }
+        }
+      }
+    );
   }
-  error(message, msg) {
-    super.error(message, msg);
-    if (msg && this.config.errorPort) {
-      this.#sendToPort("error", {
-        ...msg,
-        error: {
-          // `name` keeps the error-port payload Catch-node compatible and
-          // consistent with the auto-emit from a thrown error.
-          name: "Error",
-          message,
-          source: this.#nodeSource()
-        },
-        [INPUT_KEY]: msg
-      });
-      const store = _IONode.#invocation.getStore();
-      if (store) store.errorEmitted = true;
+  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");
     }
   }
-  updateWires(wires) {
-    this.node.updateWires(wires);
+  i18n(key, substitutions) {
+    const nodeType = this.constructor.type;
+    return this.RED._(`${nodeType}.${key}`, substitutions);
   }
-  receive(msg) {
-    this.node.receive(msg);
+  setTimeout(fn, ms) {
+    const timer = setTimeout(() => {
+      this.timers.delete(timer);
+      fn();
+    }, ms);
+    this.timers.add(timer);
+    return timer;
   }
-  get x() {
-    return this.node.x;
+  setInterval(fn, ms) {
+    const interval = setInterval(fn, ms);
+    this.intervals.add(interval);
+    return interval;
   }
-  get y() {
-    return this.node.y;
+  clearTimeout(timer) {
+    clearTimeout(timer);
+    this.timers.delete(timer);
   }
-  get g() {
-    return this.node.g;
+  clearInterval(interval) {
+    clearInterval(interval);
+    this.intervals.delete(interval);
   }
-  get wires() {
-    return this.node.wires;
+  on(event, callback) {
+    this.node.on(event, callback);
   }
-  get credentials() {
-    return this.node.credentials;
+  log(msg) {
+    this.node.log(msg);
   }
-};
-
-// src/core/server/nodes/config-node.ts
-var ConfigNode = class extends Node {
-  static category = "config";
-  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 : context;
-      return setupContext(target, store);
-    };
-    this.context = Object.assign(resolve, {
-      node: setupContext(context),
-      global: setupContext(context.global)
-    });
+  warn(message) {
+    this.node.warn(message);
   }
-  get userIds() {
-    return this.config._users;
+  error(message, msg) {
+    this.node.error(message, msg);
   }
-  get users() {
-    return this.userIds.map((id) => this.RED.nodes.getNode(id)?._node).filter((node) => node != null);
+  get id() {
+    return this.node.id;
   }
-  getUser(index) {
-    const id = this.userIds[index];
-    if (!id) return void 0;
-    return this.RED.nodes.getNode(id)?._node;
+  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/factories.ts
-function defineIONode(def) {
-  const NodeClass = class extends IONode {
-    static type = def.type;
-    static category = def.category ?? "function";
-    static color = def.color ?? "#a6bbcf";
-    static align = def.align;
-    static configSchema = def.configSchema;
-    static credentialsSchema = def.credentialsSchema;
-    static settingsSchema = def.settingsSchema;
-    static inputSchema = def.inputSchema;
-    static outputsSchema = def.outputsSchema;
-    static validateInput = def.validateInput ?? false;
-    static validateOutput = def.validateOutput ?? false;
-    static registered(RED) {
-      return def.registered?.(RED);
-    }
-    async input(msg) {
-      if (def.input) return def.input.call(this, msg);
-    }
-    async created() {
-      if (def.created) return def.created.call(this);
-    }
-    async closed(removed) {
-      if (def.closed) return def.closed.call(this, removed);
+// src/sdk/lib/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 previous = chains.get(lockKey) ?? Promise.resolve();
+    const run = previous.then(task, task);
+    const settled = run.then(
+      () => void 0,
+      () => void 0
+    );
+    chains.set(lockKey, settled);
+    void settled.then(() => {
+      if (chains.get(lockKey) === settled) chains.delete(lockKey);
+    });
+    return run;
   };
-  Object.defineProperty(NodeClass, "name", {
-    value: def.type.replace(
-      /(^|-)(\w)/g,
-      (_, __, c) => c.toUpperCase()
-    ),
-    configurable: true
-  });
-  return NodeClass;
-}
-function defineConfigNode(def) {
-  const NodeClass = class extends ConfigNode {
-    static type = def.type;
-    static configSchema = def.configSchema;
-    static credentialsSchema = def.credentialsSchema;
-    static settingsSchema = def.settingsSchema;
-    static registered(RED) {
-      return def.registered?.(RED);
-    }
-    async created() {
-      if (def.created) return def.created.call(this);
-    }
-    async closed(removed) {
-      if (def.closed) return def.closed.call(this, removed);
+  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
+    );
   };
-  Object.defineProperty(NodeClass, "name", {
-    value: def.type.replace(
-      /(^|-)(\w)/g,
-      (_, __, c) => c.toUpperCase()
-    ),
-    configurable: true
-  });
-  return NodeClass;
+  return { get, set, keys, update, increment };
+}
+
+// src/sdk/lib/server/nodes/io-node.ts
+var import_node_async_hooks = require("node:async_hooks");
+function isSchemaLike(obj) {
+  return obj != null && typeof obj === "object" && import_typebox3.Kind in obj;
 }
-
-// src/core/shared/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 || {});
+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;
+  // A single boolean applies to every output port; a boolean[] sets the
+  // per-port default by base-output index (missing entries default to false).
+  static validateOutput = false;
+  static get inputs() {
+    return this.inputSchema ? 1 : 0;
   }
-  /**
-   * Add custom keywords to the validator
-   */
-  addCustomKeywords(keywords) {
-    if (!keywords) return;
-    keywords.forEach((keyword) => {
-      this.ajv.addKeyword(keyword);
-    });
+  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;
   }
   /**
-   * Add custom formats to the validator
+   * 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.
    */
-  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 });
-      }
-    });
+  static get outputPortNames() {
+    const s = this.outputsSchema;
+    if (!s || Array.isArray(s) || isSchemaLike(s)) return void 0;
+    return Object.keys(s);
   }
   /**
-   * Create a validator function with caching
-   * @param schema - JSON Schema to validate against
-   * @param cacheKey - Optional cache key for reusing validators
+   * 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.
    */
-  createValidator(schema, cacheKey) {
-    if (cacheKey && !schema.$id) {
-      schema.$id = cacheKey;
-    }
-    if (schema.$id) {
-      const cached = this.ajv.getSchema(schema.$id);
-      if (cached) return cached;
+  static #invocation = new import_node_async_hooks.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)`
+          );
+        }
+      }
     }
-    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 || []);
+  [NRG_WIRE_HANDLERS](nodeRedNode, createdPromise) {
+    super[NRG_WIRE_HANDLERS](nodeRedNode, createdPromise);
+    const NC = this.constructor;
+    nodeRedNode.on(
+      "input",
+      async (msg, send, done) => {
+        try {
+          await createdPromise;
+        } catch (initError) {
+          done(
+            initError instanceof Error ? initError : new Error(String(initError))
+          );
+          return;
+        }
+        const store = { inputMsg: msg, send };
+        try {
+          nodeRedNode.log("Calling input");
+          const result = await this.#input(msg, store);
+          if (this.config.completePort) {
+            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";
+          if (this.config.errorPort && !store.errorEmitted) {
+            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));
+          }
+        }
       }
-      return {
-        valid: false,
-        errors: validator.errors || void 0,
-        errorMessage
-      };
+    );
+  }
+  input(msg) {
+    return void 0;
+  }
+  async #input(msg, store) {
+    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, {
+        // Pure predicate: never coerce or inject defaults into the live msg that
+        // continues downstream.
+        mutate: false,
+        throwOnError: true
+      });
+      this.log("Input is valid");
+    }
+    return await _IONode.#invocation.run(
+      store,
+      () => 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);
     }
-    return {
-      valid: true,
-      data
-    };
   }
   /**
-   * Format errors into a human-readable string
+   * 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. The static fallback is
+   * a single boolean (all ports) or a boolean[] (per-port, by base index).
    */
-  formatErrors(errors, options) {
-    if (!errors || errors.length === 0) {
-      return "No errors";
-    }
-    return this.ajv.errorsText(errors, {
-      separator: "; ",
-      dataVar: "data",
-      ...options
+  #validatePort(value, port) {
+    const NodeClass = this.constructor;
+    const staticFlag = NodeClass.validateOutput;
+    const staticForPort = Array.isArray(staticFlag) ? staticFlag[port] ?? false : staticFlag;
+    const configured = this.config.validateOutputs?.[port];
+    if (!(configured ?? staticForPort)) return;
+    const schema = this.#outputSchemaForPort(port);
+    if (!schema) return;
+    this.log("Validating output");
+    this.RED.validator.validate(value, schema, {
+      // Pure predicate: don't coerce or default the outgoing value.
+      mutate: false,
+      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];
   }
   /**
-   * Get detailed error information
+   * 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".
    */
-  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
-    }));
+  #returnPropertyKey(port) {
+    const configured = this.config.outputReturnProperties?.[port];
+    if (typeof configured === "string" && configured.trim()) {
+      return configured.trim();
+    }
+    return "output";
   }
   /**
-   * Add a schema to the validator for reference
+   * 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"`.
    */
-  addSchema(schema, key) {
-    this.ajv.addSchema(schema, key);
-    return this;
+  #resolveContextMode(port) {
+    return this.config.outputContextModes?.[port] ?? "carry";
   }
   /**
-   * Remove a schema from the validator
+   * 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.
    */
-  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-_]+$/
-      }
-    })
-  };
-  Object.defineProperty(RED, "_nrg", {
-    value: nrg,
-    writable: false,
-    enumerable: false,
-    configurable: false
-  });
-  Object.defineProperty(RED, "validator", {
-    get: () => nrg.validator,
-    enumerable: false,
-    configurable: false
-  });
-}
-
-// src/core/server/api/assets.ts
-var import_path = __toESM(require("path"), 1);
-var import_fs = __toESM(require("fs"), 1);
-var import_module = require("module");
-function serveFile(filePath) {
-  return (_req, res, next) => {
-    if (!import_fs.default.existsSync(filePath)) return next();
-    res.setHeader("Content-Type", "application/javascript");
-    import_fs.default.createReadStream(filePath).pipe(res);
-  };
-}
-function initAssetsRoutes(router) {
-  const resourcesDir = import_path.default.resolve(__dirname, "./resources");
-  if (!import_fs.default.existsSync(resourcesDir)) return;
-  const _require = (0, import_module.createRequire)(import_path.default.join(__dirname, "package.json"));
-  const vueFile = process.env.NODE_ENV !== "production" ? _require.resolve("vue/dist/vue.esm-browser.js") : _require.resolve("vue/dist/vue.esm-browser.prod.js");
-  router.get(
-    "/nrg/assets/nrg-client.js",
-    serveFile(import_path.default.join(resourcesDir, "nrg-client.js"))
-  );
-  router.get("/nrg/assets/vue.esm-browser.prod.js", serveFile(vueFile));
-  router.get("/nrg/assets/vue.esm-browser.js", serveFile(vueFile));
-}
-
-// src/core/server/api/routes.ts
-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/shared/schemas/type.ts
-var import_typebox3 = require("@sinclair/typebox");
-
-// src/core/shared/constants.ts
-var TYPED_INPUT_TYPES = [
-  "msg",
-  "flow",
-  "global",
-  "str",
-  "num",
-  "bool",
-  "json",
-  "bin",
-  "re",
-  "jsonata",
-  "date",
-  "env",
-  "node",
-  "cred"
-];
-
-// src/core/shared/schemas/base.ts
-var import_typebox2 = require("@sinclair/typebox");
-var NodeConfigSchema = import_typebox2.Type.Object({
-  id: import_typebox2.Type.String(),
-  type: import_typebox2.Type.String(),
-  name: import_typebox2.Type.String(),
-  z: import_typebox2.Type.Optional(import_typebox2.Type.String())
-});
-var ConfigNodeConfigSchema = import_typebox2.Type.Object({
-  ...NodeConfigSchema.properties,
-  _users: import_typebox2.Type.Array(import_typebox2.Type.String())
-});
-var IONodeConfigSchema = import_typebox2.Type.Object({
-  ...NodeConfigSchema.properties,
-  wires: import_typebox2.Type.Array(import_typebox2.Type.Array(import_typebox2.Type.String(), { default: [] }), {
-    default: [[]]
-  }),
-  x: import_typebox2.Type.Number(),
-  y: import_typebox2.Type.Number(),
-  g: import_typebox2.Type.Optional(import_typebox2.Type.String())
-});
-var TypedInputSchema = import_typebox2.Type.Object(
-  {
-    value: import_typebox2.Type.Union(
-      [
-        import_typebox2.Type.String(),
-        import_typebox2.Type.Number(),
-        import_typebox2.Type.Boolean(),
-        import_typebox2.Type.Null()
-      ],
-      {
-        description: "The actual value entered or selected.",
-        default: ""
-      }
-    ),
-    type: import_typebox2.Type.Union(
-      TYPED_INPUT_TYPES.map((type) => import_typebox2.Type.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: ""
+  #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 };
   }
-);
-var NodeSourceSchema = import_typebox2.Type.Object({
-  id: import_typebox2.Type.String(),
-  type: import_typebox2.Type.String(),
-  name: import_typebox2.Type.String()
-});
-var ErrorPortSchema = import_typebox2.Type.Object({
-  error: import_typebox2.Type.Object({
-    message: import_typebox2.Type.String(),
-    source: NodeSourceSchema
-  })
-});
-var CompletePortSchema = import_typebox2.Type.Object({
-  complete: import_typebox2.Type.Object({
-    source: NodeSourceSchema
-  })
-});
-var StatusPortSchema = import_typebox2.Type.Object({
-  status: import_typebox2.Type.Union([
-    import_typebox2.Type.Object({
-      fill: import_typebox2.Type.Optional(
-        import_typebox2.Type.Union([
-          import_typebox2.Type.Literal("red"),
-          import_typebox2.Type.Literal("green"),
-          import_typebox2.Type.Literal("yellow"),
-          import_typebox2.Type.Literal("blue"),
-          import_typebox2.Type.Literal("grey"),
-          import_typebox2.Type.Literal("gray")
-        ])
-      ),
-      shape: import_typebox2.Type.Optional(
-        import_typebox2.Type.Union([import_typebox2.Type.Literal("ring"), import_typebox2.Type.Literal("dot")])
-      ),
-      text: import_typebox2.Type.Optional(import_typebox2.Type.String())
-    }),
-    import_typebox2.Type.String()
-  ]),
-  source: NodeSourceSchema
-});
-
-// src/core/shared/schemas/type.ts
-var JSON_TYPES = /* @__PURE__ */ new Set([
-  "null",
-  "boolean",
-  "object",
-  "array",
-  "number",
-  "integer",
-  "string"
-]);
-function isJSONType(value) {
-  return typeof value === "string" && JSON_TYPES.has(value);
-}
-function NodeRef(type, options) {
-  return {
-    ...import_typebox3.Type.String({
-      description: options?.description || `Reference to ${type}`
-    }),
-    // `...options` first so user options (description, x-nrg-form, …) apply, but
-    // the framework keys below win — a caller can't clobber `format`/
-    // `x-nrg-node-type`/`Kind` and silently break NodeRef resolution.
-    ...options,
-    format: "node-id",
-    "x-nrg-node-type": type,
-    [import_typebox3.Kind]: "NodeRef"
-  };
-}
-function TypedInput2(options) {
-  const opts = options ?? {};
-  const restrictedTypes = opts["x-nrg-form"]?.typedInputTypes;
-  if (restrictedTypes && restrictedTypes.length === 0) {
-    throw new Error(
-      "SchemaType.TypedInput: typedInputTypes must list at least one type."
-    );
+  // --- Built-in port management ---
+  get baseOutputs() {
+    return this.constructor.outputs ?? 0;
   }
-  const explicitType = opts.default?.type;
-  if (restrictedTypes && explicitType !== void 0 && !restrictedTypes.includes(explicitType)) {
-    throw new Error(
-      `SchemaType.TypedInput: default type "${explicitType}" is not one of its typedInputTypes [${restrictedTypes.join(", ")}].`
+  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);
+    if (typeof port === "string" && portIndex === null) {
+      const keys = this.#namedPortKeys();
+      throw new NrgError(
+        keys && keys.length ? `sendToPort("${port}") \u2014 unknown output port. Valid named ports: ${keys.map((n) => `"${n}"`).join(", ")}.` : `sendToPort("${port}") \u2014 this node has no named output ports. Make outputsSchema a record of named schemas, or send to a numeric port index.`
+      );
+    }
+    const mode = this.#resolveContextMode(portIndex ?? 0);
+    this.#sendToPort(
+      port,
+      msg == null ? msg : this.#wrapOutgoing(msg, mode, portIndex ?? 0)
     );
   }
-  const defaultType = explicitType ?? (restrictedTypes ? restrictedTypes.includes("str") ? "str" : restrictedTypes[0] : "str");
-  return {
-    ...TypedInputSchema,
-    // `...options` first; the framework keys below win (see NodeRef).
-    ...options,
-    default: {
-      ...TypedInputSchema.default,
-      ...opts.default,
-      type: defaultType
-    },
-    "x-nrg-typed-input": true,
-    [import_typebox3.Kind]: "TypedInput"
-  };
-}
-function NrgString(options) {
-  return import_typebox3.Type.String(options);
-}
-function OutputReturnProperties(options) {
-  return import_typebox3.Type.Record(
-    import_typebox3.Type.Number(),
-    import_typebox3.Type.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
+  #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) {
+        throw new NrgError(`Unknown output port "${port}".`);
+      }
     }
-  );
-}
-function OutputContextModes(options) {
-  return import_typebox3.Type.Record(
-    import_typebox3.Type.Number(),
-    import_typebox3.Type.Union([
-      import_typebox3.Type.Literal("carry"),
-      import_typebox3.Type.Literal("trace"),
-      import_typebox3.Type.Literal("reset")
-    ]),
-    {
-      description: "Per-port context mode, keyed by output port index. A missing entry falls back to `carry`.",
-      default: {},
-      ...options
+    const out = new Array(this.totalOutputs);
+    out[portIndex] = msg;
+    this.node.send(out);
+  }
+  /** The declared named output ports (record `outputsSchema`), or null when the
+   * node has none (no schema, a tuple schema, or a single schema). */
+  #namedPortKeys() {
+    const schema = this.constructor.outputsSchema;
+    if (!schema || Array.isArray(schema) || isSchemaLike(schema)) return null;
+    return Object.keys(schema);
+  }
+  #getNamedPortIndex(name) {
+    const keys = this.#namedPortKeys();
+    if (!keys) return null;
+    const idx = keys.indexOf(name);
+    return idx === -1 ? null : idx;
+  }
+  #getBuiltinPortIndex(name) {
+    if (name === "error") {
+      return this.config.errorPort ? this.baseOutputs : null;
     }
-  );
-}
-function NrgUnsafe(options) {
-  return import_typebox3.Type.Unsafe(options);
-}
-var NrgBuilders = {
-  String: NrgString,
-  Unsafe: NrgUnsafe,
-  NodeRef,
-  TypedInput: TypedInput2,
-  OutputReturnProperties,
-  OutputContextModes
-};
-var SchemaType = Object.assign({}, import_typebox3.Type, NrgBuilders);
-function markNonValidatable(schema) {
-  const type = schema.type;
-  const hasInvalidType = type !== void 0 && (Array.isArray(type) ? !type.every(isJSONType) : !isJSONType(type));
-  if (hasInvalidType) {
-    schema["x-nrg-skip-validation"] = true;
-    if (schema.default !== void 0) {
-      schema._default = schema.default;
-      delete schema.default;
+    let idx = this.baseOutputs;
+    if (this.config.errorPort) idx++;
+    if (name === "complete") {
+      return this.config.completePort ? idx : null;
     }
-    delete schema.type;
+    if (this.config.completePort) idx++;
+    return this.config.statusPort ? idx : null;
   }
-  if (schema.properties) {
-    for (const prop of Object.values(schema.properties)) {
-      markNonValidatable(prop);
-    }
+  #nodeSource() {
+    return {
+      id: this.id,
+      type: this.constructor.type,
+      name: this.name
+    };
   }
-  if (schema.patternProperties) {
-    for (const prop of Object.values(schema.patternProperties)) {
-      markNonValidatable(prop);
+  status(status) {
+    this.node.status(status);
+    this.#sendToPort("status", {
+      status,
+      source: this.#nodeSource()
+    });
+  }
+  error(message, msg) {
+    super.error(message, msg);
+    if (msg && this.config.errorPort) {
+      this.#sendToPort("error", {
+        ...msg,
+        error: {
+          // `name` keeps the error-port payload Catch-node compatible and
+          // consistent with the auto-emit from a thrown error.
+          name: "Error",
+          message,
+          source: this.#nodeSource()
+        },
+        [INPUT_KEY]: msg
+      });
+      const store = _IONode.#invocation.getStore();
+      if (store) store.errorEmitted = true;
     }
   }
-  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-    markNonValidatable(schema.additionalProperties);
+  updateWires(wires) {
+    this.node.updateWires(wires);
   }
-  if (schema.items) {
-    markNonValidatable(schema.items);
+  receive(msg) {
+    this.node.receive(msg);
   }
-  if (schema.anyOf) {
-    schema.anyOf.forEach((s) => markNonValidatable(s));
+  get x() {
+    return this.node.x;
   }
-  if (schema.allOf) {
-    schema.allOf.forEach((s) => markNonValidatable(s));
+  get y() {
+    return this.node.y;
   }
-  if (schema.oneOf) {
-    schema.oneOf.forEach((s) => markNonValidatable(s));
+  get g() {
+    return this.node.g;
+  }
+  get wires() {
+    return this.node.wires;
+  }
+  get credentials() {
+    return this.node.credentials;
+  }
+};
+
+// src/sdk/lib/server/nodes/config-node.ts
+var ConfigNode = class extends Node {
+  static category = "config";
+  // Runtime counterpart: a real property so runtime code (the config proxy's
+  // NodeRef resolution) can verify a referenced node is a config node — the only
+  // guard a JS author gets. See NRG_CONFIG_NODE in ./symbols.
+  [NRG_CONFIG_NODE] = true;
+  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 : context;
+      return setupContext(target, store);
+    };
+    this.context = Object.assign(resolve, {
+      node: setupContext(context),
+      global: setupContext(context.global)
+    });
+  }
+  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/sdk/lib/server/nodes/factories.ts
+function normalizeSchemas(schemas, outputsSchema) {
+  for (const schema of schemas) {
+    if (schema) markNonValidatable(schema);
+  }
+  if (!outputsSchema) return;
+  if (Array.isArray(outputsSchema)) {
+    for (const schema of outputsSchema) markNonValidatable(schema);
+  } else if (import_typebox3.Kind in outputsSchema) {
+    markNonValidatable(outputsSchema);
+  } else {
+    for (const schema of Object.values(outputsSchema)) {
+      markNonValidatable(schema);
+    }
   }
-  return schema;
 }
-function defineSchema(properties, options) {
-  const schema = SchemaType.Object(properties, options);
-  return markNonValidatable(schema);
+function defineIONode(def) {
+  const NodeClass = class extends IONode {
+    static type = def.type;
+    static category = def.category ?? "function";
+    static color = def.color ?? "#a6bbcf";
+    static align = def.align;
+    static configSchema = def.configSchema;
+    static credentialsSchema = def.credentialsSchema;
+    static settingsSchema = def.settingsSchema;
+    static inputSchema = def.inputSchema;
+    static outputsSchema = def.outputsSchema;
+    static validateInput = def.validateInput ?? false;
+    static validateOutput = def.validateOutput ?? false;
+    static registered(RED) {
+      return def.registered?.(RED);
+    }
+    async input(msg) {
+      if (def.input) return def.input.call(this, msg);
+    }
+    async created() {
+      if (def.created) return def.created.call(this);
+    }
+    async closed(removed) {
+      if (def.closed) return def.closed.call(this, removed);
+    }
+  };
+  Object.defineProperty(NodeClass, "name", {
+    value: def.type.replace(
+      /(^|-)(\w)/g,
+      (_, __, c) => c.toUpperCase()
+    ),
+    configurable: true
+  });
+  normalizeSchemas(
+    [
+      NodeClass.configSchema,
+      NodeClass.credentialsSchema,
+      NodeClass.settingsSchema,
+      NodeClass.inputSchema
+    ],
+    NodeClass.outputsSchema
+  );
+  return NodeClass;
 }
-
-// src/core/server/index.ts
-function defineModule(definition) {
-  return definition;
+function defineConfigNode(def) {
+  const NodeClass = class extends ConfigNode {
+    static type = def.type;
+    static configSchema = def.configSchema;
+    static credentialsSchema = def.credentialsSchema;
+    static settingsSchema = def.settingsSchema;
+    static registered(RED) {
+      return def.registered?.(RED);
+    }
+    async created() {
+      if (def.created) return def.created.call(this);
+    }
+    async closed(removed) {
+      if (def.closed) return def.closed.call(this, removed);
+    }
+  };
+  Object.defineProperty(NodeClass, "name", {
+    value: def.type.replace(
+      /(^|-)(\w)/g,
+      (_, __, c) => c.toUpperCase()
+    ),
+    configurable: true
+  });
+  normalizeSchemas([
+    NodeClass.configSchema,
+    NodeClass.credentialsSchema,
+    NodeClass.settingsSchema
+  ]);
+  return NodeClass;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CompletePortSchema,
   ConfigNode,
-  ErrorPortSchema,
   IONode,
+  Kind,
   Node,
-  NodeSourceSchema,
   NrgError,
   SchemaType,
-  StatusPortSchema,
   defineConfigNode,
   defineIONode,
   defineModule,