@zlink-systems/nestjs 0.10.0

package/dist/contracts.d.ts

@@ -0,0 +1,229 @@
+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 { ZLinkChannelOptions, ZLinkChannelPublishHandlerRegistration, ZLinkClientCapabilityOptions, ZLinkCodecRegistryOptions, ZLinkFrameworkRegistrationOptions, ZLinkPublisherCapabilityOptions, ZLinkSpotNodeOptions, ZLinkSpotNodeRegistrationOptions, ZLinkStreamNodeOptions, ZLinkWorkerOptions } from './framework-integration-contracts';
+export type MutableCodecRegistryOptions = {
+    serializers: NonNullable<ZLinkCodecRegistryOptions['serializers']>[number][];
+    streamCodecs: NonNullable<ZLinkCodecRegistryOptions['streamCodecs']>[number][];
+};
+export interface ZLinkModuleFactoryOptions<TArgs extends unknown[] = unknown[]> {
+    readonly useFactory: (...args: TArgs) => ZLinkModuleOptions | Promise<ZLinkModuleOptions>;
+    readonly inject?: {
+        readonly [TIndex in keyof TArgs]: InjectionToken;
+    };
+    readonly imports?: ModuleMetadata['imports'];
+}
+export interface ZLinkNestHandlerDiscoveryOptions {
+    readonly handlerGroups?: readonly string[];
+}
+export interface ZLinkNestManualHandlerOptions {
+    readonly packetName: string;
+    readonly handlerType: Type;
+}
+export type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export interface InternalZLinkNestFanoutChannelOptions extends ZLinkNestHandlerDiscoveryOptions {
+    readonly routingId?: string;
+    readonly routingIdPrefix?: string;
+    readonly publisher?: ZLinkPublisherCapabilityOptions;
+    readonly subscriber?: ZLinkClientCapabilityOptions;
+    readonly publishHandlers?: readonly ZLinkChannelPublishHandlerRegistration[];
+    readonly publishHandlerTypes?: readonly ZLinkNestManualHandlerOptions[];
+}
+export interface InternalZLinkNestClientServerChannelOptions extends ZLinkNestHandlerDiscoveryOptions {
+    readonly client?: ZLinkClientCapabilityOptions;
+    readonly server?: NonNullable<ZLinkChannelOptions['server']>;
+    readonly requestHandlerTypes?: readonly ZLinkNestManualHandlerOptions[];
+    readonly sendHandlerTypes?: readonly ZLinkNestManualHandlerOptions[];
+}
+export interface ZLinkNestHandlerOptions {
+    readonly methodName?: string;
+    readonly decodePayload?: (payload: Buffer, context: ZLinkMessageContext | ZLinkRouteMessageContext | ZLinkPublishMessageContext) => unknown;
+    readonly encodeResult?: (result: unknown, context: ZLinkMessageContext | ZLinkRouteMessageContext) => unknown;
+}
+export interface ZLinkNestProviderDiscoveryOptions {
+    readonly recursive?: boolean;
+}
+export type ZLinkNestProviderDiscoveryRoot = string | {
+    readonly rootDir: string;
+    readonly options?: ZLinkNestProviderDiscoveryOptions;
+};
+export interface ZLinkNestModuleMetadata extends ModuleMetadata {
+    readonly providerDiscovery?: readonly ZLinkNestProviderDiscoveryRoot[];
+}
+export type ZLinkNestModuleRoleRoot = string;
+export type ZLinkNestTypeResolver<T> = Type<T> | (() => Type<T>);
+export interface ZLinkNestSpotActorSendHandlerOptions<TSpot extends ZLinkSpot, TActor extends ZLinkActor> {
+    readonly spot: ZLinkNestTypeResolver<TSpot>;
+    readonly actor: ZLinkNestTypeResolver<TActor>;
+    readonly packetName: string;
+    readonly methodName?: string;
+}
+export interface ZLinkNestSpotPacketHandlerOptions<TSpot extends ZLinkSpot | ZLinkInstanceSpot> {
+    readonly spot: ZLinkNestTypeResolver<TSpot>;
+    readonly packetName?: string;
+}
+export interface ZLinkNestEntrySpotPacketHandlerOptions<TEntrySpot extends ZLinkEntrySpot> {
+    readonly entrySpot: ZLinkNestTypeResolver<TEntrySpot>;
+    readonly packetName?: string;
+}
+export interface ZLinkNestSpotSubscriptionHandlerOptions<TSpot extends ZLinkSpot> {
+    readonly spot: ZLinkNestTypeResolver<TSpot>;
+    readonly channelName: string;
+    readonly topic: string;
+}
+export interface ZLinkNestEntrySpotSubscriptionHandlerOptions<TEntrySpot extends ZLinkEntrySpot> {
+    readonly entrySpot: ZLinkNestTypeResolver<TEntrySpot>;
+    readonly channelName: string;
+    readonly topic: string;
+}
+export interface ZLinkNestSpotActorRequestHandlerOptions<TSpot extends ZLinkSpot, TActor extends ZLinkActor> {
+    readonly spot: ZLinkNestTypeResolver<TSpot>;
+    readonly actor: ZLinkNestTypeResolver<TActor>;
+    readonly packetName: string;
+    readonly methodName?: string;
+}
+export interface ZLinkNestEntrySpotActorRequestHandlerOptions<TEntrySpot extends ZLinkEntrySpot, TActor extends ZLinkActor> {
+    readonly entrySpot: ZLinkNestTypeResolver<TEntrySpot>;
+    readonly actor: ZLinkNestTypeResolver<TActor>;
+    readonly packetName: string;
+    readonly methodName?: string;
+}
+export interface ZLinkNestEntrySpotActorSendHandlerOptions<TEntrySpot extends ZLinkEntrySpot, TActor extends ZLinkActor> {
+    readonly entrySpot: ZLinkNestTypeResolver<TEntrySpot>;
+    readonly actor: ZLinkNestTypeResolver<TActor>;
+    readonly packetName: string;
+    readonly methodName?: string;
+}
+export interface ZLinkNestSpotTimerHandlerOptions<TSpot extends ZLinkSpot = ZLinkSpot> {
+    readonly spot?: ZLinkNestTypeResolver<TSpot>;
+    readonly entrySpot?: ZLinkNestTypeResolver<ZLinkEntrySpot>;
+    readonly name?: string;
+    readonly periodMs?: number;
+    readonly options?: ZLinkTimerOptions;
+}
+export declare const ZLINK_MODULE_OPTIONS_BRAND: unique symbol;
+export interface ZLinkModuleOptions {
+    readonly [ZLINK_MODULE_OPTIONS_BRAND]: true;
+}
+export interface ZLinkNestModuleRegistrationOptions extends Omit<ZLinkFrameworkRegistrationOptions, 'channels' | 'routeChannels' | 'streamNodes' | 'spotNodes'> {
+    readonly [ZLINK_MODULE_OPTIONS_BRAND]: true;
+    readonly implicitHandlerAutoRegistration?: boolean;
+    readonly clientServerChannels?: Readonly<Record<string, InternalZLinkNestClientServerChannelOptions>>;
+    readonly fanoutChannels?: Readonly<Record<string, InternalZLinkNestFanoutChannelOptions>>;
+    readonly spotNodes?: readonly (string | ZLinkSpotNodeRegistrationOptions)[] | Readonly<Record<string, ZLinkSpotNodeOptions>>;
+    readonly streams?: Readonly<Record<string, ZLinkStreamNodeOptions>>;
+}
+export interface ZLinkNestFrameworkOptionsBuilder {
+    options(options: ZLinkNestFrameworkAdditionalOptions): this;
+    disableImplicitHandlerAutoRegistration(): this;
+    codecs(): ZLinkNestCodecRegistryBuilder;
+    configureDispatch(): ZLinkDispatchOptionsBuilder;
+    configureInboundDispatch(): ZLinkInboundDispatchOptions;
+    addLocationStore(store: ZLinkLocationStore): this;
+    addRelocationStore(store: ZLinkRelocationStore): this;
+    setApplicationVersion(version: bigint): this;
+    setMaintenanceWave(waveId: string): this;
+    setActorTransferTimeout(timeoutMs: number): this;
+    setMessageFollowDuration(timeoutMs: number): this;
+    setSessionReplacementCallbackTimeout(timeoutMs: number): this;
+    configureStreamCompression(): ZLinkStreamCompressionBuilder;
+    configureLocations(): ZLinkLocationOptions;
+    configureNetwork(): ZLinkNetworkOptions;
+    addClientServerChannel(name: string): ZLinkNestClientServerChannelRoleBuilder;
+    addFanoutChannel(name: string): ZLinkNestFanoutChannelBuilder;
+    addRouteMesh(name: string): ZLinkNestMeshNodeBuilder;
+    addStreamNode(name: string): ZLinkNestStreamNodeBuilder;
+    build(): ZLinkModuleOptions;
+}
+export interface ZLinkNestFrameworkAdditionalOptions {
+    readonly requestTimeoutMs?: number;
+    readonly sessionReplacementCallbackTimeoutMs?: number;
+    readonly filters?: readonly Type<ZLinkHandlerFilter>[];
+    readonly worker?: ZLinkWorkerOptions;
+    readonly dispatch?: ZLinkDispatchOptions;
+    readonly metrics?: ZLinkMetricsOptions;
+}
+export interface ZLinkNestCodecRegistryBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    use(extension: ZLinkCodecExtension): this;
+}
+export interface ZLinkNestFanoutChannelBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    enablePublisher(bind: string | undefined): this;
+    enablePublisher(port?: number): this;
+    setBindHost(bindHost: string): this;
+    setAdvertiseHost(advertiseHost: string): this;
+    routingId(routingId: string | undefined): this;
+    setRoutingIdPrefix(prefix: string): this;
+    enableSubscriber(endpoint?: string | readonly string[]): this;
+    addPublishHandler(packetName: string, handlerType: Type): this;
+    addHandlerGroup(groupName: string): this;
+}
+export interface ZLinkNestClientServerChannelRoleBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    client(): ZLinkNestClientServerChannelClientBuilder;
+    server(): ZLinkNestClientServerChannelServerBuilder;
+}
+export interface ZLinkNestClientServerChannelClientBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    connect(endpoint: string): this;
+}
+export interface ZLinkNestClientServerChannelServerBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    listen(port?: number): this;
+    setBindHost(bindHost: string): this;
+    setAdvertiseHost(advertiseHost: string): this;
+    setWeight(weight: number): this;
+    addSendHandler(packetName: string, handlerType: Type): this;
+    addRequestHandler(packetName: string, handlerType: Type): this;
+    addHandlerGroup(groupName: string): this;
+}
+export interface ZLinkNestStreamNodeBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    bind(endpoint: string | undefined): this;
+    bind(port?: number): this;
+    setBindHost(bindHost: string): this;
+    setAdvertiseHost(advertiseHost: string): this;
+    enableActorDispatch(): this;
+    setTlsServer(certificatePath: string, keyPath: string, requireClientCertificate?: boolean): this;
+    registerSession<TSession extends ZLinkSession>(sessionType: Type<TSession> | Type<ZLinkSessionFactory<TSession>>): this;
+}
+export interface ZLinkNestMeshNodeBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    channel(name: string): ZLinkNestMeshChannelBuilder;
+    listen(endpoint: string): this;
+    listen(port?: number): this;
+    setBindHost(bindHost: string): this;
+    setAdvertiseHost(advertiseHost: string): this;
+    routingId(routingId: string | undefined): this;
+    setRoutingIdPrefix(prefix: string): this;
+    setPlacementWeight(weight: number): this;
+    setActorLimit(limit: number): this;
+    setSpotLimit(limit: number): this;
+    setActivationConcurrency(limit: number): this;
+    setInstanceSpotIdleTimeout(timeoutMs: number): this;
+    configureRouterSocket(): ZLinkMeshNodeSocketConfig;
+    configureSpotPublisher(): ZLinkSpotPublisherConfig;
+    peerConnections(): ZLinkMeshPeerConnections;
+    objects(): ZLinkNestMeshObjectRoleBuilder;
+    addSendHandler(packetName: string, handlerType: Type): this;
+    addRequestHandler(packetName: string, handlerType: Type): this;
+}
+export interface ZLinkNestMeshObjectRoleBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    client(): ZLinkNestMeshObjectClientBuilder;
+    server(): ZLinkNestMeshObjectServerBuilder;
+}
+export interface ZLinkNestMeshObjectClientBuilder extends ZLinkNestFrameworkOptionsBuilder {
+}
+export interface ZLinkNestMeshObjectServerBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    addEntrySpot<TEntrySpot extends ZLinkEntrySpot>(entrySpotType: Type<TEntrySpot>): this;
+    addSpotFactory<TSpot extends ZLinkSpot>(spotType: string, implementation: Type<TSpot>, configure: (builder: ZLinkUserSpotFactoryBuilder<TSpot>) => void): this;
+    addInstanceSpotFactory<TSpot extends ZLinkInstanceSpot>(instanceSpotType: string, implementation: Type<TSpot>, configure: (builder: ZLinkInstanceSpotFactoryBuilder<TSpot>) => void): this;
+    addActorFactory<TActor extends ZLinkActor>(actorType: string, implementation: Type<ZLinkActorFactory<TActor>>, configure: (builder: ZLinkActorFactoryBuilder<TActor>) => void): this;
+}
+export interface ZLinkNestMeshChannelBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    client(): ZLinkNestMeshChannelClientBuilder;
+    server(): ZLinkNestMeshChannelServerBuilder;
+}
+export interface ZLinkNestMeshChannelClientBuilder extends ZLinkNestFrameworkOptionsBuilder {
+}
+export interface ZLinkNestMeshChannelServerBuilder extends ZLinkNestFrameworkOptionsBuilder {
+    setWeight(weight: number): this;
+    addSendHandler(packetName: string, handlerType: Type): this;
+    addRequestHandler(packetName: string, handlerType: Type): this;
+    addHandlerGroup(groupName: string): this;
+}

package/dist/contracts.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLINK_MODULE_OPTIONS_BRAND = void 0;
+exports.ZLINK_MODULE_OPTIONS_BRAND = Symbol('@zlink-systems/nestjs:module-options');

package/dist/decorators.d.ts

@@ -0,0 +1,16 @@
+import type { ZLinkActor, ZLinkEntrySpot, ZLinkInstanceSpot, ZLinkSpot } from '@zlink-systems/framework';
+import type { ZLinkNestEntrySpotActorRequestHandlerOptions, ZLinkNestEntrySpotActorSendHandlerOptions, ZLinkNestEntrySpotPacketHandlerOptions, ZLinkNestEntrySpotSubscriptionHandlerOptions, ZLinkNestHandlerOptions, ZLinkNestSpotActorRequestHandlerOptions, ZLinkNestSpotActorSendHandlerOptions, ZLinkNestSpotPacketHandlerOptions, ZLinkNestSpotSubscriptionHandlerOptions, ZLinkNestSpotTimerHandlerOptions } from './contracts';
+import { type ZLinkNestHandlerKind } from './handler-metadata';
+export declare function zlinkRequestHandler(groupName: string, packetName?: string, options?: ZLinkNestHandlerOptions): ClassDecorator;
+export declare function zlinkSendHandler(groupName: string, packetName?: string, options?: ZLinkNestHandlerOptions): ClassDecorator;
+export declare function zlinkPublishHandler(groupName: string, packetName?: string, options?: ZLinkNestHandlerOptions): ClassDecorator;
+export declare function zlinkSpotActorRequestHandler<TSpot extends ZLinkSpot, TActor extends ZLinkActor>(options: ZLinkNestSpotActorRequestHandlerOptions<TSpot, TActor>): ClassDecorator;
+export declare function zlinkSpotPacketHandler<TSpot extends ZLinkSpot | ZLinkInstanceSpot>(options: ZLinkNestSpotPacketHandlerOptions<TSpot>): ClassDecorator;
+export declare function zlinkEntrySpotPacketHandler<TEntrySpot extends ZLinkEntrySpot>(options: ZLinkNestEntrySpotPacketHandlerOptions<TEntrySpot>): ClassDecorator;
+export declare function zlinkSpotSubscriptionHandler<TSpot extends ZLinkSpot>(options: ZLinkNestSpotSubscriptionHandlerOptions<TSpot>): ClassDecorator;
+export declare function zlinkEntrySpotSubscriptionHandler<TEntrySpot extends ZLinkEntrySpot>(options: ZLinkNestEntrySpotSubscriptionHandlerOptions<TEntrySpot>): ClassDecorator;
+export declare function zlinkSpotActorSendHandler<TSpot extends ZLinkSpot, TActor extends ZLinkActor>(options: ZLinkNestSpotActorSendHandlerOptions<TSpot, TActor>): ClassDecorator;
+export declare function zlinkEntrySpotActorRequestHandler<TEntrySpot extends ZLinkEntrySpot, TActor extends ZLinkActor>(options: ZLinkNestEntrySpotActorRequestHandlerOptions<TEntrySpot, TActor>): ClassDecorator;
+export declare function zlinkEntrySpotActorSendHandler<TEntrySpot extends ZLinkEntrySpot, TActor extends ZLinkActor>(options: ZLinkNestEntrySpotActorSendHandlerOptions<TEntrySpot, TActor>): ClassDecorator;
+export declare function zlinkSpotTimerHandler<TSpot extends ZLinkSpot = ZLinkSpot>(options?: ZLinkNestSpotTimerHandlerOptions<TSpot>): ClassDecorator;
+export declare function zlinkHandler(groupName: string, kind: ZLinkNestHandlerKind, packetName?: string, options?: ZLinkNestHandlerOptions): ClassDecorator;

package/dist/decorators.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zlinkRequestHandler = zlinkRequestHandler;
+exports.zlinkSendHandler = zlinkSendHandler;
+exports.zlinkPublishHandler = zlinkPublishHandler;
+exports.zlinkSpotActorRequestHandler = zlinkSpotActorRequestHandler;
+exports.zlinkSpotPacketHandler = zlinkSpotPacketHandler;
+exports.zlinkEntrySpotPacketHandler = zlinkEntrySpotPacketHandler;
+exports.zlinkSpotSubscriptionHandler = zlinkSpotSubscriptionHandler;
+exports.zlinkEntrySpotSubscriptionHandler = zlinkEntrySpotSubscriptionHandler;
+exports.zlinkSpotActorSendHandler = zlinkSpotActorSendHandler;
+exports.zlinkEntrySpotActorRequestHandler = zlinkEntrySpotActorRequestHandler;
+exports.zlinkEntrySpotActorSendHandler = zlinkEntrySpotActorSendHandler;
+exports.zlinkSpotTimerHandler = zlinkSpotTimerHandler;
+exports.zlinkHandler = zlinkHandler;
+const common_1 = require("@nestjs/common");
+const framework_loader_1 = require("./framework-loader");
+const handler_metadata_1 = require("./handler-metadata");
+function zlinkRequestHandler(groupName, packetName, options = {}) {
+    return zlinkHandler(groupName, 'request', packetName, options);
+}
+function zlinkSendHandler(groupName, packetName, options = {}) {
+    return zlinkHandler(groupName, 'send', packetName, options);
+}
+function zlinkPublishHandler(groupName, packetName, options = {}) {
+    return zlinkHandler(groupName, 'publish', packetName, options);
+}
+function zlinkSpotActorRequestHandler(options) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestSpotActorHandlerMetadata)(target, {
+            actor: options.actor,
+            handlerType: target,
+            kind: 'spotActorRequest',
+            methodName: options.methodName ?? 'handle',
+            packetName: options.packetName,
+            spot: options.spot
+        });
+    };
+}
+function zlinkSpotPacketHandler(options) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestSpotHandlerMetadata)(target, {
+            handlerType: target,
+            kind: 'spotPacket',
+            packetName: options.packetName,
+            spot: options.spot
+        });
+    };
+}
+function zlinkEntrySpotPacketHandler(options) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestSpotHandlerMetadata)(target, {
+            entrySpot: options.entrySpot,
+            handlerType: target,
+            kind: 'entrySpotPacket',
+            packetName: options.packetName
+        });
+    };
+}
+function zlinkSpotSubscriptionHandler(options) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestSpotHandlerMetadata)(target, {
+            handlerType: target,
+            kind: 'spotSubscription',
+            spot: options.spot,
+            channelName: options.channelName,
+            topic: options.topic
+        });
+    };
+}
+function zlinkEntrySpotSubscriptionHandler(options) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestSpotHandlerMetadata)(target, {
+            entrySpot: options.entrySpot,
+            handlerType: target,
+            kind: 'entrySpotSubscription',
+            channelName: options.channelName,
+            topic: options.topic
+        });
+    };
+}
+function zlinkSpotActorSendHandler(options) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestSpotActorHandlerMetadata)(target, {
+            actor: options.actor,
+            handlerType: target,
+            kind: 'spotActorSend',
+            methodName: options.methodName ?? 'handle',
+            packetName: options.packetName,
+            spot: options.spot
+        });
+    };
+}
+function zlinkEntrySpotActorRequestHandler(options) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestSpotActorHandlerMetadata)(target, {
+            actor: options.actor,
+            entrySpot: options.entrySpot,
+            handlerType: target,
+            kind: 'entrySpotActorRequest',
+            methodName: options.methodName ?? 'handle',
+            packetName: options.packetName
+        });
+    };
+}
+function zlinkEntrySpotActorSendHandler(options) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestSpotActorHandlerMetadata)(target, {
+            actor: options.actor,
+            entrySpot: options.entrySpot,
+            handlerType: target,
+            kind: 'entrySpotActorSend',
+            methodName: options.methodName ?? 'handle',
+            packetName: options.packetName
+        });
+    };
+}
+function zlinkSpotTimerHandler(options = {}) {
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.markNestSpotTimerHandler)(target);
+        if (options.name !== undefined && options.periodMs !== undefined) {
+            (0, handler_metadata_1.appendNestSpotTimerHandlerMetadata)(target, {
+                entrySpot: options.entrySpot,
+                handlerType: target,
+                name: options.name,
+                options: options.options,
+                periodMs: options.periodMs,
+                spot: options.spot
+            });
+        }
+    };
+}
+function zlinkHandler(groupName, kind, packetName, options = {}) {
+    validateHandlerGroupName(groupName);
+    return (target) => {
+        (0, common_1.Injectable)()(target);
+        (0, handler_metadata_1.appendNestHandlerMetadata)(target, {
+            decodePayload: options.decodePayload,
+            encodeResult: options.encodeResult,
+            groupName,
+            kind,
+            methodName: options.methodName ?? 'handle',
+            packetName: packetName ?? inferPacketName(target, target)
+        });
+    };
+}
+function validateHandlerGroupName(groupName) {
+    if (groupName.trim() === '') {
+        throw new framework_loader_1.framework.ZLinkConfigurationException('ZLink handler group name must not be empty.');
+    }
+}
+function inferPacketName(handlerType, handlerToken) {
+    if (handlerType !== undefined) {
+        return handlerType.name.endsWith('Handler')
+            ? handlerType.name.slice(0, -'Handler'.length)
+            : handlerType.name;
+    }
+    const tokenName = typeof handlerToken === 'symbol'
+        ? handlerToken.description
+        : String(handlerToken);
+    if (tokenName === undefined || tokenName.trim() === '') {
+        throw new framework_loader_1.framework.ZLinkConfigurationException('ZLink handler packetName is required for anonymous provider tokens.');
+    }
+    return tokenName;
+}

package/dist/dispatch-scope.d.ts

@@ -0,0 +1,5 @@
+import type { 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

@@ -0,0 +1,19 @@
+"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");
+const dispatchContext = new node_async_hooks_1.AsyncLocalStorage();
+async function runInNestDispatchScope(moduleRef, context, callback) {
+    const contextId = core_1.ContextIdFactory.create();
+    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/drain-health-indicator.d.ts

@@ -0,0 +1,9 @@
+import type { ZLinkRouteMeshRuntime } from '@zlink-systems/framework';
+export declare class ZLinkDrainHealthIndicator {
+    private readonly runtime;
+    private readonly meshName;
+    constructor(runtime: ZLinkRouteMeshRuntime, meshName: string);
+    isHealthy(key?: string): Promise<Record<string, {
+        readonly status: 'up';
+    }>>;
+}

package/dist/drain-health-indicator.js

@@ -0,0 +1,32 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkDrainHealthIndicator = void 0;
+const common_1 = require("@nestjs/common");
+let ZLinkDrainHealthIndicator = class ZLinkDrainHealthIndicator {
+    runtime;
+    meshName;
+    constructor(runtime, meshName) {
+        this.runtime = runtime;
+        this.meshName = meshName;
+    }
+    async isHealthy(key = 'zlink') {
+        if (!this.runtime.isReady(this.meshName)) {
+            throw new Error(`${key} is draining.`);
+        }
+        return { [key]: { status: 'up' } };
+    }
+};
+exports.ZLinkDrainHealthIndicator = ZLinkDrainHealthIndicator;
+exports.ZLinkDrainHealthIndicator = ZLinkDrainHealthIndicator = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object, String])
+], ZLinkDrainHealthIndicator);