@ebarahona/loopback-transport-core 1.0.0 → 1.2.0

package/dist/server/server-base.d.ts

@@ -1,15 +1,19 @@
-import { Observable } from 'rxjs';
-import { TransportServer, TransportStatus, MessageHandler, WritePacket, IncomingRequest, IncomingEvent } from '../interfaces';
-import { Serializer, Deserializer } from '../serializers';
+import type { Application } from '@loopback/core';
+import type { Observable } from 'rxjs';
+import type { IncomingEvent, IncomingRequest, MessageHandler, TransportServer, TransportStatus, WritePacket } from '../interfaces';
+import { type Deserializer, type Serializer } from '../serializers';
 /**
  * Result of handling a message. Separates "what was sent to the caller"
- * from "should the broker ack or nack this message."
+ * from "should the broker ack or nack this message".
  *
  * - `success`: Handler completed. Response was sent. Adapter should ack.
- * - `handler-error`: Handler threw or Observable errored. Error response
- *   was sent to the caller. Adapter should ack (the error was handled).
+ * - `handler-error`: Handler threw or Observable errored. Error
+ *   response was sent to the caller. Adapter should ack (the error was
+ *   handled).
  * - `infrastructure-error`: No handler found, serialization failure, or
  *   other framework-level failure. Adapter should nack/dead-letter.
+ *
+ * @public
  */
 export interface HandlerResult {
     readonly outcome: 'success' | 'handler-error' | 'infrastructure-error';
@@ -19,16 +23,19 @@ export interface HandlerResult {
  * Abstract base class for transport servers.
  *
  * Manages the handler registry, message dispatching, and serialization.
- * Each transport (Kafka, RabbitMQ, gRPC, MQTT, NATS) extends this
- * class and implements listen/close/unwrap.
+ * Each transport (Kafka, RabbitMQ, gRPC, MQTT, NATS) extends this class
+ * and implements `listen`/`close`/`unwrap`.
  *
  * Subclasses should:
- * - Call deserializer.deserialize() on raw broker messages before
- *   passing them to handleMessage()/handleEvent()
- * - Call serializer.serialize() on outbound responses
- * - Call setStatus('connected') in listen() when ready
- * - Call setStatus('disconnected') in close() when stopped
- * - Call dispose() only when the server will never be restarted
+ *
+ * - Call `deserializer.deserialize()` on raw broker messages before
+ *   passing them to `handleMessage()` / `handleEvent()`.
+ * - Call `serializer.serialize()` on outbound responses.
+ * - Call `setStatus('connected')` in `listen()` when ready.
+ * - Call `setStatus('disconnected')` in `close()` when stopped.
+ * - Call `dispose()` only when the server will never be restarted.
+ *
+ * @public
  */
 export declare abstract class ServerBase implements TransportServer {
     protected readonly messageHandlers: Map<string, MessageHandler<unknown, unknown, unknown>[]>;
@@ -43,108 +50,174 @@ export declare abstract class ServerBase implements TransportServer {
         handlerTimeoutMs?: number;
     });
     /**
-     * Start listening for messages from the broker.
-     * Subclasses should call setStatus('connected') when ready.
+     * Resolve the serializer/deserializer pair for this server from the
+     * app container, honoring transport-scoped \> generic \> subclass-default
+     * precedence.
+     *
+     * Called by the transport lifecycle observer between
+     * `bindToServers` and `listen()`. Plugins contribute tag-based
+     * serializers via {@link SERIALIZER_TAG} / {@link DESERIALIZER_TAG};
+     * subclass defaults set via the `protected serializer` /
+     * `protected deserializer` fields are still honored when no tagged
+     * binding matches.
+     *
+     * Resolution precedence (most specific wins):
+     *
+     * 1. Transport-scoped binding (tagged with `SERIALIZER_TAG` /
+     *    `DESERIALIZER_TAG` AND `TRANSPORT_NAME_TAG` equal to this
+     *    server's transport name).
+     * 2. Generic binding (tagged with `SERIALIZER_TAG` /
+     *    `DESERIALIZER_TAG` but no `TRANSPORT_NAME_TAG`).
+     * 3. Subclass default — the existing `protected serializer` /
+     *    `protected deserializer` field value.
+     *
+     * @public
+     * @param app - The LoopBack application container to resolve
+     *   serializer bindings from.
+     */
+    resolveSerializer(app: Application): Promise<void>;
+    /**
+     * Find the transport name tag for this server instance by scanning
+     * `TRANSPORT_SERVER_TAG` bindings and matching the resolved instance
+     * against `this`. Returns `undefined` if the server is not bound (in
+     * tests, or before the booter wires servers up), in which case
+     * `resolveSerializer` falls back to generic-only matching.
+     */
+    private findTransportName;
+    /**
+     * Resolve a tagged binding, preferring transport-scoped over generic.
+     * Returns `undefined` if no tagged binding exists.
+     */
+    private lookupTaggedBinding;
+    /**
+     * Start listening for messages from the broker. Subclasses should
+     * call `setStatus('connected')` when ready.
+     *
+     * @public
      */
     abstract listen(): Promise<void>;
     /**
-     * Stop listening and close connections.
-     * Subclasses should call setStatus('disconnected') when stopped.
-     * Call dispose() only when the server will never be restarted.
+     * Stop listening and close connections. Subclasses should call
+     * `setStatus('disconnected')` when stopped. Call `dispose()` only
+     * when the server will never be restarted.
+     *
+     * @public
      */
     abstract close(): Promise<void>;
     /**
      * Access the underlying native server/consumer.
+     *
+     * @public
+     * @typeParam T - Caller-asserted native server shape.
      */
     abstract unwrap<T>(): T;
     /**
-     * Emit a status change. Called by transport adapters in listen() and close().
+     * Emit a status change. Called by transport adapters in `listen()`
+     * and `close()`.
      */
     protected setStatus(status: TransportStatus): void;
     /**
-     * Permanently complete the status stream. After this call, no further
-     * status emissions are possible and the server instance cannot restart.
-     * Existing subscribers receive the complete notification.
+     * Permanently complete the status stream. After this call, no
+     * further status emissions are possible and the server instance
+     * cannot restart. Existing subscribers receive the complete
+     * notification.
      *
-     * Call only when the server is being permanently disposed.
-     * Normal close() should call setStatus('disconnected'), NOT dispose().
+     * Call only when the server is being permanently disposed. Normal
+     * `close()` should call `setStatus('disconnected')`, NOT `dispose()`.
      */
     protected dispose(): void;
     /**
      * Register a handler for a message pattern.
      *
-     * For request/response handlers (@messageHandler): duplicate patterns
-     * throw an error. Only one handler per pattern is allowed.
+     * For request/response handlers (`@messageHandler`): duplicate
+     * patterns throw an error. Only one handler per pattern is allowed.
+     *
+     * For event handlers (`@eventHandler`): multiple handlers on the
+     * same pattern are stored in an array and all execute.
      *
-     * For event handlers (@eventHandler): multiple handlers on the same
-     * pattern are stored in an array and all execute.
+     * Mixing `@messageHandler` and `@eventHandler` on the same pattern
+     * throws.
      *
-     * Mixing @messageHandler and @eventHandler on the same pattern throws.
+     * Handlers are never mutated. Each server owns its own handler
+     * array, so the same handler object can be safely shared across
+     * servers.
      *
-     * Handlers are never mutated. Each server owns its own handler array,
-     * so the same handler object can be safely shared across servers.
+     * @public
+     * @param pattern - The message pattern (already normalized by the registry).
+     * @param handler - The handler to register.
+     * @throws TransportConfigError When a request handler is duplicated
+     *   or a request/event mix is attempted on the same pattern.
      */
     addHandler(pattern: string, handler: MessageHandler): void;
     /**
      * Get all registered handlers. Returns a defensive copy.
+     *
+     * @public
      */
     getHandlers(): ReadonlyMap<string, readonly MessageHandler[]>;
     /**
-     * Remove all registered handlers.
-     * Called before rebinding on restart to prevent duplicate registration.
+     * Remove all registered handlers. Called before rebinding on
+     * restart to prevent duplicate registration.
+     *
+     * @public
      */
     clearHandlers(): void;
     /**
      * Get handlers by pattern. Normalizes the pattern before lookup.
      * Returns a defensive copy for external consumers.
+     *
+     * @public
      */
     getHandlersByPattern(pattern: string | Record<string, unknown>): readonly MessageHandler[] | undefined;
     /**
-     * Internal handler lookup. Returns the live array for dispatch performance.
+     * Internal handler lookup. Returns the live array for dispatch
+     * performance.
      */
     private lookupHandlers;
     /**
      * Handle a request/response message.
      *
-     * Invokes the handler and calls respond() with each result value.
+     * Invokes the handler and calls `respond()` with each result value.
      * Observable subscriptions are tracked and cleaned up on completion,
      * error, or timeout.
      *
-     * Returns a HandlerResult that separates response semantics from
-     * broker settlement semantics:
+     * Returns a {@link HandlerResult} that separates response semantics
+     * from broker settlement semantics:
      *
      * - `success`: Handler completed normally. Ack the message.
      * - `handler-error`: Handler threw or Observable errored. The error
-     *   response was already sent to the caller. Ack the message --
-     *   the error was handled as an application-level response.
+     *   response was already sent to the caller. Ack the message — the
+     *   error was handled as an application-level response.
      * - `infrastructure-error`: No handler found or framework failure.
      *   Nack/dead-letter the message.
      *
-     * Observable handlers that do not complete within handlerTimeoutMs
-     * are terminated with a timeout error (handler-error).
+     * Observable handlers that do not complete within
+     * `handlerTimeoutMs` are terminated with a timeout error
+     * (`handler-error`).
      *
-     * If respond() throws (adapter publication failure), the error is
-     * caught and returned as infrastructure-error.
+     * If `respond()` throws (adapter publication failure), the error is
+     * caught and returned as `infrastructure-error`.
      */
     protected handleMessage(request: IncomingRequest, respond: (packet: WritePacket) => void, context?: unknown): Promise<HandlerResult>;
     /**
-     * Core handler execution. Separated from handleMessage so that
-     * respond() failures bubble up and are caught by the outer wrapper.
+     * Core handler execution. Separated from `handleMessage` so that
+     * `respond()` failures bubble up and are caught by the outer
+     * wrapper.
      */
     private executeHandler;
     /**
      * Handle a fire-and-forget event.
      *
-     * Invokes all chained handlers for the pattern.
-     * Errors are logged but not propagated (fire-and-forget semantics).
+     * Invokes all chained handlers for the pattern. Errors are logged
+     * but not propagated (fire-and-forget semantics).
      *
-     * Observable event handlers that do not complete within handlerTimeoutMs
-     * are terminated and logged.
+     * Observable event handlers that do not complete within
+     * `handlerTimeoutMs` are terminated and logged.
      */
     protected handleEvent(event: IncomingEvent, context?: unknown): Promise<void>;
     /**
-     * Normalize a pattern to a consistent string key.
-     * Delegates to the shared normalizePattern utility.
+     * Normalize a pattern to a consistent string key. Delegates to the
+     * shared `normalizePattern` utility.
      */
     protected normalizePattern(pattern: string | Record<string, unknown>): string;
     /**

package/dist/server/server-base.js

@@ -1,49 +1,137 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerBase = void 0;
 const rxjs_1 = require("rxjs");
-const debug_1 = require("debug");
+const debug_1 = __importDefault(require("debug"));
+const errors_1 = require("../helpers/errors");
+const keys_1 = require("../keys");
 const serializers_1 = require("../serializers");
 const utils_1 = require("../utils");
 const debug = (0, debug_1.default)('loopback:transport:server');
-const DEFAULT_HANDLER_TIMEOUT_MS = 30000;
+const DEFAULT_HANDLER_TIMEOUT_MS = 30_000;
 /**
  * Abstract base class for transport servers.
  *
  * Manages the handler registry, message dispatching, and serialization.
- * Each transport (Kafka, RabbitMQ, gRPC, MQTT, NATS) extends this
- * class and implements listen/close/unwrap.
+ * Each transport (Kafka, RabbitMQ, gRPC, MQTT, NATS) extends this class
+ * and implements `listen`/`close`/`unwrap`.
  *
  * Subclasses should:
- * - Call deserializer.deserialize() on raw broker messages before
- *   passing them to handleMessage()/handleEvent()
- * - Call serializer.serialize() on outbound responses
- * - Call setStatus('connected') in listen() when ready
- * - Call setStatus('disconnected') in close() when stopped
- * - Call dispose() only when the server will never be restarted
+ *
+ * - Call `deserializer.deserialize()` on raw broker messages before
+ *   passing them to `handleMessage()` / `handleEvent()`.
+ * - Call `serializer.serialize()` on outbound responses.
+ * - Call `setStatus('connected')` in `listen()` when ready.
+ * - Call `setStatus('disconnected')` in `close()` when stopped.
+ * - Call `dispose()` only when the server will never be restarted.
+ *
+ * @public
  */
 class ServerBase {
+    messageHandlers = new Map();
+    statusSubject = new rxjs_1.ReplaySubject(1);
+    serializer;
+    deserializer;
+    handlerTimeoutMs;
+    status$ = this.statusSubject.asObservable();
     constructor(options) {
-        this.messageHandlers = new Map();
-        this.statusSubject = new rxjs_1.ReplaySubject(1);
-        this.status$ = this.statusSubject.asObservable();
         this.serializer = options?.serializer ?? new serializers_1.JsonSerializer();
         this.deserializer = options?.deserializer ?? new serializers_1.JsonDeserializer();
-        this.handlerTimeoutMs = options?.handlerTimeoutMs ?? DEFAULT_HANDLER_TIMEOUT_MS;
+        this.handlerTimeoutMs =
+            options?.handlerTimeoutMs ?? DEFAULT_HANDLER_TIMEOUT_MS;
+    }
+    /**
+     * Resolve the serializer/deserializer pair for this server from the
+     * app container, honoring transport-scoped \> generic \> subclass-default
+     * precedence.
+     *
+     * Called by the transport lifecycle observer between
+     * `bindToServers` and `listen()`. Plugins contribute tag-based
+     * serializers via {@link SERIALIZER_TAG} / {@link DESERIALIZER_TAG};
+     * subclass defaults set via the `protected serializer` /
+     * `protected deserializer` fields are still honored when no tagged
+     * binding matches.
+     *
+     * Resolution precedence (most specific wins):
+     *
+     * 1. Transport-scoped binding (tagged with `SERIALIZER_TAG` /
+     *    `DESERIALIZER_TAG` AND `TRANSPORT_NAME_TAG` equal to this
+     *    server's transport name).
+     * 2. Generic binding (tagged with `SERIALIZER_TAG` /
+     *    `DESERIALIZER_TAG` but no `TRANSPORT_NAME_TAG`).
+     * 3. Subclass default — the existing `protected serializer` /
+     *    `protected deserializer` field value.
+     *
+     * @public
+     * @param app - The LoopBack application container to resolve
+     *   serializer bindings from.
+     */
+    async resolveSerializer(app) {
+        const transportName = await this.findTransportName(app);
+        const serializer = await this.lookupTaggedBinding(app, keys_1.SERIALIZER_TAG, transportName);
+        if (serializer !== undefined) {
+            this.serializer = serializer;
+        }
+        const deserializer = await this.lookupTaggedBinding(app, keys_1.DESERIALIZER_TAG, transportName);
+        if (deserializer !== undefined) {
+            this.deserializer = deserializer;
+        }
+    }
+    /**
+     * Find the transport name tag for this server instance by scanning
+     * `TRANSPORT_SERVER_TAG` bindings and matching the resolved instance
+     * against `this`. Returns `undefined` if the server is not bound (in
+     * tests, or before the booter wires servers up), in which case
+     * `resolveSerializer` falls back to generic-only matching.
+     */
+    async findTransportName(app) {
+        for (const binding of app.findByTag(keys_1.TRANSPORT_SERVER_TAG)) {
+            const instance = await app.get(binding.key);
+            if (instance === this) {
+                const tag = binding.tagMap?.[keys_1.TRANSPORT_NAME_TAG];
+                return typeof tag === 'string' && tag.length > 0 ? tag : undefined;
+            }
+        }
+        return undefined;
     }
     /**
-     * Emit a status change. Called by transport adapters in listen() and close().
+     * Resolve a tagged binding, preferring transport-scoped over generic.
+     * Returns `undefined` if no tagged binding exists.
+     */
+    async lookupTaggedBinding(app, tag, transportName) {
+        const candidates = app.findByTag(tag);
+        if (transportName !== undefined) {
+            for (const binding of candidates) {
+                if (binding.tagMap?.[keys_1.TRANSPORT_NAME_TAG] === transportName) {
+                    return app.get(binding.key);
+                }
+            }
+        }
+        for (const binding of candidates) {
+            if (binding.tagMap?.[keys_1.TRANSPORT_NAME_TAG] === undefined) {
+                return app.get(binding.key);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Emit a status change. Called by transport adapters in `listen()`
+     * and `close()`.
      */
     setStatus(status) {
         this.statusSubject.next(status);
     }
     /**
-     * Permanently complete the status stream. After this call, no further
-     * status emissions are possible and the server instance cannot restart.
-     * Existing subscribers receive the complete notification.
+     * Permanently complete the status stream. After this call, no
+     * further status emissions are possible and the server instance
+     * cannot restart. Existing subscribers receive the complete
+     * notification.
      *
-     * Call only when the server is being permanently disposed.
-     * Normal close() should call setStatus('disconnected'), NOT dispose().
+     * Call only when the server is being permanently disposed. Normal
+     * `close()` should call `setStatus('disconnected')`, NOT `dispose()`.
      */
     dispose() {
         this.statusSubject.next('disconnected');
@@ -52,33 +140,42 @@ class ServerBase {
     /**
      * Register a handler for a message pattern.
      *
-     * For request/response handlers (@messageHandler): duplicate patterns
-     * throw an error. Only one handler per pattern is allowed.
+     * For request/response handlers (`@messageHandler`): duplicate
+     * patterns throw an error. Only one handler per pattern is allowed.
      *
-     * For event handlers (@eventHandler): multiple handlers on the same
-     * pattern are stored in an array and all execute.
+     * For event handlers (`@eventHandler`): multiple handlers on the
+     * same pattern are stored in an array and all execute.
      *
-     * Mixing @messageHandler and @eventHandler on the same pattern throws.
+     * Mixing `@messageHandler` and `@eventHandler` on the same pattern
+     * throws.
      *
-     * Handlers are never mutated. Each server owns its own handler array,
-     * so the same handler object can be safely shared across servers.
+     * Handlers are never mutated. Each server owns its own handler
+     * array, so the same handler object can be safely shared across
+     * servers.
+     *
+     * @public
+     * @param pattern - The message pattern (already normalized by the registry).
+     * @param handler - The handler to register.
+     * @throws TransportConfigError When a request handler is duplicated
+     *   or a request/event mix is attempted on the same pattern.
      */
     addHandler(pattern, handler) {
         const normalized = this.normalizePattern(pattern);
         const existing = this.messageHandlers.get(normalized);
         if (existing) {
-            // Reject mixed handler types on the same pattern
-            if (existing[0].isEventHandler !== handler.isEventHandler) {
-                throw new Error(`Cannot mix @messageHandler and @eventHandler for pattern: ${normalized}. ` +
+            const first = existing[0];
+            // Reject mixed handler types on the same pattern.
+            if (first && first.isEventHandler !== handler.isEventHandler) {
+                throw new errors_1.TransportConfigError(`Cannot mix @messageHandler and @eventHandler for pattern: ${normalized}. ` +
                     'A pattern must be exclusively request/response or event, not both.');
             }
-            // Reject duplicate request/response handlers
+            // Reject duplicate request/response handlers.
             if (!handler.isEventHandler) {
-                throw new Error(`Handler already registered for pattern: ${normalized}. ` +
+                throw new errors_1.TransportConfigError(`Handler already registered for pattern: ${normalized}. ` +
                     'Only one @messageHandler per pattern is allowed. ' +
                     'Use @eventHandler for multiple handlers on the same pattern.');
             }
-            // Append event handler to the array
+            // Append event handler to the array.
             existing.push(handler);
             return;
         }
@@ -86,6 +183,8 @@ class ServerBase {
     }
     /**
      * Get all registered handlers. Returns a defensive copy.
+     *
+     * @public
      */
     getHandlers() {
         const copy = new Map();
@@ -95,8 +194,10 @@ class ServerBase {
         return copy;
     }
     /**
-     * Remove all registered handlers.
-     * Called before rebinding on restart to prevent duplicate registration.
+     * Remove all registered handlers. Called before rebinding on
+     * restart to prevent duplicate registration.
+     *
+     * @public
      */
     clearHandlers() {
         this.messageHandlers.clear();
@@ -104,13 +205,16 @@ class ServerBase {
     /**
      * Get handlers by pattern. Normalizes the pattern before lookup.
      * Returns a defensive copy for external consumers.
+     *
+     * @public
      */
     getHandlersByPattern(pattern) {
         const handlers = this.lookupHandlers(pattern);
         return handlers ? [...handlers] : undefined;
     }
     /**
-     * Internal handler lookup. Returns the live array for dispatch performance.
+     * Internal handler lookup. Returns the live array for dispatch
+     * performance.
      */
     lookupHandlers(pattern) {
         return this.messageHandlers.get(this.normalizePattern(pattern));
@@ -118,28 +222,29 @@ class ServerBase {
     /**
      * Handle a request/response message.
      *
-     * Invokes the handler and calls respond() with each result value.
+     * Invokes the handler and calls `respond()` with each result value.
      * Observable subscriptions are tracked and cleaned up on completion,
      * error, or timeout.
      *
-     * Returns a HandlerResult that separates response semantics from
-     * broker settlement semantics:
+     * Returns a {@link HandlerResult} that separates response semantics
+     * from broker settlement semantics:
      *
      * - `success`: Handler completed normally. Ack the message.
      * - `handler-error`: Handler threw or Observable errored. The error
-     *   response was already sent to the caller. Ack the message --
-     *   the error was handled as an application-level response.
+     *   response was already sent to the caller. Ack the message — the
+     *   error was handled as an application-level response.
      * - `infrastructure-error`: No handler found or framework failure.
      *   Nack/dead-letter the message.
      *
-     * Observable handlers that do not complete within handlerTimeoutMs
-     * are terminated with a timeout error (handler-error).
+     * Observable handlers that do not complete within
+     * `handlerTimeoutMs` are terminated with a timeout error
+     * (`handler-error`).
      *
-     * If respond() throws (adapter publication failure), the error is
-     * caught and returned as infrastructure-error.
+     * If `respond()` throws (adapter publication failure), the error is
+     * caught and returned as `infrastructure-error`.
      */
     async handleMessage(request, respond, context) {
-        // Wrap respond to catch adapter publication failures
+        // Wrap respond to catch adapter publication failures.
         const safeRespond = (packet) => {
             try {
                 respond(packet);
@@ -157,8 +262,9 @@ class ServerBase {
         }
     }
     /**
-     * Core handler execution. Separated from handleMessage so that
-     * respond() failures bubble up and are caught by the outer wrapper.
+     * Core handler execution. Separated from `handleMessage` so that
+     * `respond()` failures bubble up and are caught by the outer
+     * wrapper.
      */
     async executeHandler(request, respond, context) {
         const handlers = this.lookupHandlers(request.pattern);
@@ -168,6 +274,11 @@ class ServerBase {
             return { outcome: 'infrastructure-error', error: new Error(err) };
         }
         const handler = handlers[0];
+        if (!handler) {
+            const err = `No handler for pattern: ${request.pattern}`;
+            respond({ err: this.serializeError(err), isDisposed: true });
+            return { outcome: 'infrastructure-error', error: new Error(err) };
+        }
         let result;
         try {
             result = await handler(request.data, context);
@@ -178,14 +289,14 @@ class ServerBase {
         }
         if ((0, rxjs_1.isObservable)(result)) {
             const obs = result.pipe((0, rxjs_1.timeout)(this.handlerTimeoutMs));
-            return new Promise((resolve) => {
+            return new Promise(resolve => {
                 let settled = false;
-                const settle = (result) => {
+                const settle = (settledResult) => {
                     if (settled)
                         return;
                     settled = true;
                     subscription?.unsubscribe();
-                    resolve(result);
+                    resolve(settledResult);
                 };
                 let subscription;
                 subscription = obs.subscribe({
@@ -235,11 +346,11 @@ class ServerBase {
     /**
      * Handle a fire-and-forget event.
      *
-     * Invokes all chained handlers for the pattern.
-     * Errors are logged but not propagated (fire-and-forget semantics).
+     * Invokes all chained handlers for the pattern. Errors are logged
+     * but not propagated (fire-and-forget semantics).
      *
-     * Observable event handlers that do not complete within handlerTimeoutMs
-     * are terminated and logged.
+     * Observable event handlers that do not complete within
+     * `handlerTimeoutMs` are terminated and logged.
      */
     async handleEvent(event, context) {
         const handlers = this.lookupHandlers(event.pattern);
@@ -264,8 +375,8 @@ class ServerBase {
         }
     }
     /**
-     * Normalize a pattern to a consistent string key.
-     * Delegates to the shared normalizePattern utility.
+     * Normalize a pattern to a consistent string key. Delegates to the
+     * shared `normalizePattern` utility.
      */
     normalizePattern(pattern) {
         return (0, utils_1.normalizePattern)(pattern);