@zlink-systems/nestjs 0.29.1 → 0.30.1

package/dist/contracts.d.ts

@@ -1,5 +1,5 @@
 import type { InjectionToken, ModuleMetadata } from '@nestjs/common';
-import type { Type, ZLinkActor, ZLinkActorFactory, ZLinkCodecExtension, ZLinkDispatchOptions, ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions, ZLinkEntrySpot, ZLinkHandlerFilter, ZLinkLocationStore, ZLinkLocationOptions, ZLinkRelocationStore, ZLinkActorFactoryBuilder, ZLinkInstanceSpotFactoryBuilder, ZLinkUserSpotFactoryBuilder, ZLinkInstanceSpot, ZLinkMeshNodeSocketConfig, ZLinkMeshPeerConnections, ZLinkMetricsOptions, ZLinkNetworkOptions, ZLinkMessageContext, ZLinkPublishMessageContext, ZLinkRouteMessageContext, ZLinkSession, ZLinkSessionFactory, ZLinkSpot, ZLinkSpotPublisherConfig, ZLinkStreamCompressionBuilder, ZLinkTimerOptions } from '@zlink-systems/framework';
+import type { Type, ZLinkActor, ZLinkActorFactory, ZLinkCodecExtension, ZLinkDispatchOptions, ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions, ZLinkEntrySpot, ZLinkHandlerFilter, ZLinkLocationStore, ZLinkLocationOptions, ZLinkRelocationStore, ZLinkActorFactoryBuilder, ZLinkInstanceSpotFactoryBuilder, ZLinkUserSpotFactoryBuilder, ZLinkInstanceSpot, ZLinkMeshNodeSocketConfig, ZLinkMeshPeerConnections, ZLinkMetricsOptions, ZLinkNetworkOptions, ZLinkMessageContext, ZLinkPublishMessageContext, ZLinkRouteMessageContext, ZLinkSession, ZLinkSessionFactory, ZLinkSpot, ZLinkStreamCompressionBuilder, ZLinkTimerOptions } from '@zlink-systems/framework';
 import type { ZLinkChannelOptions, ZLinkChannelPublishHandlerRegistration, ZLinkClientCapabilityOptions, ZLinkCodecRegistryOptions, ZLinkFrameworkRegistrationOptions, ZLinkPublisherCapabilityOptions, ZLinkSpotNodeOptions, ZLinkSpotNodeRegistrationOptions, ZLinkStreamNodeOptions, ZLinkWorkerOptions } from './framework-integration-contracts';
 export type MutableCodecRegistryOptions = {
     serializers: NonNullable<ZLinkCodecRegistryOptions['serializers']>[number][];
@@ -23,6 +23,7 @@ export type Mutable<T> = {
     -readonly [K in keyof T]: T[K];
 };
 export interface InternalZLinkNestFanoutChannelOptions extends ZLinkNestHandlerDiscoveryOptions {
+    readonly sendTimeoutMs?: number;
     readonly routingId?: string;
     readonly routingIdPrefix?: string;
     readonly noDrop?: boolean;
@@ -157,6 +158,7 @@ export interface ZLinkNestFanoutChannelBuilder extends ZLinkNestFrameworkOptions
     routingId(routingId: string | undefined): this;
     setRoutingIdPrefix(prefix: string): this;
     setNoDrop(noDrop?: boolean): this;
+    setSendTimeout(timeoutMs: number): this;
     enableSubscriber(endpoint?: string | readonly string[]): this;
     subscribe(topic: string): this;
     addPublishHandler(packetName: string, handlerType: Type): this;
@@ -203,7 +205,6 @@ export interface ZLinkNestMeshNodeBuilder extends ZLinkNestFrameworkOptionsBuild
     setActivationConcurrency(limit: number): this;
     setInstanceSpotIdleTimeout(timeoutMs: number): this;
     configureRouterSocket(): ZLinkMeshNodeSocketConfig;
-    configureSpotPublisher(): ZLinkSpotPublisherConfig;
     peerConnections(): ZLinkMeshPeerConnections;
     objects(): ZLinkNestMeshObjectRoleBuilder;
     addSendHandler(packetName: string, handlerType: Type): this;

package/dist/framework-integration-contracts.d.ts

@@ -110,6 +110,7 @@ export interface ZLinkChannelOptions {
     readonly routingId?: string;
     readonly routingIdPrefix?: string;
     readonly noDrop?: boolean;
+    readonly sendTimeoutMs?: number;
     readonly requestTimeoutMs?: number;
     readonly client?: ZLinkClientCapabilityOptions;
     readonly publisher?: ZLinkPublisherCapabilityOptions;
@@ -203,11 +204,6 @@ export interface ZLinkSpotNodeOptions {
     readonly routeSendHandlers?: readonly ZLinkRouteMeshSendHandlerRegistration[];
     readonly routeRequestHandlers?: readonly ZLinkRouteMeshRequestHandlerRegistration[];
     readonly requestTimeoutMs?: number;
-    readonly publisherConfig?: {
-        readonly sendHighWaterMark?: number;
-        readonly sendTimeoutMs?: number;
-        readonly lingerMs?: number;
-    };
     readonly entrySpotTimerHandlers?: readonly ZLinkEntrySpotTimerHandlerRegistration[];
     readonly entrySpotPacketHandlers?: readonly ZLinkEntrySpotPacketHandlerRegistration[];
     readonly entrySpotSubscriptionHandlers?: readonly ZLinkEntrySpotSubscriptionHandlerRegistration[];

package/dist/framework-loader.d.ts

@@ -1,12 +1,21 @@
-import type { Type, ZLinkActorClient, ZLinkActorManager, ZLinkChannelClient, ZLinkCodecRegistrar, ZLinkCodecRegistryBuilder, ZLinkDispatchOptions, ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions, ZLinkLocationOptionValues, ZLinkLocationOptions, ZLinkEntrySpot, ZLinkFanoutClient, ZLinkHandlerFilterContext, ZLinkRouteClient, ZLinkSpot, ZLinkSpotManager, ZLinkSpotOutbound, ZLinkSpotPublisherClient, ZLinkStreamCompressionBuilder, ZLinkStreamCompressionCodec } from '@zlink-systems/framework';
+import type { Type, ZLinkActorClient, ZLinkActorManager, ZLinkChannelClient, ZLinkCodecRegistrar, ZLinkCodecRegistryBuilder, ZLinkDispatchOptions, ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions, ZLinkLocationOptionValues, ZLinkLocationOptions, ZLinkMessageContext, ZLinkEntrySpot, ZLinkFanoutClient, ZLinkHandlerFilterContext, ZLinkRouteClient, ZLinkSpot, ZLinkSpotManager, ZLinkSpotOutbound, ZLinkSpotPublisherClient, ZLinkStreamCompressionBuilder, ZLinkStreamCompressionCodec } from '@zlink-systems/framework';
 import type { ZLinkHttpExecutionScheduler } from '@zlink-systems/http-client';
 import type { ZLinkCodecSerializerRegistration, ZLinkFrameworkRegistration, ZLinkFrameworkRegistrationOptions, ZLinkNestIntegrationRuntimeHost, ZLinkProviderResolver, ZLinkStreamCodecRegistration } from './framework-integration-contracts';
 export type FrameworkRuntimeHost = ZLinkNestIntegrationRuntimeHost;
+interface HandlerResolver {
+    resolve<T>(type: Type<T>): Promise<T>;
+}
 interface FrameworkIntegrationModule {
     ZLinkSpotActorSend(packetName?: string): MethodDecorator;
     ZLinkSpotActorRequest(packetName?: string): MethodDecorator;
     disposeIntegrationHandler(instance: unknown): Promise<void>;
     disposeIntegrationHandlers(instances: readonly unknown[]): Promise<void>;
+    registerIntegrationHandlerInstanceScopeFactory(resolver: ZLinkProviderResolver, factory: {
+        prepare?(type: Type): void;
+        create(context?: ZLinkMessageContext): HandlerResolver & {
+            dispose(): Promise<void>;
+        };
+    }): void;
     readonly MAX_LISTENER_PORT: number;
     readonly ZLINK_MAX_PUBLIC_WEIGHT: number;
     readonly ZLINK_MAX_CAPACITY: number;
@@ -39,6 +48,7 @@ interface FrameworkIntegrationModule {
     createIntegrationSpotOutbound(runtime: ZLinkNestIntegrationRuntimeHost): ZLinkSpotOutbound;
     createIntegrationHttpExecutionScheduler(runtime: ZLinkNestIntegrationRuntimeHost): ZLinkHttpExecutionScheduler;
     validateActorTransferTimeout(timeoutMs: number): number;
+    requireValidSendTimeoutMs(label: string, value: number | undefined): void;
     validateMessageFollowDuration(timeoutMs: number): number;
     validateSessionReplacementCallbackTimeout(timeoutMs: number): number;
     validateRoutingIdPrefix(prefix: string): string;
@@ -59,9 +69,7 @@ interface FrameworkIntegrationModule {
     registerRelocationStore(options: {
         relocationStoreInstance?: import('@zlink-systems/framework').ZLinkRelocationStore;
     }, store: import('@zlink-systems/framework').ZLinkRelocationStore): void;
-    registerIntegrationHandlerFilterScope(resolver: ZLinkProviderResolver, runner: (context: ZLinkHandlerFilterContext, callback: (scope: {
-        resolve<T>(type: Type<T>): Promise<T>;
-    }) => Promise<unknown>) => Promise<unknown>): void;
+    registerIntegrationHandlerFilterScope(resolver: ZLinkProviderResolver, runner: (context: ZLinkHandlerFilterContext, callback: (scope: HandlerResolver) => Promise<unknown>) => Promise<unknown>): void;
 }
 export declare const framework: FrameworkIntegrationModule;
 export {};

package/dist/framework-loader.js

@@ -20,7 +20,8 @@ function loadFramework() {
         isValidPositiveCapacity: internal.isValidPositiveCapacity,
         isValidListenerPort: internal.isValidListenerPort,
         isValidCapacity: internal.isValidCapacity,
-        requirePublicWeight: internal.requirePublicWeight
+        requirePublicWeight: internal.requirePublicWeight,
+        requireValidSendTimeoutMs: internal.requireValidSendTimeoutMs
     };
 }
 // The Nest package is a workspace adapter. It loads the framework's private

package/dist/handler-adapters.d.ts

@@ -2,10 +2,11 @@ import { ModuleRef } from '@nestjs/core';
 import type { ZLinkChannelOptions } from './framework-integration-contracts';
 import type { ZLinkNestManualHandlerOptions } from './contracts';
 import type { DiscoveredNestProvider } from './provider-discovery';
-export declare function createDiscoveredRequestHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['requestHandlers']>;
-export declare function createDiscoveredSendHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef): NonNullable<NonNullable<ZLinkChannelOptions['routeMesh']>['sendHandlers']>;
-export declare function createDiscoveredChannelSendHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['sendHandlers']>;
-export declare function createDiscoveredPublishHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['publishHandlers']>;
-export declare function createManualRequestHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['requestHandlers']>;
-export declare function createManualPublishHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['publishHandlers']>;
-export declare function createManualSendHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef): NonNullable<ZLinkChannelOptions['sendHandlers']>;
+import { type NestHandlerFactories } from './providers';
+export declare function createDiscoveredRequestHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['requestHandlers']>;
+export declare function createDiscoveredSendHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<NonNullable<ZLinkChannelOptions['routeMesh']>['sendHandlers']>;
+export declare function createDiscoveredChannelSendHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['sendHandlers']>;
+export declare function createDiscoveredPublishHandlers(providerRefs: readonly DiscoveredNestProvider[], handlerGroups: readonly string[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['publishHandlers']>;
+export declare function createManualRequestHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['requestHandlers']>;
+export declare function createManualPublishHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['publishHandlers']>;
+export declare function createManualSendHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef, factories?: NestHandlerFactories): NonNullable<ZLinkChannelOptions['sendHandlers']>;

package/dist/handler-adapters.js

@@ -11,66 +11,65 @@ const core_1 = require("@nestjs/core");
 const framework_loader_1 = require("./framework-loader");
 const dispatch_scope_1 = require("./dispatch-scope");
 const providers_1 = require("./providers");
-function createDiscoveredRequestHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'request', moduleRef, (ref, metadata) => ({
+function createDiscoveredRequestHandlers(providerRefs, handlerGroups, moduleRef, factories = new Map()) {
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'request', moduleRef, factories, (ref, metadata, factory) => ({
         async handle(payload, context) {
-            const result = await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
+            const result = await invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context);
             return metadata.encodeResult === undefined
                 ? result
                 : metadata.encodeResult(result, context);
         }
     }));
 }
-function createDiscoveredSendHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, (ref, metadata) => ({
+function createDiscoveredSendHandlers(providerRefs, handlerGroups, moduleRef, factories = new Map()) {
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, factories, (ref, metadata, factory) => ({
         async handle(payload, context) {
-            await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
+            await invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context);
         }
     }));
 }
-function createDiscoveredChannelSendHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, (ref, metadata) => ({
+function createDiscoveredChannelSendHandlers(providerRefs, handlerGroups, moduleRef, factories = new Map()) {
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'send', moduleRef, factories, (ref, metadata, factory) => ({
         async handle(payload, context) {
-            await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
+            await invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context);
         }
     }));
 }
-function createDiscoveredPublishHandlers(providerRefs, handlerGroups, moduleRef) {
-    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'publish', moduleRef, (ref, metadata) => ({
+function createDiscoveredPublishHandlers(providerRefs, handlerGroups, moduleRef, factories = new Map()) {
+    return createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, 'publish', moduleRef, factories, (ref, metadata, factory) => ({
         async handle(payload, context) {
-            await invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context);
+            await invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context);
         }
     }));
 }
-function createManualRequestHandlers(handlerTypes, moduleRef) {
-    return createManualHandlerRegistrations(handlerTypes, moduleRef, (result) => result);
+function createManualRequestHandlers(handlerTypes, moduleRef, factories = new Map()) {
+    return createManualHandlerRegistrations(handlerTypes, moduleRef, factories, (result) => result);
 }
-function createManualPublishHandlers(handlerTypes, moduleRef) {
-    return createManualHandlerRegistrations(handlerTypes, moduleRef, () => undefined);
+function createManualPublishHandlers(handlerTypes, moduleRef, factories = new Map()) {
+    return createManualHandlerRegistrations(handlerTypes, moduleRef, factories, () => undefined);
 }
-function createManualSendHandlers(handlerTypes, moduleRef) {
-    return createManualHandlerRegistrations(handlerTypes, moduleRef, () => undefined);
+function createManualSendHandlers(handlerTypes, moduleRef, factories = new Map()) {
+    return createManualHandlerRegistrations(handlerTypes, moduleRef, factories, () => undefined);
 }
-function createManualHandlerRegistrations(handlerTypes, moduleRef, result) {
+function createManualHandlerRegistrations(handlerTypes, moduleRef, factories, result) {
     return (handlerTypes ?? []).map((registration) => {
-        (0, providers_1.validateNestConstructorDependencies)(moduleRef, registration.handlerType);
+        const factory = (0, providers_1.registeredNestHandlerFactory)(factories, registration.handlerType, moduleRef);
         return {
             packetName: registration.packetName,
             handler: {
                 async handle(payload, context) {
-                    return result(await invokeManualHandler(moduleRef, registration.handlerType, payload, context));
+                    return result(await invokeManualHandler(moduleRef, registration.handlerType, factory, payload, context));
                 }
             }
         };
     });
 }
-function createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, kind, moduleRef, createHandler) {
+function createDiscoveredHandlerRegistrations(providerRefs, handlerGroups, kind, moduleRef, factories, createHandler) {
     const descriptors = createDiscoveredHandlerDescriptors(providerRefs, handlerGroups, kind);
     return descriptors.map(({ ref, metadata }) => {
-        (0, providers_1.validateNestConstructorDependencies)(moduleRef, ref.handlerKey);
         return {
             packetName: metadata.packetName,
-            handler: createHandler(ref, metadata)
+            handler: createHandler(ref, metadata, (0, providers_1.registeredNestHandlerFactory)(factories, ref.handlerKey, moduleRef))
         };
     });
 }
@@ -99,8 +98,8 @@ function createDiscoveredHandlerDescriptors(providerRefs, handlerGroups, kind) {
     }
     return selected;
 }
-async function invokeDiscoveredHandler(moduleRef, ref, metadata, payload, context) {
-    const instance = await resolveHandlerInstance(moduleRef, ref.handlerKey, context);
+async function invokeDiscoveredHandler(moduleRef, ref, metadata, factory, payload, context) {
+    const instance = await resolveHandlerInstance(moduleRef, factory, context);
     try {
         const method = instance[metadata.methodName];
         if (typeof method !== 'function') {
@@ -112,8 +111,8 @@ async function invokeDiscoveredHandler(moduleRef, ref, metadata, payload, contex
         await framework_loader_1.framework.disposeIntegrationHandler(instance);
     }
 }
-async function invokeManualHandler(moduleRef, handlerType, payload, context) {
-    const instance = await resolveHandlerInstance(moduleRef, handlerType, context);
+async function invokeManualHandler(moduleRef, handlerType, factory, payload, context) {
+    const instance = await resolveHandlerInstance(moduleRef, factory, context);
     try {
         const method = instance.handle;
         if (typeof method !== 'function') {
@@ -125,13 +124,13 @@ async function invokeManualHandler(moduleRef, handlerType, payload, context) {
         await framework_loader_1.framework.disposeIntegrationHandler(instance);
     }
 }
-async function resolveHandlerInstance(moduleRef, handlerType, context) {
+async function resolveHandlerInstance(moduleRef, factory, context) {
     const currentContextId = (0, dispatch_scope_1.currentNestDispatchContext)();
     const contextId = currentContextId ?? core_1.ContextIdFactory.create();
     if (currentContextId === undefined) {
         moduleRef.registerRequestByContextId({ zlinkContext: context }, contextId);
     }
-    return (await (0, providers_1.createNestHandlerInstance)(moduleRef, contextId, new Map(), handlerType));
+    return (await factory(moduleRef, contextId, new Map()));
 }
 function decodePayload(metadata, payload, context) {
     if (Buffer.isBuffer(payload) || payload instanceof Uint8Array) {

package/dist/module.js

@@ -107,7 +107,7 @@ let ZLinkModule = ZLinkModule_1 = class ZLinkModule {
                 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 (0, registration_composer_1.createDiscoveredRegistration)(resolvedOptions, discovery, moduleRef);
             }
         };
         return {
@@ -158,7 +158,7 @@ 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))
+        useFactory: (discovery, moduleRef) => (0, registration_composer_1.createDiscoveredRegistration)(options, discovery, moduleRef)
     };
     return {
         module: ZLinkModule,

package/dist/options-builder.js

@@ -268,10 +268,15 @@ class DefaultZLinkNestFanoutChannelBuilder extends ZLinkNestOptionsBuilder {
         this.channelOptions.routingIdPrefix = framework_loader_1.framework.validateRoutingIdPrefix(prefix);
         return this;
     }
-    setNoDrop(noDrop) {
+    setNoDrop(noDrop = true) {
         this.channelOptions.noDrop = noDrop;
         return this;
     }
+    setSendTimeout(timeoutMs) {
+        framework_loader_1.framework.requireValidSendTimeoutMs(`Fanout channel '${this.name}' send timeout`, timeoutMs);
+        this.channelOptions.sendTimeoutMs = timeoutMs;
+        return this;
+    }
     enableSubscriber(endpoint) {
         const mode = endpoint === undefined ? 'automatic' : 'manual';
         if (this.subscriberMode !== undefined && this.subscriberMode !== mode) {
@@ -584,10 +589,6 @@ class DefaultZLinkNestMeshNodeBuilder extends ZLinkNestOptionsBuilder {
         this.spotOptions.router ??= {};
         return this.spotOptions.router;
     }
-    configureSpotPublisher() {
-        this.spotOptions.publisherConfig ??= {};
-        return this.spotOptions.publisherConfig;
-    }
     peerConnections() {
         this.spotOptions.router ??= {};
         return new DefaultZLinkNestMeshPeerConnections(this.spotOptions.router);

package/dist/providers.d.ts

@@ -10,7 +10,12 @@ export declare function conditionalClientProviders(registration: ZLinkFrameworkR
 export declare function conditionalClientProvidersForFactory(registration?: ZLinkFrameworkRegistration): Provider[];
 export declare function conditionalClientTokens(): InjectionToken[];
 export declare function createRuntimeHost(registration: ZLinkFrameworkRegistration, moduleRef: ModuleRef, discovery: DiscoveryService): RuntimeHostWithNestLifecycle;
-export declare function createNestHandlerInstance<T>(moduleRef: ModuleRef, contextId: import('@nestjs/core').ContextId, dependencies: Map<unknown, Promise<unknown>>, type: Type<T>): Promise<T>;
-export declare function validateNestConstructorDependencies(moduleRef: ModuleRef, type: Type): void;
+export type NestHandlerFactories = Map<Type, NestHandlerFactory>;
+export declare function nestHandlerFactories(registration: ZLinkFrameworkRegistration, prepared?: NestHandlerFactories): NestHandlerFactories;
+export declare function registeredNestHandlerFactory<T>(factories: NestHandlerFactories, type: Type<T>, moduleRef: ModuleRef): NestHandlerFactory<T>;
+export type NestHandlerFactory<T = unknown> = ((moduleRef: ModuleRef, contextId: import('@nestjs/core').ContextId, dependencies: Map<unknown, unknown>) => T | Promise<T>) & {
+    readonly scopeFree?: () => T;
+};
+export declare function prepareNestHandlerFactory<T>(type: Type<T>, moduleRef?: ModuleRef): NestHandlerFactory<T>;
 export declare function providerToken(provider: Provider): InjectionToken;
 export {};