@bonsae/nrg 0.14.0 → 0.15.0

package/test/index.js

@@ -182,6 +182,7 @@ function createNodeRedNode(options = {}) {
     flow: flowCtx,
     global: globalCtx
   };
+  const handlers = /* @__PURE__ */ new Map();
   return {
     id: options.id ?? `node-${Math.random().toString(36).slice(2, 10)}`,
     type: options.type ?? "test-node",
@@ -195,7 +196,15 @@ function createNodeRedNode(options = {}) {
     log: vi.fn(),
     warn: vi.fn(),
     error: vi.fn(),
-    on: vi.fn(),
+    on: vi.fn((event, handler) => {
+      if (!handlers.has(event)) handlers.set(event, []);
+      handlers.get(event).push(handler);
+    }),
+    emit: vi.fn(async (event, ...args) => {
+      for (const handler of handlers.get(event) ?? []) {
+        await handler(...args);
+      }
+    }),
     send: vi.fn(),
     status: vi.fn(),
     updateWires: vi.fn(),
@@ -385,6 +394,9 @@ function initValidator(RED) {
   });
 }
 
+// src/core/server/nodes/symbols.ts
+var WIRE_HANDLERS = Symbol("wireHandlers");
+
 // src/test/index.ts
 function buildConfig(NodeClass, userConfig = {}) {
   const defaults = {};
@@ -409,16 +421,23 @@ function attachHelpers(node, nodeRedNode) {
   nodeRedNode.status.mockImplementation((status) => {
     statusCalls.push(status);
   });
-  const nodeRef = node;
   const helpers = {
     async receive(msg) {
       const sendFn = vi2.fn((outMsg) => {
         nodeRedNode.send(outMsg);
       });
-      await nodeRef._input(msg, sendFn);
+      const doneFn = vi2.fn();
+      await nodeRedNode.emit("input", msg, sendFn, doneFn);
+      if (doneFn.mock.calls[0]?.[0] instanceof Error) {
+        throw doneFn.mock.calls[0][0];
+      }
     },
     async close(removed = false) {
-      await nodeRef._closed(removed);
+      const doneFn = vi2.fn();
+      await nodeRedNode.emit("close", removed, doneFn);
+      if (doneFn.mock.calls[0]?.[0] instanceof Error) {
+        throw doneFn.mock.calls[0][0];
+      }
     },
     reset() {
       sentMessages.length = 0;
@@ -500,12 +519,13 @@ async function createNode(NodeClass, options = {}) {
     credentials,
     ...overrideOpts
   });
-  await Promise.resolve(
-    NodeClass._registered?.(RED) ?? NodeClass.registered?.(RED)
-  );
+  NodeClass.validateSettings(RED);
+  await Promise.resolve(NodeClass.registered?.(RED));
   const node = new NodeClass(RED, nodeRedNode, config, credentials);
+  const createdPromise = Promise.resolve(node.created?.());
+  node[WIRE_HANDLERS](nodeRedNode, createdPromise);
+  await createdPromise;
   const augmented = attachHelpers(node, nodeRedNode);
-  await Promise.resolve(augmented.created?.());
   return { node: augmented, RED };
 }
 export {

package/types/server.d.ts

@@ -375,8 +375,18 @@ export interface TNodeRef<T = any> extends TSchema {
 type ResolveNodeRefs<T> = T extends TypedInput<any> ? T : T extends (...args: any[]) => any ? T : T extends Array<infer Item> ? ResolveNodeRefs<Item>[] : T extends object ? {
 	[K in keyof T]: ResolveNodeRefs<T[K]>;
 } : T;
-/** Infers the TypeScript type from a schema, resolving node references to their instance types. */
-export type Infer<T extends TSchema> = ResolveNodeRefs<Static<T>>;
+/**
+ * Infers the TypeScript type from a schema or a record of schemas.
+ *
+ * - Single schema: `Infer<typeof MySchema>` → the inferred message type
+ * - Record of schemas: `Infer<typeof outputsSchema>` → `{ portName: InferredType }` port map
+ *
+ * The record form produces a simple mapped type that resolves eagerly,
+ * giving `sendToPort()` proper autocomplete in class-based nodes.
+ */
+export type Infer<T extends TSchema | Record<string, TSchema>> = T extends TSchema ? ResolveNodeRefs<Static<T>> : {
+	[K in keyof T & string]: T[K] extends TSchema ? ResolveNodeRefs<Static<T[K]>> : never;
+};
 type TypedInputType = (typeof TYPED_INPUT_TYPES)[number];
 /** Schema type representing a Node-RED TypedInput (value + type pair). */
 export interface TTypedInput<T = unknown> extends TSchema {
@@ -390,7 +400,9 @@ export type Schema<T extends TProperties = TProperties> = TObject<T>;
 type InferOr<T, Fallback> = T extends TSchema ? Infer<T> : Fallback;
 type InferOutputs<T> = T extends readonly TSchema[] ? {
 	[K in keyof T]: T[K] extends TSchema ? Infer<T[K]> : never;
-} : T extends TSchema ? Infer<T> : any;
+} : T extends TSchema ? Infer<T> : T extends Record<string, TSchema> ? {
+	[K in keyof T & string]: Infer<T[K]>;
+} : any;
 declare const NodeConfigSchema: import("@sinclair/typebox").TObject<{
 	id: import("@sinclair/typebox").TString;
 	type: import("@sinclair/typebox").TString;
@@ -414,6 +426,43 @@ declare const IONodeConfigSchema: import("@sinclair/typebox").TObject<{
 	name: import("@sinclair/typebox").TString;
 	z: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
+export declare const ErrorPortSchema: import("@sinclair/typebox").TObject<{
+	error: import("@sinclair/typebox").TObject<{
+		message: import("@sinclair/typebox").TString;
+		source: import("@sinclair/typebox").TObject<{
+			id: import("@sinclair/typebox").TString;
+			type: import("@sinclair/typebox").TString;
+			name: import("@sinclair/typebox").TString;
+		}>;
+	}>;
+}>;
+export declare const CompletePortSchema: import("@sinclair/typebox").TObject<{
+	complete: import("@sinclair/typebox").TObject<{
+		source: import("@sinclair/typebox").TObject<{
+			id: import("@sinclair/typebox").TString;
+			type: import("@sinclair/typebox").TString;
+			name: import("@sinclair/typebox").TString;
+		}>;
+	}>;
+}>;
+export declare const StatusPortSchema: import("@sinclair/typebox").TObject<{
+	status: import("@sinclair/typebox").TObject<{
+		fill: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[
+			import("@sinclair/typebox").TLiteral<"red">,
+			import("@sinclair/typebox").TLiteral<"green">
+		]>>;
+		shape: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[
+			import("@sinclair/typebox").TLiteral<"dot">,
+			import("@sinclair/typebox").TLiteral<"string">
+		]>>;
+		text: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+	}>;
+	source: import("@sinclair/typebox").TObject<{
+		id: import("@sinclair/typebox").TString;
+		type: import("@sinclair/typebox").TString;
+		name: import("@sinclair/typebox").TString;
+	}>;
+}>;
 declare function NodeRef<T extends new (...args: any[]) => any>(nodeClass: T, options?: NrgSchemaOptions): TNodeRef<InstanceType<T>>;
 declare function TypedInput$1<T = unknown>(options?: NrgSchemaOptions): TTypedInput<T>;
 /**
@@ -445,7 +494,7 @@ interface NodeContextStore {
 	set<T = any>(key: string, value: T): Promise<void>;
 	keys(): Promise<string[]>;
 }
-interface NodeConstructor<T = any, TConfig = any, TCredentials = any> {
+export interface NodeConstructor<T = any, TConfig = any, TCredentials = any> {
 	readonly type: string;
 	readonly category: string;
 	readonly color?: string;
@@ -456,12 +505,13 @@ interface NodeConstructor<T = any, TConfig = any, TCredentials = any> {
 	readonly credentialsSchema?: Schema;
 	readonly settingsSchema?: Schema;
 	readonly inputSchema?: Schema;
-	readonly outputsSchema?: Schema | Schema[];
+	readonly outputsSchema?: Schema | Schema[] | Record<string, Schema>;
 	readonly validateInput?: boolean;
 	readonly validateOutput?: boolean;
 	readonly name: string;
 	registered?(RED: RED): void | Promise<void>;
-	_registered?(RED: RED): void | Promise<void>;
+	register(RED: RED): void | Promise<void>;
+	validateSettings(RED: RED): void;
 	new (RED: RED, node: NodeRedNode, config: NodeConfig<TConfig>, credentials: NodeCredentials<TCredentials>): T;
 }
 type NodeConfig<TConfig = any> = TConfig & Static<typeof NodeConfigSchema>;
@@ -485,6 +535,7 @@ interface INode<TConfig = any, TCredentials = any, TSettings = any> {
 	created?(): void | Promise<void>;
 	closed?(removed?: boolean): void | Promise<void>;
 }
+declare const WIRE_HANDLERS: unique symbol;
 /**
  * Abstract base class for all NRG nodes. Provides lifecycle hooks, config
  * validation, logging, timers, i18n, and settings management.
@@ -493,14 +544,19 @@ interface INode<TConfig = any, TCredentials = any, TSettings = any> {
  * for shared configuration nodes.
  */
 declare abstract class Node$1<TConfig = any, TCredentials = any, TSettings = any> implements INode<TConfig, TCredentials, TSettings> {
+	#private;
 	static readonly type: string;
 	static readonly category: "config" | string;
 	static readonly configSchema?: Schema;
 	static readonly credentialsSchema?: Schema;
 	static readonly settingsSchema?: Schema;
-	private static _cachedSettings;
 	static registered?(RED: RED): void | Promise<void>;
 	static validateSettings(RED: RED): void;
+	/**
+	 * Registers this node class with Node-RED. Handles instance creation,
+	 * event handler wiring, settings validation, and the user's registered() hook.
+	 */
+	static register(RED: RED): Promise<void>;
 	protected readonly RED: RED;
 	protected readonly node: NodeRedNode;
 	protected readonly context: ConfigNodeContext | IONodeContext;
@@ -508,6 +564,7 @@ declare abstract class Node$1<TConfig = any, TCredentials = any, TSettings = any
 	private readonly timers;
 	private readonly intervals;
 	constructor(RED: RED, node: NodeRedNode, config: NodeConfig<TConfig>, credentials: NodeCredentials<TCredentials>);
+	[WIRE_HANDLERS](nodeRedNode: NodeRedNode, createdPromise: Promise<void>): void;
 	i18n(key: string, substitutions?: Record<string, string>): string;
 	setTimeout(fn: () => void, ms: number): NodeJS.Timeout;
 	setInterval(fn: () => void, ms: number): NodeJS.Timeout;
@@ -543,29 +600,31 @@ declare abstract class Node$1<TConfig = any, TCredentials = any, TSettings = any
  * ```
  */
 export declare abstract class IONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any, TSettings = any> extends Node$1<TConfig, TCredentials, TSettings> implements IIONode<TConfig, TCredentials, TInput, TOutput, TSettings> {
+	#private;
 	static readonly align?: "left" | "right";
 	static readonly color: HexColor;
 	static readonly inputSchema?: Schema;
-	static readonly outputsSchema?: Schema | Schema[];
+	static readonly outputsSchema?: Schema | Schema[] | Record<string, Schema>;
 	static readonly validateInput: boolean;
 	static readonly validateOutput: boolean;
 	static get inputs(): 0 | 1;
 	static get outputs(): number;
-	private _send;
 	readonly config: IONodeConfig<TConfig>;
 	protected readonly context: IONodeContext;
 	constructor(RED: RED, node: NodeRedNode, config: IONodeConfig<TConfig>, credentials: IONodeCredentials<TCredentials>);
+	[WIRE_HANDLERS](nodeRedNode: NodeRedNode, createdPromise: Promise<void>): void;
 	input(msg: TInput): void | Promise<void>;
 	send(msg: TOutput): void;
+	get baseOutputs(): number;
+	get totalOutputs(): number;
 	/**
 	 * Send a message to a specific output port by index or name.
-	 * Named ports: `"error"`, `"complete"`, `"status"` — resolved automatically
-	 * based on the node's emit port configuration.
+	 * Built-in ports: `"error"`, `"complete"`, `"status"` — resolved automatically
+	 * based on the node's built-in port configuration.
+	 * Custom named ports are resolved from `outputsSchema` when it is a record.
 	 * Numeric indices refer to the base output ports (0-based).
 	 */
-	sendToPort(port: number | "error" | "complete" | "status", msg: TOutput): void;
-	private _getEmitPortIndex;
-	private _nodeSource;
+	sendToPort<P extends (keyof TOutput & string) | number | "error" | "complete" | "status">(port: P, msg: P extends keyof TOutput ? TOutput[P] : unknown): void;
 	status(status: IONodeStatus): void;
 	error(message: string, msg?: any): void;
 	updateWires(wires: string[][]): void;
@@ -594,8 +653,9 @@ type IONodeContext = {
 	global: NodeContextStore;
 };
 type HexColor = `#${string}`;
-type BoundIONode<TC extends TSchema | undefined, TCr extends TSchema | undefined, TS extends TSchema | undefined, TIn extends TSchema | undefined, TOut extends TSchema | readonly TSchema[] | undefined> = IONode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TIn, any>, InferOutputs<TOut>, InferOr<TS, any>>;
-interface IIONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any, TSettings = any> extends INode<TConfig, TCredentials, TSettings> {
+type BoundIONode<TC extends TSchema | undefined, TCr extends TSchema | undefined, TS extends TSchema | undefined, TIn extends TSchema | undefined, TOut extends TSchema | readonly TSchema[] | Record<string, TSchema> | undefined> = IONode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TIn, any>, InferOutputs<TOut>, InferOr<TS, any>>;
+/** Public instance interface for IO nodes. Implemented by {@link IONode}. */
+export interface IIONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any, TSettings = any> extends INode<TConfig, TCredentials, TSettings> {
 	readonly config: IONodeConfig<TConfig>;
 	readonly credentials: IONodeCredentials<TCredentials> | undefined;
 	readonly x: number;
@@ -607,9 +667,11 @@ interface IIONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any
 	status(status: IONodeStatus): void;
 	updateWires(wires: string[][]): void;
 	receive(msg: TInput): void;
-	sendToPort(port: number | "error" | "complete" | "status", msg: TOutput): void;
+	readonly baseOutputs: number;
+	readonly totalOutputs: number;
+	sendToPort<P extends (keyof TOutput & string) | number | "error" | "complete" | "status">(port: P, msg: P extends keyof TOutput ? TOutput[P] : unknown): void;
 }
-interface IONodeDefinition<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined, TInputSchema extends TSchema | undefined = undefined, TOutputsSchema extends TSchema | readonly TSchema[] | undefined = undefined> {
+interface IONodeDefinition<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined, TInputSchema extends TSchema | undefined = undefined, TOutputsSchema extends TSchema | readonly TSchema[] | Record<string, TSchema> | undefined = undefined> {
 	type: string;
 	category?: string;
 	color?: HexColor;
@@ -656,7 +718,8 @@ type ConfigNodeContext = {
 	global: NodeContextStore;
 };
 type BoundConfigNode<TC extends TSchema | undefined, TCr extends TSchema | undefined, TS extends TSchema | undefined> = ConfigNode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TS, any>>;
-interface IConfigNode<TConfig = any, TCredentials = any, TSettings = any> extends INode<TConfig, TCredentials, TSettings> {
+/** Public instance interface for config nodes. Implemented by {@link ConfigNode}. */
+export interface IConfigNode<TConfig = any, TCredentials = any, TSettings = any> extends INode<TConfig, TCredentials, TSettings> {
 	readonly config: ConfigNodeConfig<TConfig>;
 	readonly credentials: ConfigNodeCredentials<TCredentials> | undefined;
 	readonly userIds: string[];
@@ -672,6 +735,27 @@ interface ConfigNodeDefinition<TConfigSchema extends TSchema | undefined = undef
 	created?(this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>): void | Promise<void>;
 	closed?(this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>, removed?: boolean): void | Promise<void>;
 }
+/**
+ * Registers a custom node with Node-RED.
+ *
+ * @param RED - The Node-RED runtime API object
+ * @param NodeClass - A node class extending Node, IONode, or ConfigNode
+ * @throws If NodeClass does not extend Node
+ * @throws If NodeClass.type is not defined
+ */
+export declare function registerType(RED: RED, NodeClass: NodeConstructor): Promise<void>;
+type RegistrationFunction = ((RED: RED) => Promise<void>) & {
+	nodes: NodeConstructor[];
+};
+/**
+ * Registers multiple node classes with Node-RED.
+ *
+ * Returns a Node-RED package function that Node-RED calls with the RED
+ * runtime object when loading the package.
+ *
+ * @param nodes - Array of node classes to register
+ */
+export declare function registerTypes(nodes: NodeConstructor[]): RegistrationFunction;
 /**
  * Creates an IO node class from a definition object. Provides automatic type
  * inference from schemas, reducing boilerplate compared to the class-based API.
@@ -690,7 +774,7 @@ interface ConfigNodeDefinition<TConfigSchema extends TSchema | undefined = undef
  * });
  * ```
  */
-export declare function defineIONode<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined, TInputSchema extends TSchema | undefined = undefined, TOutputsSchema extends TSchema | readonly TSchema[] | undefined = undefined>(def: IONodeDefinition<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>): NodeConstructor<IIONode<InferOr<TConfigSchema, any>, InferOr<TCredsSchema, any>, InferOr<TInputSchema, any>, InferOutputs<TOutputsSchema>>>;
+export declare function defineIONode<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined, TInputSchema extends TSchema | undefined = undefined, TOutputsSchema extends TSchema | readonly TSchema[] | Record<string, TSchema> | undefined = undefined>(def: IONodeDefinition<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>): NodeConstructor<IIONode<InferOr<TConfigSchema, any>, InferOr<TCredsSchema, any>, InferOr<TInputSchema, any>, InferOutputs<TOutputsSchema>>>;
 /**
  * Creates a config node class from a definition object.
  *
@@ -708,27 +792,6 @@ export declare function defineConfigNode<TConfigSchema extends TSchema | undefin
 export declare class NrgError extends Error {
 	constructor(message: string);
 }
-/**
- * Registers a custom node with Node-RED.
- *
- * @param RED - The Node-RED runtime API object
- * @param NodeClass - A node class extending Node, IONode, or ConfigNode
- * @throws If NodeClass does not extend Node
- * @throws If NodeClass.type is not defined
- */
-export declare function registerType(RED: RED, NodeClass: NodeConstructor): Promise<void>;
-type RegistrationFunction = ((RED: RED) => Promise<void>) & {
-	nodes: NodeConstructor[];
-};
-/**
- * Registers multiple node classes with Node-RED.
- *
- * Returns a Node-RED package function that Node-RED calls with the RED
- * runtime object when loading the package.
- *
- * @param nodes - Array of node classes to register
- */
-export declare function registerTypes(nodes: NodeConstructor[]): RegistrationFunction;
 /** Defines the set of nodes exported by a Node-RED package. */
 export interface ModuleDefinition {
 	nodes: NodeConstructor[];

package/types/test.d.ts

@@ -214,12 +214,13 @@ interface NodeConstructor<T = any, TConfig = any, TCredentials = any> {
 	readonly credentialsSchema?: Schema;
 	readonly settingsSchema?: Schema;
 	readonly inputSchema?: Schema;
-	readonly outputsSchema?: Schema | Schema[];
+	readonly outputsSchema?: Schema | Schema[] | Record<string, Schema>;
 	readonly validateInput?: boolean;
 	readonly validateOutput?: boolean;
 	readonly name: string;
 	registered?(RED: RED): void | Promise<void>;
-	_registered?(RED: RED): void | Promise<void>;
+	register(RED: RED): void | Promise<void>;
+	validateSettings(RED: RED): void;
 	new (RED: RED, node: NodeRedNode, config: NodeConfig<TConfig>, credentials: NodeCredentials<TCredentials>): T;
 }
 type NodeConfig<TConfig = any> = TConfig & Static<typeof NodeConfigSchema>;

package/vite/index.js

@@ -661,18 +661,34 @@ function getSchemaReferences(filePath) {
     }
   }
   const schemaRefs = /* @__PURE__ */ new Map();
-  function extractIdentifiers(node) {
+  const recordPortNames = /* @__PURE__ */ new Map();
+  let outputsSchemaIsRecord = false;
+  function extractIdentifiers(node, propName) {
     if (ts.isIdentifier(node)) return [node.text];
     if (ts.isArrayLiteralExpression(node)) {
       return node.elements.filter(ts.isIdentifier).map((el) => el.text);
     }
+    if (ts.isObjectLiteralExpression(node) && propName === "outputsSchema") {
+      const ids = [];
+      outputsSchemaIsRecord = true;
+      for (const prop of node.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.initializer)) {
+          const portName = ts.isIdentifier(prop.name) ? prop.name.text : ts.isStringLiteral(prop.name) ? prop.name.text : void 0;
+          if (portName) {
+            ids.push(prop.initializer.text);
+            recordPortNames.set(prop.initializer.text, portName);
+          }
+        }
+      }
+      return ids;
+    }
     return [];
   }
   for (const stmt of source.statements) {
     if (ts.isClassDeclaration(stmt)) {
       for (const member of stmt.members) {
         if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) && member.name.text in SCHEMA_PROP_SEMANTICS && member.initializer) {
-          const ids = extractIdentifiers(member.initializer);
+          const ids = extractIdentifiers(member.initializer, member.name.text);
           if (ids.length > 0) {
             schemaRefs.set(member.name.text, ids);
           }
@@ -686,7 +702,7 @@ function getSchemaReferences(filePath) {
         if (arg && ts.isObjectLiteralExpression(arg)) {
           for (const prop of arg.properties) {
             if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text in SCHEMA_PROP_SEMANTICS) {
-              const ids = extractIdentifiers(prop.initializer);
+              const ids = extractIdentifiers(prop.initializer, prop.name.text);
               if (ids.length > 0) {
                 schemaRefs.set(prop.name.text, ids);
               }
@@ -699,15 +715,17 @@ function getSchemaReferences(filePath) {
   const result = [];
   for (const [propName, identifiers] of schemaRefs) {
     const semanticName = SCHEMA_PROP_SEMANTICS[propName];
-    const isArray = identifiers.length > 1;
+    const isArray = identifiers.length > 1 && !outputsSchemaIsRecord;
+    const isRecord = propName === "outputsSchema" && outputsSchemaIsRecord;
     for (const identifier of identifiers) {
       const importSource = importMap.get(identifier);
       if (importSource) {
         result.push({
           localName: identifier,
-          semanticName: isArray ? identifier : semanticName,
+          semanticName: isArray || isRecord ? identifier : semanticName,
           importSource,
-          tupleProp: isArray ? semanticName : void 0
+          tupleProp: isArray || isRecord ? semanticName : void 0,
+          recordPortName: isRecord ? recordPortNames.get(identifier) : void 0
         });
       }
     }
@@ -734,10 +752,18 @@ function getFactoryInfo(filePath) {
   }
   return null;
 }
-function buildTypeArg(schemaMap, semanticName) {
+function buildTypeArg(schemaMap, semanticName, portNameMap) {
   const names = schemaMap.get(semanticName);
   if (!names || names.length === 0) return "any";
-  if (names.length === 1) return `Infer<typeof ${names[0]}>`;
+  if (names.length === 1 && !portNameMap?.has(names[0]))
+    return `Infer<typeof ${names[0]}>`;
+  if (portNameMap && names.some((n) => portNameMap.has(n))) {
+    const entries = names.map((n) => {
+      const portName = portNameMap.get(n);
+      return portName ? `${portName}: Infer<typeof ${n}>` : null;
+    }).filter(Boolean);
+    return `{ ${entries.join(", ")} }`;
+  }
   return `[${names.map((n) => `Infer<typeof ${n}>`).join(", ")}]`;
 }
 function buildNodeReexports(srcDir, entryFile) {
@@ -755,12 +781,17 @@ function buildNodeReexports(srcDir, entryFile) {
       const interfaceName = factoryInfo.factoryName === "defineIONode" ? "IIONode" : "IConfigNode";
       lines.push(`import _${ns} from "${specifier}";`);
       const schemaMap = /* @__PURE__ */ new Map();
+      const portNameMap = /* @__PURE__ */ new Map();
       for (const ref of schemaRefs) {
         const key = ref.tupleProp ?? ref.semanticName;
         if (!schemaMap.has(key)) schemaMap.set(key, []);
         schemaMap.get(key).push(ref.localName);
+        if (ref.recordPortName) {
+          portNameMap.set(ref.localName, ref.recordPortName);
+        }
       }
       const hasSchemas = schemaMap.size > 0;
+      const hasRecordOutputs = portNameMap.size > 0;
       const nrgImports = ["NodeConstructor", interfaceName];
       if (hasSchemas) nrgImports.push("Infer");
       lines.push(
@@ -785,11 +816,16 @@ function buildNodeReexports(srcDir, entryFile) {
       }
       let typeArgs;
       if (factoryInfo.factoryName === "defineIONode") {
+        const outputsArg = buildTypeArg(
+          schemaMap,
+          "OutputsSchema",
+          portNameMap.size > 0 ? portNameMap : void 0
+        );
         typeArgs = [
           buildTypeArg(schemaMap, "ConfigSchema"),
           buildTypeArg(schemaMap, "CredentialsSchema"),
           buildTypeArg(schemaMap, "InputSchema"),
-          buildTypeArg(schemaMap, "OutputsSchema")
+          outputsArg
         ].join(", ");
       } else {
         typeArgs = [
@@ -1586,9 +1622,10 @@ function generateHelpDoc(nodeClass, labels, t) {
     if (inputSection) lines.push(inputSection);
   }
   if (nodeClass.outputsSchema) {
-    if (Array.isArray(nodeClass.outputsSchema)) {
+    const os2 = nodeClass.outputsSchema;
+    if (Array.isArray(os2)) {
       const portSections = [];
-      nodeClass.outputsSchema.forEach((schema, i) => {
+      os2.forEach((schema, i) => {
         const title = `${t.sections.port} ${i + 1}`;
         const portPropLabels = labels.outputs?.[i];
         const section = generateSchemaSection({
@@ -1604,6 +1641,26 @@ function generateHelpDoc(nodeClass, labels, t) {
       if (portSections.length) {
         lines.push(
           `<h3>${t.sections.outputs}</h3>
+${portSections.join("\n")}`
+        );
+      }
+    } else if (!("type" in os2 || "properties" in os2)) {
+      const portSections = [];
+      for (const [portName, schema] of Object.entries(os2)) {
+        const portPropLabels = labels.outputs?.[portName];
+        const section = generateSchemaSection({
+          title: portName,
+          schema,
+          t,
+          labels: portPropLabels,
+          heading: "####",
+          includeDefault: false
+        });
+        if (section) portSections.push(section);
+      }
+      if (portSections.length) {
+        lines.push(
+          `<h3>${t.sections.outputs}</h3>
 ${portSections.join("\n")}`
         );
       }
@@ -1611,7 +1668,7 @@ ${portSections.join("\n")}`
       const outputPropLabels = labels.outputs?.[0];
       const section = generateSchemaSection({
         title: t.sections.output,
-        schema: nodeClass.outputsSchema,
+        schema: os2,
         t,
         labels: outputPropLabels,
         includeDefault: false