@ebarahona/loopback-transport-core 1.0.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,YAAY;AACZ,6DAAyD;AAAjD,yHAAA,kBAAkB,OAAA;AAE1B,SAAS;AACT,uDAAmD;AAA3C,mHAAA,eAAe,OAAA;AAEvB,wBAAwB;AACxB,+BAIgB;AAHd,yGAAA,iBAAiB,OAAA;AACjB,4GAAA,oBAAoB,OAAA;AACpB,0GAAA,kBAAkB,OAAA;AAGpB,WAAW;AACX,uCAA2C;AAAnC,2GAAA,eAAe,OAAA;AAkBvB,UAAU;AACV,qCAMmB;AALjB,2GAAA,gBAAgB,OAAA;AAOlB,aAAa;AACb,2CAUsB;AATpB,4GAAA,cAAc,OAAA;AACd,0GAAA,YAAY,OAAA;AACZ,qGAAA,OAAO,OAAA;AACP,0GAAA,YAAY,OAAA;AAIZ,sHAAA,wBAAwB,OAAA;AACxB,oHAAA,sBAAsB,OAAA;AAGxB,QAAQ;AACR,iCAAyC;AAAjC,yGAAA,gBAAgB,OAAA;AAExB,SAAS;AACT,mCAAqC;AAA7B,qGAAA,WAAW,OAAA;AAEnB,SAAS;AACT,mCAAmD;AAA3C,oGAAA,UAAU,OAAA;AAElB,cAAc;AACd,6CAMuB;AAHrB,6GAAA,cAAc,OAAA;AACd,+GAAA,gBAAgB,OAAA"}

package/dist/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './packet.interface';
+export * from './transport-server.interface';
+export * from './transport-client.interface';
+export * from './message-handler.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./packet.interface"), exports);
+__exportStar(require("./transport-server.interface"), exports);
+__exportStar(require("./transport-client.interface"), exports);
+__exportStar(require("./message-handler.interface"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qDAAmC;AACnC,+DAA6C;AAC7C,+DAA6C;AAC7C,8DAA4C"}

package/dist/interfaces/message-handler.interface.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+/**
+ * Function that handles an incoming message.
+ */
+export interface MessageHandler<TInput = unknown, TContext = unknown, TResult = unknown> {
+    (data: TInput, ctx?: TContext): Promise<TResult> | Promise<Observable<TResult>> | TResult | Observable<TResult>;
+    /**
+     * True for @eventHandler, false for @messageHandler.
+     */
+    isEventHandler?: boolean;
+    /**
+     * Target transport name (e.g., 'kafka', 'rabbitmq').
+     * First-class property for routing, not buried in extras.
+     */
+    transport?: string;
+    /**
+     * Transport-specific metadata (e.g., QoS for MQTT, consumer group for Kafka).
+     * Does not contain framework routing metadata (use transport field instead).
+     */
+    extras?: Readonly<Record<string, unknown>>;
+}

package/dist/interfaces/message-handler.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=message-handler.interface.js.map

package/dist/interfaces/message-handler.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-handler.interface.js","sourceRoot":"","sources":["../../src/interfaces/message-handler.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/packet.interface.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Unique identifier for correlating request/response messages.
+ */
+export interface PacketId {
+    id: string;
+}
+/**
+ * Inbound message envelope. Used for both requests and events.
+ * Events omit the id field.
+ */
+export interface ReadPacket<T = unknown> {
+    pattern: string;
+    data: T;
+}
+/**
+ * Outbound response envelope. Sent back for request/response patterns.
+ */
+export interface WritePacket<T = unknown> {
+    err?: Error | string | Record<string, unknown>;
+    response?: T;
+    isDisposed?: boolean;
+}
+/**
+ * A request with a correlation ID for response matching.
+ */
+export type OutgoingRequest = ReadPacket & PacketId;
+/**
+ * An event with no correlation ID (fire-and-forget).
+ */
+export type OutgoingEvent = ReadPacket;
+/**
+ * Server receives a request with correlation ID.
+ */
+export type IncomingRequest = ReadPacket & PacketId;
+/**
+ * Server receives an event (no correlation).
+ */
+export type IncomingEvent = ReadPacket;
+/**
+ * Response correlated to a request by ID.
+ */
+export type IncomingResponse = WritePacket & PacketId;

package/dist/interfaces/packet.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=packet.interface.js.map

package/dist/interfaces/packet.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packet.interface.js","sourceRoot":"","sources":["../../src/interfaces/packet.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/transport-client.interface.d.ts

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { TransportStatus } from './transport-server.interface';
+/**
+ * Interface that all transport clients must implement.
+ * Used for sending messages to brokers (producer side).
+ */
+export interface TransportClient {
+    /**
+     * Establish connection to the broker.
+     * Called lazily on first send/emit, or explicitly for eager connection.
+     */
+    connect(): Promise<void>;
+    /**
+     * Close the connection.
+     */
+    close(): Promise<void>;
+    /**
+     * Send a request and wait for a response (request/response pattern).
+     * Returns a cold Observable: the message is sent when subscribed.
+     *
+     * @param pattern - String or object pattern to match on the server side
+     * @param data - The message payload
+     */
+    send<TResult = unknown, TInput = unknown>(pattern: string | Record<string, unknown>, data: TInput): Observable<TResult>;
+    /**
+     * Emit an event with no response expected (fire-and-forget pattern).
+     * Returns a Promise that resolves when the event is dispatched.
+     *
+     * @param pattern - String or object event pattern
+     * @param data - The event payload
+     */
+    emit<TInput = unknown>(pattern: string | Record<string, unknown>, data: TInput): Promise<void>;
+    /**
+     * Observable stream of connection status changes.
+     */
+    readonly status$: Observable<TransportStatus>;
+    /**
+     * Access the underlying native client (e.g., KafkaJS Producer).
+     */
+    unwrap<T>(): T;
+}

package/dist/interfaces/transport-client.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transport-client.interface.js.map

package/dist/interfaces/transport-client.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-client.interface.js","sourceRoot":"","sources":["../../src/interfaces/transport-client.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/transport-server.interface.d.ts

@@ -0,0 +1,44 @@
+import { Observable } from 'rxjs';
+import { MessageHandler } from './message-handler.interface';
+/**
+ * Transport connection status.
+ */
+export type TransportStatus = 'connected' | 'disconnected' | 'reconnecting' | 'error';
+/**
+ * Interface that all transport servers must implement.
+ * Each transport (Kafka, RabbitMQ, gRPC, MQTT, NATS) provides
+ * a concrete implementation.
+ */
+export interface TransportServer {
+    /**
+     * Start listening for messages.
+     */
+    listen(): Promise<void>;
+    /**
+     * Stop listening and close connections.
+     */
+    close(): Promise<void>;
+    /**
+     * Observable stream of connection status changes.
+     */
+    readonly status$: Observable<TransportStatus>;
+    /**
+     * Access the underlying native client (e.g., KafkaJS Consumer).
+     */
+    unwrap<T>(): T;
+    /**
+     * Register a message handler for a pattern.
+     */
+    addHandler(pattern: string, handler: MessageHandler): void;
+    /**
+     * Get all registered handlers. Returns a read-only view.
+     * Each pattern maps to an array of handlers (one for request/response,
+     * potentially many for event fan-out).
+     */
+    getHandlers(): ReadonlyMap<string, readonly MessageHandler[]>;
+    /**
+     * Remove all registered handlers.
+     * Called before rebinding on restart to prevent duplicate registration.
+     */
+    clearHandlers(): void;
+}

package/dist/interfaces/transport-server.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transport-server.interface.js.map

package/dist/interfaces/transport-server.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-server.interface.js","sourceRoot":"","sources":["../../src/interfaces/transport-server.interface.ts"],"names":[],"mappings":""}

package/dist/keys.d.ts

@@ -0,0 +1,88 @@
+import { Application, Binding, BindingKey, Constructor, Provider } from '@loopback/core';
+import { TransportClient, TransportServer } from './interfaces';
+import type { HandlerRegistry } from './registry';
+/**
+ * Tag used to identify transport server bindings.
+ * Transport adapters should tag their server bindings with this value.
+ */
+export declare const TRANSPORT_SERVER_TAG = "transport-server";
+/**
+ * Tag key for the transport name on server bindings.
+ */
+export declare const TRANSPORT_NAME_TAG = "transport";
+export declare namespace TransportBindings {
+    /**
+     * Binding key for the handler registry.
+     */
+    const HANDLER_REGISTRY: BindingKey<HandlerRegistry>;
+    /**
+     * Binding key for the current message payload.
+     * Set by the handler registry before invoking the handler.
+     */
+    const CURRENT_PAYLOAD: BindingKey<unknown>;
+    /**
+     * Binding key for the current transport context.
+     * Set by the transport server before invoking the handler.
+     */
+    const CURRENT_CONTEXT: BindingKey<unknown>;
+    /**
+     * Binding key prefix for transport configurations.
+     */
+    const CONFIG_PREFIX = "transport.config";
+    /**
+     * Binding key prefix for transport clients.
+     */
+    const CLIENT_PREFIX = "transport.client";
+    /**
+     * Binding key prefix for transport servers.
+     */
+    const SERVER_PREFIX = "transport.server";
+    /**
+     * Get a binding key for a specific transport's configuration.
+     */
+    function config(transport: string): BindingKey<Record<string, unknown>>;
+    /**
+     * Get a binding key for a specific transport's client.
+     */
+    function client(transport: string): BindingKey<TransportClient>;
+    /**
+     * Get a binding key for a specific transport's server.
+     */
+    function server(transport: string): BindingKey<TransportServer>;
+    /**
+     * Register a concrete transport server instance.
+     *
+     * Use when the server is already constructed (e.g., in tests or
+     * when no DI is needed).
+     *
+     * @param app - The LoopBack application
+     * @param transport - Transport name (e.g., 'kafka', 'rabbitmq')
+     * @param instance - A concrete transport server instance
+     */
+    function registerServer(app: Application, transport: string, instance: TransportServer): Binding<TransportServer>;
+    /**
+     * Register a transport server class with the IoC container.
+     *
+     * The class is instantiated by the container, enabling constructor
+     * injection of config, clients, health checks, and other dependencies.
+     * This is the recommended registration method for transport adapters.
+     *
+     * @param app - The LoopBack application
+     * @param transport - Transport name (e.g., 'kafka', 'rabbitmq')
+     * @param serverClass - A transport server class constructor
+     */
+    function registerServerClass(app: Application, transport: string, serverClass: Constructor<TransportServer>): Binding<TransportServer>;
+    /**
+     * Register a transport server provider.
+     *
+     * Providers enable async factory patterns with full DI support.
+     * Use when server construction requires async initialization or
+     * complex setup logic. The binding is singleton-scoped so every
+     * resolution returns the same server instance.
+     *
+     * @param app - The LoopBack application
+     * @param transport - Transport name (e.g., 'kafka', 'rabbitmq')
+     * @param serverProvider - A provider class that produces a TransportServer
+     */
+    function registerServerProvider(app: Application, transport: string, serverProvider: Constructor<Provider<TransportServer>>): Binding<TransportServer>;
+}

package/dist/keys.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportBindings = exports.TRANSPORT_NAME_TAG = exports.TRANSPORT_SERVER_TAG = void 0;
+const core_1 = require("@loopback/core");
+/**
+ * Tag used to identify transport server bindings.
+ * Transport adapters should tag their server bindings with this value.
+ */
+exports.TRANSPORT_SERVER_TAG = 'transport-server';
+/**
+ * Tag key for the transport name on server bindings.
+ */
+exports.TRANSPORT_NAME_TAG = 'transport';
+var TransportBindings;
+(function (TransportBindings) {
+    /**
+     * Binding key for the handler registry.
+     */
+    TransportBindings.HANDLER_REGISTRY = core_1.BindingKey.create('transport.handler-registry');
+    /**
+     * Binding key for the current message payload.
+     * Set by the handler registry before invoking the handler.
+     */
+    TransportBindings.CURRENT_PAYLOAD = core_1.BindingKey.create('transport.current.payload');
+    /**
+     * Binding key for the current transport context.
+     * Set by the transport server before invoking the handler.
+     */
+    TransportBindings.CURRENT_CONTEXT = core_1.BindingKey.create('transport.current.context');
+    /**
+     * Binding key prefix for transport configurations.
+     */
+    TransportBindings.CONFIG_PREFIX = 'transport.config';
+    /**
+     * Binding key prefix for transport clients.
+     */
+    TransportBindings.CLIENT_PREFIX = 'transport.client';
+    /**
+     * Binding key prefix for transport servers.
+     */
+    TransportBindings.SERVER_PREFIX = 'transport.server';
+    /**
+     * Get a binding key for a specific transport's configuration.
+     */
+    function config(transport) {
+        return core_1.BindingKey.create(`${TransportBindings.CONFIG_PREFIX}.${transport}`);
+    }
+    TransportBindings.config = config;
+    /**
+     * Get a binding key for a specific transport's client.
+     */
+    function client(transport) {
+        return core_1.BindingKey.create(`${TransportBindings.CLIENT_PREFIX}.${transport}`);
+    }
+    TransportBindings.client = client;
+    /**
+     * Get a binding key for a specific transport's server.
+     */
+    function server(transport) {
+        return core_1.BindingKey.create(`${TransportBindings.SERVER_PREFIX}.${transport}`);
+    }
+    TransportBindings.server = server;
+    /**
+     * Tag a transport server binding for booter discovery.
+     */
+    function tagServerBinding(binding, transport) {
+        return binding
+            .tag(exports.TRANSPORT_SERVER_TAG)
+            .tag({ [exports.TRANSPORT_NAME_TAG]: transport });
+    }
+    /**
+     * Register a concrete transport server instance.
+     *
+     * Use when the server is already constructed (e.g., in tests or
+     * when no DI is needed).
+     *
+     * @param app - The LoopBack application
+     * @param transport - Transport name (e.g., 'kafka', 'rabbitmq')
+     * @param instance - A concrete transport server instance
+     */
+    function registerServer(app, transport, instance) {
+        return tagServerBinding(app.bind(server(transport)).to(instance), transport);
+    }
+    TransportBindings.registerServer = registerServer;
+    /**
+     * Register a transport server class with the IoC container.
+     *
+     * The class is instantiated by the container, enabling constructor
+     * injection of config, clients, health checks, and other dependencies.
+     * This is the recommended registration method for transport adapters.
+     *
+     * @param app - The LoopBack application
+     * @param transport - Transport name (e.g., 'kafka', 'rabbitmq')
+     * @param serverClass - A transport server class constructor
+     */
+    function registerServerClass(app, transport, serverClass) {
+        return tagServerBinding(app
+            .bind(server(transport))
+            .toClass(serverClass)
+            .inScope(core_1.BindingScope.SINGLETON), transport);
+    }
+    TransportBindings.registerServerClass = registerServerClass;
+    /**
+     * Register a transport server provider.
+     *
+     * Providers enable async factory patterns with full DI support.
+     * Use when server construction requires async initialization or
+     * complex setup logic. The binding is singleton-scoped so every
+     * resolution returns the same server instance.
+     *
+     * @param app - The LoopBack application
+     * @param transport - Transport name (e.g., 'kafka', 'rabbitmq')
+     * @param serverProvider - A provider class that produces a TransportServer
+     */
+    function registerServerProvider(app, transport, serverProvider) {
+        return tagServerBinding(app
+            .bind(server(transport))
+            .toProvider(serverProvider)
+            .inScope(core_1.BindingScope.SINGLETON), transport);
+    }
+    TransportBindings.registerServerProvider = registerServerProvider;
+})(TransportBindings || (exports.TransportBindings = TransportBindings = {}));
+//# sourceMappingURL=keys.js.map

package/dist/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":";;;AAAA,yCAOwB;AAIxB;;;GAGG;AACU,QAAA,oBAAoB,GAAG,kBAAkB,CAAC;AAEvD;;GAEG;AACU,QAAA,kBAAkB,GAAG,WAAW,CAAC;AAE9C,IAAiB,iBAAiB,CA4IjC;AA5ID,WAAiB,iBAAiB;IAChC;;OAEG;IACU,kCAAgB,GAAG,iBAAU,CAAC,MAAM,CAC/C,4BAA4B,CAC7B,CAAC;IAEF;;;OAGG;IACU,iCAAe,GAAG,iBAAU,CAAC,MAAM,CAC9C,2BAA2B,CAC5B,CAAC;IAEF;;;OAGG;IACU,iCAAe,GAAG,iBAAU,CAAC,MAAM,CAC9C,2BAA2B,CAC5B,CAAC;IAEF;;OAEG;IACU,+BAAa,GAAG,kBAAkB,CAAC;IAEhD;;OAEG;IACU,+BAAa,GAAG,kBAAkB,CAAC;IAEhD;;OAEG;IACU,+BAAa,GAAG,kBAAkB,CAAC;IAEhD;;OAEG;IACH,SAAgB,MAAM,CAAC,SAAiB;QACtC,OAAO,iBAAU,CAAC,MAAM,CAAC,GAAG,kBAAA,aAAa,IAAI,SAAS,EAAE,CAAC,CAAC;IAC5D,CAAC;IAFe,wBAAM,SAErB,CAAA;IAED;;OAEG;IACH,SAAgB,MAAM,CAAC,SAAiB;QACtC,OAAO,iBAAU,CAAC,MAAM,CAAC,GAAG,kBAAA,aAAa,IAAI,SAAS,EAAE,CAAC,CAAC;IAC5D,CAAC;IAFe,wBAAM,SAErB,CAAA;IAED;;OAEG;IACH,SAAgB,MAAM,CAAC,SAAiB;QACtC,OAAO,iBAAU,CAAC,MAAM,CAAC,GAAG,kBAAA,aAAa,IAAI,SAAS,EAAE,CAAC,CAAC;IAC5D,CAAC;IAFe,wBAAM,SAErB,CAAA;IAED;;OAEG;IACH,SAAS,gBAAgB,CACvB,OAAiC,EACjC,SAAiB;QAEjB,OAAO,OAAO;aACX,GAAG,CAAC,4BAAoB,CAAC;aACzB,GAAG,CAAC,EAAC,CAAC,0BAAkB,CAAC,EAAE,SAAS,EAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;OASG;IACH,SAAgB,cAAc,CAC5B,GAAgB,EAChB,SAAiB,EACjB,QAAyB;QAEzB,OAAO,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC;IAC/E,CAAC;IANe,gCAAc,iBAM7B,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,mBAAmB,CACjC,GAAgB,EAChB,SAAiB,EACjB,WAAyC;QAEzC,OAAO,gBAAgB,CACrB,GAAG;aACA,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;aACvB,OAAO,CAAC,WAAW,CAAC;aACpB,OAAO,CAAC,mBAAY,CAAC,SAAS,CAAC,EAClC,SAAS,CACV,CAAC;IACJ,CAAC;IAZe,qCAAmB,sBAYlC,CAAA;IAED;;;;;;;;;;;OAWG;IACH,SAAgB,sBAAsB,CACpC,GAAgB,EAChB,SAAiB,EACjB,cAAsD;QAEtD,OAAO,gBAAgB,CACrB,GAAG;aACA,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;aACvB,UAAU,CAAC,cAAc,CAAC;aAC1B,OAAO,CAAC,mBAAY,CAAC,SAAS,CAAC,EAClC,SAAS,CACV,CAAC;IACJ,CAAC;IAZe,wCAAsB,yBAYrC,CAAA;AACH,CAAC,EA5IgB,iBAAiB,iCAAjB,iBAAiB,QA4IjC"}

package/dist/registry/handler-registry.d.ts

@@ -0,0 +1,77 @@
+import { Application } from '@loopback/core';
+import { MessageHandler } from '../interfaces';
+/**
+ * Discovers @messageHandler and @eventHandler decorated methods
+ * from controllers and registers them with the appropriate transport server.
+ *
+ * This class does NOT run in the constructor. It is invoked by
+ * TransportBooter after all controllers are registered.
+ *
+ * Handler invocations use per-message child contexts for concurrency
+ * safety. The application context is never mutated per-message.
+ *
+ * Context lifetime extends until the handler result (including Observable
+ * streams) fully completes, errors, or times out.
+ */
+export declare class HandlerRegistry {
+    /**
+     * Registry keyed by `transport::pattern` to support the same pattern
+     * on different transports without collision.
+     */
+    private readonly handlers;
+    private discovered;
+    /**
+     * Scan all controllers in the application for transport decorators
+     * and register the handlers.
+     *
+     * Idempotent: clears previously discovered handlers before scanning.
+     */
+    discoverHandlers(app: Application): Promise<void>;
+    /**
+     * Bind discovered handlers to the registered transport servers.
+     * Throws if discovery has not been run.
+     *
+     * Handles precedence: transport-specific handlers override wildcard
+     * handlers for the same pattern on that transport's server.
+     */
+    bindToServers(app: Application): Promise<void>;
+    /**
+     * Get all discovered handlers.
+     */
+    getHandlers(): ReadonlyMap<string, readonly MessageHandler[]>;
+    /**
+     * Whether discovery has been run.
+     */
+    isDiscovered(): boolean;
+    /**
+     * Build the registry key from transport and raw pattern.
+     * Normalizes the pattern (sorts object keys) before keying.
+     * Format: `transport::normalizedPattern` or `*::normalizedPattern`.
+     */
+    private buildKey;
+    /**
+     * Extract the pattern portion from a registry key.
+     */
+    private extractPattern;
+    private scanMessageHandlers;
+    private scanEventHandlers;
+    /**
+     * Shared scanner for both @messageHandler and @eventHandler metadata.
+     * The isEvent flag controls duplicate/chaining rules.
+     */
+    private scanHandlers;
+    /**
+     * Create a handler function that invokes the controller method through
+     * LoopBack's native invocation pipeline.
+     *
+     * Each invocation creates a uniquely named child Context from the
+     * application context. Per-message bindings (payload, transport context)
+     * are scoped to the child context and cannot collide with concurrent
+     * messages.
+     *
+     * The child context lifetime extends until the handler result fully
+     * resolves. For Observable results, the context stays open until the
+     * Observable completes, errors, or times out.
+     */
+    private createHandler;
+}