@feasibleone/blong 1.16.1 → 1.18.0

package/dist/types.d.ts

@@ -1,10 +1,11 @@
 // Generated by dts-bundle-generator v9.5.1
 
+import { ChokidarOptions, FSWatcherEventMap } from 'chokidar';
 import { SrvRecord } from 'dns';
 import { EventEmitter } from 'events';
 import { Socket, TcpNetConnectOpts } from 'net';
 import Assert from 'node:assert';
-import { Dirent } from 'node:fs';
+import { Dirent, StatSyncFn } from 'node:fs';
 import { Agent } from 'node:http';
 import { Duplex } from 'node:stream';
 import { Level, LogFn, Logger as PinoLogger } from 'pino';
@@ -17573,6 +17574,207 @@ 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>;
+/**
+ * Model system types.
+ *
+ * A ModelSpec describes one "subject.object" domain entity and drives:
+ * - automatic Browse / New / Open / Report page generation
+ * - schema enrichment (server OpenAPI merged with browser overlay)
+ * - dropdown dependency tracking and caching
+ */
+/** {value, label} pair used in all dropdown and select widgets */
+export interface IDropdownOption {
+	value: unknown;
+	label: string;
+	[key: string]: unknown;
+}
+/** Widget metadata overlay  */
+export interface IWidgetOverride {
+	type?: string;
+	/** Named dropdown: 'rule.country', 'marine.species', etc. */
+	dropdown?: string;
+	options?: Array<{
+		value: unknown;
+		label: string;
+	}>;
+	keyValue?: boolean;
+	fieldClass?: string;
+	itemClassName?: string;
+	label?: string;
+	master?: Record<string, string>;
+	parent?: string;
+	autoSelect?: boolean;
+	selectionMode?: "single" | "multiple";
+	hidden?: string[];
+	widgets?: string[];
+	params?: Record<string, unknown>;
+	[key: string]: unknown;
+}
+/** JSON Schema property overlay — the browser model adds/overrides field metadata */
+export interface IPropertyOverride {
+	title?: string;
+	type?: string;
+	filter?: boolean;
+	sort?: boolean;
+	required?: boolean;
+	default?: unknown;
+	widget?: IWidgetOverride;
+	validation?: unknown;
+	properties?: Record<string, IPropertyOverride>;
+	items?: {
+		properties?: Record<string, IPropertyOverride>;
+	};
+	[key: string]: unknown;
+}
+/** Schema overlay — top-level properties map per subject.object */
+export interface ISchemaOverlay {
+	properties?: Record<string, IPropertyOverride>;
+	[key: string]: unknown;
+}
+/** Named card layout — a group of fields rendered as one collapsible card */
+export interface ICardOverride {
+	className?: string;
+	label?: string;
+	title?: string;
+	hidden?: boolean;
+	widgets: Array<string | IInlineWidget>;
+}
+/** Inline widget descriptor (used inside card.widgets arrays) */
+export interface IInlineWidget {
+	name: string;
+	type: string;
+	page?: string;
+	params?: Record<string, unknown>;
+}
+/** Tab in the editor layout */
+export interface ILayoutTab {
+	id: string;
+	label?: string;
+	icon?: string;
+	widgets: Array<string | string[]>;
+}
+/** Permission names for each CRUD action */
+export interface IBrowserPermissions {
+	browse: string;
+	add: string;
+	edit: string;
+	delete: string;
+}
+/** Browse page configuration */
+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;
+	/** Whether to show "Create" button */
+	create?: Array<{
+		title?: string;
+		type?: string;
+		permission?: string;
+	}>;
+	/** Extra toolbar buttons */
+	toolbar?: unknown[];
+}
+/** Editor page configuration */
+export interface IEditorConfig {
+	resultSet?: string;
+}
+/** Report page configuration */
+export interface IReportConfig {
+	title?: string;
+	permission?: string;
+}
+/** Method name overrides — defaults to semantic triple naming */
+export interface IMethodsConfig {
+	find?: string;
+	get?: string;
+	add?: string;
+	edit?: string;
+	remove?: string;
+	report?: string;
+}
+/**
+ * ModelSpec — the browser-side description of one "subject.object" domain entity.
+ *
+ * Used by modelFactory() to auto-generate Browse/New/Open/Report pages.
+ */
+export interface IModelSpec {
+	/** Namespace / subject, e.g. 'marine', 'rule' */
+	subject: string;
+	/** Entity name, e.g. 'coral', 'condition' */
+	object: string;
+	/** Human-readable title, e.g. 'Coral'. Defaults to capitalized object. */
+	objectTitle?: string;
+	/** Primary key field path, e.g. 'coralId'. Defaults to `${object}Id`. */
+	keyField?: string;
+	/** Name field path (dotted), e.g. 'coral.coralName'. Defaults to `${object}.${object}Name`. */
+	nameField?: string;
+	/** JSON Schema overlay merged on top of server OpenAPI schema */
+	schema?: ISchemaOverlay;
+	/** Named card layout definitions */
+	cards?: Record<string, ICardOverride>;
+	/** Browse page configuration */
+	browser?: IBrowserConfig;
+	/** Editor page configuration */
+	editor?: IEditorConfig;
+	/** Report page configuration */
+	report?: IReportConfig;
+	/** Tab layouts for editor */
+	layouts?: {
+		edit?: ILayoutTab[] | string[];
+		[key: string]: unknown;
+	};
+	/** Method name overrides */
+	methods?: IMethodsConfig;
+}
+/** Model spec as accepted by modelFactory — objectTitle/keyField/nameField are optional */
+export type IPartialModelSpec = IModelSpec;
+/** Fully resolved model spec — all defaults filled in */
+export interface IResolvedModelSpec extends Required<IModelSpec> {
+	objectTitle: string;
+	keyField: string;
+	nameField: string;
+	browser: Required<IBrowserConfig> & {
+		permission: IBrowserPermissions;
+	};
+	editor: Required<IEditorConfig>;
+	report: Required<IReportConfig>;
+	methods: Required<IMethodsConfig>;
+}
+/** Mock OpenAPI document (minimal shape used by schemaFetcher) */
+export interface IMockOpenApiDoc {
+	paths?: Record<string, Record<string, {
+		operationId?: string;
+		requestBody?: {
+			content?: {
+				"application/json"?: {
+					schema?: Record<string, unknown>;
+				};
+			};
+		};
+		responses?: {
+			"200"?: {
+				content?: {
+					"application/json"?: {
+						schema?: Record<string, unknown>;
+					};
+				};
+			};
+		};
+	}>>;
+	"x-ui-customizations"?: Record<string, Record<string, unknown>>;
+}
+export interface IMock {
+	/** Mock OpenAPI documents keyed by subject name */
+	subjects?: Record<string, object[]>;
+	/** Pre-populated dropdown data keyed by dropdown name */
+	dropdowns?: Record<string, IDropdownOption[]>;
+}
 export type ServerContext = {
 	queryBuilder?: Knex;
 	kcAdminClient?: KeycloakAdminClient;
@@ -17591,6 +17793,82 @@ export interface ILog {
 	logger: (level: Level, bindings: object) => ILogger;
 	child: PinoLogger["child"];
 }
+/** A flat map of dotted-path → [prev, next] pairs that represent changed keys */
+export type ConfigDiff = Map<string, {
+	prev: unknown;
+	next: unknown;
+}>;
+/** 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.
+ *
+ * - `'throw'`   — throw immediately (default; keeps misuse from going unnoticed)
+ * - `'collect'` — accumulate errors and return them from exitConfigFactoryPhase()
+ *                 (useful in tests that explicitly verify the anti-pattern is caught)
+ */
+export type FactoryPhaseMode = "throw" | "collect";
+export interface IConfigRuntime {
+	/** Current effective config, exposed as a live proxy */
+	readonly snapshot: object;
+	/** Raw (non-proxy) snapshot of the current effective config */
+	readonly rawSnapshot: object;
+	/** Load (or reload) config from all sources; returns the updated snapshot */
+	load(params?: object): Promise<object>;
+	/**
+	 * Reload config in-place.  The backing store of the proxy is updated so all
+	 * existing proxy references automatically reflect the new values.
+	 * Returns the computed diff.
+	 */
+	reload(): Promise<ConfigDiff>;
+	/** Compute the diff between two plain config objects without modifying state */
+	diff(prev: object, next: object): ConfigDiff;
+	/** Register a subscriber to be called after every successful reload */
+	subscribe(fn: ConfigSubscriber): () => void;
+	/** Enter the config factory phase */
+	enterConfig(mode?: FactoryPhaseMode): void;
+	/** Exit the config factory phase */
+	exitConfig(): Error[];
+}
+export interface IWatcher extends EventEmitter<FSWatcherEventMap> {
+	close(): Promise<void>;
+}
+export type HRTime = [
+	number,
+	number
+];
+export interface IPlatformApi {
+	platform: "server" | "browser";
+	loadConfig: (config: string | object) => Promise<{
+		loadedConfig?: object;
+		configRuntime?: IConfigRuntime;
+	}>;
+	readdir: (path: string) => Promise<Dirent[]>;
+	scan: (...path: string[]) => Promise<Dirent[]>;
+	existsSync: (path: string) => boolean;
+	createRequire?: (path: string | URL) => NodeJS.Require;
+	join: (...paths: string[]) => string;
+	dirname: (path: string) => string;
+	basename: (path: string, ext?: string) => string;
+	relative: (from: string, to: string) => string;
+	extname: (path: string) => string;
+	resolve: (...paths: string[]) => string;
+	readFileSync: (path: string, options?: {
+		encoding: BufferEncoding;
+	}) => string | Buffer;
+	writeFileSync: (path: string, data: string | Buffer, options?: {
+		encoding: BufferEncoding;
+	}) => void;
+	statSync: StatSyncFn;
+	watch?: (path: string | string[], options?: ChokidarOptions) => IWatcher;
+	timing: {
+		diff: (time: HRTime, newTime: HRTime) => number;
+		after: (milliseconds: number) => HRTime;
+		now: (previous?: HRTime) => HRTime;
+		isAfter: (time: HRTime, timeout: HRTime) => boolean;
+		spare: (time: HRTime, latency?: number) => number;
+	};
+}
 export interface IErrorFactory {
 	get(type?: string): unknown;
 	fetch(type: string): object;
@@ -17674,6 +17952,9 @@ export interface IApiSchema {
 	}, source: string): Promise<Record<string, GatewaySchema>>;
 	generateFile(file: string): Promise<boolean>;
 	generateDir(dir: string, files: Dirent[]): Promise<boolean>;
+	loadApi(locations: string | string[] | object | object[] | {
+		assets: object;
+	}, source: string): unknown;
 }
 export interface IGateway {
 	route: (validations: Record<string, GatewaySchema>, pkg: {
@@ -17687,36 +17968,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;
@@ -17724,25 +18001,26 @@ export interface IApi {
 	rpc: IRpcServer;
 	local: ILocal;
 	registry: IRegistry;
-	utBus: {
-		config: object;
-		register: (methods: object, namespace: string, id: string, pkg: {
-			version: string;
-		}) => void;
-		unregister: (methods: string[], namespace: string) => void;
-		subscribe: (methods: object, namespace: string, id: string, pkg: {
-			version: string;
-		}) => void;
-		unsubscribe: (methods: string[], namespace: string) => void;
-		dispatch: (...params: unknown[]) => boolean | Promise<unknown>;
-		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;
-	};
-	utLog: {
-		createLog: ILog["logger"];
-	};
+	register: (methods: object, namespace: string, id: string, pkg: {
+		version: string;
+	}) => void;
+	unregister: (methods: string[], namespace: string) => void;
+	subscribe: (methods: object, namespace: string, id: string, pkg: {
+		version: string;
+	}) => void;
+	unsubscribe: (methods: string[], namespace: string) => void;
+	dispatch: (...params: unknown[]) => boolean | Promise<unknown>;
+	methodId: (name: string) => string;
+	getPath: (name: string) => string;
+	importMethod: (methodName: string, options?: object) => (...params: unknown[]) => Promise<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: {
 		utError: IError;
@@ -17765,6 +18043,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>;
@@ -17772,54 +18051,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?: () => 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.
@@ -17831,15 +18106,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;
@@ -17851,7 +18135,7 @@ export interface IMeta {
 	expect?: string[] | string;
 	opcode?: string;
 	source?: string;
-	forward?: object;
+	forward?: Record<string, string>;
 	httpResponse?: {
 		type?: string;
 		redirect?: string;
@@ -17900,14 +18184,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;
@@ -17920,24 +18204,20 @@ export interface IMeta {
 		timestamp: number;
 	}>;
 }
-export type HRTime = [
-	number,
-	number
-];
 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;
@@ -17991,7 +18271,8 @@ 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 {
 	trace?: LogFn;
@@ -18054,9 +18335,16 @@ export interface ILib {
 		name: string;
 	};
 	assert: typeof Assert | undefined;
+	yaml: {
+		parse: <T>(source: string, options?: unknown) => T;
+		parseAllDocuments: <T>(source: string, options?: unknown) => T;
+		parseDocument: <T>(source: string, options?: unknown) => T;
+		stringify: (value: unknown, options?: unknown) => string;
+	};
 	ulid: () => string;
 	uuid4: () => string;
 	uuid7: () => string;
+	timing: IPlatformApi["timing"];
 	setProperty: (obj: Record<string, unknown>, path: string, value: unknown) => void;
 	merge<T, S1>(target: T, source: S1): T & S1;
 	merge<T, S1, S2>(target: T, source1: S1, source2: S2): T & S1 & S2;
@@ -18084,8 +18372,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;
@@ -18120,6 +18410,7 @@ export interface IHandlerProxy<T> {
 			};
 		};
 	};
+	apiSchema: IApiSchema;
 }
 export type ImportProxyCallback<T, C> = (blong: IHandlerProxy<T>) => PortHandler<T, C> | IAdapterFactory<T, C> | Record<string, PortHandler<T, C>>;
 export type Definition<T, C> = object | ImportProxyCallback<T, C> | ImportProxyCallback<T, C>[];
@@ -18147,11 +18438,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>;
 /**
@@ -18162,21 +18453,13 @@ export declare const handler: <T = Record<string, unknown>, C = AdapterContext>(
  * The inner function should return a map whose keys are dot-notation method names
  * (e.g. `'coral.browse'`) and values are async functions that return component
  * metadata `{title, permission, icon, component: async () => ReactComponent}`.
- *
- * @example
- * ```ts
- * export default componentHandler(blong => function coralBrowse() {
- *   return {
- *     'coral.browse': async () => ({
- *       title: 'Browse Corals',
- *       permission: 'marine.coral.browse',
- *       component: async () => (await import('./CoralBrowse.js')).default,
- *     }),
- *   };
- * });
- * ```
  */
-export declare const componentHandler: <T = Record<string, unknown>, C = AdapterContext>(definition: Definition<T, C>) => Definition<T, C>;
+export interface IComponent {
+	title?: string;
+	permission?: string;
+	icon?: string;
+	component: (params?: Record<string, unknown>) => Promise<unknown>;
+}
 /** Action definition for use with `defineActions`. */
 export interface IActionDef {
 	title?: string;
@@ -18216,30 +18499,32 @@ export declare const defineActions: (actions: Record<string, IActionDef>) => ((_
 export declare const library: <T = Record<string, unknown>>(definition: Lib<T>) => Lib<T>;
 export declare const validation: (validation: ValidationDefinition) => ValidationDefinition;
 export declare const api: (api: ApiDefinition) => ApiDefinition;
+export declare const model: <T extends IModelSpec>(definition: () => () => Promise<T>) => (() => () => Promise<T>);
+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 type Kinds = "lib" | "validation" | "api" | "solution" | "server" | "browser" | "adapter" | "orchestrator" | "handler";
-export declare const kind: (what: {}) => Kinds | undefined;
+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: {
 	handler: <T = Record<string, unknown>, C = AdapterContext>(definition: Definition<T, C>) => Definition<T, C>;
-	componentHandler: <T = Record<string, unknown>, C = AdapterContext>(definition: Definition<T, C>) => Definition<T, C>;
 	defineActions: (actions: Record<string, IActionDef>) => ((_blong: unknown) => Record<string, () => IActionDef>);
 	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>;
-	kind: (what: {}) => Kinds | undefined;
+	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;
 };
 
 export {