@nestjs/core 12.0.0-alpha.5 → 12.0.0-alpha.7

package/middleware/builder.js

@@ -74,7 +74,11 @@ export class MiddlewareBuilder {
                 .map(route => ({
                 method: route.method,
                 path: route.path,
-                regex: new RegExp('^(' + route.path.replace(regexMatchParams, wildcard) + ')$', 'g'),
+                // No `g` flag: each regex is reused across every route below, and a
+                // global regex advances `lastIndex` on a match, so the next `test()`
+                // would resume mid-string and fail the `^` anchor. The pattern is
+                // anchored and only used with `test()`, so `g` buys nothing anyway.
+                regex: new RegExp('^(' + route.path.replace(regexMatchParams, wildcard) + ')$'),
             }));
             return routes.filter(route => {
                 const isOverlapped = (item) => {

package/nest-application-context.js

@@ -164,7 +164,7 @@ export class NestApplicationContext extends AbstractInstanceResolver {
      * @returns {this} The Nest application context instance
      */
     enableShutdownHooks(signals = [], options = {}) {
-        if (isEmptyArray(signals)) {
+        if (!signals || isEmptyArray(signals)) {
             signals = Object.values(ShutdownSignal);
         }
         else {

package/nest-application.d.ts

@@ -32,7 +32,7 @@ export declare class NestApplication extends NestApplicationContext<NestApplicat
     applyOptions(): void;
     createServer<T = any>(): T;
     registerModules(): Promise<void>;
-    registerWsModule(): void;
+    registerWsModule(): Promise<void>;
     init(): Promise<this>;
     registerParserMiddleware(): void;
     registerRouter(): Promise<void>;
@@ -68,6 +68,7 @@ export declare class NestApplication extends NestApplicationContext<NestApplicat
     private getProtocol;
     private registerMiddleware;
     private applyInstanceDecoratorIfRegistered;
+    private applyFunctionDecoratorIfRegistered;
     private loadSocketModule;
     private loadMicroservicesModule;
 }

package/nest-application.js

@@ -4,6 +4,7 @@ import { platform } from 'os';
 import { ApplicationConfig } from './application-config.js';
 import { MESSAGES } from './constants.js';
 import { optionalRequire } from './helpers/optional-require.js';
+import { makeSafeInstanceDecorator } from './helpers/safe-instance-decorator.js';
 import { Injector } from './injector/injector.js';
 import { MiddlewareContainer } from './middleware/container.js';
 import { MiddlewareModule } from './middleware/middleware-module.js';
@@ -85,18 +86,18 @@ export class NestApplication extends NestApplicationContext {
         return this.httpAdapter.getHttpServer();
     }
     async registerModules() {
-        this.registerWsModule();
+        await this.registerWsModule();
         if (this.microservicesModule) {
             this.microservicesModule.register(this.container, this.graphInspector, this.config, this.appOptions);
             this.microservicesModule.setupClients(this.container);
         }
         await this.middlewareModule.register(this.middlewareContainer, this.container, this.config, this.injector, this.httpAdapter, this.graphInspector, this.appOptions);
     }
-    registerWsModule() {
+    async registerWsModule() {
         if (!this.socketModule) {
             return;
         }
-        this.socketModule.register(this.container, this.config, this.graphInspector, this.appOptions, this.httpServer);
+        await this.socketModule.register(this.container, this.config, this.graphInspector, this.appOptions, this.httpServer);
         this.isWsModuleRegistered = true;
     }
     async init() {
@@ -204,7 +205,7 @@ export class NestApplication extends NestApplicationContext {
         this.routesResolver.registerExceptionHandler();
     }
     connectMicroservice(microserviceOptions, hybridAppOptions = {}) {
-        const { NestMicroservice } = loadPackageCached('@nestjs/microservices');
+        const { NestMicroservice } = loadPackageCached('@nestjs/microservices', 'NestFactory');
         const { inheritAppConfig } = hybridAppOptions;
         const applicationConfig = inheritAppConfig
             ? this.config
@@ -230,7 +231,7 @@ export class NestApplication extends NestApplicationContext {
         return this;
     }
     use(...args) {
-        this.httpAdapter.use(...args);
+        this.httpAdapter.use(...this.applyFunctionDecoratorIfRegistered(args));
         return this;
     }
     useBodyParser(...args) {
@@ -411,10 +412,31 @@ export class NestApplication extends NestApplicationContext {
     }
     applyInstanceDecoratorIfRegistered(...instances) {
         if (this.appOptions.instrument?.instanceDecorator) {
-            return instances.map(instance => this.appOptions.instrument.instanceDecorator(instance));
+            const decorate = makeSafeInstanceDecorator(this.appOptions.instrument.instanceDecorator);
+            return instances.map(instance => decorate(instance));
         }
         return instances;
     }
+    applyFunctionDecoratorIfRegistered(args) {
+        if (!this.appOptions.instrument?.instanceDecorator) {
+            return args;
+        }
+        const decorate = makeSafeInstanceDecorator(this.appOptions.instrument.instanceDecorator);
+        // Decorators may return a non-function value for plain middleware
+        // functions; fall back to the original argument so the HTTP adapter
+        // always receives a valid handler.
+        const decorateFunction = (arg) => {
+            if (!isFunction(arg)) {
+                return arg;
+            }
+            const decorated = decorate(arg);
+            return isFunction(decorated) ? decorated : arg;
+        };
+        // Map over the original arguments to preserve arity: appending a trailing
+        // `undefined` to a single-argument `use(fn)` call would make Express 5's
+        // router throw "argument handler must be a function".
+        return args.map(decorateFunction);
+    }
     async loadSocketModule() {
         if (!this.socketModule) {
             const socketModule = await optionalRequire('@nestjs/websockets/socket-module', () => import('@nestjs/websockets/socket-module.js'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "12.0.0-alpha.5",
+  "version": "12.0.0-alpha.7",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -28,18 +28,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "postinstall": "opencollective || exit 0"
-  },
-  "collective": {
-    "type": "opencollective",
-    "url": "https://opencollective.com/nest",
-    "donation": {
-      "text": "Become a partner:"
-    }
-  },
   "dependencies": {
-    "@nuxt/opencollective": "0.4.1",
     "fast-safe-stringify": "2.1.1",
     "iterare": "1.2.1",
     "path-to-regexp": "8.4.2",
@@ -47,7 +36,7 @@
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "^12.0.0-alpha.5"
+    "@nestjs/common": "^12.0.0-alpha.7"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
@@ -68,5 +57,5 @@
       "optional": true
     }
   },
-  "gitHead": "d91b72cc9567e6a09e3ad6075b2fb801e71adfc8"
+  "gitHead": "66e89ffc3d14e47d572bd6ea3f8714fa6916160b"
 }

package/router/legacy-route-converter.d.ts

@@ -12,5 +12,5 @@ export declare class LegacyRouteConverter {
         logs?: boolean;
     }): string;
     static printError(route: string): void;
-    static printWarning(route: string): void;
+    static printWarning(route: string, convertedRoute?: string): void;
 }

package/router/legacy-route-converter.js

@@ -21,37 +21,48 @@ export class LegacyRouteConverter {
             ? this.printWarning.bind(this)
             : () => { };
         if (normalizedRoute.endsWith('/(.*)/')) {
+            const convertedRoute = route.replace('(.*)', '{*path}');
             // Skip printing warning for the "all" wildcard.
             if (normalizedRoute !== '/(.*)/') {
-                printWarning(route);
+                printWarning(route, convertedRoute);
             }
-            return route.replace('(.*)', '{*path}');
+            return convertedRoute;
         }
         if (normalizedRoute.endsWith('/*/')) {
+            const convertedRoute = route.replace('*', '{*path}');
             // Skip printing warning for the "all" wildcard.
             if (normalizedRoute !== '/*/') {
-                printWarning(route);
+                printWarning(route, convertedRoute);
             }
-            return route.replace('*', '{*path}');
+            return convertedRoute;
         }
         if (normalizedRoute.endsWith('/+/')) {
-            printWarning(route);
-            return route.replace('/+', '/*path');
+            const convertedRoute = route.replace('/+', '/*path');
+            printWarning(route, convertedRoute);
+            return convertedRoute;
         }
         // When route includes any wildcard segments in the middle.
         if (normalizedRoute.includes('/*/')) {
-            printWarning(route);
-            // Replace each /*/ segment with a named parameter using different name for each segment.
-            return route.replaceAll('/*/', (match, offset) => {
-                return `/*path${offset}/`;
-            });
+            // Replace each "*" segment with a named parameter, using a different name
+            // for each. Match "/*" with a lookahead for the following "/" so the
+            // trailing slash is not consumed. Consuming it made two adjacent "/*/*/"
+            // segments share a slash, so only the first one got converted and the
+            // second was left as an unnamed "*" that path-to-regexp still rejects.
+            const convertedRoute = route.replaceAll(/\/\*(?=\/)/g, (match, offset) => `/*path${offset}`);
+            printWarning(route, convertedRoute);
+            return convertedRoute;
         }
         return route;
     }
     static printError(route) {
         this.logger.error(UNSUPPORTED_PATH_MESSAGE `${route}`);
     }
-    static printWarning(route) {
-        this.logger.warn(UNSUPPORTED_PATH_MESSAGE `${route}` + ' Attempting to auto-convert...');
+    static printWarning(route, convertedRoute) {
+        // Surface the auto-converted result so users can map the flagged path to a
+        // concrete fix, instead of only seeing the (often prefixed) offending path.
+        const autoConvertMessage = convertedRoute
+            ? ` Attempting to auto-convert to "${convertedRoute}"...`
+            : ' Attempting to auto-convert...';
+        this.logger.warn(UNSUPPORTED_PATH_MESSAGE `${route}` + autoConvertMessage);
     }
 }

package/router/router-execution-context.d.ts

@@ -48,4 +48,5 @@ export declare class RouterExecutionContext {
     })[]): (<TRequest, TResponse>(args: any[], req: TRequest, res: TResponse, next: Function) => Promise<void>) | null;
     createHandleResponseFn(callback: (...args: unknown[]) => unknown, isResponseHandled: boolean, redirectResponse?: RedirectResponse, httpStatusCode?: number): HandleResponseFn;
     private isResponseHandled;
+    private attachSseAbortSignal;
 }

package/router/router-execution-context.js

@@ -1,4 +1,4 @@
-import { ForbiddenException, } from '@nestjs/common';
+import { ForbiddenException, SSE_ABORT_CONTROLLER, } from '@nestjs/common';
 import { CUSTOM_ROUTE_ARGS_METADATA, HEADERS_METADATA, HTTP_CODE_METADATA, isEmptyArray, isString, REDIRECT_METADATA, RENDER_METADATA, ROUTE_ARGS_METADATA, RouteParamtypes, SSE_METADATA, } from '@nestjs/common/internal';
 import { FORBIDDEN_MESSAGE, } from '../guards/index.js';
 import { ContextUtils } from '../helpers/context-utils.js';
@@ -30,7 +30,7 @@ export class RouterExecutionContext {
     }
     create(instance, callback, methodName, moduleKey, requestMethod, contextId = STATIC_CONTEXT, inquirerId) {
         const contextType = 'http';
-        const { argsLength, fnHandleResponse, paramtypes, getParamsMetadata, httpStatusCode, responseHeaders, hasCustomHeaders, } = this.getMetadata(instance, callback, methodName, moduleKey, requestMethod, contextType);
+        const { argsLength, fnHandleResponse, isSseHandler, paramtypes, getParamsMetadata, httpStatusCode, responseHeaders, hasCustomHeaders, } = this.getMetadata(instance, callback, methodName, moduleKey, requestMethod, contextType);
         const paramsOptions = this.contextUtils.mergeParamsMetatypes(getParamsMetadata(moduleKey, contextId, inquirerId), paramtypes);
         const pipes = this.pipesContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
         const guards = this.guardsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
@@ -47,7 +47,15 @@ export class RouterExecutionContext {
             this.responseController.setStatus(res, httpStatusCode);
             hasCustomHeaders &&
                 this.responseController.setHeaders(res, responseHeaders);
-            const result = await this.interceptorsConsumer.intercept(interceptors, [req, res, next], instance, callback, handler(args, req, res, next), contextType);
+            if (isSseHandler) {
+                // Attach a per-request AbortController before the handler runs so async
+                // @Sse() handlers can observe client disconnects via @SseSignal() during
+                // their setup. The controller is aborted in RouterResponseController.sse()
+                // when the underlying connection closes.
+                this.attachSseAbortSignal(req);
+            }
+            const resultOrDeferred = this.interceptorsConsumer.intercept(interceptors, [req, res, next], instance, callback, handler(args, req, res, next), contextType);
+            const result = isSseHandler ? resultOrDeferred : await resultOrDeferred;
             await fnHandleResponse(result, res, req);
         };
     }
@@ -66,6 +74,7 @@ export class RouterExecutionContext {
         const isResponseHandled = this.isResponseHandled(instance, methodName, paramsMetadata);
         const httpRedirectResponse = this.reflectRedirect(callback);
         const fnHandleResponse = this.createHandleResponseFn(callback, isResponseHandled, httpRedirectResponse);
+        const isSseHandler = !!this.reflectSse(callback);
         const httpCode = this.reflectHttpStatusCode(callback);
         const httpStatusCode = httpCode ?? this.responseController.getStatusByMethod(requestMethod);
         const responseHeaders = this.reflectResponseHeaders(callback);
@@ -73,6 +82,7 @@ export class RouterExecutionContext {
         const handlerMetadata = {
             argsLength,
             fnHandleResponse,
+            isSseHandler,
             paramtypes,
             getParamsMetadata,
             httpStatusCode,
@@ -196,4 +206,17 @@ export class RouterExecutionContext {
         const isPassthroughEnabled = this.contextUtils.reflectPassthrough(instance, methodName);
         return hasResponseOrNextDecorator && !isPassthroughEnabled;
     }
+    attachSseAbortSignal(req) {
+        const carrier = req;
+        // Attach to both the framework request and its raw form (when present), since
+        // @SseSignal() reads from the execution-context request while
+        // RouterResponseController.sse() operates on the raw request.
+        if (!carrier[SSE_ABORT_CONTROLLER]) {
+            carrier[SSE_ABORT_CONTROLLER] = new AbortController();
+        }
+        if (carrier.raw && !carrier.raw[SSE_ABORT_CONTROLLER]) {
+            carrier.raw[SSE_ABORT_CONTROLLER] =
+                carrier[SSE_ABORT_CONTROLLER];
+        }
+    }
 }

package/router/router-response-controller.d.ts

@@ -26,4 +26,5 @@ export declare class RouterResponseController {
         statusCode?: number;
     }): Promise<void>;
     private assertObservable;
+    private getOrCreateAbortController;
 }

package/router/router-response-controller.js

@@ -1,4 +1,4 @@
-import { HttpStatus, Logger, RequestMethod, } from '@nestjs/common';
+import { HttpStatus, Logger, RequestMethod, SSE_ABORT_CONTROLLER, } from '@nestjs/common';
 import { EMPTY, lastValueFrom, isObservable } from 'rxjs';
 import { catchError, concatMap, map } from 'rxjs/operators';
 import { SseStream, } from './sse-stream.js';
@@ -49,76 +49,146 @@ export class RouterResponseController {
     async sse(result, response, request, options) {
         // It's possible that we sent headers already so don't use a stream
         if (response.writableEnded) {
+            // The response is already gone: abort the request-scoped signal so
+            // handler cleanup wired to @SseSignal() still runs, and swallow late
+            // handler rejections that can no longer be delivered to the client.
+            this.getOrCreateAbortController(request).abort();
+            Promise.resolve(result).catch((err) => this.logger.error(err));
             return;
         }
-        const observableResult = await Promise.resolve(result);
-        this.assertObservable(observableResult);
         const stream = new SseStream(request);
         const statusCode = options?.statusCode ??
             response.statusCode ??
             200;
-        stream.pipe(response, {
-            additionalHeaders: options?.additionalHeaders,
-            statusCode,
-        });
+        // Create a per-request AbortController and expose its signal on the request
+        // object so async @Sse() handlers can observe client disconnects (via the
+        // @SseSignal() parameter decorator) and stop/clean up in-flight setup work.
+        // The controller is reused if one was already attached upstream (e.g. when the
+        // handler is wrapped by interceptors and the signal was created earlier).
+        const abortController = this.getOrCreateAbortController(request);
         return new Promise((resolve, reject) => {
             let settled = false;
-            const onClose = () => {
-                settled = true;
-                subscription.unsubscribe();
+            let closeRequested = false;
+            let subscription;
+            const disconnectSource = request.socket ?? response;
+            // Ends the request-scoped lifetime: stops listening for disconnects and
+            // aborts the signal handed to the route handler. Every terminal path of
+            // the SSE lifecycle (disconnect, completion, error) funnels through here,
+            // so a handler that ties its resources to the signal releases them once,
+            // regardless of how the stream ended. `abort()` is idempotent, so paths
+            // that already aborted on disconnect are unaffected.
+            const finalize = () => {
+                disconnectSource.removeListener('close', onClose);
+                abortController.abort();
+            };
+            const endStream = () => {
                 if (!stream.writableEnded) {
                     stream.end();
                 }
+            };
+            const onClose = () => {
+                if (settled || closeRequested) {
+                    return;
+                }
+                closeRequested = true;
+                if (!subscription) {
+                    finalize();
+                    return;
+                }
+                settled = true;
+                finalize();
+                subscription?.unsubscribe();
+                endStream();
                 response.end();
                 resolve();
             };
-            const subscription = observableResult
-                .pipe(map((message) => {
-                if (isObject(message)) {
-                    return message;
+            disconnectSource.once('close', onClose);
+            Promise.resolve(result)
+                .then(observableResult => {
+                if (settled) {
+                    return;
                 }
-                return { data: message };
-            }), concatMap(message => new Promise(resolve => stream.writeMessage(message, () => resolve()))), catchError(err => {
-                if (!stream.headersCommitted) {
-                    throw err;
+                this.assertObservable(observableResult);
+                if (closeRequested) {
+                    // The client disconnected while the async handler was resolving.
+                    // Do not subscribe the producer Observable after the consumer has
+                    // already gone away — subscribing only to abort it in the same tick
+                    // would start producer side effects just to immediately cancel them.
+                    settled = true;
+                    endStream();
+                    response.end();
+                    resolve();
+                    return;
                 }
-                const data = err instanceof Error ? err.message : err;
-                stream.writeMessage({ type: 'error', data }, writeError => {
-                    if (writeError) {
-                        this.logger.error(writeError);
+                stream.pipe(response, {
+                    additionalHeaders: options?.additionalHeaders,
+                    statusCode,
+                });
+                subscription = observableResult
+                    .pipe(map((message) => {
+                    if (isObject(message)) {
+                        return message;
+                    }
+                    return { data: message };
+                }), concatMap(message => new Promise(resolve => stream.writeMessage(message, () => resolve()))), catchError(err => {
+                    if (!stream.headersCommitted) {
+                        throw err;
                     }
+                    const data = err instanceof Error ? err.message : err;
+                    stream.writeMessage({ type: 'error', data }, writeError => {
+                        if (writeError) {
+                            this.logger.error(writeError);
+                        }
+                    });
+                    return EMPTY;
+                }))
+                    .subscribe({
+                    error: err => {
+                        if (settled) {
+                            return;
+                        }
+                        settled = true;
+                        finalize();
+                        endStream();
+                        reject(err);
+                    },
+                    complete: () => {
+                        if (settled) {
+                            return;
+                        }
+                        settled = true;
+                        finalize();
+                        endStream();
+                        resolve();
+                    },
                 });
-                return EMPTY;
-            }))
-                .subscribe({
-                error: err => {
-                    settled = true;
-                    request.removeListener('close', onClose);
-                    if (!stream.writableEnded) {
-                        stream.end();
+                // Commit SSE headers on the next macrotask. Pipe validation errors
+                // propagate through microtasks (which complete before macrotasks),
+                // so if the lifecycle errored, `settled` is already true and we
+                // skip the write. Otherwise headers are sent immediately rather
+                // than waiting for the first Observable emission.
+                setTimeout(() => {
+                    if (!settled) {
+                        stream.commitHeaders();
                     }
-                    reject(err);
-                },
-                complete: () => {
+                }, 0);
+            })
+                .catch(err => {
+                if (settled) {
+                    return;
+                }
+                if (closeRequested) {
                     settled = true;
-                    request.removeListener('close', onClose);
-                    if (!stream.writableEnded) {
-                        stream.end();
-                    }
+                    endStream();
+                    response.end();
                     resolve();
-                },
-            });
-            // Commit SSE headers on the next macrotask. Pipe validation errors
-            // propagate through microtasks (which complete before macrotasks),
-            // so if the lifecycle errored, `settled` is already true and we
-            // skip the write. Otherwise headers are sent immediately rather
-            // than waiting for the first Observable emission.
-            setTimeout(() => {
-                if (!settled) {
-                    stream.commitHeaders();
+                    return;
                 }
-            }, 0);
-            request.on('close', onClose);
+                settled = true;
+                finalize();
+                endStream();
+                reject(err);
+            });
         });
     }
     assertObservable(value) {
@@ -126,4 +196,11 @@ export class RouterResponseController {
             throw new ReferenceError('You must return an Observable stream to use Server-Sent Events (SSE).');
         }
     }
+    getOrCreateAbortController(request) {
+        const carrier = request;
+        if (!carrier[SSE_ABORT_CONTROLLER]) {
+            carrier[SSE_ABORT_CONTROLLER] = new AbortController();
+        }
+        return carrier[SSE_ABORT_CONTROLLER];
+    }
 }

package/router/sse-stream.d.ts

@@ -22,6 +22,7 @@ export type HeaderStream = WritableHeaderStream & ReadHeaders;
  * - type
  * - id
  * - retry
+ * - comment
  *
  * If constructed with a HTTP Request, it will optimise the socket for streaming.
  * If this stream is piped to an HTTP Response, it will set appropriate headers.

package/router/sse-stream.js

@@ -1,13 +1,25 @@
 import { Transform } from 'stream';
-import { isObject } from '@nestjs/common/internal';
+import { isNil, isObject, isUndefined } from '@nestjs/common/internal';
+function serializeSseLines(value, prefix) {
+    return value
+        .split(/\r\n|\r|\n/)
+        .map(line => `${prefix}${line}\n`)
+        .join('');
+}
 function toDataString(data) {
     if (isObject(data)) {
         return toDataString(JSON.stringify(data));
     }
-    return data
-        .split(/\r\n|\r|\n/)
-        .map(line => `data: ${line}\n`)
-        .join('');
+    return serializeSseLines(data, 'data: ');
+}
+function toCommentString(comment) {
+    return serializeSseLines(comment, ': ');
+}
+function isCommentOnly(message) {
+    return (!isNil(message.comment) &&
+        isUndefined(message.data) &&
+        isUndefined(message.type) &&
+        isUndefined(message.retry));
 }
 /**
  * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
@@ -18,6 +30,7 @@ function toDataString(data) {
  * - type
  * - id
  * - retry
+ * - comment
  *
  * If constructed with a HTTP Request, it will optimise the socket for streaming.
  * If this stream is piped to an HTTP Response, it will set appropriate headers.
@@ -64,7 +77,7 @@ export class SseStream extends Transform {
         if (this._destination.writeHead) {
             this._destination.writeHead(statusCode, {
                 ...additionalHeaders,
-                // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
+                // See https://github.com/dunglas/mercure/blob/main/subscribe.go#L347-L362
                 'Content-Type': 'text/event-stream',
                 Connection: 'keep-alive',
                 // Disable cache, even for old browsers and proxies
@@ -82,12 +95,10 @@ export class SseStream extends Transform {
         this.commitHeaders();
         const sanitize = (val) => String(val).replace(/[\r\n]/g, '');
         let data = message.type ? `event: ${sanitize(message.type)}\n` : '';
-        data +=
-            message.id !== undefined && message.id !== null
-                ? `id: ${sanitize(message.id)}\n`
-                : '';
-        data += message.retry ? `retry: ${sanitize(message.retry)}\n` : '';
-        data += message.data ? toDataString(message.data) : '';
+        data += !isNil(message.id) ? `id: ${sanitize(message.id)}\n` : '';
+        data += !isNil(message.retry) ? `retry: ${sanitize(message.retry)}\n` : '';
+        data += !isNil(message.comment) ? toCommentString(message.comment) : '';
+        data += !isNil(message.data) ? toDataString(message.data) : '';
         data += '\n';
         this.push(data);
         callback();
@@ -96,7 +107,7 @@ export class SseStream extends Transform {
      * Calls `.write` but handles the drain if needed
      */
     writeMessage(message, cb) {
-        if (message.id === undefined || message.id === null) {
+        if (isNil(message.id) && !isCommentOnly(message)) {
             this.lastEventId++;
             message.id = this.lastEventId.toString();
         }

package/scanner.js

@@ -40,6 +40,9 @@ export class DependenciesScanner {
     async scanForModules({ moduleDefinition, lazy, scope = [], ctxRegistry = [], overrides = [], }) {
         const { moduleRef: moduleInstance, inserted: moduleInserted } = (await this.insertOrOverrideModule(moduleDefinition, overrides, scope)) ??
             {};
+        if (lazy && !moduleInserted && moduleInstance?.isInstantiated) {
+            return [];
+        }
         moduleDefinition =
             this.getOverrideModuleByModule(moduleDefinition, overrides)?.newModule ??
                 moduleDefinition;
@@ -81,7 +84,7 @@ export class DependenciesScanner {
         if (!moduleInstance) {
             return registeredModuleRefs;
         }
-        if (lazy && moduleInserted) {
+        if (lazy) {
             this.container.bindGlobalsToImports(moduleInstance);
         }
         return [moduleInstance].concat(registeredModuleRefs);