@bonsae/nrg 0.18.5 → 0.19.0

package/types/client.d.ts

@@ -1,12 +1,36 @@
 // Generated by dts-bundle-generator v9.5.1
 
-import { SchemaOptions, Static, TSchema } from '@sinclair/typebox';
+import { Static, TSchema } from '@sinclair/typebox';
+import { SchemaObject } from 'ajv';
 import { App, Component } from 'vue';
 
 interface NodeRefResolved<T = any> {
 	readonly __nrg_node_ref: true;
 	readonly __instance: T;
 }
+interface TypedInputResolved {
+	resolve(...args: any[]): any;
+	value: unknown;
+	type: string;
+}
+interface JsonSchemaObjectExtensions {
+	format?: "node-id" | "flow-id" | "topic-path" | (string & {});
+	/** expose this settings property to the editor via RED.settings */
+	exportable?: boolean;
+	/** set by SchemaType.NodeRef — the referenced config node type */
+	"x-nrg-node-type"?: string;
+	/** set by SchemaType.TypedInput — marks a TypedInput value/type pair */
+	"x-nrg-typed-input"?: boolean;
+	/** set by markNonValidatable — ajv skips this property */
+	"x-nrg-skip-validation"?: boolean;
+	/** form rendering hints consumed by the auto-generated editor form */
+	"x-nrg-form"?: {
+		icon?: string;
+		typedInputTypes?: string[];
+		editorLanguage?: string;
+		toggle?: boolean;
+	};
+}
 export interface NodeStateCredentials {
 	[key: string]: any;
 }
@@ -68,6 +92,18 @@ export interface NodeRedNode {
 	_newState?: NodeRedNode;
 	_app?: App | null;
 	_: (str: string) => string;
+	/** dynamic port count (base outputs + enabled built-in ports) */
+	outputs?: number;
+	/** injected when the node has an inputSchema */
+	validateInput?: boolean;
+	/** injected when the node has an outputsSchema */
+	validateOutput?: boolean;
+	/** present when the node's configSchema declares SchemaType.ReturnProperty() */
+	returnProperty?: string;
+	/** built-in port toggles, present when declared in the configSchema */
+	errorPort?: boolean;
+	completePort?: boolean;
+	statusPort?: boolean;
 	[key: string]: any;
 }
 export interface NodeDefinition {
@@ -92,6 +128,56 @@ export interface NodeDefinition {
 	onPaletteRemove?: (this: NodeRedNode) => void;
 	form?: NodeFormDefinition;
 }
+/** Form rendering hints carried by the `x-nrg-form` schema keyword. */
+export type NrgFormOptions = NonNullable<JsonSchemaObjectExtensions["x-nrg-form"]>;
+/**
+ * A serialized property schema inside {@link JsonSchemaObject} `properties`,
+ * including NRG's custom keywords (shared vocabulary in core/schema-options)
+ * that drive form rendering and NodeRef/TypedInput identification.
+ */
+export interface JsonPropertySchema extends JsonSchemaObjectExtensions {
+	type?: string | string[];
+	properties?: Record<string, JsonPropertySchema>;
+	required?: string[];
+	enum?: unknown[];
+	anyOf?: JsonPropertySchema[];
+	const?: unknown;
+	items?: JsonPropertySchema;
+	title?: string;
+	description?: string;
+	default?: unknown;
+}
+/**
+ * A serialized JSON Schema object as the build pipeline emits it (never a
+ * live TypeBox instance). Extends ajv's `SchemaObject` so it flows into
+ * validator APIs without casts, while keeping the `type: "object"`
+ * discriminant and structured `properties`/`required` that ajv's open
+ * `[x: string]: any` shape does not provide.
+ */
+export interface JsonSchemaObject extends SchemaObject {
+	type: "object";
+	properties?: Record<string, JsonPropertySchema>;
+	required?: string[];
+}
+/**
+ * A node definition as it exists at editor runtime, after the build pipeline
+ * merged in the schema-derived artifacts (defaults, credentials, serialized
+ * schemas). Authors write {@link NodeDefinition}; the inliner provides the
+ * rest.
+ */
+export interface RuntimeNodeDefinition extends NodeDefinition {
+	defaults?: NodeDefaults;
+	credentials?: NodeCredentials;
+	configSchema?: JsonSchemaObject;
+	credentialsSchema?: JsonSchemaObject;
+	inputSchema?: JsonSchemaObject;
+	/**
+	 * Single port, positional ports, or named ports (key = port name).
+	 * Not constrained to object schemas: with returnProperty the raw sent
+	 * value is validated, so results may be any schema shape.
+	 */
+	outputsSchema?: JsonPropertySchema | JsonPropertySchema[] | Record<string, JsonPropertySchema>;
+}
 export interface NodeDefaults {
 	[key: string]: {
 		value: any;
@@ -109,16 +195,6 @@ export interface NodeCredentials {
 		required?: boolean;
 	};
 }
-export interface MergedNodeDefinition extends NodeDefinition {
-	defaults?: NodeDefaults;
-	credentials?: NodeCredentials;
-	configSchema?: Record<string, any>;
-	credentialsSchema?: {
-		properties?: Record<string, any>;
-	};
-	outputsSchema?: Record<string, any>;
-	inputSchema?: Record<string, any>;
-}
 export interface NodeFeatures {
 	hasInputSchema: boolean;
 	hasOutputSchema: boolean;
@@ -128,12 +204,16 @@ export interface TypedInputValue {
 	value: string;
 	type: string;
 }
-type _ToClient<T> = T extends NodeRefResolved<any> ? string : T extends {
-	resolve(...args: any[]): any;
-	value: unknown;
-	type: string;
-} ? TypedInputValue : T extends (...args: any[]) => any ? T : T extends Array<infer I> ? _ToClient<I>[] : T extends object ? {
-	[K in keyof T]: _ToClient<T[K]>;
+/**
+ * Maps a schema's static type to the raw values the editor form holds.
+ * The server counterpart (`ResolvedStatic` in server/schemas/types) maps the
+ * same brands — shared via core/brands — to resolved runtime values instead.
+ * - `NodeRef<T>` → `string` (the referenced node's id)
+ * - `TypedInput<T>` → `TypedInputValue` (raw value + type pair)
+ * - Functions pass through, arrays and objects map recursively
+ */
+export type EditorStatic<T> = T extends NodeRefResolved<any> ? string : T extends TypedInputResolved ? TypedInputValue : T extends (...args: any[]) => any ? T : T extends Array<infer I> ? EditorStatic<I>[] : T extends object ? {
+	[K in keyof T]: EditorStatic<T[K]>;
 } : T;
 /**
  * Infers the client-side TypeScript type from a TypeBox schema.
@@ -151,7 +231,7 @@ type _ToClient<T> = T extends NodeRefResolved<any> ? string : T extends {
  * type Config = Infer<typeof ConfigSchema>;
  * ```
  */
-export type Infer<T extends TSchema> = _ToClient<Static<T>>;
+export type Infer<T extends TSchema> = EditorStatic<Static<T>>;
 
 export {};
 

package/types/server.d.ts

@@ -273,6 +273,8 @@ interface NodeRedNodes {
 	}) | undefined;
 	createNode(node: NodeRedNode, config: Record<string, any>): void;
 	getCredentials(id: string): Record<string, any> | undefined;
+	/** Merge credentials into a node's stored credential set (runtime API). */
+	addCredentials(id: string, credentials: Record<string, any>): void;
 	eachNode(callback: (node: any) => void): void;
 	getType(type: string): any;
 	getNodeInfo(type: string): any;
@@ -353,10 +355,17 @@ declare class TypedInput<T = unknown> {
 	get value(): unknown;
 	resolve(msg?: Record<string, any>): Promise<T>;
 }
-interface NrgSchemaExtensions {
+interface JsonSchemaObjectExtensions {
 	format?: "node-id" | "flow-id" | "topic-path" | (string & {});
+	/** expose this settings property to the editor via RED.settings */
 	exportable?: boolean;
+	/** set by SchemaType.NodeRef — the referenced config node type */
 	"x-nrg-node-type"?: string;
+	/** set by SchemaType.TypedInput — marks a TypedInput value/type pair */
+	"x-nrg-typed-input"?: boolean;
+	/** set by markNonValidatable — ajv skips this property */
+	"x-nrg-skip-validation"?: boolean;
+	/** form rendering hints consumed by the auto-generated editor form */
 	"x-nrg-form"?: {
 		icon?: string;
 		typedInputTypes?: string[];
@@ -444,8 +453,8 @@ export interface TNodeRef<T = any> extends TSchema {
 	format: "node-id";
 	"x-nrg-node-type"?: string;
 }
-type ResolveNodeRefs<T> = T extends NodeRefResolved<infer I> ? I : 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]>;
+type ResolvedStatic<T> = T extends NodeRefResolved<infer I> ? I : T extends TypedInput<any> ? T : T extends (...args: any[]) => any ? T : T extends Array<infer Item> ? ResolvedStatic<Item>[] : T extends object ? {
+	[K in keyof T]: ResolvedStatic<T[K]>;
 } : T;
 /**
  * Infers the TypeScript type from a schema or a record of schemas.
@@ -456,8 +465,8 @@ type ResolveNodeRefs<T> = T extends NodeRefResolved<infer I> ? I : T extends Typ
  * 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;
+export type Infer<T extends TSchema | Record<string, TSchema>> = T extends TSchema ? ResolvedStatic<Static<T>> : {
+	[K in keyof T & string]: T[K] extends TSchema ? ResolvedStatic<Static<T[K]>> : never;
 };
 type TypedInputType = (typeof TYPED_INPUT_TYPES)[number];
 /** Schema type representing a Node-RED TypedInput (value + type pair). */
@@ -466,7 +475,7 @@ export interface TTypedInput<T = unknown> extends TSchema {
 	static: TypedInput<T>;
 	"x-nrg-typed-input": true;
 }
-interface NrgSchemaOptions extends SchemaOptions, NrgSchemaExtensions {
+interface NrgSchemaOptions extends SchemaOptions, JsonSchemaObjectExtensions {
 }
 /** An NRG object schema created by {@link defineSchema}. */
 export type Schema<T extends TProperties = TProperties> = TObject<T>;
@@ -482,13 +491,18 @@ type InferOutputs<T> = T extends readonly TSchema[] ? {
 } : any;
 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>;
+declare function ReturnProperty(options?: NrgSchemaOptions & {
+	default?: string;
+}): import("@sinclair/typebox").TString;
 /**
  * Extended TypeBox type builder with NRG-specific schema types.
- * Includes all standard TypeBox types plus {@link NodeRef} and {@link TypedInput}.
+ * Includes all standard TypeBox types plus {@link NodeRef}, {@link TypedInput}
+ * and {@link ReturnProperty}.
  */
 export declare const SchemaType: import("@sinclair/typebox").JavaScriptTypeBuilder & {
 	NodeRef: typeof NodeRef;
 	TypedInput: typeof TypedInput$1;
+	ReturnProperty: typeof ReturnProperty;
 };
 /**
  * Creates a validated object schema from a set of properties. Automatically
@@ -522,7 +536,7 @@ export interface NodeConstructor<T = any, TConfig = any, TCredentials = any> {
 	readonly credentialsSchema?: Schema;
 	readonly settingsSchema?: Schema;
 	readonly inputSchema?: Schema;
-	readonly outputsSchema?: Schema | Schema[] | Record<string, Schema>;
+	readonly outputsSchema?: TSchema | TSchema[] | Record<string, TSchema>;
 	readonly validateInput?: boolean;
 	readonly validateOutput?: boolean;
 	readonly name: string;
@@ -600,10 +614,32 @@ declare abstract class Node$1<TConfig = any, TCredentials = any, TSettings = any
 	get credentials(): NodeCredentials<TCredentials> | undefined;
 	get settings(): TSettings;
 }
+/**
+ * Controls how an outgoing message carries the incoming message's context:
+ * - `"nest"` (default): keep all incoming keys and push the full input under
+ *   `input`, so the prior message — including any value the result overwrites
+ *   — is always recoverable (`msg.input.output`). The `input` chain
+ *   accumulates one frame per node, forming a provenance trail visible in the
+ *   debug panel.
+ * - `"carry"`: keep all incoming keys (including any upstream `input`) but do
+ *   not record this node — context flows through without growing.
+ * - `"reset"`: drop all inherited context; the outgoing message is only the
+ *   result at the return key.
+ */
+export type ContextMode = "nest" | "carry" | "reset";
 /**
  * Base class for nodes that process messages. Provides input/output handling,
  * schema validation, status updates, and emit port management.
  *
+ * Every node has a return key (`"output"` by default): the value passed to
+ * `send()` is merged into the incoming message at that key and the full prior
+ * message is kept under `input` (`{ ...msg, [returnKey]: result, input: msg }`),
+ * so upstream properties propagate and the provenance chain is recoverable.
+ * Declaring `returnProperty` in the `configSchema` only lets the flow author
+ * override the key in the editor — it does not change that a return key always
+ * exists. `this.send(x)` always means "x is the result", never "x is the whole
+ * message".
+ *
  * @example
  * ```ts
  * export default class MyNode extends IONode<Config, any, Input, Output> {
@@ -612,7 +648,8 @@ declare abstract class Node$1<TConfig = any, TCredentials = any, TSettings = any
  *   static readonly color = "#ffffff" as const;
  *
  *   async input(msg: Input) {
- *     this.send({ payload: msg.payload.toUpperCase() });
+ *     // sends { ...msg, output: <result>, input: msg }
+ *     this.send(msg.output.toUpperCase());
  *   }
  * }
  * ```
@@ -622,7 +659,7 @@ export declare abstract class IONode<TConfig = any, TCredentials = any, TInput =
 	static readonly align?: "left" | "right";
 	static readonly color: HexColor;
 	static readonly inputSchema?: Schema;
-	static readonly outputsSchema?: Schema | Schema[] | Record<string, Schema>;
+	static readonly outputsSchema?: TSchema | TSchema[] | Record<string, TSchema>;
 	static readonly validateInput: boolean;
 	static readonly validateOutput: boolean;
 	static get inputs(): 0 | 1;
@@ -632,7 +669,7 @@ export declare abstract class IONode<TConfig = any, TCredentials = any, TInput =
 	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;
+	send(msg: TOutput, contextMode?: ContextMode): void;
 	get baseOutputs(): number;
 	get totalOutputs(): number;
 	/**
@@ -645,7 +682,7 @@ export declare abstract class IONode<TConfig = any, TCredentials = any, TInput =
 	 * throw an error or call `this.error()` for the error port, and the complete
 	 * port is sent automatically on successful input processing.
 	 */
-	sendToPort<P extends (TOutput extends Record<string, Record<string, any>> ? keyof TOutput & string : never) | number>(port: P, msg: P extends keyof TOutput ? TOutput[P] : unknown): void;
+	sendToPort<P extends (TOutput extends Record<string, Record<string, any>> ? keyof TOutput & string : never) | number>(port: P, msg: P extends keyof TOutput ? TOutput[P] : unknown, contextMode?: ContextMode): void;
 	status(status: IONodeStatus): void;
 	error(message: string, msg?: any): void;
 	updateWires(wires: string[][]): void;
@@ -660,6 +697,7 @@ type IONodeContextScope = NodeContextScope;
 type IONodeConfig<TConfig = any> = NodeConfig<TConfig> & Static<typeof IONodeConfigSchema> & {
 	validateInput?: boolean;
 	validateOutput?: boolean;
+	returnProperty?: string;
 };
 type IONodeCredentials<TCredentials = any> = NodeCredentials<TCredentials>;
 type IONodeStatus = {

package/types/shims/brands.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Type-level contract shared by the server and client planes.
+ *
+ * `Static<>` of NRG's special schemas (NodeRef, TypedInput) produces these
+ * brand shapes. Each plane maps them differently:
+ *
+ * - server `ResolvedStatic` (server/schemas/types): brand → runtime value
+ *   (NodeRef → the node instance, TypedInput → the resolving wrapper)
+ * - client `EditorStatic` (client/types): brand → editor form value
+ *   (NodeRef → the referenced node id string, TypedInput → { value, type })
+ *
+ * Both planes import the brands from here, type-only, so renaming or
+ * reshaping a brand is a compile error on both sides instead of silent
+ * type drift. Keep this module free of runtime code and imports from
+ * either plane.
+ */
+/** Brand produced by `Static` of a NodeRef schema. */
+interface NodeRefResolved<T = any> {
+    readonly __nrg_node_ref: true;
+    readonly __instance: T;
+}
+/**
+ * Structural shape of a resolved TypedInput (the server's TypedInput class
+ * instance). The client matches this shape to map the field to its raw
+ * editor value pair.
+ */
+interface TypedInputResolved {
+    resolve(...args: any[]): any;
+    value: unknown;
+    type: string;
+}
+export type { NodeRefResolved, TypedInputResolved };

package/types/shims/{form → client/form}/components/node-red-editor-input.vue.d.ts

@@ -29,7 +29,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: string;
     };
 }>, {
-    editor: import("vue").ShallowRef<any, any>;
+    editorInstance: import("vue").ShallowRef<any, any>;
     expandedEditorTray: import("vue").ShallowRef<any, any>;
 }, {
     editorId: string;

package/types/shims/{form → client/form}/components/node-red-json-schema-form.vue.d.ts

@@ -1,3 +1,23 @@
+import type { PropType } from "vue";
+import type { JsonPropertySchema } from "../../types";
+type FieldSchema = JsonPropertySchema;
+interface FormField {
+    key: string;
+    label: string;
+    icon: string;
+    inputType: "text" | "number" | "boolean" | "select" | "typed" | "config" | "editor" | "array-text";
+    required: boolean;
+    htmlType?: "text" | "number" | "password";
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    multiple?: boolean;
+    types?: (NodeRED.DefaultTypedInputType | NodeRED.TypedInputTypeDefinition)[];
+    configType?: string;
+    language?: string;
+    toggle?: boolean;
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     node: {
         type: PropType<NodeRED.BaseNode>;
@@ -15,7 +35,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     configFields(): FormField[];
     credentialFields(): FormField[];
 }, {
-    recalculateOutputs(): void;
     resolveI18n(prefix: string, key: string): string | undefined;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     node: {
@@ -657,7 +676,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             default: string;
         };
     }>, {
-        editor: import("vue").ShallowRef<any, any>;
+        editorInstance: import("vue").ShallowRef<any, any>;
         expandedEditorTray: import("vue").ShallowRef<any, any>;
     }, {
         editorId: string;

package/types/shims/{form → client/form}/components/node-red-select-input.vue.d.ts

@@ -1,3 +1,4 @@
+import { type PropType } from "vue";
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     modelValue: {
         type: (StringConstructor | ArrayConstructor)[];

package/types/shims/{form → client/form}/components/node-red-typed-input.vue.d.ts

@@ -1,3 +1,4 @@
+import { type PropType } from "vue";
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     modelValue: {
         type: PropType<{

package/types/shims/client/types.d.ts

@@ -0,0 +1,206 @@
+import type { Component, App } from "vue";
+import type { TSchema, Static } from "@sinclair/typebox";
+import type { SchemaObject } from "ajv";
+import type { NodeRefResolved, TypedInputResolved } from "../brands";
+import type { JsonSchemaObjectExtensions } from "../schema-options";
+export interface NodeStateCredentials {
+    [key: string]: any;
+}
+export interface NodeState {
+    credentials: NodeStateCredentials;
+    [key: string]: any;
+}
+export interface NodeButtonDefinition {
+    toggle: string;
+    onClick: () => void;
+    enabled?: () => boolean;
+    visible?: () => boolean;
+}
+export interface NodeRedNodeButtonDefinition {
+    toggle: string;
+    onclick: () => void;
+    enabled?: () => boolean;
+    visible?: () => boolean;
+}
+export interface NodeFormDefinition {
+    component?: Component;
+}
+export interface NodeRedNode {
+    id: string;
+    type: string;
+    name: string;
+    category: string;
+    x: string;
+    y: string;
+    g: string;
+    z: string;
+    credentials: Record<string, any>;
+    _def: {
+        defaults: Record<string, {
+            value: string;
+            type?: string;
+            label?: string;
+            required?: boolean;
+        }>;
+        credentials: Record<string, {
+            value: string;
+            type?: "password" | "text";
+            label?: string;
+            required?: boolean;
+        }>;
+        category: string;
+        color?: string;
+        icon?: string;
+        label?: ((this: NodeRedNode) => string) | string;
+        inputs?: number;
+        outputs?: number;
+        paletteLabel?: ((this: NodeRedNode) => string) | string;
+        labelStyle?: ((this: NodeRedNode) => string) | string;
+        inputLabels?: ((this: NodeRedNode, index: number) => string) | string;
+        outputLabels?: ((this: NodeRedNode, index: number) => string) | string;
+        align?: "left" | "right";
+        button?: NodeRedNodeButtonDefinition;
+    };
+    _newState?: NodeRedNode;
+    _app?: App | null;
+    _: (str: string) => string;
+    /** dynamic port count (base outputs + enabled built-in ports) */
+    outputs?: number;
+    /** injected when the node has an inputSchema */
+    validateInput?: boolean;
+    /** injected when the node has an outputsSchema */
+    validateOutput?: boolean;
+    /** present when the node's configSchema declares SchemaType.ReturnProperty() */
+    returnProperty?: string;
+    /** built-in port toggles, present when declared in the configSchema */
+    errorPort?: boolean;
+    completePort?: boolean;
+    statusPort?: boolean;
+    [key: string]: any;
+}
+export interface NodeDefinition {
+    type: string;
+    category?: string;
+    color?: string;
+    icon?: ((this: NodeRedNode) => string) | string;
+    label?: ((this: NodeRedNode) => string) | string;
+    inputs?: number;
+    outputs?: number;
+    paletteLabel?: ((this: NodeRedNode) => string) | string;
+    labelStyle?: ((this: NodeRedNode) => string) | string;
+    inputLabels?: ((this: NodeRedNode, index: number) => string) | string;
+    outputLabels?: ((this: NodeRedNode, index: number) => string) | string;
+    align?: "left" | "right";
+    button?: NodeButtonDefinition;
+    onEditResize?: (this: NodeRedNode, size: {
+        width: number;
+        height: number;
+    }) => void;
+    onPaletteAdd?: (this: NodeRedNode) => void;
+    onPaletteRemove?: (this: NodeRedNode) => void;
+    form?: NodeFormDefinition;
+}
+/** Form rendering hints carried by the `x-nrg-form` schema keyword. */
+export type NrgFormOptions = NonNullable<JsonSchemaObjectExtensions["x-nrg-form"]>;
+/**
+ * A serialized property schema inside {@link JsonSchemaObject} `properties`,
+ * including NRG's custom keywords (shared vocabulary in core/schema-options)
+ * that drive form rendering and NodeRef/TypedInput identification.
+ */
+export interface JsonPropertySchema extends JsonSchemaObjectExtensions {
+    type?: string | string[];
+    properties?: Record<string, JsonPropertySchema>;
+    required?: string[];
+    enum?: unknown[];
+    anyOf?: JsonPropertySchema[];
+    const?: unknown;
+    items?: JsonPropertySchema;
+    title?: string;
+    description?: string;
+    default?: unknown;
+}
+/**
+ * A serialized JSON Schema object as the build pipeline emits it (never a
+ * live TypeBox instance). Extends ajv's `SchemaObject` so it flows into
+ * validator APIs without casts, while keeping the `type: "object"`
+ * discriminant and structured `properties`/`required` that ajv's open
+ * `[x: string]: any` shape does not provide.
+ */
+export interface JsonSchemaObject extends SchemaObject {
+    type: "object";
+    properties?: Record<string, JsonPropertySchema>;
+    required?: string[];
+}
+/**
+ * A node definition as it exists at editor runtime, after the build pipeline
+ * merged in the schema-derived artifacts (defaults, credentials, serialized
+ * schemas). Authors write {@link NodeDefinition}; the inliner provides the
+ * rest.
+ */
+export interface RuntimeNodeDefinition extends NodeDefinition {
+    defaults?: NodeDefaults;
+    credentials?: NodeCredentials;
+    configSchema?: JsonSchemaObject;
+    credentialsSchema?: JsonSchemaObject;
+    inputSchema?: JsonSchemaObject;
+    /**
+     * Single port, positional ports, or named ports (key = port name).
+     * Not constrained to object schemas: with returnProperty the raw sent
+     * value is validated, so results may be any schema shape.
+     */
+    outputsSchema?: JsonPropertySchema | JsonPropertySchema[] | Record<string, JsonPropertySchema>;
+}
+export interface NodeDefaults {
+    [key: string]: {
+        value: any;
+        type?: string;
+        label?: string;
+        required?: boolean;
+        validate?: (this: NodeRedNode, value: any, opt: any) => any;
+    };
+}
+export interface NodeCredentials {
+    [key: string]: {
+        value?: string;
+        type?: "password" | "text";
+        label?: string;
+        required?: boolean;
+    };
+}
+export interface NodeFeatures {
+    hasInputSchema: boolean;
+    hasOutputSchema: boolean;
+}
+/** Client-side representation of a TypedInput field: the raw value string and its type selector. */
+export interface TypedInputValue {
+    value: string;
+    type: string;
+}
+/**
+ * Maps a schema's static type to the raw values the editor form holds.
+ * The server counterpart (`ResolvedStatic` in server/schemas/types) maps the
+ * same brands — shared via core/brands — to resolved runtime values instead.
+ * - `NodeRef<T>` → `string` (the referenced node's id)
+ * - `TypedInput<T>` → `TypedInputValue` (raw value + type pair)
+ * - Functions pass through, arrays and objects map recursively
+ */
+export type EditorStatic<T> = T extends NodeRefResolved<any> ? string : T extends TypedInputResolved ? TypedInputValue : T extends (...args: any[]) => any ? T : T extends Array<infer I> ? EditorStatic<I>[] : T extends object ? {
+    [K in keyof T]: EditorStatic<T[K]>;
+} : T;
+/**
+ * Infers the client-side TypeScript type from a TypeBox schema.
+ *
+ * Resolves schema types to their client form representations:
+ * - `NodeRef<T>` → `string` (node ID in the editor)
+ * - `TypedInput<T>` → `{ value: string; type: string }`
+ * - All other types resolve via TypeBox's `Static<T>`
+ *
+ * @example
+ * ```ts
+ * import type { Infer } from "@bonsae/nrg/client";
+ * import type { ConfigSchema } from "../schemas/my-node";
+ *
+ * type Config = Infer<typeof ConfigSchema>;
+ * ```
+ */
+export type Infer<T extends TSchema> = EditorStatic<Static<T>>;

package/types/shims/components.d.ts

@@ -11,13 +11,13 @@ declare module "vue" {
   }
 
   export interface GlobalComponents {
-    NodeRedConfigInput: (typeof import("./form/components/node-red-config-input.vue"))["default"];
-    NodeRedEditorInput: (typeof import("./form/components/node-red-editor-input.vue"))["default"];
-    NodeRedInputLabel: (typeof import("./form/components/node-red-input-label.vue"))["default"];
-    NodeRedInput: (typeof import("./form/components/node-red-input.vue"))["default"];
-    NodeRedJsonSchemaForm: (typeof import("./form/components/node-red-json-schema-form.vue"))["default"];
-    NodeRedSelectInput: (typeof import("./form/components/node-red-select-input.vue"))["default"];
-    NodeRedToggle: (typeof import("./form/components/node-red-toggle.vue"))["default"];
-    NodeRedTypedInput: (typeof import("./form/components/node-red-typed-input.vue"))["default"];
+    NodeRedConfigInput: (typeof import("./client/form/components/node-red-config-input.vue"))["default"];
+    NodeRedEditorInput: (typeof import("./client/form/components/node-red-editor-input.vue"))["default"];
+    NodeRedInputLabel: (typeof import("./client/form/components/node-red-input-label.vue"))["default"];
+    NodeRedInput: (typeof import("./client/form/components/node-red-input.vue"))["default"];
+    NodeRedJsonSchemaForm: (typeof import("./client/form/components/node-red-json-schema-form.vue"))["default"];
+    NodeRedSelectInput: (typeof import("./client/form/components/node-red-select-input.vue"))["default"];
+    NodeRedToggle: (typeof import("./client/form/components/node-red-toggle.vue"))["default"];
+    NodeRedTypedInput: (typeof import("./client/form/components/node-red-typed-input.vue"))["default"];
   }
 }

package/types/shims/constants.d.ts

@@ -0,0 +1,4 @@
+declare const TYPED_INPUT_TYPES: readonly ["msg", "flow", "global", "str", "num", "bool", "json", "bin", "re", "jsonata", "date", "env", "node", "cred"];
+/** Reserved config property names for built-in ports (error, complete, status) */
+declare const BUILTIN_PORT_KEYS: readonly ["errorPort", "completePort", "statusPort"];
+export { BUILTIN_PORT_KEYS, TYPED_INPUT_TYPES };