@zlink-systems/nestjs 0.10.0

package/dist/handler-metadata.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendNestHandlerMetadata = appendNestHandlerMetadata;
+exports.readNestHandlerMetadata = readNestHandlerMetadata;
+exports.appendNestSpotActorHandlerMetadata = appendNestSpotActorHandlerMetadata;
+exports.readNestSpotActorHandlerMetadata = readNestSpotActorHandlerMetadata;
+exports.appendNestSpotHandlerMetadata = appendNestSpotHandlerMetadata;
+exports.readNestSpotHandlerMetadata = readNestSpotHandlerMetadata;
+exports.markNestSpotTimerHandler = markNestSpotTimerHandler;
+exports.appendNestSpotTimerHandlerMetadata = appendNestSpotTimerHandlerMetadata;
+exports.readNestSpotTimerHandlerMetadata = readNestSpotTimerHandlerMetadata;
+exports.hasNestSpotTimerHandlerMetadata = hasNestSpotTimerHandlerMetadata;
+exports.nestHandlerMetadataEntries = nestHandlerMetadataEntries;
+exports.nestSpotActorHandlerMetadataEntries = nestSpotActorHandlerMetadataEntries;
+exports.nestSpotHandlerMetadataEntries = nestSpotHandlerMetadataEntries;
+exports.nestSpotTimerHandlerMetadataEntries = nestSpotTimerHandlerMetadataEntries;
+const tokens_1 = require("./tokens");
+const handlerMetadata = new Map();
+const spotActorHandlerMetadata = new Map();
+const spotHandlerMetadata = new Map();
+const spotTimerHandlerMetadata = new Map();
+const spotTimerHandlerTokens = new Set();
+function appendNestHandlerMetadata(handlerToken, metadata) {
+    const current = readNestHandlerMetadata(handlerToken);
+    handlerMetadata.set(handlerToken, [...current, metadata]);
+    if (typeof handlerToken === 'function') {
+        Object.defineProperty(handlerToken, tokens_1.ZLINK_NEST_HANDLER_GROUP, {
+            configurable: true,
+            enumerable: false,
+            value: [...current, metadata],
+            writable: false
+        });
+    }
+}
+function readNestHandlerMetadata(handlerToken) {
+    if (handlerToken === undefined) {
+        return [];
+    }
+    let reflected;
+    if (typeof handlerToken === 'function') {
+        const metadataBySymbol = handlerToken;
+        reflected = metadataBySymbol[tokens_1.ZLINK_NEST_HANDLER_GROUP];
+    }
+    return handlerMetadata.get(handlerToken) ?? reflected ?? [];
+}
+function appendNestSpotActorHandlerMetadata(handlerToken, metadata) {
+    const current = readNestSpotActorHandlerMetadata(handlerToken);
+    spotActorHandlerMetadata.set(handlerToken, [...current, metadata]);
+}
+function readNestSpotActorHandlerMetadata(handlerToken) {
+    return handlerToken === undefined ? [] : spotActorHandlerMetadata.get(handlerToken) ?? [];
+}
+function appendNestSpotHandlerMetadata(handlerToken, metadata) {
+    const current = readNestSpotHandlerMetadata(handlerToken);
+    spotHandlerMetadata.set(handlerToken, [...current, metadata]);
+}
+function readNestSpotHandlerMetadata(handlerToken) {
+    return handlerToken === undefined ? [] : spotHandlerMetadata.get(handlerToken) ?? [];
+}
+function markNestSpotTimerHandler(handlerToken) {
+    spotTimerHandlerTokens.add(handlerToken);
+}
+function appendNestSpotTimerHandlerMetadata(handlerToken, metadata) {
+    const current = readNestSpotTimerHandlerMetadata(handlerToken);
+    spotTimerHandlerMetadata.set(handlerToken, [...current, metadata]);
+}
+function readNestSpotTimerHandlerMetadata(handlerToken) {
+    return handlerToken === undefined ? [] : spotTimerHandlerMetadata.get(handlerToken) ?? [];
+}
+function hasNestSpotTimerHandlerMetadata(handlerToken) {
+    return handlerToken !== undefined && spotTimerHandlerTokens.has(handlerToken);
+}
+function nestHandlerMetadataEntries() {
+    return [...handlerMetadata.entries()];
+}
+function nestSpotActorHandlerMetadataEntries() {
+    return [...spotActorHandlerMetadata.entries()];
+}
+function nestSpotHandlerMetadataEntries() {
+    return [...spotHandlerMetadata.entries()];
+}
+function nestSpotTimerHandlerMetadataEntries() {
+    return [...spotTimerHandlerMetadata.entries()];
+}

package/dist/http-client-module.d.ts

@@ -0,0 +1,28 @@
+import type { DynamicModule, InjectionToken, ModuleMetadata } from '@nestjs/common';
+import { ZLinkHttpClient, type HttpResponse, type ZLinkHttpClientBuilder, type ZLinkHttpRequestBuilder } from '@zlink-systems/http-client';
+export interface ZLinkNamedHttpClientOptions {
+    readonly name: string;
+    readonly baseUrl: string;
+    readonly configure?: (builder: ZLinkHttpClientBuilder) => void;
+}
+export interface ZLinkHttpClientModuleOptions {
+    readonly imports: ModuleMetadata['imports'];
+    readonly clients: readonly ZLinkNamedHttpClientOptions[];
+}
+export interface ZLinkServerHttpRequestBuilder extends ZLinkHttpRequestBuilder {
+    submit(): Promise<void>;
+    yield<T>(): Promise<HttpResponse<T>>;
+}
+export interface ZLinkServerHttpClient extends Omit<ZLinkHttpClient, 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options'> {
+    get(path: string): ZLinkServerHttpRequestBuilder;
+    post(path: string): ZLinkServerHttpRequestBuilder;
+    put(path: string): ZLinkServerHttpRequestBuilder;
+    delete(path: string): ZLinkServerHttpRequestBuilder;
+    patch(path: string): ZLinkServerHttpRequestBuilder;
+    head(path: string): ZLinkServerHttpRequestBuilder;
+    options(path: string): ZLinkServerHttpRequestBuilder;
+}
+export declare function zlinkHttpClientToken(name: string): InjectionToken;
+export declare class ZLinkHttpClientModule {
+    static forRoot(options: ZLinkHttpClientModuleOptions): DynamicModule;
+}

package/dist/http-client-module.js

@@ -0,0 +1,96 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ZLinkHttpClientModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkHttpClientModule = void 0;
+exports.zlinkHttpClientToken = zlinkHttpClientToken;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const http_client_1 = require("@zlink-systems/http-client");
+const framework_loader_1 = require("./framework-loader");
+const tokens_1 = require("./tokens");
+const ZLINK_HTTP_CLIENT_REGISTRY = Symbol.for('@zlink-systems/nestjs:http-client-registry');
+function zlinkHttpClientToken(name) {
+    const normalized = name.trim();
+    if (normalized.length === 0) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException('HTTP client registration name is required.');
+    }
+    return Symbol.for(`@zlink-systems/nestjs:http-client:${normalized}`);
+}
+class ZLinkHttpClientRegistry {
+    clients = new Map();
+    constructor(registrations, moduleRef) {
+        const runtime = new Proxy({}, {
+            get: (_target, property) => {
+                const current = moduleRef.get(tokens_1.ZLINK_FRAMEWORK_RUNTIME, { strict: false });
+                return Reflect.get(current, property);
+            }
+        });
+        const scheduler = framework_loader_1.framework.createIntegrationHttpExecutionScheduler(runtime);
+        for (const registration of registrations) {
+            const name = registration.name.trim();
+            zlinkHttpClientToken(name);
+            if (this.clients.has(name)) {
+                throw new framework_loader_1.framework.ZLinkConfigurationException(`HTTP client '${name}' is already registered.`);
+            }
+            const builder = http_client_1.ZLinkHttpClient.create(registration.baseUrl).executionScheduler(scheduler);
+            registration.configure?.(builder);
+            this.clients.set(name, builder.build());
+        }
+    }
+    get(name) {
+        const client = this.clients.get(name);
+        if (client === undefined) {
+            throw new framework_loader_1.framework.ZLinkConfigurationException(`HTTP client '${name}' is not registered.`);
+        }
+        return client;
+    }
+    async onModuleDestroy() {
+        await Promise.all([...this.clients.values()].map((client) => client.close()));
+        this.clients.clear();
+    }
+}
+let ZLinkHttpClientModule = ZLinkHttpClientModule_1 = class ZLinkHttpClientModule {
+    static forRoot(options) {
+        validateRegistrations(options.clients);
+        const registry = {
+            provide: ZLINK_HTTP_CLIENT_REGISTRY,
+            inject: [core_1.ModuleRef],
+            useFactory: (moduleRef) => new ZLinkHttpClientRegistry(options.clients, moduleRef)
+        };
+        const clients = options.clients.map((registration) => ({
+            provide: zlinkHttpClientToken(registration.name),
+            inject: [ZLINK_HTTP_CLIENT_REGISTRY],
+            useFactory: (owner) => owner.get(registration.name.trim())
+        }));
+        return {
+            module: ZLinkHttpClientModule_1,
+            imports: options.imports,
+            providers: [registry, ...clients],
+            exports: clients.map((provider) => providerToken(provider))
+        };
+    }
+};
+exports.ZLinkHttpClientModule = ZLinkHttpClientModule;
+exports.ZLinkHttpClientModule = ZLinkHttpClientModule = ZLinkHttpClientModule_1 = __decorate([
+    (0, common_1.Module)({})
+], ZLinkHttpClientModule);
+function validateRegistrations(registrations) {
+    const names = new Set();
+    for (const registration of registrations) {
+        const name = registration.name.trim();
+        zlinkHttpClientToken(name);
+        if (names.has(name)) {
+            throw new framework_loader_1.framework.ZLinkConfigurationException(`HTTP client '${name}' is already registered.`);
+        }
+        names.add(name);
+    }
+}
+function providerToken(provider) {
+    return typeof provider === 'function' ? provider : provider.provide;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import 'reflect-metadata';
+import type { ZLinkNestFrameworkOptionsBuilder } from './contracts';
+export type { ZLinkModuleFactoryOptions, ZLinkModuleOptions, ZLinkNestCodecRegistryBuilder, ZLinkNestClientServerChannelClientBuilder, ZLinkNestClientServerChannelRoleBuilder, ZLinkNestClientServerChannelServerBuilder, ZLinkNestEntrySpotActorRequestHandlerOptions, ZLinkNestEntrySpotActorSendHandlerOptions, ZLinkNestEntrySpotPacketHandlerOptions, ZLinkNestEntrySpotSubscriptionHandlerOptions, ZLinkNestFanoutChannelBuilder, ZLinkNestFrameworkAdditionalOptions, ZLinkNestFrameworkOptionsBuilder, ZLinkNestHandlerOptions, ZLinkNestModuleMetadata, ZLinkNestModuleRoleRoot, ZLinkNestProviderDiscoveryOptions, ZLinkNestProviderDiscoveryRoot, ZLinkNestMeshChannelBuilder, ZLinkNestMeshObjectClientBuilder, ZLinkNestMeshObjectRoleBuilder, ZLinkNestMeshObjectServerBuilder, ZLinkNestMeshNodeBuilder, ZLinkNestSpotActorRequestHandlerOptions, ZLinkNestSpotActorSendHandlerOptions, ZLinkNestSpotPacketHandlerOptions, ZLinkNestSpotSubscriptionHandlerOptions, ZLinkNestSpotTimerHandlerOptions, ZLinkNestStreamNodeBuilder, ZLinkNestTypeResolver } from './contracts';
+export * from './decorators';
+export * from './module';
+export * from './tokens';
+export * from './drain-health-indicator';
+export * from './http-client-module';
+export type { ZLinkNestHandlerKind } from './handler-metadata';
+export declare function zlinkFramework(): ZLinkNestFrameworkOptionsBuilder;

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zlinkFramework = zlinkFramework;
+require("reflect-metadata");
+const options_builder_1 = require("./options-builder");
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./tokens"), exports);
+__exportStar(require("./drain-health-indicator"), exports);
+__exportStar(require("./http-client-module"), exports);
+function zlinkFramework() {
+    return (0, options_builder_1.createZLinkNestFrameworkOptionsBuilder)();
+}

package/dist/internal-tokens.d.ts

@@ -0,0 +1,2 @@
+export declare const ZLINK_SPOT_HANDLE_RESOLVER: unique symbol;
+export declare const ZLINK_ACTOR_SPOT_HANDLE_RESOLVER: unique symbol;

package/dist/internal-tokens.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLINK_ACTOR_SPOT_HANDLE_RESOLVER = exports.ZLINK_SPOT_HANDLE_RESOLVER = void 0;
+exports.ZLINK_SPOT_HANDLE_RESOLVER = Symbol.for('@zlink-systems/framework:spot-ref-resolver');
+exports.ZLINK_ACTOR_SPOT_HANDLE_RESOLVER = Symbol.for('@zlink-systems/framework:actor-spot-ref-resolver');

package/dist/module.d.ts

@@ -0,0 +1,11 @@
+import type { DynamicModule, ModuleMetadata, Provider } from '@nestjs/common';
+import type { ZLinkFrameworkRegistration } from './framework-integration-contracts';
+import type { ZLinkModuleFactoryOptions, ZLinkModuleOptions, ZLinkNestModuleMetadata, ZLinkNestModuleRoleRoot, ZLinkNestProviderDiscoveryOptions } from './contracts';
+export declare function zlinkDiscoverProviders(rootDir: string, options?: ZLinkNestProviderDiscoveryOptions): Provider[];
+export declare function zlinkModule(metadata: ZLinkNestModuleMetadata): ClassDecorator;
+export declare function zlinkModule(roleRoot: ZLinkNestModuleRoleRoot, metadata: ModuleMetadata): ClassDecorator;
+export declare class ZLinkModule {
+    static forRoot(options?: ZLinkModuleOptions): DynamicModule;
+    static forRootFactory<TArgs extends unknown[]>(options: ZLinkModuleFactoryOptions<TArgs>): DynamicModule;
+}
+export declare function createZLinkDynamicModule(registration: ZLinkFrameworkRegistration): DynamicModule;

package/dist/module.js

@@ -0,0 +1,203 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var ZLinkModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkModule = void 0;
+exports.zlinkDiscoverProviders = zlinkDiscoverProviders;
+exports.zlinkModule = zlinkModule;
+exports.createZLinkDynamicModule = createZLinkDynamicModule;
+const node_module_1 = require("node:module");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const tokens_1 = require("./tokens");
+const handler_metadata_1 = require("./handler-metadata");
+const framework_loader_1 = require("./framework-loader");
+const options_builder_1 = require("./options-builder");
+const registration_composer_1 = require("./registration-composer");
+const providers_1 = require("./providers");
+const auto_discovery_marker_1 = require("./auto-discovery-marker");
+function zlinkDiscoverProviders(rootDir, options = {}) {
+    return [...loadDecoratedProviderModules(rootDir, options)];
+}
+function zlinkModule(metadataOrRoleRoot, metadata) {
+    const moduleMetadata = typeof metadataOrRoleRoot === 'string' ? metadata : metadataOrRoleRoot;
+    if (moduleMetadata === undefined) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException('zlinkModule metadata is required.');
+    }
+    const { providerDiscovery, providers, ...rest } = moduleMetadata;
+    const discoveredProviders = typeof metadataOrRoleRoot === 'string'
+        ? createDefaultProviderDiscoveryProviders(metadataOrRoleRoot)
+        : createProviderDiscoveryProviders(providerDiscovery);
+    return (0, common_1.Module)({
+        ...rest,
+        providers: [
+            ...(providers ?? []),
+            ...discoveredProviders
+        ]
+    });
+}
+function loadDecoratedProviderModules(rootDir, options) {
+    if (!node_fs_1.default.existsSync(rootDir)) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`ZLink provider discovery root does not exist: ${rootDir}`);
+    }
+    const providers = new Set();
+    const stat = node_fs_1.default.statSync(rootDir);
+    if (stat.isFile()) {
+        addDecoratedProviderModuleExports(providers, rootDir);
+        return providers;
+    }
+    for (const entry of node_fs_1.default.readdirSync(rootDir, { withFileTypes: true })) {
+        const fullPath = node_path_1.default.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            if (options.recursive === true) {
+                for (const provider of loadDecoratedProviderModules(fullPath, options)) {
+                    providers.add(provider);
+                }
+            }
+            continue;
+        }
+        if (entry.isFile()) {
+            addDecoratedProviderModuleExports(providers, fullPath);
+        }
+    }
+    return providers;
+}
+function addDecoratedProviderModuleExports(providers, filePath) {
+    if (!/\.(?:cjs|mjs|js)$/.test(filePath) || /\.d\.js$/.test(filePath)) {
+        return;
+    }
+    const source = node_fs_1.default.readFileSync(filePath, 'utf8');
+    if (!/(?:zlink(?:Request|Send|Publish|Spot|EntrySpot)[A-Za-z]*Handler|ZLinkPacket)/.test(source)) {
+        return;
+    }
+    const loaded = (0, node_module_1.createRequire)(__filename)(filePath);
+    for (const value of Object.values(loaded)) {
+        const frameworkMetadata = typeof value === 'function'
+            ? (value[Symbol.for('@zlink-systems/framework:decorator')] ?? [])
+            : [];
+        if (typeof value === 'function'
+            && ((0, handler_metadata_1.readNestHandlerMetadata)(value).length > 0
+                || (0, handler_metadata_1.readNestSpotActorHandlerMetadata)(value).length > 0
+                || (0, handler_metadata_1.readNestSpotHandlerMetadata)(value).length > 0
+                || (0, handler_metadata_1.hasNestSpotTimerHandlerMetadata)(value)
+                || (frameworkMetadata.some((entry) => entry.kind === 'packet')
+                    && typeof value.prototype?.handle === 'function'))) {
+            providers.add((0, auto_discovery_marker_1.markAutoDiscoveredProvider)(value));
+        }
+    }
+}
+let ZLinkModule = ZLinkModule_1 = class ZLinkModule {
+    static forRoot(options = (0, options_builder_1.createZLinkNestFrameworkOptionsBuilder)().build()) {
+        const resolvedOptions = (0, registration_composer_1.assertBuiltModuleOptions)(options);
+        if ((0, registration_composer_1.hasNestHandlerDiscovery)(resolvedOptions)) {
+            return createDiscoveringZLinkDynamicModule(resolvedOptions);
+        }
+        return createZLinkDynamicModule(framework_loader_1.framework.createFrameworkRegistration((0, registration_composer_1.createRegistrationOptions)(resolvedOptions)));
+    }
+    static forRootFactory(options) {
+        const registrationProvider = {
+            provide: tokens_1.ZLINK_FRAMEWORK_REGISTRATION,
+            inject: [...(options.inject ?? []), core_1.DiscoveryService, core_1.ModuleRef],
+            useFactory: async (...args) => {
+                const discovery = args[args.length - 2];
+                const moduleRef = args[args.length - 1];
+                const factoryArgs = args.slice(0, -2);
+                const resolvedOptions = (0, registration_composer_1.assertBuiltModuleOptions)(await options.useFactory(...factoryArgs));
+                return framework_loader_1.framework.createFrameworkRegistration((0, registration_composer_1.createDiscoveredOptions)(resolvedOptions, discovery, moduleRef));
+            }
+        };
+        return {
+            module: ZLinkModule_1,
+            imports: [...(options.imports ?? []), core_1.DiscoveryModule],
+            providers: [
+                registrationProvider,
+                {
+                    provide: tokens_1.ZLINK_FRAMEWORK_RUNTIME,
+                    inject: [tokens_1.ZLINK_FRAMEWORK_REGISTRATION, core_1.ModuleRef, core_1.DiscoveryService],
+                    useFactory: (registration, moduleRef, discovery) => (0, providers_1.createRuntimeHost)(registration, moduleRef, discovery)
+                },
+                ...(0, providers_1.alwaysAvailableClientProviders)(),
+                ...(0, providers_1.conditionalClientProvidersForFactory)()
+            ],
+            exports: [
+                tokens_1.ZLINK_FRAMEWORK_RUNTIME,
+                ...(0, providers_1.alwaysAvailableClientTokens)(),
+                ...(0, providers_1.conditionalClientTokens)()
+            ]
+        };
+    }
+};
+exports.ZLinkModule = ZLinkModule;
+exports.ZLinkModule = ZLinkModule = ZLinkModule_1 = __decorate([
+    (0, common_1.Module)({})
+], ZLinkModule);
+function createZLinkDynamicModule(registration) {
+    const providers = [
+        { provide: tokens_1.ZLINK_FRAMEWORK_REGISTRATION, useValue: registration },
+        {
+            provide: tokens_1.ZLINK_FRAMEWORK_RUNTIME,
+            inject: [core_1.ModuleRef, core_1.DiscoveryService],
+            useFactory: (moduleRef, discovery) => (0, providers_1.createRuntimeHost)(registration, moduleRef, discovery)
+        },
+        ...(0, providers_1.alwaysAvailableClientProviders)(registration),
+        ...(0, providers_1.conditionalClientProviders)(registration)
+    ];
+    return {
+        module: ZLinkModule,
+        imports: [core_1.DiscoveryModule],
+        providers,
+        exports: providers.map(providers_1.providerToken)
+    };
+}
+function createDiscoveringZLinkDynamicModule(options) {
+    const registrationProvider = {
+        provide: tokens_1.ZLINK_FRAMEWORK_REGISTRATION,
+        inject: [core_1.DiscoveryService, core_1.ModuleRef],
+        useFactory: (discovery, moduleRef) => framework_loader_1.framework.createFrameworkRegistration((0, registration_composer_1.createDiscoveredOptions)(options, discovery, moduleRef))
+    };
+    return {
+        module: ZLinkModule,
+        imports: [core_1.DiscoveryModule],
+        providers: [
+            registrationProvider,
+            {
+                provide: tokens_1.ZLINK_FRAMEWORK_RUNTIME,
+                inject: [tokens_1.ZLINK_FRAMEWORK_REGISTRATION, core_1.ModuleRef, core_1.DiscoveryService],
+                useFactory: (registration, moduleRef, discovery) => (0, providers_1.createRuntimeHost)(registration, moduleRef, discovery)
+            },
+            ...(0, providers_1.alwaysAvailableClientProviders)(),
+            ...(0, providers_1.conditionalClientProvidersForFactory)()
+        ],
+        exports: [
+            tokens_1.ZLINK_FRAMEWORK_RUNTIME,
+            ...(0, providers_1.alwaysAvailableClientTokens)(),
+            ...(0, providers_1.conditionalClientTokens)()
+        ]
+    };
+}
+function createProviderDiscoveryProviders(roots) {
+    return (roots ?? []).flatMap((root) => {
+        if (typeof root === 'string') {
+            return zlinkDiscoverProviders(root);
+        }
+        return zlinkDiscoverProviders(root.rootDir, root.options);
+    });
+}
+function createDefaultProviderDiscoveryProviders(roleRoot) {
+    return createProviderDiscoveryProviders(defaultProviderDiscoveryRoots(roleRoot));
+}
+function defaultProviderDiscoveryRoots(roleRoot) {
+    return node_fs_1.default.existsSync(roleRoot)
+        ? [{ rootDir: roleRoot, options: { recursive: true } }]
+        : [];
+}

package/dist/options-builder.d.ts

@@ -0,0 +1,2 @@
+import { type ZLinkNestFrameworkOptionsBuilder } from './contracts';
+export declare function createZLinkNestFrameworkOptionsBuilder(): ZLinkNestFrameworkOptionsBuilder;