@zlink-systems/nestjs 0.10.0

package/dist/provider-discovery.d.ts

@@ -0,0 +1,36 @@
+import type { InjectionToken } from '@nestjs/common';
+import type { DiscoveryService, ModuleRef } from '@nestjs/core';
+import type { Type } from '@zlink-systems/framework';
+import { type ZLinkNestHandlerMetadata, type ZLinkNestSpotActorHandlerMetadata, type ZLinkNestSpotHandlerMetadata, type ZLinkNestSpotTimerHandlerMetadata } from './handler-metadata';
+export interface DiscoveredNestProvider {
+    readonly handlerKey: InjectionToken;
+    readonly handlerName: string;
+    readonly token: InjectionToken;
+    readonly metadata: ZLinkNestHandlerMetadata;
+}
+export interface DiscoveredNestSpotActorProvider {
+    readonly handlerKey: Type;
+    readonly handlerName: string;
+    readonly token: InjectionToken;
+    readonly metadata: ZLinkNestSpotActorHandlerMetadata;
+}
+export interface DiscoveredNestSpotProvider {
+    readonly handlerKey: Type;
+    readonly handlerName: string;
+    readonly token: InjectionToken;
+    readonly metadata: ZLinkNestSpotHandlerMetadata;
+}
+export interface DiscoveredNestSpotTimerProvider {
+    readonly handlerKey: Type;
+    readonly handlerName: string;
+    readonly token: InjectionToken;
+    readonly metadata: ZLinkNestSpotTimerHandlerMetadata;
+}
+export interface DiscoveredNestSessionProvider {
+    readonly handlerKey: Type;
+}
+export declare function discoverSessionProviderRefs(discovery: DiscoveryService, moduleRef: ModuleRef): DiscoveredNestSessionProvider[];
+export declare function discoverProviderRefs(discovery: DiscoveryService, moduleRef: ModuleRef): DiscoveredNestProvider[];
+export declare function discoverSpotProviderRefs(discovery: DiscoveryService, moduleRef: ModuleRef): DiscoveredNestSpotProvider[];
+export declare function discoverSpotActorProviderRefs(discovery: DiscoveryService, moduleRef: ModuleRef): DiscoveredNestSpotActorProvider[];
+export declare function discoverSpotTimerProviderRefs(discovery: DiscoveryService, moduleRef: ModuleRef): DiscoveredNestSpotTimerProvider[];

package/dist/provider-discovery.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverSessionProviderRefs = discoverSessionProviderRefs;
+exports.discoverProviderRefs = discoverProviderRefs;
+exports.discoverSpotProviderRefs = discoverSpotProviderRefs;
+exports.discoverSpotActorProviderRefs = discoverSpotActorProviderRefs;
+exports.discoverSpotTimerProviderRefs = discoverSpotTimerProviderRefs;
+const framework_loader_1 = require("./framework-loader");
+const auto_discovery_marker_1 = require("./auto-discovery-marker");
+const handler_metadata_1 = require("./handler-metadata");
+function discoverSessionProviderRefs(discovery, moduleRef) {
+    const refs = [];
+    const seen = new Set();
+    const metadataSymbol = Symbol.for('@zlink-systems/framework:decorator');
+    for (const wrapper of discovery.getProviders()) {
+        const handlerType = wrapper.metatype;
+        if (typeof handlerType !== 'function'
+            || seen.has(handlerType)
+            || !(0, auto_discovery_marker_1.isAutoDiscoveredProvider)(handlerType)) {
+            continue;
+        }
+        //  The symbol is only present on decorated handlers, so the lookup has to
+        //  admit undefined for the fallback to mean anything.
+        const metadata = handlerType[metadataSymbol] ?? [];
+        if (metadata.some((entry) => entry.kind === 'packet')
+            && typeof handlerType.prototype?.handle === 'function'
+            && tryGetProviderInstance(moduleRef, handlerType) !== undefined) {
+            seen.add(handlerType);
+            refs.push({ handlerKey: handlerType });
+        }
+    }
+    return refs;
+}
+function discoverProviderRefs(discovery, moduleRef) {
+    return discoverDecoratedProviderRefs({
+        discovery,
+        moduleRef,
+        metadataEntries: (0, handler_metadata_1.nestHandlerMetadataEntries)(),
+        readMetadata: handler_metadata_1.readNestHandlerMetadata,
+        metadataKey: (metadata) => `${metadata.groupName}:${metadata.kind}:${metadata.packetName}`,
+        createRef: ({ handlerKey, handlerName, token, metadata }) => ({
+            handlerKey,
+            handlerName,
+            token,
+            metadata
+        })
+    });
+}
+function discoverSpotProviderRefs(discovery, moduleRef) {
+    return discoverDecoratedClassProviderRefs({
+        discovery,
+        moduleRef,
+        metadataEntries: (0, handler_metadata_1.nestSpotHandlerMetadataEntries)(),
+        readMetadata: handler_metadata_1.readNestSpotHandlerMetadata,
+        metadataKey: (metadata) => `${metadata.kind}:${metadata.packetName ?? metadata.topic ?? ''}`,
+        invalidClassMessage: 'ZLink SPOT handler decorators must be applied to class providers.',
+        createRef: ({ handlerKey, handlerName, token, metadata }) => ({
+            handlerKey,
+            handlerName,
+            token,
+            metadata
+        })
+    });
+}
+function discoverSpotActorProviderRefs(discovery, moduleRef) {
+    return discoverDecoratedClassProviderRefs({
+        discovery,
+        moduleRef,
+        metadataEntries: (0, handler_metadata_1.nestSpotActorHandlerMetadataEntries)(),
+        readMetadata: handler_metadata_1.readNestSpotActorHandlerMetadata,
+        metadataKey: (metadata) => `${metadata.kind}:${metadata.packetName}`,
+        invalidClassMessage: 'ZLink SPOT actor handler decorators must be applied to class providers.',
+        createRef: ({ handlerKey, handlerName, token, metadata }) => ({
+            handlerKey,
+            handlerName,
+            token,
+            metadata
+        })
+    });
+}
+function discoverSpotTimerProviderRefs(discovery, moduleRef) {
+    return discoverDecoratedClassProviderRefs({
+        discovery,
+        moduleRef,
+        metadataEntries: (0, handler_metadata_1.nestSpotTimerHandlerMetadataEntries)(),
+        readMetadata: handler_metadata_1.readNestSpotTimerHandlerMetadata,
+        metadataKey: (metadata) => metadata.name,
+        invalidClassMessage: 'ZLink SPOT timer handler decorators must be applied to class providers.',
+        createRef: ({ handlerKey, handlerName, token, metadata }) => ({
+            handlerKey,
+            handlerName,
+            token,
+            metadata
+        })
+    });
+}
+function discoverDecoratedProviderRefs(options) {
+    const refs = [];
+    const seen = new Set();
+    for (const wrapper of options.discovery.getProviders()) {
+        const token = wrapper.token;
+        if (token === undefined) {
+            continue;
+        }
+        const instance = wrapper.instance === undefined ? undefined : wrapper.instance;
+        for (const handlerKey of providerMetadataCandidateTokens(wrapper.metatype, instance, token)) {
+            appendDiscoveredProviderRefs(refs, seen, {
+                handlerKey,
+                token,
+                instance,
+                metadataList: options.readMetadata(handlerKey),
+                metadataKey: options.metadataKey,
+                createRef: options.createRef
+            });
+        }
+    }
+    for (const [handlerKey, metadataList] of options.metadataEntries) {
+        const instance = tryGetProviderInstance(options.moduleRef, handlerKey);
+        if (instance === undefined) {
+            continue;
+        }
+        appendDiscoveredProviderRefs(refs, seen, {
+            handlerKey,
+            token: handlerKey,
+            instance,
+            metadataList,
+            metadataKey: options.metadataKey,
+            createRef: options.createRef
+        });
+    }
+    return refs;
+}
+function discoverDecoratedClassProviderRefs(options) {
+    return discoverDecoratedProviderRefs({
+        ...options,
+        createRef: (input) => {
+            if (typeof input.handlerKey !== 'function') {
+                throw new framework_loader_1.framework.ZLinkConfigurationException(options.invalidClassMessage);
+            }
+            return options.createRef({
+                ...input,
+                handlerKey: input.handlerKey
+            });
+        }
+    });
+}
+function appendDiscoveredProviderRefs(refs, seen, options) {
+    const handlerName = handlerKeyName(options.handlerKey);
+    for (const metadata of options.metadataList) {
+        const key = `${String(options.token)}:${handlerName}:${options.metadataKey(metadata)}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        refs.push(options.createRef({
+            handlerKey: options.handlerKey,
+            handlerName,
+            token: options.token,
+            instance: options.instance,
+            metadata
+        }));
+    }
+}
+function providerMetadataCandidateTokens(metatype, instance, token) {
+    return [...new Set([metatype, instance?.constructor, token].filter(isInjectionToken))];
+}
+function isInjectionToken(value) {
+    return typeof value === 'function' || typeof value === 'string' || typeof value === 'symbol';
+}
+function tryGetProviderInstance(moduleRef, token) {
+    try {
+        return moduleRef.get(token, { strict: false });
+    }
+    catch {
+        return undefined;
+    }
+}
+function handlerKeyName(handlerKey) {
+    if (typeof handlerKey === 'function') {
+        return handlerKey.name;
+    }
+    if (typeof handlerKey === 'symbol') {
+        return handlerKey.description ?? handlerKey.toString();
+    }
+    return handlerKey;
+}

package/dist/providers.d.ts

@@ -0,0 +1,16 @@
+import type { InjectionToken, OnModuleDestroy, OnModuleInit, Provider } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import type { Type } from '@zlink-systems/framework';
+import type { ZLinkFrameworkRegistration } from './framework-integration-contracts';
+import { type FrameworkRuntimeHost } from './framework-loader';
+type RuntimeHostWithNestLifecycle = FrameworkRuntimeHost & OnModuleInit & OnModuleDestroy;
+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 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

@@ -0,0 +1,426 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alwaysAvailableClientProviders = alwaysAvailableClientProviders;
+exports.alwaysAvailableClientTokens = alwaysAvailableClientTokens;
+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");
+const core_1 = require("@nestjs/core");
+const tokens_1 = require("./tokens");
+const internal_tokens_1 = require("./internal-tokens");
+const framework_loader_1 = require("./framework-loader");
+const dispatch_scope_1 = require("./dispatch-scope");
+const ALWAYS_AVAILABLE_CLIENT_PROVIDER_SPECS = [
+    {
+        token: tokens_1.ZLINK_CHANNEL_CLIENT,
+        create: (registration, runtime) => framework_loader_1.framework.createIntegrationChannelClient(registration, runtime)
+    },
+    {
+        token: tokens_1.ZLINK_CHANNEL_RUNTIME_OPTIONS,
+        create: (_registration, runtime) => runtime.channelRuntimeOptions
+    },
+    {
+        token: tokens_1.ZLINK_FANOUT_CLIENT,
+        create: (registration, runtime) => framework_loader_1.framework.createIntegrationFanoutClient(registration, runtime)
+    },
+    {
+        token: tokens_1.ZLINK_ROUTE_CLIENT,
+        create: (registration, runtime) => framework_loader_1.framework.createIntegrationRouteClient(registration, runtime)
+    },
+    {
+        token: tokens_1.ZLINK_BOUND_SESSION_FACTORY,
+        create: (_registration, runtime) => runtime.boundSessionFactory
+    }
+];
+function alwaysAvailableClientProviders(registration) {
+    return [
+        ...ALWAYS_AVAILABLE_CLIENT_PROVIDER_SPECS.map((spec) => createAlwaysAvailableClientProvider(spec, registration)),
+        { provide: tokens_1.ZLINK_MESSAGE_METADATA_POLICY, useValue: Object.freeze({ forward: true }) }
+    ];
+}
+function createAlwaysAvailableClientProvider(spec, registration) {
+    if (registration !== undefined) {
+        return {
+            provide: spec.token,
+            inject: [tokens_1.ZLINK_FRAMEWORK_RUNTIME],
+            useFactory: (runtime) => spec.create(registration, runtime)
+        };
+    }
+    return {
+        provide: spec.token,
+        inject: [tokens_1.ZLINK_FRAMEWORK_REGISTRATION, tokens_1.ZLINK_FRAMEWORK_RUNTIME],
+        useFactory: (resolved, runtime) => spec.create(resolved, runtime)
+    };
+}
+function alwaysAvailableClientTokens() {
+    return [
+        tokens_1.ZLINK_CHANNEL_CLIENT,
+        tokens_1.ZLINK_ROUTE_CLIENT,
+        tokens_1.ZLINK_FANOUT_CLIENT,
+        tokens_1.ZLINK_BOUND_SESSION_FACTORY,
+        tokens_1.ZLINK_MESSAGE_METADATA_POLICY,
+    ];
+}
+function conditionalClientProviders(registration) {
+    return CONDITIONAL_CLIENT_PROVIDER_SPECS
+        .filter((spec) => spec.isEnabled(registration))
+        .map((spec) => createConditionalClientProvider(spec, registration));
+}
+const CONDITIONAL_CLIENT_PROVIDER_SPECS = [
+    {
+        token: tokens_1.ZLINK_CLIENT_SERVER_RUNTIME,
+        requiresRuntime: true,
+        isEnabled: (registration) => [...registration.channels.values()]
+            .some(channel => channel.client !== undefined || channel.server !== undefined),
+        create: (_registration, runtime) => requireRuntime(runtime).clientServerRuntime
+    },
+    {
+        token: tokens_1.ZLINK_FANOUT_RUNTIME,
+        requiresRuntime: true,
+        isEnabled: (registration) => [...registration.channels.values()]
+            .some(channel => channel.subscriber !== undefined
+            && (channel.subscriber.manualConnections?.length ?? 0) === 0),
+        create: (_registration, runtime) => requireRuntime(runtime).fanoutRuntime
+    },
+    {
+        token: tokens_1.ZLINK_ROUTE_MESH_RUNTIME_OPTIONS,
+        requiresRuntime: true,
+        isEnabled: (registration) => registration.spotNodes.size > 0,
+        create: (_registration, runtime) => requireRuntime(runtime).routeMeshRuntimeOptions
+    },
+    {
+        token: tokens_1.ZLINK_ROUTE_MESH_RUNTIME,
+        requiresRuntime: true,
+        isEnabled: (registration) => registration.spotNodes.size > 0,
+        create: (_registration, runtime) => requireRuntime(runtime).routeMeshRuntime
+    },
+    {
+        token: tokens_1.ZLINK_SPOT_MANAGER,
+        requiresRuntime: true,
+        isEnabled: (registration) => framework_loader_1.framework.hasSpotNode(registration) && hasLocationStores(registration),
+        create: (registration, runtime, moduleRef, discovery) => createSpotManager(registration, requireRuntime(runtime), moduleRef, discovery)
+    },
+    {
+        token: tokens_1.ZLINK_SPOT_OUTBOUND,
+        requiresRuntime: true,
+        isEnabled: (registration) => framework_loader_1.framework.hasSpotNode(registration),
+        create: (registration, runtime, moduleRef, discovery) => createSpotOutbound(registration, requireRuntime(runtime), moduleRef, discovery)
+    },
+    {
+        token: tokens_1.ZLINK_SPOT_PUBLISHER_CLIENT,
+        requiresRuntime: true,
+        isEnabled: (registration) => framework_loader_1.framework.hasSpotPublisherClient(registration),
+        create: (registration, runtime) => framework_loader_1.framework.createIntegrationSpotPublisherClient(registration, requireRuntime(runtime))
+    },
+    {
+        token: tokens_1.ZLINK_ACTOR_CLIENT,
+        requiresRuntime: true,
+        isEnabled: (registration) => framework_loader_1.framework.hasSpotNode(registration) && hasLocationStores(registration),
+        create: (_registration, runtime) => framework_loader_1.framework.createIntegrationActorClient(requireRuntime(runtime))
+    },
+    {
+        token: tokens_1.ZLINK_ACTOR_MANAGER,
+        requiresRuntime: true,
+        isEnabled: (registration) => framework_loader_1.framework.hasActorManager(registration),
+        create: async (registration, runtime, moduleRef, discovery) => {
+            const host = requireRuntime(runtime);
+            return framework_loader_1.framework.createIntegrationActorManager(registration, host, moduleRef === undefined ? undefined : createProviderResolver(moduleRef, discovery));
+        }
+    },
+    {
+        token: tokens_1.ZLINK_LOCATION_RUNTIME_QUERY,
+        requiresRuntime: true,
+        isEnabled: (registration) => hasLocationStores(registration),
+        create: (_registration, runtime) => {
+            const query = requireRuntime(runtime).locationRuntimeQuery;
+            if (query === undefined) {
+                throw new framework_loader_1.framework.ZLinkConfigurationException('Location runtime query requires location stores.');
+            }
+            return query;
+        }
+    },
+    {
+        token: internal_tokens_1.ZLINK_SPOT_HANDLE_RESOLVER,
+        requiresRuntime: true,
+        isEnabled: (registration) => hasLocationStores(registration),
+        create: (_registration, runtime) => {
+            const resolver = requireRuntime(runtime).createLocationHandleResolver();
+            if (resolver === undefined) {
+                throw new framework_loader_1.framework.ZLinkConfigurationException('SpotHandle resolver requires location stores.');
+            }
+            return resolver;
+        }
+    },
+    {
+        token: internal_tokens_1.ZLINK_ACTOR_SPOT_HANDLE_RESOLVER,
+        requiresRuntime: true,
+        isEnabled: (registration) => hasLocationStores(registration),
+        create: (_registration, runtime) => {
+            const resolver = requireRuntime(runtime).createLocationHandleResolver();
+            if (resolver === undefined) {
+                throw new framework_loader_1.framework.ZLinkConfigurationException('Actor SpotHandle resolver requires location stores.');
+            }
+            return resolver;
+        }
+    }
+];
+function conditionalClientProvidersForFactory() {
+    return CONDITIONAL_CLIENT_PROVIDER_SPECS.map(createConditionalClientProviderForFactory);
+}
+function createConditionalClientProviderForFactory(spec) {
+    return createConditionalClientProviderFromSpec(spec, { checkEnabled: true });
+}
+function createConditionalClientProvider(spec, registration) {
+    return createConditionalClientProviderFromSpec(spec, { registration, checkEnabled: false });
+}
+function createConditionalClientProviderFromSpec(spec, options) {
+    return {
+        provide: spec.token,
+        inject: conditionalClientProviderInject(spec, options),
+        useFactory: (...args) => {
+            const { registration, runtime, moduleRef, discovery } = conditionalClientProviderArgs(spec, options, args);
+            if (options.checkEnabled && !spec.isEnabled(registration)) {
+                return null;
+            }
+            return spec.create(registration, runtime, moduleRef, discovery);
+        }
+    };
+}
+function conditionalClientProviderInject(spec, options) {
+    return [
+        ...(options.registration === undefined ? [tokens_1.ZLINK_FRAMEWORK_REGISTRATION] : []),
+        ...(spec.requiresRuntime ? [tokens_1.ZLINK_FRAMEWORK_RUNTIME] : []),
+        core_1.ModuleRef,
+        core_1.DiscoveryService
+    ];
+}
+function conditionalClientProviderArgs(spec, options, args) {
+    let index = 0;
+    const registration = options.registration ?? args[index++];
+    const runtime = spec.requiresRuntime ? args[index++] : undefined;
+    const moduleRef = args[index++];
+    const discovery = args[index++];
+    return { registration, runtime, moduleRef, discovery };
+}
+function requireRuntime(runtime) {
+    if (runtime === undefined) {
+        throw new framework_loader_1.framework.ZLinkConfigurationException('ZLink runtime host is not available.');
+    }
+    return runtime;
+}
+function conditionalClientTokens() {
+    return [
+        tokens_1.ZLINK_CLIENT_SERVER_RUNTIME,
+        tokens_1.ZLINK_FANOUT_RUNTIME,
+        tokens_1.ZLINK_ROUTE_MESH_RUNTIME_OPTIONS,
+        tokens_1.ZLINK_ROUTE_MESH_RUNTIME,
+        tokens_1.ZLINK_SPOT_MANAGER,
+        tokens_1.ZLINK_SPOT_OUTBOUND,
+        tokens_1.ZLINK_SPOT_PUBLISHER_CLIENT,
+        tokens_1.ZLINK_ACTOR_CLIENT,
+        tokens_1.ZLINK_ACTOR_MANAGER,
+        tokens_1.ZLINK_LOCATION_RUNTIME_QUERY
+    ];
+}
+function hasLocationStores(registration) {
+    return registration.locations.useInMemoryStores
+        || registration.locations.storeInstance !== undefined;
+}
+function createRuntimeHost(registration, moduleRef, discovery) {
+    const runtime = framework_loader_1.framework.createIntegrationRuntimeHost(registration, createProviderResolver(moduleRef, discovery));
+    runtime.onModuleInit = async () => {
+        await runtime.start();
+    };
+    runtime.onModuleDestroy = async () => {
+        await runtime.shutdown();
+    };
+    runtime.onApplicationBootstrap = async () => { };
+    return runtime;
+}
+function createProviderResolver(moduleRef, discovery) {
+    const resolver = {
+        get(type) {
+            const discovered = findDiscoveredProviderInstance(discovery, type);
+            if (discovered !== undefined) {
+                return discovered;
+            }
+            try {
+                return moduleRef.get(type, { strict: false });
+            }
+            catch {
+                return undefined;
+            }
+        },
+        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 });
+        }
+    };
+    Object.defineProperty(resolver, Symbol.for('@zlink-systems/framework.handler-instance-scope-factory'), {
+        value: {
+            create(context) {
+                const currentContextId = (0, dispatch_scope_1.currentNestDispatchContext)();
+                const contextId = currentContextId ?? core_1.ContextIdFactory.create();
+                if (context !== undefined && currentContextId === undefined) {
+                    moduleRef.registerRequestByContextId({ zlinkContext: context }, contextId);
+                }
+                const instances = new Map();
+                const dependencies = new Map();
+                const owned = [];
+                let disposed = false;
+                return {
+                    async resolve(type) {
+                        if (disposed) {
+                            throw new Error('Handler instance scope is already disposed.');
+                        }
+                        let instance = instances.get(type);
+                        if (instance === undefined) {
+                            instance = createNestHandlerInstance(moduleRef, contextId, dependencies, type)
+                                .then(async (created) => {
+                                if (disposed) {
+                                    await disposeNestOwnedHandler(created);
+                                    throw new Error('Handler instance scope was disposed during activation.');
+                                }
+                                owned.push(created);
+                                return created;
+                            });
+                            instances.set(type, instance);
+                        }
+                        return await instance;
+                    },
+                    async dispose() {
+                        if (disposed)
+                            return;
+                        disposed = true;
+                        const pending = [...instances.values()];
+                        await Promise.allSettled(pending);
+                        for (let index = owned.length - 1; index >= 0; index -= 1) {
+                            await disposeNestOwnedHandler(owned[index]);
+                        }
+                        owned.length = 0;
+                        instances.clear();
+                        dependencies.clear();
+                    }
+                };
+            }
+        },
+        enumerable: false
+    });
+    framework_loader_1.framework.registerIntegrationHandlerFilterScope(resolver, (context, callback) => (0, dispatch_scope_1.runInNestDispatchScope)(moduleRef, context, async () => {
+        const contextId = (0, dispatch_scope_1.currentNestDispatchContext)();
+        const dependencies = new Map();
+        const owned = [];
+        try {
+            return await callback({
+                async resolve(type) {
+                    const instance = await createNestHandlerInstance(moduleRef, contextId, dependencies, type);
+                    owned.push(instance);
+                    return instance;
+                }
+            });
+        }
+        finally {
+            for (let index = owned.length - 1; index >= 0; index -= 1) {
+                await disposeNestOwnedHandler(owned[index]);
+            }
+        }
+    }));
+    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) ?? [])
+    ];
+    const declared = Reflect.getMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, type);
+    for (const dependency of declared ?? []) {
+        reflected[dependency.index] = dependency.param;
+    }
+    const optional = new Set(Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, type) ?? []);
+    const parameters = await Promise.all(reflected.map((token, index) => resolveNestHandlerDependency(moduleRef, contextId, dependencies, token, optional.has(index))));
+    const instance = new type(...parameters);
+    const properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, type);
+    const optionalProperties = new Set(Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, type) ?? []);
+    for (const property of properties ?? []) {
+        const dependency = await resolveNestHandlerDependency(moduleRef, contextId, dependencies, property.type, optionalProperties.has(property.key));
+        if (dependency !== undefined) {
+            instance[property.key] = dependency;
+        }
+    }
+    return instance;
+}
+async function resolveNestHandlerDependency(moduleRef, contextId, dependencies, token, optional) {
+    const forwardReference = typeof token === 'object'
+        && token !== null
+        && 'forwardRef' in token
+        ? token
+        : undefined;
+    const resolvedToken = typeof forwardReference?.forwardRef === 'function'
+        ? forwardReference.forwardRef()
+        : token;
+    let dependency = dependencies.get(resolvedToken);
+    if (dependency === undefined) {
+        dependency = moduleRef.resolve(resolvedToken, contextId, { strict: false });
+        dependencies.set(resolvedToken, dependency);
+    }
+    try {
+        return await dependency;
+    }
+    catch (error) {
+        dependencies.delete(resolvedToken);
+        if (optional)
+            return undefined;
+        throw error;
+    }
+}
+function findDiscoveredProviderInstance(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;
+        }
+    }
+    return undefined;
+}
+function providerToken(provider) {
+    return typeof provider === 'function' ? provider : provider.provide;
+}
+async function createSpotManager(registration, runtime, moduleRef, discovery) {
+    return framework_loader_1.framework.createIntegrationSpotManager(registration, runtime, moduleRef === undefined ? undefined : createProviderResolver(moduleRef, discovery));
+}
+async function createSpotOutbound(_registration, runtime, _moduleRef, _discovery) {
+    return framework_loader_1.framework.createIntegrationSpotOutbound(runtime);
+}

package/dist/registration-composer.d.ts

@@ -0,0 +1,7 @@
+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;