@feasibleone/blong 1.16.1 → 1.18.0

package/types.ts

@@ -24,12 +24,15 @@ import {
     type TUnknown,
 } from 'typebox';
 // import type {client} from 'node-vault';
-import type {Dirent} from 'node:fs';
+import type {ChokidarOptions, FSWatcherEventMap} from 'chokidar';
+import type {EventEmitter} from 'events';
+import type {Dirent, StatSyncFn} from 'node:fs';
 import type {Duplex} from 'node:stream';
 import type {OpenAPI, OpenAPIV2, OpenAPIV3_1} from 'openapi-types';
 import type {Level, LogFn, Logger as PinoLogger} from 'pino';
 import merge from 'ut-function.merge';
 import type {Knex} from './knex.js';
+import type {IMock, IModelSpec} from './model.ts';
 
 // export {
 //     AppsV1Api,
@@ -45,6 +48,7 @@ export type * from 'mongodb';
 export type {IJsonSchema, OpenAPI, OpenAPIV2, OpenAPIV3, OpenAPIV3_1} from 'openapi-types';
 // export type {Level, LogFn, Logger as PinoLogger} from 'pino';
 export type {Knex} from './knex.js';
+export type * from './model.ts';
 
 export type ServerContext = {
     queryBuilder?: Knex;
@@ -75,6 +79,89 @@ export interface ILog {
     child: PinoLogger['child'];
 }
 
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** 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;
@@ -160,6 +247,10 @@ export interface IApiSchema {
     ): 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 {
@@ -175,28 +266,30 @@ 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,
+        source: string,
     ) => Promise<void>;
     connected: () => Promise<boolean>;
 }
@@ -204,15 +297,7 @@ export interface IRegistry {
 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;
@@ -220,24 +305,27 @@ 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; remote: IRemote; type: typeof Type}) => {
         extends?:
@@ -262,6 +350,21 @@ export interface IErrorMap {
           };
 }
 
+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>;
@@ -269,59 +372,63 @@ 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',
-    ) => {name: string; fn: () => 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;
+    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: (...params: unknown[]) => Promise<object>};
+    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.
@@ -333,11 +440,14 @@ 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>> {
@@ -345,6 +455,17 @@ export interface IAdapterFactory<T = Record<string, unknown>, C = Record<string,
     (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;
@@ -356,7 +477,7 @@ export interface IMeta {
     expect?: string[] | string;
     opcode?: string;
     source?: string;
-    forward?: object;
+    forward?: Record<string, string>;
     httpResponse?: {
         type?: string;
         redirect?: string;
@@ -402,16 +523,16 @@ 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;
+    timeout?: HRTime;
     timer?: (
         name?: string,
-        newTime?: HRTime | false,
+        newTime?: HRTime | undefined,
     ) => {
         [name: string]: number;
     };
@@ -422,19 +543,18 @@ export interface IMeta {
     checkpoints?: Array<{name: string; data?: unknown; timestamp: number}>;
 }
 
-export type HRTime = [number, number];
-
 export interface IContext {
-    trace: number;
+    // trace: number;
     session?: {
         [name: string]: unknown;
     };
-    conId?: string;
+    conId?: string | number;
     requests: Map<
         string,
-        {$meta: IMeta; end: (error: Error) => {local: object; literals: object[]}}
+        {$meta: IMeta; end?: (error: Error) => {local: object; literals: object[]}}
     >;
     waiting: Set<(error: Error) => void>;
+    buffer?: Buffer;
 }
 
 export interface ITypedError extends Error {
@@ -492,7 +612,11 @@ 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 {
@@ -567,9 +691,16 @@ export interface ILib {
     /** @deprecated The framework now auto-names step arrays from handler names. */
     group: (name: string) => (handlers: ChainStep[]) => ChainStep[] & {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;
@@ -608,17 +739,24 @@ export type ApiDefinition = (blong: IValidationProxy) =>
       };
 
 export type PortHandler<T, C> = <R>(
-    this: ReturnType<IAdapterFactory<T, C>>,
-    params: {},
+    this: Adapter<T, C>,
+    params: object,
     $meta: IMeta,
     context?: IContext,
 ) => Promise<R> | R;
-export type PortHandlerBound = <T>(params: {}, $meta: IMeta, context?: IContext) => Promise<T> | T;
+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;
 }
-export interface ISchema {}
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ISchema {} // this is being extended via ambient declarations in ~.schema.ts
 export interface IHandlerProxy<T> {
     config: T;
     handler: {
@@ -639,6 +777,7 @@ export interface IHandlerProxy<T> {
     gateway: {
         config: () => {public: {sign: object; encrypt: object}};
     };
+    apiSchema: IApiSchema;
 }
 
 export type ImportProxyCallback<T, C> = (
@@ -674,9 +813,9 @@ const Kind: symbol = Symbol.for('blong:kind');
 export type Kind = typeof Kind;
 
 export abstract class Internal {
-    #log?: ILog;
+    #log?: ILog | undefined;
     protected log?: ReturnType<ILog['logger']>;
-    public constructor(api?: {log: ILog}) {
+    public constructor(api?: {log?: ILog}) {
         this.#log = api?.log;
     }
     protected merge: ILib['merge'] = (...args: Parameters<ILib['merge']>) => {
@@ -688,7 +827,8 @@ export abstract class Internal {
     public async stop(): Promise<unknown> {
         return this;
     }
-    public async start(...params: unknown[]): Promise<unknown> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    public async start(..._args: unknown[]): Promise<unknown> {
         return this;
     }
 }
@@ -705,23 +845,13 @@ export 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 const componentHandler = <T = Record<string, unknown>, C = AdapterContext>(
-    definition: Definition<T, C>,
-): Definition<T, C> => Object.defineProperty(definition, Kind, {value: 'handler'});
+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 {
@@ -737,7 +867,9 @@ export interface IActionDef {
     /** Action names whose query caches should be invalidated on success. */
     invalidates?: string[];
     /** Static params merged into every invocation. */
-    params?: Record<string, unknown> | ((params: Record<string, unknown>) => Record<string, unknown>);
+    params?:
+        | Record<string, unknown>
+        | ((params: Record<string, unknown>) => Record<string, unknown>);
 }
 
 /**
@@ -763,10 +895,7 @@ export const defineActions = (
     actions: Record<string, IActionDef>,
 ): ((_blong: unknown) => Record<string, () => IActionDef>) =>
     Object.defineProperty(
-        (_blong: unknown) =>
-            Object.fromEntries(
-                Object.entries(actions).map(([key, value]) => [key, () => value]),
-            ),
+        () => Object.fromEntries(Object.entries(actions).map(([key, value]) => [key, () => value])),
         Kind,
         {value: 'handler'},
     );
@@ -777,6 +906,11 @@ export const validation = (validation: ValidationDefinition): ValidationDefiniti
     Object.defineProperty(validation, Kind, {value: 'validation'});
 export const api = (api: ApiDefinition): ApiDefinition =>
     Object.defineProperty(api, Kind, {value: 'api'});
+export const model = <T extends IModelSpec>(
+    definition: () => () => Promise<T>,
+): (() => () => Promise<T>) => Object.defineProperty(definition, Kind, {value: 'model'});
+export const fixture = <T extends IMock>(definition: () => T): (() => T) =>
+    Object.defineProperty(definition, Kind, {value: 'fixture'});
 
 export const validationHandlers: (
     handlers: Record<string, TFunction<[ApiSchema]>>,
@@ -798,21 +932,41 @@ export const validationHandlers: (
         ),
     );
 
-export const realm = <T extends TObject>(definition: SolutionFactory<T>): SolutionFactory<T> =>
-    Object.defineProperty(definition, Kind, {value: 'solution'});
-export const server = <T extends TObject>(definition: SolutionFactory<T>): SolutionFactory<T> =>
-    Object.defineProperty(definition, Kind, {value: 'server'});
-export const browser = <T extends TObject>(definition: SolutionFactory<T>): SolutionFactory<T> =>
-    Object.defineProperty(definition, Kind, {value: 'browser'});
+export const realm = <T extends TObject>(
+    definition: SolutionFactory<T>,
+): SolutionFactory<T> & {[Kind]: 'solution'} =>
+    Object.defineProperty(definition as SolutionFactory<T> & {[Kind]: 'solution'}, Kind, {
+        value: 'solution',
+    });
+export const server = <T extends TObject>(
+    definition: SolutionFactory<T>,
+): SolutionFactory<T> & {[Kind]: 'server'} =>
+    Object.defineProperty(definition as SolutionFactory<T> & {[Kind]: 'server'}, Kind, {
+        value: 'server',
+    });
+export const browser = <T extends TObject>(
+    definition: SolutionFactory<T>,
+): SolutionFactory<T> & {[Kind]: 'browser'} =>
+    Object.defineProperty(definition as SolutionFactory<T> & {[Kind]: 'browser'}, Kind, {
+        value: 'browser',
+    });
 export const layer = (
     activation: Record<string, boolean | object>,
-): Record<string, boolean | object> => Object.defineProperty(activation, Kind, {value: 'layer'});
+): Record<string, boolean | object> & {[Kind]: 'layer'} =>
+    Object.defineProperty(activation, Kind, {value: 'layer'});
 export const adapter = <T, C = AdapterContext>(
     definition: IAdapterFactory<T, C>,
-): IAdapterFactory<T, C> => Object.defineProperty(definition, Kind, {value: 'adapter'});
+): IAdapterFactory<T, C> & {[Kind]: 'adapter'} =>
+    Object.defineProperty(definition as IAdapterFactory<T, C> & {[Kind]: 'adapter'}, Kind, {
+        value: 'adapter',
+    });
 export const orchestrator = <T, C = AdapterContext>(
     definition: IAdapterFactory<T, C>,
-): IAdapterFactory<T, C> => Object.defineProperty(definition, Kind, {value: 'orchestrator'});
+): IAdapterFactory<T, C> & {[Kind]: 'orchestrator'} =>
+    Object.defineProperty(definition as IAdapterFactory<T, C> & {[Kind]: 'orchestrator'}, Kind, {
+        value: 'orchestrator',
+    });
+
 export type Kinds =
     | 'lib'
     | 'validation'
@@ -822,12 +976,14 @@ export type Kinds =
     | 'browser'
     | 'adapter'
     | 'orchestrator'
-    | 'handler';
-export const kind = (what: {[Kind]: Kinds | undefined}): Kinds | undefined => what[Kind];
+    | 'handler'
+    | 'model'
+    | 'fixture'
+    | '';
+export const kind = (what: {[Kind]: Kinds | undefined}): Kinds => what[Kind] || '';
 
 export default {
     handler,
-    componentHandler,
     defineActions,
     library,
     validation,
@@ -837,5 +993,6 @@ export default {
     browser,
     adapter,
     orchestrator,
+    fixture,
     kind,
 };