@zlink-systems/nestjs 0.25.0 → 0.27.0

package/dist/dispatch-scope.d.ts

@@ -1,5 +1,4 @@
-import type { Type, ZLinkMessageContext } from '@zlink-systems/framework';
+import type { ZLinkMessageContext } from '@zlink-systems/framework';
 import type { ContextId, ModuleRef } from '@nestjs/core';
 export declare function runInNestDispatchScope<T>(moduleRef: ModuleRef, context: ZLinkMessageContext, callback: () => Promise<T>): Promise<T>;
-export declare function resolveInNestDispatchScope<T>(moduleRef: ModuleRef, type: Type<T>): Promise<T>;
 export declare function currentNestDispatchContext(): ContextId | undefined;

package/dist/dispatch-scope.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runInNestDispatchScope = runInNestDispatchScope;
-exports.resolveInNestDispatchScope = resolveInNestDispatchScope;
 exports.currentNestDispatchContext = currentNestDispatchContext;
 const node_async_hooks_1 = require("node:async_hooks");
 const core_1 = require("@nestjs/core");
@@ -11,9 +10,6 @@ async function runInNestDispatchScope(moduleRef, context, callback) {
     moduleRef.registerRequestByContextId({ zlinkContext: context }, contextId);
     return dispatchContext.run(contextId, callback);
 }
-async function resolveInNestDispatchScope(moduleRef, type) {
-    return await moduleRef.resolve(type, dispatchContext.getStore(), { strict: false });
-}
 function currentNestDispatchContext() {
     return dispatchContext.getStore();
 }

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

@@ -9,7 +9,7 @@ export interface ZLinkWorkerOptions {
     readonly maxThreads: number;
     readonly idleTimeoutMs: number;
 }
-export interface ZLinkNestIntegrationRuntimeHost extends Pick<import('@zlink-systems/framework').ZLinkFrameworkRuntime, 'shutdown'> {
+export interface ZLinkNestIntegrationRuntimeHost extends Pick<import('@zlink-systems/framework').ZLinkFrameworkRuntime, 'shutdown' | 'getListenerStatus'> {
     readonly channelRuntimeOptions: unknown;
     readonly routeMeshRuntimeOptions: import('@zlink-systems/framework').ZLinkRouteMeshRuntimeOptions;
     readonly boundSessionFactory: unknown;

package/dist/framework-loader.d.ts

@@ -3,8 +3,17 @@ 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 FrameworkIntegrationModule {
+    ZLinkSpotActorSend(packetName?: string): MethodDecorator;
+    ZLinkSpotActorRequest(packetName?: string): MethodDecorator;
+    disposeIntegrationHandler(instance: unknown): Promise<void>;
+    disposeIntegrationHandlers(instances: readonly unknown[]): Promise<void>;
+    readonly MAX_LISTENER_PORT: number;
+    readonly ZLINK_MAX_PUBLIC_WEIGHT: number;
+    readonly ZLINK_MAX_CAPACITY: number;
+    readonly ZLINK_MAX_STABLE_TYPE_BYTES: number;
     readonly ZLinkConfigurationException: new (message: string) => Error;
     createFrameworkRegistration(options: ZLinkFrameworkRegistrationOptions): ZLinkFrameworkRegistration;
+    normalizeFrameworkRegistration(options: ZLinkFrameworkRegistrationOptions): ZLinkFrameworkRegistration;
     hasActorManager(registration: ZLinkFrameworkRegistration): boolean;
     hasSpotNode(registration: ZLinkFrameworkRegistration): boolean;
     hasSpotPublisherClient(registration: ZLinkFrameworkRegistration): boolean;
@@ -33,6 +42,11 @@ interface FrameworkIntegrationModule {
     validateMessageFollowDuration(timeoutMs: number): number;
     validateSessionReplacementCallbackTimeout(timeoutMs: number): number;
     validateRoutingIdPrefix(prefix: string): string;
+    isValidPublicWeight(value: number): boolean;
+    requirePublicWeight(value: number, label: string): number;
+    isValidPositiveCapacity(value: number): boolean;
+    isValidListenerPort(value: number): boolean;
+    isValidCapacity(value: number): boolean;
     registerEntrySpot(options: {
         entrySpotType?: Type<ZLinkEntrySpot>;
     }, entrySpotType: Type<ZLinkEntrySpot>): void;
@@ -42,6 +56,9 @@ interface FrameworkIntegrationModule {
     registerActorFactory(options: {
         actorFactories?: Record<string, Type>;
     }, actorType: string, factoryType: Type): void;
+    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;

package/dist/framework-loader.js

@@ -9,7 +9,19 @@ const node_path_1 = __importDefault(require("node:path"));
 function loadFramework() {
     const requireFramework = (0, node_module_1.createRequire)(__filename);
     const frameworkEntry = requireFramework.resolve('@zlink-systems/framework');
-    return requireFramework(node_path_1.default.join(node_path_1.default.dirname(frameworkEntry), 'nest-integration'));
+    const internal = requireFramework(node_path_1.default.join(node_path_1.default.dirname(frameworkEntry), 'internal'));
+    return {
+        ...requireFramework(node_path_1.default.join(node_path_1.default.dirname(frameworkEntry), 'nest-integration')),
+        MAX_LISTENER_PORT: internal.MAX_LISTENER_PORT,
+        ZLINK_MAX_PUBLIC_WEIGHT: internal.ZLINK_MAX_PUBLIC_WEIGHT,
+        ZLINK_MAX_CAPACITY: internal.ZLINK_MAX_CAPACITY,
+        ZLINK_MAX_STABLE_TYPE_BYTES: internal.ZLINK_MAX_STABLE_TYPE_BYTES,
+        isValidPublicWeight: internal.isValidPublicWeight,
+        isValidPositiveCapacity: internal.isValidPositiveCapacity,
+        isValidListenerPort: internal.isValidListenerPort,
+        isValidCapacity: internal.isValidCapacity,
+        requirePublicWeight: internal.requirePublicWeight
+    };
 }
 // The Nest package is a workspace adapter. It loads the framework's private
 // composition bridge without turning that bridge into a package subpath.

package/dist/handler-adapters.d.ts

@@ -9,5 +9,3 @@ export declare function createDiscoveredPublishHandlers(providerRefs: readonly D
 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']>;
-export declare function createManualRouteSendHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef): NonNullable<NonNullable<ZLinkChannelOptions['routeMesh']>['sendHandlers']>;
-export declare function createManualRouteRequestHandlers(handlerTypes: readonly ZLinkNestManualHandlerOptions[] | undefined, moduleRef: ModuleRef): NonNullable<NonNullable<ZLinkChannelOptions['routeMesh']>['requestHandlers']>;

package/dist/handler-adapters.js

@@ -7,8 +7,6 @@ exports.createDiscoveredPublishHandlers = createDiscoveredPublishHandlers;
 exports.createManualRequestHandlers = createManualRequestHandlers;
 exports.createManualPublishHandlers = createManualPublishHandlers;
 exports.createManualSendHandlers = createManualSendHandlers;
-exports.createManualRouteSendHandlers = createManualRouteSendHandlers;
-exports.createManualRouteRequestHandlers = createManualRouteRequestHandlers;
 const core_1 = require("@nestjs/core");
 const framework_loader_1 = require("./framework-loader");
 const dispatch_scope_1 = require("./dispatch-scope");
@@ -53,12 +51,6 @@ function createManualPublishHandlers(handlerTypes, moduleRef) {
 function createManualSendHandlers(handlerTypes, moduleRef) {
     return createManualHandlerRegistrations(handlerTypes, moduleRef, () => undefined);
 }
-function createManualRouteSendHandlers(handlerTypes, moduleRef) {
-    return createManualHandlerRegistrations(handlerTypes, moduleRef, () => undefined);
-}
-function createManualRouteRequestHandlers(handlerTypes, moduleRef) {
-    return createManualHandlerRegistrations(handlerTypes, moduleRef, (result) => result);
-}
 function createManualHandlerRegistrations(handlerTypes, moduleRef, result) {
     return (handlerTypes ?? []).map((registration) => ({
         packetName: registration.packetName,
@@ -111,7 +103,7 @@ async function invokeDiscoveredHandler(moduleRef, ref, metadata, payload, contex
         return await method.call(instance, decodePayload(metadata, payload, context), context);
     }
     finally {
-        await (0, providers_1.disposeNestOwnedHandler)(instance);
+        await framework_loader_1.framework.disposeIntegrationHandler(instance);
     }
 }
 async function invokeManualHandler(moduleRef, handlerType, payload, context) {
@@ -124,7 +116,7 @@ async function invokeManualHandler(moduleRef, handlerType, payload, context) {
         return await method.call(instance, decodePayload(undefined, payload, context), context);
     }
     finally {
-        await (0, providers_1.disposeNestOwnedHandler)(instance);
+        await framework_loader_1.framework.disposeIntegrationHandler(instance);
     }
 }
 async function resolveHandlerInstance(moduleRef, handlerType, context) {

package/dist/handler-metadata.d.ts

@@ -14,7 +14,6 @@ export type ZLinkNestSpotActorHandlerKind = 'spotActorSend' | 'spotActorRequest'
 export interface ZLinkNestSpotActorHandlerMetadata {
     readonly kind: ZLinkNestSpotActorHandlerKind;
     readonly packetName: string;
-    readonly methodName: string;
     readonly handlerType: Type;
     readonly actor: ZLinkNestTypeResolver<ZLinkActor>;
     readonly spot?: ZLinkNestTypeResolver<ZLinkSpot>;
@@ -40,7 +39,9 @@ export interface ZLinkNestSpotTimerHandlerMetadata {
 }
 export declare function appendNestHandlerMetadata(handlerToken: InjectionToken, metadata: ZLinkNestHandlerMetadata): void;
 export declare function readNestHandlerMetadata(handlerToken: InjectionToken | undefined): readonly ZLinkNestHandlerMetadata[];
-export declare function appendNestSpotActorHandlerMetadata(handlerToken: InjectionToken, metadata: ZLinkNestSpotActorHandlerMetadata): void;
+export declare function appendNestSpotActorHandlerMetadata(handlerToken: InjectionToken, metadata: ZLinkNestSpotActorHandlerMetadata & {
+    readonly methodName: string;
+}): void;
 export declare function readNestSpotActorHandlerMetadata(handlerToken: InjectionToken | undefined): readonly ZLinkNestSpotActorHandlerMetadata[];
 export declare function appendNestSpotHandlerMetadata(handlerToken: InjectionToken, metadata: ZLinkNestSpotHandlerMetadata): void;
 export declare function readNestSpotHandlerMetadata(handlerToken: InjectionToken | undefined): readonly ZLinkNestSpotHandlerMetadata[];

package/dist/handler-metadata.js

@@ -15,6 +15,7 @@ exports.nestSpotActorHandlerMetadataEntries = nestSpotActorHandlerMetadataEntrie
 exports.nestSpotHandlerMetadataEntries = nestSpotHandlerMetadataEntries;
 exports.nestSpotTimerHandlerMetadataEntries = nestSpotTimerHandlerMetadataEntries;
 const tokens_1 = require("./tokens");
+const framework_loader_1 = require("./framework-loader");
 const handlerMetadata = new Map();
 const spotActorHandlerMetadata = new Map();
 const spotHandlerMetadata = new Map();
@@ -44,8 +45,13 @@ function readNestHandlerMetadata(handlerToken) {
     return handlerMetadata.get(handlerToken) ?? reflected ?? [];
 }
 function appendNestSpotActorHandlerMetadata(handlerToken, metadata) {
+    const { methodName, ...registration } = metadata;
+    const decorator = metadata.kind === 'spotActorSend' || metadata.kind === 'entrySpotActorSend'
+        ? framework_loader_1.framework.ZLinkSpotActorSend(metadata.packetName)
+        : framework_loader_1.framework.ZLinkSpotActorRequest(metadata.packetName);
+    decorator(metadata.handlerType.prototype, methodName, {});
     const current = readNestSpotActorHandlerMetadata(handlerToken);
-    spotActorHandlerMetadata.set(handlerToken, [...current, metadata]);
+    spotActorHandlerMetadata.set(handlerToken, [...current, registration]);
 }
 function readNestSpotActorHandlerMetadata(handlerToken) {
     return handlerToken === undefined ? [] : (spotActorHandlerMetadata.get(handlerToken) ?? []);

package/dist/http-client-module.js

@@ -14,6 +14,7 @@ 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 providers_1 = require("./providers");
 const ZLINK_HTTP_CLIENT_REGISTRY = Symbol.for('@zlink-systems/nestjs:http-client-registry');
 function zlinkHttpClientToken(name) {
     const normalized = name.trim();
@@ -74,7 +75,7 @@ let ZLinkHttpClientModule = ZLinkHttpClientModule_1 = class ZLinkHttpClientModul
             module: ZLinkHttpClientModule_1,
             imports: options.imports,
             providers: [registry, ...clients],
-            exports: clients.map((provider) => providerToken(provider))
+            exports: clients.map((provider) => (0, providers_1.providerToken)(provider))
         };
     }
 };
@@ -93,6 +94,3 @@ function validateRegistrations(registrations) {
         names.add(name);
     }
 }
-function providerToken(provider) {
-    return typeof provider === 'function' ? provider : provider.provide;
-}

package/dist/module.js

@@ -96,10 +96,7 @@ function addDecoratedProviderModuleExports(providers, filePath) {
 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)));
+        return createDiscoveringZLinkDynamicModule(resolvedOptions);
     }
     static forRootFactory(options) {
         const registrationProvider = {
@@ -157,6 +154,7 @@ function createZLinkDynamicModule(registration) {
     };
 }
 function createDiscoveringZLinkDynamicModule(options) {
+    const conditionalProviders = (0, providers_1.conditionalClientProvidersForFactory)(framework_loader_1.framework.normalizeFrameworkRegistration((0, registration_composer_1.createRegistrationOptions)(options)));
     const registrationProvider = {
         provide: tokens_1.ZLINK_FRAMEWORK_REGISTRATION,
         inject: [core_1.DiscoveryService, core_1.ModuleRef],
@@ -173,12 +171,12 @@ function createDiscoveringZLinkDynamicModule(options) {
                 useFactory: (registration, moduleRef, discovery) => (0, providers_1.createRuntimeHost)(registration, moduleRef, discovery)
             },
             ...(0, providers_1.alwaysAvailableClientProviders)(),
-            ...(0, providers_1.conditionalClientProvidersForFactory)()
+            ...conditionalProviders
         ],
         exports: [
             tokens_1.ZLINK_FRAMEWORK_RUNTIME,
             ...(0, providers_1.alwaysAvailableClientTokens)(),
-            ...(0, providers_1.conditionalClientTokens)()
+            ...conditionalProviders.map(providers_1.providerToken)
         ]
     };
 }

package/dist/options-builder.js

@@ -95,13 +95,9 @@ class ZLinkNestOptionsBuilder {
         return this;
     }
     addRelocationStore(store) {
-        this.state.additionalOptions = {
-            ...this.state.additionalOptions,
-            locations: {
-                ...(this.state.additionalOptions.locations ?? {}),
-                relocationStoreInstance: store
-            }
-        };
+        const locations = { ...(this.state.additionalOptions.locations ?? {}) };
+        framework_loader_1.framework.registerRelocationStore(locations, store);
+        this.state.additionalOptions = { ...this.state.additionalOptions, locations };
         return this;
     }
     setApplicationVersion(version) {
@@ -360,8 +356,8 @@ class DefaultZLinkNestClientServerChannelServerBuilder extends ZLinkNestOptionsB
         this.channel = channel;
     }
     listen(port = 0) {
-        if (!Number.isInteger(port) || port < 0 || port > 65_535) {
-            throw new framework_loader_1.framework.ZLinkConfigurationException(`ClientServer channel '${this.name}' port must be between 0 and 65535.`);
+        if (!framework_loader_1.framework.isValidListenerPort(port)) {
+            throw new framework_loader_1.framework.ZLinkConfigurationException(`ClientServer channel '${this.name}' port must be between 0 and ${framework_loader_1.framework.MAX_LISTENER_PORT}.`);
         }
         this.updateServer({ port });
         this.updateBind();
@@ -380,8 +376,8 @@ class DefaultZLinkNestClientServerChannelServerBuilder extends ZLinkNestOptionsB
         return this;
     }
     setWeight(weight) {
-        if (!Number.isInteger(weight) || weight < 0 || weight > 10_000) {
-            throw new framework_loader_1.framework.ZLinkConfigurationException(`ClientServer channel '${this.name}' weight must be between 0 and 10000.`);
+        if (!framework_loader_1.framework.isValidPublicWeight(weight)) {
+            throw new framework_loader_1.framework.ZLinkConfigurationException(`ClientServer channel '${this.name}' weight must be between 0 and ${framework_loader_1.framework.ZLINK_MAX_PUBLIC_WEIGHT}.`);
         }
         this.updateServer({ weight });
         return this;
@@ -426,17 +422,11 @@ function requireClientServerText(value, label) {
 }
 function requireListenerPort(port, label) {
     const normalized = port ?? 0;
-    if (!Number.isInteger(normalized) || normalized < 0 || normalized > 65_535) {
-        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} port must be between 0 and 65535.`);
+    if (!framework_loader_1.framework.isValidListenerPort(normalized)) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} port must be between 0 and ${framework_loader_1.framework.MAX_LISTENER_PORT}.`);
     }
     return normalized;
 }
-function requirePublicWeight(value, label) {
-    if (!Number.isInteger(value) || value < 0 || value > 10_000) {
-        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} must be an integer in 0..10000.`);
-    }
-    return value;
-}
 function rejectFixedRoutingId(routingId, memberName) {
     if (routingId !== undefined) {
         throw new framework_loader_1.framework.ZLinkConfigurationException(`Mesh member '${memberName}' cannot combine a fixed routing id with a generated prefix.`);
@@ -559,8 +549,8 @@ class DefaultZLinkNestMeshNodeBuilder extends ZLinkNestOptionsBuilder {
         return this;
     }
     setPlacementWeight(weight) {
-        if (!Number.isInteger(weight) || weight < 0 || weight > 10_000) {
-            throw new framework_loader_1.framework.ZLinkConfigurationException('Placement weight must be an integer in 0..10000.');
+        if (!framework_loader_1.framework.isValidPublicWeight(weight)) {
+            throw new framework_loader_1.framework.ZLinkConfigurationException(`Placement weight must be an integer in 0..${framework_loader_1.framework.ZLINK_MAX_PUBLIC_WEIGHT}.`);
         }
         this.spotOptions.placementWeight = weight;
         return this;
@@ -850,9 +840,9 @@ class DefaultZLinkNestMeshObjectServerBuilder extends ZLinkNestOptionsBuilder {
 function validateObjectFactory(stableType, label) {
     if (typeof stableType !== 'string' ||
         Buffer.byteLength(stableType) < 1 ||
-        Buffer.byteLength(stableType) > 255 ||
+        Buffer.byteLength(stableType) > framework_loader_1.framework.ZLINK_MAX_STABLE_TYPE_BYTES ||
         stableType.includes('\0')) {
-        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} must contain 1..255 UTF-8 bytes and no NUL.`);
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} must contain 1..${framework_loader_1.framework.ZLINK_MAX_STABLE_TYPE_BYTES} UTF-8 bytes and no NUL.`);
     }
     return stableType;
 }
@@ -879,19 +869,19 @@ function validateUserSpotFactoryConfiguration(options) {
     }
 }
 function validateStableTypeLimit(value) {
-    if (value !== undefined && (!Number.isInteger(value) || value < 0 || value > 2_147_483_647)) {
-        throw new framework_loader_1.framework.ZLinkConfigurationException('stableTypeLimit must be an integer from 0 through 2147483647.');
+    if (value !== undefined && !framework_loader_1.framework.isValidCapacity(value)) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`stableTypeLimit must be an integer from 0 through ${framework_loader_1.framework.ZLINK_MAX_CAPACITY}.`);
     }
 }
 function requirePositiveCapacity(value, label) {
-    if (!Number.isSafeInteger(value) || value <= 0 || value > 0x7fff_ffff) {
-        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} must be an integer in 1..2147483647.`);
+    if (!framework_loader_1.framework.isValidPositiveCapacity(value)) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} must be an integer in 1..${framework_loader_1.framework.ZLINK_MAX_CAPACITY}.`);
     }
     return value;
 }
 function requireCapacity(value, label) {
-    if (!Number.isSafeInteger(value) || value < 0 || value > 0x7fff_ffff) {
-        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} must be an integer in 0..2147483647.`);
+    if (!framework_loader_1.framework.isValidCapacity(value)) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException(`${label} must be an integer in 0..${framework_loader_1.framework.ZLINK_MAX_CAPACITY}.`);
     }
     return value;
 }
@@ -936,7 +926,7 @@ class DefaultZLinkNestMeshChannelServerBuilder extends ZLinkNestOptionsBuilder {
         this.channel = channel;
     }
     setWeight(weight) {
-        this.channel.weight = requirePublicWeight(weight, 'Mesh channel weight');
+        this.channel.weight = framework_loader_1.framework.requirePublicWeight(weight, 'Mesh channel weight');
         return this;
     }
     addSendHandler(packetName, handlerType) {

package/dist/providers.d.ts

@@ -7,10 +7,9 @@ type RuntimeHostWithNestLifecycle = FrameworkRuntimeHost & OnModuleInit & OnModu
 export declare function alwaysAvailableClientProviders(registration?: ZLinkFrameworkRegistration): Provider[];
 export declare function alwaysAvailableClientTokens(): InjectionToken[];
 export declare function conditionalClientProviders(registration: ZLinkFrameworkRegistration): Provider[];
-export declare function conditionalClientProvidersForFactory(): Provider[];
+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 disposeNestOwnedHandler(instance: unknown): Promise<void>;
 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 providerToken(provider: Provider): InjectionToken;
 export {};

package/dist/providers.js

@@ -6,7 +6,6 @@ exports.conditionalClientProviders = conditionalClientProviders;
 exports.conditionalClientProvidersForFactory = conditionalClientProvidersForFactory;
 exports.conditionalClientTokens = conditionalClientTokens;
 exports.createRuntimeHost = createRuntimeHost;
-exports.disposeNestOwnedHandler = disposeNestOwnedHandler;
 exports.createNestHandlerInstance = createNestHandlerInstance;
 exports.providerToken = providerToken;
 const constants_1 = require("@nestjs/common/constants");
@@ -165,11 +164,8 @@ const CONDITIONAL_CLIENT_PROVIDER_SPECS = [
         }
     }
 ];
-function conditionalClientProvidersForFactory() {
-    return CONDITIONAL_CLIENT_PROVIDER_SPECS.map(createConditionalClientProviderForFactory);
-}
-function createConditionalClientProviderForFactory(spec) {
-    return createConditionalClientProviderFromSpec(spec, { checkEnabled: true });
+function conditionalClientProvidersForFactory(registration) {
+    return CONDITIONAL_CLIENT_PROVIDER_SPECS.filter((spec) => registration === undefined || spec.isEnabled(registration)).map((spec) => createConditionalClientProviderFromSpec(spec, { checkEnabled: registration === undefined }));
 }
 function createConditionalClientProvider(spec, registration) {
     return createConditionalClientProviderFromSpec(spec, { registration, checkEnabled: false });
@@ -240,7 +236,7 @@ function createRuntimeHost(registration, moduleRef, discovery) {
 function createProviderResolver(moduleRef, discovery) {
     const resolver = {
         get(type) {
-            const discovered = findDiscoveredProviderInstance(discovery, type);
+            const discovered = findDiscoveredProvider(discovery, type)?.instance;
             if (discovered !== undefined) {
                 return discovered;
             }
@@ -252,20 +248,9 @@ function createProviderResolver(moduleRef, discovery) {
             }
         },
         async create(type) {
-            try {
-                // Spot and actor lifecycles request a fresh application object for
-                // each activation. ModuleRef.resolve() returns the registered
-                // singleton when the application also lists that class as a Nest
-                // provider, which would make later Spot contexts overwrite earlier
-                // activations. ModuleRef.create() preserves dependency injection
-                // while creating an independent object.
-                return await moduleRef.create(type);
-            }
-            catch {
-                // Fall back to direct construction through Nest for classes that are
-                // not registered as providers.
-            }
-            return await moduleRef.resolve(type, undefined, { strict: false });
+            const owner = findDiscoveredProvider(discovery, type)?.host;
+            const creationModuleRef = owner?.getProviderByKey(core_1.ModuleRef).instance ?? moduleRef;
+            return await creationModuleRef.create(type);
         }
     };
     Object.defineProperty(resolver, Symbol.for('@zlink-systems/framework.handler-instance-scope-factory'), {
@@ -289,7 +274,7 @@ function createProviderResolver(moduleRef, discovery) {
                         if (instance === undefined) {
                             instance = createNestHandlerInstance(moduleRef, contextId, dependencies, type).then(async (created) => {
                                 if (disposed) {
-                                    await disposeNestOwnedHandler(created);
+                                    await framework_loader_1.framework.disposeIntegrationHandler(created);
                                     throw new Error('Handler instance scope was disposed during activation.');
                                 }
                                 owned.push(created);
@@ -305,12 +290,14 @@ function createProviderResolver(moduleRef, discovery) {
                         disposed = true;
                         const pending = [...instances.values()];
                         await Promise.allSettled(pending);
-                        for (let index = owned.length - 1; index >= 0; index -= 1) {
-                            await disposeNestOwnedHandler(owned[index]);
+                        try {
+                            await framework_loader_1.framework.disposeIntegrationHandlers(owned);
+                        }
+                        finally {
+                            owned.length = 0;
+                            instances.clear();
+                            dependencies.clear();
                         }
-                        owned.length = 0;
-                        instances.clear();
-                        dependencies.clear();
                     }
                 };
             }
@@ -331,27 +318,11 @@ function createProviderResolver(moduleRef, discovery) {
             });
         }
         finally {
-            for (let index = owned.length - 1; index >= 0; index -= 1) {
-                await disposeNestOwnedHandler(owned[index]);
-            }
+            await framework_loader_1.framework.disposeIntegrationHandlers(owned);
         }
     }));
     return resolver;
 }
-async function disposeNestOwnedHandler(instance) {
-    if (instance === null || instance === undefined)
-        return;
-    const value = instance;
-    if (typeof value.dispose === 'function') {
-        await value.dispose();
-    }
-    else if (typeof value.close === 'function') {
-        await value.close();
-    }
-    else if (typeof value.onModuleDestroy === 'function') {
-        await value.onModuleDestroy();
-    }
-}
 async function createNestHandlerInstance(moduleRef, contextId, dependencies, type) {
     const reflected = [
         ...(Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) ??
@@ -398,12 +369,12 @@ async function resolveNestHandlerDependency(moduleRef, contextId, dependencies,
         throw error;
     }
 }
-function findDiscoveredProviderInstance(discovery, type) {
+function findDiscoveredProvider(discovery, type) {
     for (const wrapper of discovery?.getProviders() ?? []) {
-        if (wrapper.instance !== undefined &&
-            wrapper.instance !== null &&
-            (wrapper.token === type || wrapper.metatype === type || wrapper.instance.constructor === type)) {
-            return wrapper.instance;
+        if (wrapper.token === type ||
+            wrapper.metatype === type ||
+            wrapper.instance?.constructor === type) {
+            return wrapper;
         }
     }
     return undefined;

package/dist/registration-composer.d.ts

@@ -1,7 +1,6 @@
 import type { DiscoveryService, ModuleRef } from '@nestjs/core';
 import type { ZLinkFrameworkRegistrationOptions } from './framework-integration-contracts';
 import { type ZLinkModuleOptions, type ZLinkNestModuleRegistrationOptions } from './contracts';
-export declare function hasNestHandlerDiscovery(options: ZLinkNestModuleRegistrationOptions): boolean;
 export declare function createDiscoveredOptions(options: ZLinkNestModuleRegistrationOptions, discovery: DiscoveryService, moduleRef: ModuleRef): ZLinkFrameworkRegistrationOptions;
 export declare function createRegistrationOptions(options: ZLinkNestModuleRegistrationOptions): ZLinkFrameworkRegistrationOptions;
 export declare function assertBuiltModuleOptions(options: ZLinkModuleOptions): ZLinkNestModuleRegistrationOptions;

package/dist/registration-composer.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasNestHandlerDiscovery = hasNestHandlerDiscovery;
 exports.createDiscoveredOptions = createDiscoveredOptions;
 exports.createRegistrationOptions = createRegistrationOptions;
 exports.assertBuiltModuleOptions = assertBuiltModuleOptions;
@@ -9,19 +8,6 @@ const provider_discovery_1 = require("./provider-discovery");
 const handler_adapters_1 = require("./handler-adapters");
 const framework_loader_1 = require("./framework-loader");
 const spot_node_handler_registry_1 = require("./spot-node-handler-registry");
-function hasNestHandlerDiscovery(options) {
-    return (hasConfiguredSpotNodes(options.spotNodes) ||
-        Object.values(options.clientServerChannels ?? {}).some((channel) => (channel.handlerGroups ?? []).length > 0 ||
-            (channel.requestHandlerTypes ?? []).length > 0 ||
-            (channel.sendHandlerTypes ?? []).length > 0) ||
-        Object.values(options.fanoutChannels ?? {}).some((channel) => (channel.handlerGroups ?? []).length > 0 || (channel.publishHandlerTypes ?? []).length > 0));
-}
-function hasConfiguredSpotNodes(value) {
-    if (value === undefined) {
-        return false;
-    }
-    return Array.isArray(value) ? value.length > 0 : Object.keys(value).length > 0;
-}
 function createDiscoveredOptions(options, discovery, moduleRef) {
     const registrationOptions = createRegistrationOptions(options);
     const channels = { ...(registrationOptions.channels ?? {}) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/nestjs",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -21,8 +21,8 @@
   },
   "dependencies": {
     "@nestjs/common": "^10.4.22",
-    "@zlink-systems/framework": "0.25.0",
-    "@zlink-systems/http-client": "0.25.0",
+    "@zlink-systems/framework": "0.27.0",
+    "@zlink-systems/http-client": "0.27.0",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.2"
   },