@bonsae/nrg-runtime 0.33.0 → 0.35.0

package/index.cjs

@@ -36,8 +36,6 @@ __export(runtime_exports, {
   Node: () => Node,
   NrgError: () => NrgError,
   SchemaType: () => SchemaType,
-  defineConfigNode: () => defineConfigNode,
-  defineIONode: () => defineIONode,
   defineModule: () => defineModule,
   defineSchema: () => defineSchema,
   registerType: () => registerType,
@@ -46,9 +44,11 @@ __export(runtime_exports, {
 module.exports = __toCommonJS(runtime_exports);
 
 // src/sdk/lib/server/nodes/symbols.ts
-var NRG_WIRE_HANDLERS = Symbol.for("nrg.wireHandlers");
+var NRG_SETUP_CLOSE_HANDLER = Symbol.for("nrg.setupCloseHandler");
+var NRG_SETUP_INPUT_HANDLER = Symbol.for("nrg.setupInputHandler");
 var NRG_NODE = Symbol.for("nrg.node");
 var NRG_CONFIG_NODE = Symbol.for("nrg.configNode");
+var NRG_PORTS = Symbol.for("nrg.ports");
 
 // src/sdk/lib/shared/errors.ts
 var NrgError = class _NrgError extends Error {
@@ -65,7 +65,7 @@ function defineModule(definition) {
     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.`
+        `defineModule: "${name}" is not an nrg node class \u2014 extend IONode/ConfigNode.`
       );
     }
   }
@@ -84,11 +84,6 @@ var Validator = class {
   // 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);
@@ -129,7 +124,6 @@ var Validator = class {
    * Add custom keywords to the given ajv instance
    */
   addCustomKeywords(ajv, keywords) {
-    if (!keywords) return;
     keywords.forEach((keyword) => {
       ajv.addKeyword(keyword);
     });
@@ -138,7 +132,6 @@ var Validator = class {
    * 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);
@@ -147,13 +140,22 @@ var Validator = class {
       }
     });
   }
+  // Object-keyed compile cache for `$id`-less schemas. AJV caches by `$id`; a
+  // schema without one (an ad-hoc `SchemaType.Object`, or a flow-author override
+  // a node memoizes and revalidates every message) would otherwise recompile —
+  // and accumulate — on every `compile()`. Keyed by the schema OBJECT so a reused
+  // instance compiles once; a WeakMap so the entry is collected with the schema.
+  // One per AJV (coercing vs pure) since each keeps its own compiled forms.
+  pureInlineCache = /* @__PURE__ */ new WeakMap();
+  mutateInlineCache = /* @__PURE__ */ new WeakMap();
   /**
-   * 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.
+   * Compile (and cache) a validator for a schema. Schemas WITH an `$id` use AJV's
+   * own registry (`defineSchema` gives every schema a unique `$id`, so `getSchema`
+   * returns the previously compiled validator). Schemas WITHOUT one — a flow-author
+   * override, or an ad-hoc `SchemaType.Object` — are cached by object reference
+   * here, so a caller that reuses the same schema instance compiles it only once
+   * (no unbounded recompile/leak). We never write `$id` (no mutation of the
+   * caller's schema).
    *
    * @param schema - JSON Schema to validate against
    * @param mutate - `true` (default) uses the coercing instance; `false` uses the
@@ -162,33 +164,16 @@ var Validator = class {
   createValidator(schema, mutate = true) {
     const ajv = mutate ? this.ajv : this.pureAjv;
     if (schema.$id) {
-      const cached = ajv.getSchema(schema.$id);
-      if (cached) return cached;
+      const cached2 = ajv.getSchema(schema.$id);
+      if (cached2) return cached2;
+      return ajv.compile(schema);
     }
-    return ajv.compile(schema);
-  }
-  /**
-   * 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.
-   */
-  reserveSchemaId(schema, owner) {
-    const id = schema.$id;
-    if (!id) return;
-    const existing = this.registeredSchemaIds.get(id);
-    if (existing && existing.schema !== schema) {
-      throw new NrgError(
-        `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 });
+    const cache = mutate ? this.mutateInlineCache : this.pureInlineCache;
+    const cached = cache.get(schema);
+    if (cached) return cached;
+    const compiled = ajv.compile(schema);
+    cache.set(schema, compiled);
+    return compiled;
   }
   /**
    * Validate data against a schema and return a structured result
@@ -304,25 +289,25 @@ function initValidator(RED) {
 }
 
 // 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";
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_module = require("node:module");
+var CLIENT_ASSET = true ? "nrg.718765b9.js" : "nrg.js";
 function serveFile(filePath) {
   return (_req, res, next) => {
-    if (!import_fs.default.existsSync(filePath)) return next();
+    if (!import_node_fs.default.existsSync(filePath)) return next();
     res.setHeader("Content-Type", "application/javascript");
-    import_fs.default.createReadStream(filePath).pipe(res);
+    import_node_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 resourcesDir = import_node_path.default.resolve(__dirname, "./resources");
+  if (!import_node_fs.default.existsSync(resourcesDir)) return;
+  const _require = (0, import_node_module.createRequire)(import_node_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))
+    serveFile(import_node_path.default.join(resourcesDir, CLIENT_ASSET))
   );
   router.get("/nrg/assets/vue.esm-browser.prod.js", serveFile(vueFile));
 }
@@ -335,206 +320,41 @@ function initRoutes(RED) {
   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: ""
+// 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.`
+      );
     }
+    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
+    };
   }
-);
-
-// 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."
-    );
-  }
-  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(", ")}].`
-    );
-  }
-  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);
+  return result;
 }
-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;
-  }
-  if (schema.properties) {
-    for (const prop of Object.values(schema.properties)) {
-      markNonValidatable(prop);
-    }
-  }
-  if (schema.patternProperties) {
-    for (const prop of Object.values(schema.patternProperties)) {
-      markNonValidatable(prop);
-    }
-  }
-  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-    markNonValidatable(schema.additionalProperties);
-  }
-  if (schema.items) {
-    markNonValidatable(schema.items);
-  }
-  if (schema.anyOf) {
-    schema.anyOf.forEach((s) => markNonValidatable(s));
-  }
-  if (schema.allOf) {
-    schema.allOf.forEach((s) => markNonValidatable(s));
-  }
-  if (schema.oneOf) {
-    schema.oneOf.forEach((s) => markNonValidatable(s));
+function getSettingsFromSchema(schema, nodeType) {
+  const settings = {};
+  if (!schema?.properties) return settings;
+  const prefix = nodeType.replace(/-./g, (x) => x[1].toUpperCase());
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    const settingKey = prefix + key.charAt(0).toUpperCase() + key.slice(1);
+    settings[settingKey] = {
+      value: prop.default,
+      exportable: prop.exportable ?? false
+    };
   }
-  return schema;
-}
-function defineSchema(properties, options) {
-  const schema = SchemaType.Object(properties, options);
-  return markNonValidatable(schema);
+  return settings;
 }
 
-// src/sdk/lib/shared/schemas/index.ts
-var import_typebox3 = require("@sinclair/typebox");
-
 // src/sdk/lib/server/registration.ts
 async function registerType(RED, NodeClass) {
   RED.log.debug(`Registering Type: ${NodeClass.type}`);
@@ -546,49 +366,52 @@ async function registerType(RED, NodeClass) {
   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 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);
+  if (NodeClass.color && !/^#[0-9A-Fa-f]{6}$/.test(NodeClass.color)) {
+    throw new NrgError(
+      `Invalid color "${NodeClass.color}" for ${NodeClass.type}: must be a 6-digit hex color like "#a6bbcf" (shorthand "#abc" is not accepted).`
+    );
   }
-  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}" }).`
-          );
+  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;
         }
-        continue;
+      );
+      createdPromise.catch(() => {
+        this.status({ fill: "red", shape: "ring", text: "created() failed" });
+      });
+      node[NRG_SETUP_CLOSE_HANDLER]();
+      if (NRG_SETUP_INPUT_HANDLER in node && typeof node[NRG_SETUP_INPUT_HANDLER] === "function") {
+        node[NRG_SETUP_INPUT_HANDLER](createdPromise);
       }
-      RED.validator.reserveSchemaId(schema, owner);
+    },
+    {
+      credentials: NodeClass.credentialsSchema ? getCredentialsFromSchema(NodeClass.credentialsSchema) : void 0,
+      settings: NodeClass.settingsSchema ? getSettingsFromSchema(NodeClass.settingsSchema, NodeClass.type) : void 0
     }
+  );
+  NodeClass.validateSettings(RED);
+  try {
+    await Promise.resolve(NodeClass.registered?.(RED));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    RED.log.error(
+      `Error during registered hook for ${NodeClass.type}: ${message}`
+    );
   }
+  RED.log.debug(`Type registered: ${NodeClass.type}`);
 }
 function registerTypes(nodes) {
   const fn = Object.assign(
@@ -596,7 +419,6 @@ function registerTypes(nodes) {
       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);
@@ -613,7 +435,7 @@ function registerTypes(nodes) {
 }
 
 // src/sdk/lib/server/typed-input.ts
-var TypedInput2 = class {
+var TypedInput = class {
   constructor(RED, node, input) {
     this.RED = RED;
     this.node = node;
@@ -684,7 +506,7 @@ function setupConfigProxy(opts) {
         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);
+            ref = new TypedInput(RED, node, value);
             typedInputCache.set(value, ref);
           }
           return ref;
@@ -711,31 +533,8 @@ function setupConfigProxy(opts) {
   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.`
-      );
-    }
-    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 {
+var Node = class {
   /**
    * Runtime NRG-node brand — inherited by every subclass (IONode/ConfigNode and
    * factory-built classes) and checked by `defineModule` at runtime. See
@@ -747,6 +546,11 @@ var Node = class _Node {
   static configSchema;
   static credentialsSchema;
   static settingsSchema;
+  // Per-type settings, resolved from `RED.settings` and validated once by
+  // `validateSettings` at registration; the instance `settings` getter returns
+  // it. It's *assigned* (never mutated in place), so every node type gets its
+  // own value with no cross-subclass sharing — a plain static, no cache needed.
+  static resolvedSettings;
   static validateSettings(RED) {
     if (!this.settingsSchema) return;
     RED.log.info("Validating settings");
@@ -761,93 +565,28 @@ var Node = class _Node {
       }
     }
     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;
-        }
+      if (settings[key] === void 0 && prop._default !== void 0) {
+        settings[key] = prop._default;
       }
     }
     RED.validator.validate(settings, this.settingsSchema, {
       throwOnError: true
     });
-    cachedSettingsMap.set(this, settings);
+    this.resolvedSettings = settings;
     RED.log.info("Settings are valid");
   }
-  static #buildSettings(NC) {
-    if (!NC.settingsSchema) return;
-    const settings = {};
-    const prefix = NC.type.replace(/-./g, (x) => x[1].toUpperCase());
-    for (const [key, prop] of Object.entries(NC.settingsSchema.properties)) {
-      const settingKey = prefix + key.charAt(0).toUpperCase() + key.slice(1);
-      settings[settingKey] = {
-        value: prop.default,
-        exportable: prop.exportable ?? false
-      };
-    }
-    return settings;
-  }
-  /**
-   * Registers this node class with Node-RED. Handles instance creation,
-   * event handler wiring, settings validation, and the user's registered() hook.
-   */
-  static async register(RED) {
-    const NodeClass = this;
-    if (NodeClass.color && !/^#[0-9A-Fa-f]{6}$/.test(NodeClass.color)) {
-      throw new NrgError(
-        `Invalid color "${NodeClass.color}" for ${NodeClass.type}: must be a 6-digit hex color like "#a6bbcf" (shorthand "#abc" is not accepted).`
-      );
-    }
-    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)
-      }
-    );
-    NodeClass.validateSettings(RED);
-    try {
-      await Promise.resolve(NodeClass.registered?.(RED));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      RED.log.error(
-        `Error during registered hook for ${NodeClass.type}: ${message}`
-      );
-    }
-  }
   RED;
   node;
   context;
   config;
-  timers = /* @__PURE__ */ new Set();
-  intervals = /* @__PURE__ */ new Set();
+  #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");
+      this.node.log("Validating configs");
       const configResult = this.RED.validator.validate(
         config,
         constructor.configSchema,
@@ -858,7 +597,7 @@ var Node = class _Node {
         }
       );
       if (!configResult.valid && configResult.errors?.length) {
-        this.warn(
+        this.node.warn(
           `Config validation errors: ${configResult.errors.map((e) => `${e.instancePath} ${e.message}`).join("; ")}`
         );
       }
@@ -870,7 +609,7 @@ var Node = class _Node {
       schema: constructor.configSchema
     });
     if (constructor.credentialsSchema && credentials) {
-      this.log("Validating credentials");
+      this.node.log("Validating credentials");
       const credResult = this.RED.validator.validate(
         credentials,
         constructor.credentialsSchema,
@@ -879,27 +618,30 @@ var Node = class _Node {
         }
       );
       if (!credResult.valid && credResult.errors?.length) {
-        this.warn(
+        this.node.warn(
           `Credentials validation errors: ${credResult.errors.map((e) => `${e.instancePath} ${e.message}`).join("; ")}`
         );
       }
     }
   }
-  [NRG_WIRE_HANDLERS](nodeRedNode, createdPromise) {
-    nodeRedNode.on(
+  // Wires the `close` handler, common to every node kind. IONode adds the `input`
+  // handler separately (NRG_SETUP_INPUT_HANDLER), so this setup carries none of the
+  // input-only `createdPromise`.
+  [NRG_SETUP_CLOSE_HANDLER]() {
+    this.node.on(
       "close",
       async (removed, done) => {
         try {
-          this.log("Calling closed");
+          this.node.log("Calling closed");
           await this.#closed(removed);
-          this.log("Node was closed");
+          this.node.log("Node was closed");
           done();
         } catch (error) {
           if (error instanceof Error) {
-            this.error("Error while closing node: " + error.message);
+            this.node.error("Error while closing node: " + error.message);
             done(error);
           } else {
-            this.error("Unknown error occurred while closing node");
+            this.node.error("Unknown error occurred while closing node");
             done(new Error("Unknown error occurred while closing node"));
           }
         }
@@ -910,12 +652,12 @@ var Node = class _Node {
     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");
+      this.node.log("clearing timers and intervals");
+      this.#timers.forEach((t) => clearTimeout(t));
+      this.#intervals.forEach((i) => clearInterval(i));
+      this.#timers.clear();
+      this.#intervals.clear();
+      this.node.log("timers and intervals cleared");
     }
   }
   i18n(key, substitutions) {
@@ -924,24 +666,24 @@ var Node = class _Node {
   }
   setTimeout(fn, ms) {
     const timer = setTimeout(() => {
-      this.timers.delete(timer);
+      this.#timers.delete(timer);
       fn();
     }, ms);
-    this.timers.add(timer);
+    this.#timers.add(timer);
     return timer;
   }
   setInterval(fn, ms) {
     const interval = setInterval(fn, ms);
-    this.intervals.add(interval);
+    this.#intervals.add(interval);
     return interval;
   }
   clearTimeout(timer) {
     clearTimeout(timer);
-    this.timers.delete(timer);
+    this.#timers.delete(timer);
   }
   clearInterval(interval) {
     clearInterval(interval);
-    this.intervals.delete(interval);
+    this.#intervals.delete(interval);
   }
   on(event, callback) {
     this.node.on(event, callback);
@@ -969,7 +711,7 @@ var Node = class _Node {
   }
   get settings() {
     const constructor = this.constructor;
-    return cachedSettingsMap.get(constructor) ?? {};
+    return constructor.resolvedSettings ?? {};
   }
 };
 
@@ -1048,56 +790,32 @@ function setupContext(context, store) {
 
 // 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;
-}
 var RETURN_PROPERTY_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 var INPUT_KEY = "input";
 var IONode = class _IONode extends Node {
   static align;
+  /**
+   * Node palette color. The template-literal type only enforces a leading `#`
+   * (an exact 6-hex-digit template type is infeasible — it explodes to `TS2590`),
+   * so shorthand (`#abc`) and invalid hex type-check but are rejected at runtime.
+   * The real gate is the `/^#[0-9A-Fa-f]{6}$/` check in `Node.register`.
+   */
   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;
+  // Port topology is TS-types-only: the build extracts a node's `Input`/`Output`
+  // generics and stamps them under `NRG_PORTS`. There is no schema fallback.
   static get inputs() {
-    return this.inputSchema ? 1 : 0;
+    return this[NRG_PORTS]?.inputs ?? 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;
+    return this[NRG_PORTS]?.outputs ?? 0;
   }
   /**
-   * 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.
+   * The names of the base output ports for a named-port node (`Port<T>` record
+   * in the `Output` generic), in declaration order — otherwise `undefined` (a
+   * single or positional output). Read straight off the injected topology.
    */
   static get outputPortNames() {
-    const s = this.outputsSchema;
-    if (!s || Array.isArray(s) || isSchemaLike(s)) return void 0;
-    return Object.keys(s);
+    return this[NRG_PORTS]?.outputNames;
   }
   /**
    * Per-`input()`-invocation context, scoped via AsyncLocalStorage. One store
@@ -1113,7 +831,6 @@ var IONode = class _IONode extends Node {
    * 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();
@@ -1137,10 +854,10 @@ var IONode = class _IONode extends Node {
       }
     }
   }
-  [NRG_WIRE_HANDLERS](nodeRedNode, createdPromise) {
-    super[NRG_WIRE_HANDLERS](nodeRedNode, createdPromise);
-    const NC = this.constructor;
-    nodeRedNode.on(
+  // Wires the `input` handler (IONode only). The base Node wires `close`
+  // separately (NRG_SETUP_CLOSE_HANDLER); the registrar invokes both.
+  [NRG_SETUP_INPUT_HANDLER](createdPromise) {
+    this.node.on(
       "input",
       async (msg, send, done) => {
         try {
@@ -1153,7 +870,7 @@ var IONode = class _IONode extends Node {
         }
         const store = { inputMsg: msg, send };
         try {
-          nodeRedNode.log("Calling input");
+          this.node.log("Calling input");
           const result = await this.#input(msg, store);
           if (this.config.completePort) {
             this.#sendToPort("complete", {
@@ -1166,7 +883,7 @@ var IONode = class _IONode extends Node {
             });
           }
           done();
-          nodeRedNode.log("Input processed");
+          this.node.log("Input processed");
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : "Unknown error during input handling";
           if (this.config.errorPort && !store.errorEmitted) {
@@ -1183,13 +900,13 @@ var IONode = class _IONode extends Node {
             });
           }
           if (error instanceof Error) {
-            nodeRedNode.error(
+            this.node.error(
               "Error while processing input: " + error.message,
               msg
             );
             done(error);
           } else {
-            nodeRedNode.error(
+            this.node.error(
               "Unknown error occurred during input handling",
               msg
             );
@@ -1203,17 +920,19 @@ var IONode = class _IONode extends Node {
     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");
+    const shouldValidateInput = this.config.validateInput ?? false;
+    if (shouldValidateInput) {
+      const inputSchema = this.#effectiveInputSchema();
+      if (inputSchema) {
+        this.node.log("Validating input");
+        this.RED.validator.validate(msg, inputSchema, {
+          // Pure predicate: never coerce or inject defaults into the live msg
+          // that continues downstream.
+          mutate: false,
+          throwOnError: true
+        });
+        this.node.log("Input is valid");
+      }
     }
     return await _IONode.#invocation.run(
       store,
@@ -1221,8 +940,8 @@ var IONode = class _IONode extends Node {
     );
   }
   send(msg) {
-    const multi = this.baseOutputs > 1 && Array.isArray(msg);
-    const values = multi ? msg.slice(0, this.baseOutputs) : [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);
@@ -1240,39 +959,67 @@ var IONode = class _IONode extends Node {
   }
   /**
    * 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).
+   * (`config.validateOutputs[port]`, whose default the node author seeds in the
+   * config schema) is on and a schema exists for that port.
    */
   #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 (!this.config.validateOutputs?.[port]) return;
+    const schema = this.#effectiveOutputSchema(port);
     if (!schema) return;
-    this.log("Validating output");
+    this.node.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");
+    this.node.log("Output is valid");
+  }
+  // Per-instance cache of resolved data-validation schemas, keyed by the raw JSON
+  // string (a node's config is immutable for its lifetime). `null` = the string
+  // is unusable (bad JSON, or valid JSON that does not compile) → the boundary is
+  // not validated. Memoizing keeps the SAME parsed object across messages, so
+  // the validator's object-keyed compile cache hits: no per-message JSON.parse,
+  // no per-message recompile/leak, and the warning fires exactly once.
+  #overrideSchemas = /* @__PURE__ */ new Map();
+  /** Resolve a data-validation schema (a JSON-Schema string from config — the
+   * author default, overridable by the flow author in the editor) to a schema
+   * object, memoized per instance. `undefined` → no schema (blank / not a
+   * string), so the boundary is not validated. A string that is invalid JSON, or
+   * valid JSON that does NOT compile (a typo'd keyword), also yields `undefined`
+   * — warned once here rather than throwing on every message inside `validate()`. */
+  #resolveOverride(raw) {
+    if (typeof raw !== "string" || !raw.trim()) return void 0;
+    const cached = this.#overrideSchemas.get(raw);
+    if (cached !== void 0) return cached ?? void 0;
+    let resolved = null;
+    try {
+      const parsed = JSON.parse(raw);
+      this.RED.validator.createValidator(parsed, false);
+      resolved = parsed;
+    } catch (e) {
+      const reason = e instanceof Error ? e.message : "parse/compile error";
+      this.node.warn(
+        `Ignoring an invalid data-validation schema (${reason}); skipping validation.`
+      );
+    }
+    this.#overrideSchemas.set(raw, resolved);
+    return resolved ?? void 0;
+  }
+  /** The schema used for INPUT validation: the `config.inputSchema` field (the
+   * node author's default, overridable by the flow author). Data-validation
+   * schemas are config-driven only — there is no static schema. */
+  #effectiveInputSchema() {
+    return this.#resolveOverride(this.config.inputSchema);
   }
-  /** 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 schema used for OUTPUT validation on a port: the `config.outputSchemas`
+   * field for that port (author default, flow-author-overridable). */
+  #effectiveOutputSchema(port) {
+    return this.#resolveOverride(this.config.outputSchemas?.[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`).
+   * via `outputReturnProperties[port]` (the node author's declared default and/or
+   * the flow author's per-port override, which the editor always allows).
    * `this.send(x)` always means "x is the value at this port's return key",
    * never "x is the whole outgoing message".
    */
@@ -1285,8 +1032,8 @@ var IONode = class _IONode extends Node {
   }
   /**
    * 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"`.
+   * per-port config (`config.outputContextModes[port]`, which the editor lets the
+   * flow author set on any port), falling back to `"carry"`.
    */
   #resolveContextMode(port) {
     return this.config.outputContextModes?.[port] ?? "carry";
@@ -1308,19 +1055,28 @@ var IONode = class _IONode extends Node {
     return { ...input, [key]: value };
   }
   // --- Built-in port management ---
-  get baseOutputs() {
+  // Private, override-proof accessors the framework reads for port routing. A
+  // consumer field named `baseOutputs`/`totalOutputs` shadows the PUBLIC getters
+  // below (self-inflicted), but never these `#` ones the framework relies on.
+  get #baseOutputs() {
     return this.constructor.outputs ?? 0;
   }
-  get totalOutputs() {
-    let count = this.baseOutputs;
+  get #totalOutputs() {
+    let count = this.#baseOutputs;
     if (this.config.errorPort) count++;
     if (this.config.completePort) count++;
     if (this.config.statusPort) count++;
     return count;
   }
+  get baseOutputs() {
+    return this.#baseOutputs;
+  }
+  get totalOutputs() {
+    return this.#totalOutputs;
+  }
   /**
    * Send a message to a specific output port by index or name.
-   * Custom named ports are resolved from `outputsSchema` when it is a record.
+   * Named ports are resolved from the node's named `Port<T>` Output generic.
    * Numeric indices refer to the base output ports (0-based).
    *
    * Built-in ports (`"error"`, `"complete"`, `"status"`) are managed by the
@@ -1338,13 +1094,18 @@ var IONode = class _IONode extends Node {
     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.`
+        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. Declare named ports with a Port<T> record in the node's Output generic, or send to a numeric port index.`
       );
     }
-    const mode = this.#resolveContextMode(portIndex ?? 0);
+    const idx = portIndex ?? 0;
+    if (msg == null) {
+      this.#sendToPort(port, msg);
+      return;
+    }
+    this.#validatePort(msg, idx);
     this.#sendToPort(
       port,
-      msg == null ? msg : this.#wrapOutgoing(msg, mode, portIndex ?? 0)
+      this.#wrapOutgoing(msg, this.#resolveContextMode(idx), idx)
     );
   }
   #sendToPort(port, msg) {
@@ -1360,16 +1121,16 @@ var IONode = class _IONode extends Node {
         throw new NrgError(`Unknown output port "${port}".`);
       }
     }
-    const out = new Array(this.totalOutputs);
+    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). */
+  /** The declared named output ports (from the injected `Output`-generic
+   * topology's `Port<T>` record), or null when the node has none (a
+   * positional/single output, or no declaration). */
   #namedPortKeys() {
-    const schema = this.constructor.outputsSchema;
-    if (!schema || Array.isArray(schema) || isSchemaLike(schema)) return null;
-    return Object.keys(schema);
+    const NC = this.constructor;
+    return NC[NRG_PORTS]?.outputNames ?? null;
   }
   #getNamedPortIndex(name) {
     const keys = this.#namedPortKeys();
@@ -1379,9 +1140,9 @@ var IONode = class _IONode extends Node {
   }
   #getBuiltinPortIndex(name) {
     if (name === "error") {
-      return this.config.errorPort ? this.baseOutputs : null;
+      return this.config.errorPort ? this.#baseOutputs : null;
     }
-    let idx = this.baseOutputs;
+    let idx = this.#baseOutputs;
     if (this.config.errorPort) idx++;
     if (name === "complete") {
       return this.config.completePort ? idx : null;
@@ -1391,9 +1152,9 @@ var IONode = class _IONode extends Node {
   }
   #nodeSource() {
     return {
-      id: this.id,
+      id: this.node.id,
       type: this.constructor.type,
-      name: this.name
+      name: this.node.name
     };
   }
   status(status) {
@@ -1451,7 +1212,6 @@ var ConfigNode = class extends Node {
   // 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();
@@ -1480,96 +1240,224 @@ var ConfigNode = class extends Node {
   }
 };
 
-// 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);
+// 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: ""
     }
   }
+);
+
+// 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 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);
+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 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."
+    );
+  }
+  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(", ")}].`
+    );
+  }
+  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
     }
-    async closed(removed) {
-      if (def.closed) return def.closed.call(this, removed);
+  );
+}
+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
     }
-  };
-  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;
 }
-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);
+function OutputSchemas(options) {
+  return import_typebox2.Type.Record(import_typebox2.Type.Number(), import_typebox2.Type.String(), {
+    description: "Per-port output data-validation schema (JSON Schema string), keyed by output port index.",
+    default: {},
+    ...options
+  });
+}
+function InputSchema(options) {
+  return import_typebox2.Type.String({
+    description: "Input data-validation schema (JSON Schema string).",
+    default: "",
+    ...options
+  });
+}
+function NrgUnsafe(options) {
+  return import_typebox2.Type.Unsafe(options);
+}
+var NRG_SCHEMA_TYPES_FACTORIES = {
+  String: NrgString,
+  Unsafe: NrgUnsafe,
+  NodeRef,
+  TypedInput: TypedInput2,
+  OutputReturnProperties,
+  OutputContextModes,
+  OutputSchemas,
+  InputSchema
+};
+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;
     }
-    async created() {
-      if (def.created) return def.created.call(this);
+    delete schema.type;
+  }
+  if (schema.properties) {
+    for (const prop of Object.values(schema.properties)) {
+      markNonValidatable(prop);
     }
-    async closed(removed) {
-      if (def.closed) return def.closed.call(this, removed);
+  }
+  if (schema.patternProperties) {
+    for (const prop of Object.values(schema.patternProperties)) {
+      markNonValidatable(prop);
     }
-  };
-  Object.defineProperty(NodeClass, "name", {
-    value: def.type.replace(
-      /(^|-)(\w)/g,
-      (_, __, c) => c.toUpperCase()
-    ),
-    configurable: true
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    markNonValidatable(schema.additionalProperties);
+  }
+  if (schema.items) {
+    markNonValidatable(schema.items);
+  }
+  if (schema.anyOf) {
+    schema.anyOf.forEach((s) => markNonValidatable(s));
+  }
+  if (schema.allOf) {
+    schema.allOf.forEach((s) => markNonValidatable(s));
+  }
+  if (schema.oneOf) {
+    schema.oneOf.forEach((s) => markNonValidatable(s));
+  }
+  return schema;
+}
+function defineSchema(properties, options) {
+  const schema = SchemaType.Object(properties, {
+    ...options,
+    $id: options?.$id ?? crypto.randomUUID()
   });
-  normalizeSchemas([
-    NodeClass.configSchema,
-    NodeClass.credentialsSchema,
-    NodeClass.settingsSchema
-  ]);
-  return NodeClass;
+  return markNonValidatable(schema);
 }
+
+// src/sdk/lib/shared/schemas/index.ts
+var import_typebox3 = require("@sinclair/typebox");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConfigNode,
@@ -1578,8 +1466,6 @@ function defineConfigNode(def) {
   Node,
   NrgError,
   SchemaType,
-  defineConfigNode,
-  defineIONode,
   defineModule,
   defineSchema,
   registerType,