@feasibleone/blong 1.17.0 → 1.18.1

package/dist/types.d.ts

@@ -9,6 +9,7 @@ import { Dirent, StatSyncFn } from 'node:fs';
 import { Agent } from 'node:http';
 import { Duplex } from 'node:stream';
 import { Level, LogFn, Logger as PinoLogger } from 'pino';
+import React$1 from 'react';
 import { Readable, Writable } from 'stream';
 import { ConnectionOptions as ConnectionOptions_2, TLSSocket, TLSSocketOptions } from 'tls';
 import { Static, TArray, TBoolean, TFunction, TNever, TNumber, TObject, TSchema, TString, TUnknown, Type } from 'typebox';
@@ -17574,6 +17575,335 @@ declare namespace DeferredKeySelection {
 }
 export type AggregationQueryResult<TResult, TIntersectProps2 extends {}> = ArrayIfAlready<TResult, UnwrapArrayMember<TResult> extends DeferredKeySelection<infer TBase, infer TKeys, infer THasSelect, infer TAliasMapping, infer TSingle, infer TIntersectProps, infer TUnionProps> ? true extends THasSelect ? DeferredKeySelection<TBase, TKeys, THasSelect, TAliasMapping, TSingle, TIntersectProps & TIntersectProps2, TUnionProps> : DeferredKeySelection<{}, never, true, {}, false, TIntersectProps2> : TIntersectProps2>;
 export type ResolveResult<S> = DeferredKeySelection.Resolve<S>;
+/** All supported widget types */
+export type WidgetType = "input" | "mask" | "text" | "textArea" | "password" | "number" | "integer" | "currency" | "percent" | "boolean" | "checkbox" | "switch" | "date" | "time" | "dateTime" | "dateRange" | "dropdown" | "dropdownTree" | "select" | "selectTable" | "multiSelect" | "multiSelectTree" | "multiSelectPanel" | "multiSelectTreeTable" | "chips" | "file" | "image" | "imageUpload" | "autocomplete" | "table" | "navigator" | "json" | "code" | "divider" | "label" | "link" | "custom";
+/** Base widget configuration (stored in schema x-widget) */
+export interface IWidgetConfig {
+	type: WidgetType;
+	/** For dropdown/multiSelect — action name to fetch options */
+	fetch?: string;
+	/** Named dropdown key — loads options via portal.dropdown.list */
+	dropdown?: string;
+	/** Options list for static select/multiSelect/select/tree widgets.
+	 * Flat options use `{value, label}`. TreeNode-style options use `{key, label, children}`. */
+	options?: Array<{
+		value?: unknown;
+		label?: string;
+		icon?: string;
+		key?: string | number;
+		children?: unknown[];
+		[extra: string]: unknown;
+	}>;
+	/** Parent field name for cascaded dropdowns/tables (supports '$.selected.field' or just 'field') */
+	parent?: string;
+	/** Key mapping for cascaded table filtering: {ownKey: parentKey} */
+	master?: Record<string, string>;
+	/** Auto-select first filtered row when parent selection changes */
+	autoSelect?: boolean;
+	/** Copy-to-clipboard icon (input widget) */
+	copy?: boolean;
+	/** Mask pattern (mask widget) */
+	mask?: string;
+	/** Column definitions for table widget */
+	columns?: string[] | Record<string, IFieldConfig>;
+	/** Pivot config for static or dynamic pivots */
+	pivot?: IPivotConfig;
+	/** Field names to hide in table (used as implicit keys) */
+	hidden?: string[];
+	/** Selection mode for table widget */
+	selectionMode?: "single" | "multiple";
+	/** Label shown inside the widget (e.g. as table toolbar title instead of field label) */
+	label?: string;
+	/** Label field name in fetched options */
+	labelField?: string;
+	/** Value field name in fetched options */
+	valueField?: string;
+	/** Render this widget in read-only display mode regardless of card/form edit-ability */
+	readOnly?: boolean;
+	/** Custom component type (for 'custom' type) */
+	component?: React$1.ComponentType<IWidgetProps>;
+	/** Table action permissions */
+	actions?: {
+		allowAdd?: boolean;
+		allowDelete?: boolean;
+		allowEdit?: boolean;
+		allowSelect?: boolean;
+	};
+	/** Whether to show the inline editor directly inside the cell (boolean/dropdown) */
+	inlineEdit?: boolean;
+	/** Accepted file types (file/imageUpload widgets) */
+	accept?: string;
+	/** Maximum file size in bytes (file/image widgets) */
+	maxSize?: number;
+	/** Base URL prefix for image display (image/imageUpload widgets) */
+	basePath?: string;
+	/** Exclude boundary times (dateRange widget: end = 23:59:59 instead of 00:00:00 next day) */
+	exclusive?: boolean;
+	/** Show time-only pickers (dateRange/time widget) */
+	timeOnly?: boolean;
+	/**
+	 * Action name to load list data from the server (table + navigator widgets).
+	 * When set, the widget manages its own data loading, pagination, search, and
+	 * sort independently of the react-hook-form value.
+	 */
+	listAction?: string;
+	/** Static params merged into every `listAction` call */
+	listParams?: Record<string, unknown>;
+	/**
+	 * Property name in the `listAction` response that contains the rows array.
+	 * Defaults to `'items'`. Set to `''` to use the response directly as an array.
+	 */
+	resultSet?: string;
+	/** Initial rows per page for listAction mode (default 25) */
+	pageSize?: number;
+	/**
+	 * Primary key field name in row data — used for template resolution (`${id}`)
+	 * and for the DataTable `dataKey`. Defaults to `'id'`.
+	 */
+	keyField?: string;
+	/** Parent key field for navigator tree building (default 'parentId') */
+	parentField?: string;
+	/**
+	 * Custom toolbar buttons (left side). Support `${id}`, `${current}`, `${selected}`,
+	 * and `${current.field}` template resolution and `enabled: 'current' | 'selected'`.
+	 */
+	toolbar?: IWidgetToolbarButton[];
+	/** Custom toolbar buttons (right side) */
+	toolbarRight?: IWidgetToolbarButton[];
+}
+/**
+ * Toolbar button for widget-level toolbars (table, navigator).
+ * Similar to IToolbarButton but scoped to widget-level row context.
+ */
+export interface IWidgetToolbarButton {
+	label?: string;
+	icon?: string;
+	/** Direct RPC method name called via dispatch */
+	method?: string;
+	permission?: string;
+	/** Confirmation dialog message before invoking */
+	confirm?: string;
+	/** Enabled condition based on current row selection */
+	enabled?: boolean | "current" | "selected";
+	/**
+	 * Params passed to the method. Supports template strings:
+	 * `${id}` → keyField value, `${current}` → current row,
+	 * `${selected}` → selected rows array, `${current.field}` → field of current row.
+	 */
+	params?: Record<string, unknown> | string;
+	/** Success hint text shown as overlay near the button after the action completes */
+	successHint?: string;
+}
+/** Pivot config for table widget */
+export interface IPivotConfig {
+	/** Static pivot: fixed row examples */
+	examples?: Record<string, unknown>[];
+	/** Dynamic pivot: field name of the dropdown whose options feed the rows */
+	dropdown?: string;
+	/** Key mapping from examples/options to data array */
+	join: {
+		example?: string;
+		option?: string;
+		item: string;
+	};
+}
+/** Object entry in a card's widget list — renders the named array field as a table, showing only the specified columns */
+export interface ICardWidgetEntry {
+	/** Field name from the schema (must be a table/array field) */
+	name: string;
+	/** Unique render key (allows showing the same field multiple times with different column subsets) */
+	id: string;
+	/** Column names from the field's items.properties to display */
+	widgets: string[];
+}
+/** Field configuration within a card */
+export interface IFieldConfig {
+	title?: string;
+	widget?: Partial<IWidgetConfig>;
+	readOnly?: boolean;
+	hidden?: boolean;
+	required?: boolean;
+}
+/** Card configuration */
+export interface ICardConfig {
+	label?: string;
+	/** Field list for this card (preferred alias: widgets) */
+	fields?: Record<string, IFieldConfig> | string[];
+	/** Alias for fields — supports plain field names or ICardWidgetEntry objects for column-subset table views */
+	widgets?: (string | ICardWidgetEntry)[];
+	className?: string;
+	readOnly?: boolean;
+	collapsible?: boolean;
+	loading?: boolean;
+	/** When true: card is not shown visually; fields render as hidden inputs */
+	hidden?: boolean;
+	/** Permission key required to display this card. If set and no checkPermission
+	 *  callback is provided (or it returns false), the card is not rendered. */
+	permission?: string;
+	/** Watch path for reactive cards (e.g. '$.selected.personTable') */
+	watch?: string;
+	/** Match condition to show polymorphic detail cards */
+	match?: Record<string, unknown>;
+	/** Parent table path for master-detail */
+	parent?: string;
+	/** Master-detail key mapping */
+	master?: Record<string, string>;
+	autoSelect?: boolean;
+}
+/** Props that every widget component receives */
+export interface IWidgetProps {
+	/** Field id — forwarded to the inner control for label/id association (same value as name) */
+	id?: string;
+	name: string;
+	schema: IEnrichedFieldSchema;
+	value: unknown;
+	onChange: (value: unknown) => void;
+	onBlur: () => void;
+	error?: {
+		message?: string;
+	};
+	readOnly?: boolean;
+	loading?: boolean;
+	disabled?: boolean;
+	/** All current form values — enables inter-widget reactivity (cascaded dropdowns etc.) */
+	formValues?: Record<string, unknown>;
+	/**
+	 * Called by table widgets when a row is selected (selectionMode: 'single').
+	 * Passes null when the selection is cleared.
+	 */
+	onSelect?: (name: string, selection: {
+		row: Record<string, unknown>;
+		index: number;
+	} | null) => void;
+	/** Dropdown option maps — keyed by dropdown name, each value is the options array.
+	 *  Passed to TableWidget so column-level dropdown schemas can resolve their options. */
+	dropdowns?: Record<string, unknown[]>;
+}
+/** Widget registry interface */
+export interface IWidgetRegistry {
+	register(type: string, component: React$1.ComponentType<IWidgetProps>): void;
+	get(type: string): React$1.ComponentType<IWidgetProps> | undefined;
+	list(): string[];
+}
+/** Enriched field schema — normalized JSON Schema with widget config */
+export interface IEnrichedFieldSchema {
+	title?: string;
+	type?: string;
+	/** JSON Schema format (e.g. 'date', 'date-time', 'email') */
+	format?: string;
+	description?: string;
+	/** Placeholder text for input widgets */
+	placeholder?: string;
+	minLength?: number;
+	maxLength?: number;
+	minimum?: number;
+	maximum?: number;
+	pattern?: string;
+	enum?: unknown[];
+	readOnly?: boolean;
+	required?: boolean;
+	/** Normalized widget config */
+	widget?: IWidgetConfig;
+	/** Nested object properties — for composite/grouped fields accessed via dot-notation paths */
+	properties?: Record<string, IEnrichedFieldSchema>;
+	/** JSON Schema items — describes the shape of array-field rows (used by TableWidget) */
+	items?: {
+		properties?: Record<string, IEnrichedFieldSchema | Record<string, unknown>>;
+	};
+	/** Include field in filter panel */
+	"x-filter"?: boolean;
+	/** Enable inline column filtering (shows filter row in DataTable) */
+	"x-filterable"?: boolean;
+	/** Enable column sorting */
+	"x-sort"?: boolean;
+	/** Action method name — renders the field cell as a clickable link */
+	action?: string;
+	/** Card names to show this field in */
+	"x-cards"?: string[];
+	/** Raw x-widget extension from OpenAPI */
+	"x-widget"?: Partial<IWidgetConfig>;
+	/** Field name */
+	name?: string;
+}
+/** Enriched object schema — normalized JSON Schema for an entity */
+export interface IEnrichedSchema {
+	title?: string;
+	description?: string;
+	properties?: Record<string, IEnrichedFieldSchema>;
+	required?: string[];
+	/** Schema name (e.g. 'model.tree') */
+	name?: string;
+}
+/** Extended action reference — action name plus static params override */
+export interface IActionRef {
+	name: string;
+	params?: Record<string, unknown>;
+}
+/** Toolbar button configuration */
+export interface IToolbarButton {
+	label?: string;
+	icon?: string;
+	/** Action name (string) or extended ref */
+	action?: string | IActionRef;
+	/** Direct RPC method name (bypass action registry) */
+	method?: string;
+	permission?: string;
+	/** Trigger form submit before invoking */
+	submit?: boolean;
+	/** Confirmation dialog message before invoking */
+	confirm?: string;
+	/** Enabled condition */
+	enabled?: boolean | "dirty" | "clean" | "current" | "selected";
+	visible?: boolean;
+	align?: "left" | "right";
+	/** Split-button sub-items */
+	menu?: IToolbarButton[];
+	/** Extra params passed to the action/method on invocation.
+	 * May be a plain object or a string template using `${field}`, `${current}`,
+	 * `${selected}` and `${current.field}` syntax for row-context interpolation. */
+	params?: Record<string, unknown> | string;
+	/** Success hint text shown in an overlay near the button after the action completes */
+	successHint?: string;
+}
+export type LayoutRow = string | (string | string[])[];
+export type FlatLayoutConfig = LayoutRow[];
+/** A single tab/step item in a tab or steps layout */
+export interface ILayoutTabItem {
+	id: string;
+	label?: string;
+	icon?: string;
+	/** Card names shown in this tab/step. A string is a single-card deck; a string[] is a
+	 *  multi-card deck where all cards are stacked vertically in the same grid column. */
+	widgets: (string | string[])[];
+	/** Optional React component rendered in place of cards (e.g. Explorer) */
+	component?: React$1.ComponentType;
+}
+/** Tab or steps layout (object form) */
+export interface ITabLayoutConfig {
+	orientation?: "top" | "left" | "bottom" | "right";
+	type?: "steps";
+	items: ILayoutTabItem[];
+}
+/** A single panel in a split layout */
+export interface ISplitLayoutPanel {
+	/** Panel size as percentage (default auto-distributed) */
+	size?: number;
+	/** Minimum size in pixels */
+	minSize?: number;
+	/** Card names rendered in this panel (stacked vertically) */
+	cards: string[];
+}
+/**
+ * Split layout — renders cards in resizable side-by-side panels using a Splitter.
+ * Ideal for navigator + table + details explorer-style layouts.
+ */
+export interface ISplitLayoutConfig {
+	type: "split";
+	/** Panel orientation: 'horizontal' (default) = side by side, 'vertical' = top/bottom */
+	orientation?: "horizontal" | "vertical";
+	panels: ISplitLayoutPanel[];
+}
+export type LayoutConfig = FlatLayoutConfig | ITabLayoutConfig | ISplitLayoutConfig;
 /**
  * Model system types.
  *
@@ -17665,20 +17995,22 @@ export interface IBrowserConfig {
 	title?: string;
 	icon?: string;
 	permission?: IBrowserPermissions;
-	/** Column transformation applied to server fetch params */
-	fetch?: (params: Record<string, unknown>) => Record<string, unknown>;
 	/** Default filter applied on page open */
 	filter?: Record<string, unknown>;
 	/** Result set key to use from server response */
 	resultSet?: string;
+	/** Extra toolbar buttons */
+	toolbar?: IToolbarButton[];
+}
+export interface IBrowserConfigOptional {
+	/** Column transformation applied to server fetch params */
+	fetch?: (params: Record<string, unknown>) => Record<string, unknown>;
 	/** Whether to show "Create" button */
 	create?: Array<{
 		title?: string;
 		type?: string;
 		permission?: string;
 	}>;
-	/** Extra toolbar buttons */
-	toolbar?: unknown[];
 }
 /** Editor page configuration */
 export interface IEditorConfig {
@@ -17717,18 +18049,15 @@ export interface IModelSpec {
 	/** JSON Schema overlay merged on top of server OpenAPI schema */
 	schema?: ISchemaOverlay;
 	/** Named card layout definitions */
-	cards?: Record<string, ICardOverride>;
+	cards?: Record<string, ICardConfig>;
 	/** Browse page configuration */
-	browser?: IBrowserConfig;
+	browser?: IBrowserConfig & IBrowserConfigOptional;
 	/** Editor page configuration */
 	editor?: IEditorConfig;
 	/** Report page configuration */
 	report?: IReportConfig;
 	/** Tab layouts for editor */
-	layouts?: {
-		edit?: ILayoutTab[] | string[];
-		[key: string]: unknown;
-	};
+	layouts?: Record<string, LayoutConfig>;
 	/** Method name overrides */
 	methods?: IMethodsConfig;
 }
@@ -17739,9 +18068,7 @@ export interface IResolvedModelSpec extends Required<IModelSpec> {
 	objectTitle: string;
 	keyField: string;
 	nameField: string;
-	browser: Required<IBrowserConfig> & {
-		permission: IBrowserPermissions;
-	};
+	browser: Required<IBrowserConfig> & IBrowserConfigOptional;
 	editor: Required<IEditorConfig>;
 	report: Required<IReportConfig>;
 	methods: Required<IMethodsConfig>;
@@ -17801,7 +18128,7 @@ export type ConfigDiff = Map<string, {
 /** Subscriber callback invoked after a successful reload */
 export type ConfigSubscriber = (diff: ConfigDiff, next: object, prev: object) => void | Promise<void>;
 /**
- * Mode used when the config proxy is queried during handler factory initialisation.
+ * Mode used when the config proxy is queried during handler factory initialization.
  *
  * - `'throw'`   — throw immediately (default; keeps misuse from going unnoticed)
  * - `'collect'` — accumulate errors and return them from exitConfigFactoryPhase()
@@ -17868,6 +18195,7 @@ export interface IPlatformApi {
 		isAfter: (time: HRTime, timeout: HRTime) => boolean;
 		spare: (time: HRTime, latency?: number) => number;
 	};
+	configs: string[];
 }
 export interface IErrorFactory {
 	get(type?: string): unknown;
@@ -17968,37 +18296,32 @@ export interface IGateway {
 export type Handlers = ((params: {
 	remote: unknown;
 	lib: object;
-	port: object;
+	port: object | undefined;
 	local: object;
 	literals: object[];
 	gateway: IGateway;
 	apiSchema: IApiSchema;
+	attachCheckpoint?: (meta: IMeta) => void;
 }) => void)[];
 export interface IRegistry {
-	start: (configOverride?: object) => Promise<IRegistry>;
+	start: (configOverride: object) => Promise<IRegistry>;
 	test: (tester?: unknown) => Promise<void>;
 	stop: () => Promise<IRegistry>;
-	ports: Map<string, IAdapterFactory>;
+	ports: Map<string, IAdapterRegistry>;
 	methods: Map<string, Handlers>;
 	modules: Map<string | symbol, IRegistry[]>;
-	createPort: (id: string) => Promise<ReturnType<IAdapterFactory>>;
-	getPort: (id: string) => ReturnType<IAdapterFactory> | undefined;
-	replaceHandlers: (id: string, handlers: object) => Promise<void>;
+	createPort: (id: string) => Promise<Adapter | undefined>;
+	getPort: (id: string) => Adapter | undefined;
+	replaceHandlers: (id: string, handlers: Handlers) => Promise<void>;
 	loadApi: (id: string, def: {
 		namespace: Record<string, string | string[]>;
-	}, source?: string) => Promise<void>;
+	}, source: string) => Promise<void>;
 	connected: () => Promise<boolean>;
 }
 export interface IApi {
 	id?: string;
 	type: typeof Type;
-	adapter: (id: string) => (api: {
-		utError: IError;
-		remote: IRemote;
-		rpc: IRpcServer;
-		local: ILocal;
-		registry: IRegistry;
-	}) => object;
+	adapter: (id: string) => IAdapterRegistry | undefined;
 	utError: IError;
 	errors: IErrorFactory;
 	gateway: unknown;
@@ -18018,7 +18341,13 @@ export interface IApi {
 	methodId: (name: string) => string;
 	getPath: (name: string) => string;
 	importMethod: (methodName: string, options?: object) => (...params: unknown[]) => Promise<unknown>;
-	attachHandlers: (target: object, patterns: unknown, adapter?: boolean) => unknown;
+	attachHandlers: (target: {
+		importedMap?: Map<string, object>;
+		imported: object;
+		config: {
+			namespace?: string | string[];
+		};
+	}, patterns: (string | RegExp)[] | string | RegExp, adapter?: boolean) => unknown;
 	createLog: ILog["logger"];
 	attachCheckpoint?: (meta: IMeta) => void;
 	handlers?: (api: {
@@ -18042,6 +18371,7 @@ export interface IErrorMap {
 		statusCode?: number;
 	};
 }
+export type Adapter<T = Record<string, unknown>, C = Record<string, unknown>> = IAdapter<T, C> & Pick<Required<IAdapter<T, C>>, "init" | "start" | "stop" | "ready" | "config" | "imported" | "errors" | "error" | "findValidation" | "getConversion" | "dispatch">;
 export interface IAdapter<T, C> {
 	validation?: TSchema;
 	config?: Config<T, C>;
@@ -18049,55 +18379,50 @@ export interface IAdapter<T, C> {
 	configBase?: string;
 	log?: ILogger;
 	errors?: Errors<IErrorMap>;
-	imported?: ReturnType<IAdapterFactory<T, C>>;
+	imported?: Record<string, PortHandlerBound>;
 	importedMap?: Map<string, IRemoteHandler>;
 	extends?: object | `adapter.${string}` | `orchestrator.${string}`;
-	activeConfig?: (this: ReturnType<IAdapterFactory<T, C>>) => Partial<Config<T, C>>;
-	init?: (this: ReturnType<IAdapterFactory<T, C>>, ...config: Partial<Config<T, C>>[]) => Promise<void>;
-	start?: (this: ReturnType<IAdapterFactory<T, C>>, configOverride: object) => Promise<object>;
-	ready?: (this: ReturnType<IAdapterFactory<T, C>>) => Promise<object>;
-	stop?: (this: ReturnType<IAdapterFactory<T, C>>) => Promise<object>;
-	connected?: (this: ReturnType<IAdapterFactory<T, C>>) => Promise<boolean>;
-	error?: (error: Error, $meta: IMeta) => void;
-	pack?: (this: ReturnType<IAdapterFactory<T, C>>, packet: {
-		size: number;
-		data: Buffer;
-	}) => Buffer;
-	unpackSize?: (this: ReturnType<IAdapterFactory<T, C>>, buffer: Buffer) => {
-		size: number;
-		data: Buffer;
-	};
-	unpack?: (this: ReturnType<IAdapterFactory<T, C>>, buffer: Buffer, options?: {
-		size: number;
-	}) => Buffer;
-	encode?: (data: unknown, $meta: IMeta, context: object, log: ILogger) => string | Buffer;
-	decode?: (buff: string | Buffer, $meta: IMeta, context: object, log: ILogger) => object[];
-	request?: (...params: unknown[]) => Promise<unknown>;
-	publish?: () => Promise<unknown>;
-	drain?: () => void;
-	findValidation?: (this: ReturnType<IAdapterFactory<T, C>>, $meta: IMeta) => () => object;
-	getConversion?: (this: ReturnType<IAdapterFactory<T, C>>, $meta: IMeta, type: "send" | "receive") => {
+	activeConfig?(this: Adapter<T, C>): Partial<Config<T, C>>;
+	init?(this: Adapter<T, C>, ...config: unknown[]): Promise<unknown>;
+	start?(this: Adapter<T, C>, ...params: unknown[]): Promise<unknown>;
+	ready?(this: Adapter<T, C>): Promise<unknown>;
+	stop?(this: Adapter<T, C>, ...params: unknown[]): Promise<unknown>;
+	link?(this: Adapter<T, C>, patterns: (string | RegExp)[] | string | RegExp, target: object): Promise<{
+		importedMap?: Map<string, object>;
+		imported?: object;
+		config?: {
+			namespace?: string | string[];
+		};
+	}>;
+	connected?(this: Adapter<T, C>): Promise<boolean>;
+	error?(error: unknown, $meta: unknown): void;
+	pack?(this: Adapter<T, C>, ...params: unknown[]): unknown;
+	unpackSize?(this: Adapter<T, C>, ...params: unknown[]): unknown;
+	unpack?(this: Adapter<T, C>, ...params: unknown[]): unknown;
+	encode?(data: unknown, $meta: unknown, context: unknown, log: unknown): Promise<string | Buffer>;
+	decode?(buff: string | Buffer, $meta: unknown, context: unknown, log: unknown): Promise<object[]>;
+	request?(...params: unknown[]): Promise<unknown>;
+	publish?(): Promise<unknown>;
+	drain?(): void;
+	findValidation?(this: Adapter<T, C>, $meta: unknown): (...params: unknown[]) => object;
+	getConversion?(this: Adapter<T, C>, $meta: unknown, type: string): {
 		name: string;
-		fn: () => object;
+		fn: (...params: unknown[]) => Promise<object>;
 	};
-	findHandler?: (this: ReturnType<IAdapterFactory<T, C>>, name: string) => () => unknown;
-	handles?: (this: ReturnType<IAdapterFactory<T, C>>, name: string) => boolean;
-	forNamespaces?: <T>(reducer: (prev: T, current: unknown) => T, initial: T) => T;
-	methodPath?: (name: string) => string;
-	dispatch?: (...params: unknown[]) => Promise<unknown>;
-	exec?: (this: ReturnType<IAdapterFactory<T, C>>, ...params: unknown[]) => Promise<unknown>;
-	bytesSent?: (count: number) => void;
-	bytesReceived?: (count: number) => void;
-	msgSent?: (count: number) => void;
-	msgReceived?: (count: number) => void;
+	findHandler?(this: Adapter<T, C>, name: string): () => unknown;
+	handles?(this: Adapter<T, C>, name: string): boolean;
+	forNamespaces?<U>(reducer: (prev: U, current: unknown) => U, initial: U): U;
+	methodPath?(name: string): string;
+	dispatch?(...params: unknown[]): Promise<unknown>;
+	exec?(this: Adapter<T, C>, ...params: unknown[]): Promise<unknown>;
+	bytesSent?(count: number): void;
+	bytesReceived?(count: number): void;
+	msgSent?(count: number): void;
+	msgReceived?(count: number): void;
 	isConnected?: Promise<boolean>;
-	event?: (name: string, params?: unknown) => Promise<object>;
-	handle?: (...params: unknown[]) => Promise<unknown>;
-	connect?: (what: unknown, context: {
-		requests: unknown;
-		waiting: unknown;
-		buffer: unknown;
-	}) => void;
+	event?(name: string, params?: unknown): Promise<object>;
+	handle?(...params: unknown[]): Promise<unknown>;
+	connect?(what: unknown, context: unknown): void;
 	/**
 	 * Optional lifecycle hook called when configuration changes.
 	 * When present, the framework calls this instead of a full stop+start cycle.
@@ -18109,15 +18434,24 @@ export interface IAdapter<T, C> {
 	 * @param next   The full new effective config snapshot (via proxy)
 	 * @param prev   The full previous effective config snapshot
 	 */
-	configChanged?: (diff: Map<string, {
-		prev: unknown;
-		next: unknown;
-	}>, next: object, prev: object) => Promise<void>;
+	configChanged?(this: Adapter<T, C>, diff: unknown, next: unknown, prev?: unknown): Promise<void>;
+	/** Allow arbitrary extra methods on adapter definitions (e.g. authenticate) */
+	[key: string]: unknown;
 }
 export interface IAdapterFactory<T = Record<string, unknown>, C = Record<string, unknown>> {
 	config?: Config<T, C> | false;
 	(api: IApi): IAdapter<T, C>;
 }
+export interface IAdapterRegistry {
+	config: unknown;
+	(api: {
+		utError: IError;
+		remote: IRemote;
+		rpc: IRpcServer;
+		local: ILocal;
+		registry: IRegistry;
+	}): Promise<Adapter>;
+}
 export interface IMeta {
 	mtid?: "request" | "response" | "error" | "notification" | "discard" | "event";
 	request?: IMeta;
@@ -18129,7 +18463,7 @@ export interface IMeta {
 	expect?: string[] | string;
 	opcode?: string;
 	source?: string;
-	forward?: object;
+	forward?: Record<string, string>;
 	httpResponse?: {
 		type?: string;
 		redirect?: string;
@@ -18178,14 +18512,14 @@ export interface IMeta {
 	deviceId?: string | string[];
 	latitude?: string | string[];
 	longitude?: string | string[];
-	conId?: number;
+	conId?: string | number;
 	dispatch?: (msg?: object, $meta?: IMeta) => [
 		msg: object,
 		$meta: IMeta
 	] | boolean | void | Promise<boolean>;
 	reply?: unknown;
-	timeout?: number;
-	timer?: (name?: string, newTime?: HRTime | false) => {
+	timeout?: HRTime;
+	timer?: (name?: string, newTime?: HRTime | undefined) => {
 		[name: string]: number;
 	};
 	gateway?: object;
@@ -18199,19 +18533,19 @@ export interface IMeta {
 	}>;
 }
 export interface IContext {
-	trace: number;
 	session?: {
 		[name: string]: unknown;
 	};
-	conId?: string;
+	conId?: string | number;
 	requests: Map<string, {
 		$meta: IMeta;
-		end: (error: Error) => {
+		end?: (error: Error) => {
 			local: object;
 			literals: object[];
 		};
 	}>;
 	waiting: Set<(error: Error) => void>;
+	buffer?: Buffer;
 }
 export interface ITypedError extends Error {
 	type: string;
@@ -18265,7 +18599,7 @@ export interface IModuleConfig<T extends TSchema = TNever> {
 	url: string;
 	config?: IActivationConfig<Partial<Static<T>> & Partial<Static<IBaseConfig>>>;
 	validation?: T;
-	children?: (string | (() => Promise<object>))[] | ((layer: ModuleApi) => unknown)[];
+	children?: (string | (() => Promise<object>))[] | ((layer: ModuleApi) => unknown)[] | Record<string, () => Promise<unknown>>;
 	glob?: Record<string, () => Promise<object>>;
 }
 export interface ILogger {
@@ -18366,8 +18700,10 @@ export type ApiDefinition = (blong: IValidationProxy) => {
 } | {
 	url: string;
 };
-export type PortHandler<T, C> = <R>(this: ReturnType<IAdapterFactory<T, C>>, params: {}, $meta: IMeta, context?: IContext) => Promise<R> | R;
-export type PortHandlerBound = <T>(params: {}, $meta: IMeta, context?: IContext) => Promise<T> | T;
+export type PortHandler<T, C> = <R>(this: Adapter<T, C>, params: object, $meta: IMeta, context?: IContext) => Promise<R> | R;
+export type PortHandlerBound = (<T>(params: object, $meta: IMeta, context?: IContext) => Promise<T> | T) & {
+	[name: string]: PortHandlerBound;
+};
 export type LibFn = <T>(...params: unknown[]) => T;
 export interface IRemoteHandler {
 	[name: string]: PortHandlerBound;
@@ -18430,11 +18766,11 @@ export declare abstract class Internal {
 	#private;
 	protected log?: ReturnType<ILog["logger"]>;
 	constructor(api?: {
-		log: ILog;
+		log?: ILog;
 	});
 	protected merge: ILib["merge"];
 	stop(): Promise<unknown>;
-	start(...params: unknown[]): Promise<unknown>;
+	start(..._args: unknown[]): Promise<unknown>;
 }
 export declare const handler: <T = Record<string, unknown>, C = AdapterContext>(definition: Definition<T, C>) => Definition<T, C>;
 /**
@@ -18496,12 +18832,12 @@ export declare const fixture: <T extends IMock>(definition: () => T) => (() => T
 export declare const validationHandlers: (handlers: Record<string, TFunction<[
 	ApiSchema
 ]>>) => ValidationDefinition;
-export declare const realm: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T>;
-export declare const server: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T>;
-export declare const browser: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T>;
-export declare const layer: (activation: Record<string, boolean | object>) => Record<string, boolean | object>;
-export declare const adapter: <T, C = AdapterContext>(definition: IAdapterFactory<T, C>) => IAdapterFactory<T, C>;
-export declare const orchestrator: <T, C = AdapterContext>(definition: IAdapterFactory<T, C>) => IAdapterFactory<T, C>;
+export declare const realm: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T> & {};
+export declare const server: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T> & {};
+export declare const browser: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T> & {};
+export declare const layer: (activation: Record<string, boolean | object>) => Record<string, boolean | object> & {};
+export declare const adapter: <T, C = AdapterContext>(definition: IAdapterFactory<T, C>) => IAdapterFactory<T, C> & {};
+export declare const orchestrator: <T, C = AdapterContext>(definition: IAdapterFactory<T, C>) => IAdapterFactory<T, C> & {};
 export type Kinds = "lib" | "validation" | "api" | "solution" | "server" | "browser" | "adapter" | "orchestrator" | "handler" | "model" | "fixture" | "";
 export declare const kind: (what: {}) => Kinds;
 declare const _default: {
@@ -18510,11 +18846,11 @@ declare const _default: {
 	library: <T = Record<string, unknown>>(definition: Lib<T>) => Lib<T>;
 	validation: (validation: ValidationDefinition) => ValidationDefinition;
 	api: (api: ApiDefinition) => ApiDefinition;
-	realm: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T>;
-	server: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T>;
-	browser: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T>;
-	adapter: <T, C = AdapterContext>(definition: IAdapterFactory<T, C>) => IAdapterFactory<T, C>;
-	orchestrator: <T, C = AdapterContext>(definition: IAdapterFactory<T, C>) => IAdapterFactory<T, C>;
+	realm: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T> & {};
+	server: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T> & {};
+	browser: <T extends TObject>(definition: SolutionFactory<T>) => SolutionFactory<T> & {};
+	adapter: <T, C = AdapterContext>(definition: IAdapterFactory<T, C>) => IAdapterFactory<T, C> & {};
+	orchestrator: <T, C = AdapterContext>(definition: IAdapterFactory<T, C>) => IAdapterFactory<T, C> & {};
 	fixture: <T extends IMock>(definition: () => T) => (() => T);
 	kind: (what: {}) => Kinds;
 };