@futdevpro/nts-dynamo 1.15.153 → 1.15.155

package/src/_services/server/app.server.ts

@@ -68,6 +68,11 @@ import { DyNTS_MemoryGuard } from '../core/memory-guard.service';
 import { DyNTS_EventLoopDiag } from '../core/event-loop-diag.service';
 import { DyNTS_RoutingModule } from '../route/routing-module.service';
 import { DyNTS_getStarRoute } from '../../_collections/star.controller';
+import { DyNTS_SafeDiagnosticStage_Type } from '../../_modules/server/safe-diagnostic/safe-diagnostic-stage.type-enum';
+import { DyNTS_SafeDiagnostic_Interface } from '../../_modules/server/safe-diagnostic/safe-diagnostic.interface';
+import {
+  DyNTS_SafeDiagnostic_ControlService
+} from '../../_modules/server/safe-diagnostic/safe-diagnostic.control-service';
 
 /**
  * 
@@ -346,6 +351,47 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
   }
   debugLog: boolean = DyNTS_global_settings.log_settings.server_debug;
 
+  private reportSafeDiagnostic(
+    code: string,
+    stage: DyNTS_SafeDiagnosticStage_Type,
+    error?: unknown,
+    status: number = 500
+  ): DyNTS_SafeDiagnostic_Interface {
+    const configuredPrefix: string | undefined = DyNTS_global_settings.systemShortCodeName;
+    const prefix: string = configuredPrefix && /^[A-Z][A-Z0-9_-]{1,31}$/.test(configuredPrefix)
+      ? configuredPrefix
+      : 'DYNTS';
+
+    return DyNTS_SafeDiagnostic_ControlService.report({
+      code: `${prefix}|${code}`,
+      stage: stage,
+      error: error,
+      status: status,
+    });
+  }
+
+  private forwardSafeDiagnostic(diagnostic: DyNTS_SafeDiagnostic_Interface): void {
+    try {
+      const pending: Promise<void> | undefined = DyNTS_GlobalService.globalErrorHandler?.(
+        DyNTS_SafeDiagnostic_ControlService.toError(diagnostic)
+      );
+
+      void pending?.catch((error: unknown): void => {
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-GLOBAL-HANDLER-REJECTED',
+          DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
+          error
+        );
+      });
+    } catch (error) {
+      this.reportSafeDiagnostic(
+        'DYNTS-AS0-GLOBAL-HANDLER-THREW',
+        DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
+        error
+      );
+    }
+  }
+
   constructor(/* extended?: boolean */){
     super();
     
@@ -353,95 +399,25 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     
     process.on(
       'unhandledRejection', 
-      (reason_theError: object, p_passWhatIsThis_maybeThePromise: any): void => {
-        if (reason_theError instanceof DyFM_Error) {
-          reason_theError.logSimple('Unhandled Rejection');
-        } else {
-          DyFM_Log.H_error(
-            'Unhandled Rejection:', (p_passWhatIsThis_maybeThePromise as Promise<any>)?.toString(), 
-            '\n    Rejection reason:', (reason_theError as Error)?.stack?.split('at')?.[0],
-            /* '\n    ErrorCode:', (reason as any)?.code, */
-            '\n\n    Stack:', 
-            (reason_theError as Error)?.stack?.replaceAll?.('\n    at', '\n      at'),
-          );
-        }
+      (reason: unknown): void => {
+        const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+          'DYNTS-AS0-BASE-UR',
+          DyNTS_SafeDiagnosticStage_Type.unhandledRejection,
+          reason
+        );
 
-        try {
-          DyNTS_GlobalService.globalErrorHandler?.(
-            new DyFM_Error({
-              errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-BASE-UR`,
-              message: 
-                `Unhandled Rejection!: "${(reason_theError as Error)?.stack?.split('at')?.[0]}"`,
-              userMessage: this.defaultErrorUserMsg,
-              addECToUserMsg: true,
-              error: reason_theError as Error,
-              additionalContent: { 
-                reason: reason_theError, 
-                rejectedPromise: p_passWhatIsThis_maybeThePromise,
-              },
-              systemVersion: DyNTS_global_settings.systemVersion,
-              level: DyFM_ErrorLevel.critical,
-            })
-          );
-        } catch (error) {
-          DyFM_Log.error('globalErrorHandler (MULTILEVEL) ERROR:', error);
-        }
+        this.forwardSafeDiagnostic(diagnostic);
       }
     );
 
-    this.asyncConstruct(/* extended */).catch((error: any): void => {
-      if (error instanceof DyFM_Error) {
-        if (error.additionalContent?.constructErrors?.length) {
-          error.additionalContent.constructErrors.forEach((errorItem: DyFM_Error): void => {
-            DyFM_Error.logSimple('(constructor asyncConstruct.catch) error:', errorItem);
-            /* if (errorItem instanceof DyFM_Error) {
-              errorItem.logSimple(`(constructor asyncConstruct.catch) error:\n`);
-            } else {
-              DyFM_Log.H_warn(
-                '(constructor asyncConstruct.catch) additional error content:\n', 
-                errorItem
-              );
-            } */
-          });
-        } else {
-          DyFM_Log.H_warn(
-            '(constructor asyncConstruct.catch) additional error content:\n', 
-            error?.additionalContent
-          );
-        }
-      }
-
-      DyFM_Error.logSimple('(constructor asyncConstruct.catch) error:', error);
-      /* if (
-        !DyNTS_global_settings.log_settings.highDetailedLogs &&
-        (error instanceof DyFM_Error)
-      ) {
-        error.logSimple(
-          `Application: "${this.params?.name}" start failed. (constructor asyncConstruct.catch)` +
-          '\n      all error messages (from this stack):\n\n"' + 
-          error._messages.join('"\n\n"') + '"\n\n'
-        );
-      } else if (error instanceof DyFM_Error) {
-        DyFM_Log.H_error(
-          `Application: "${this.params?.name}" start failed. (constructor asyncConstruct.catch)`,
-          `\n    ERROR:`, error
-        );
-      } */
-
-      const message: string = 
-        (error as DyFM_Error)?.additionalContent?.constructErrors?.flatMap(
-          (errorItem: DyFM_Error): string[] => {
-            return errorItem?._messages ?? [];
-          }
-        )?.join?.('\n') ?? 
-        (error as DyFM_Error)?.errors?.flatMap(
-          (errorItem: DyFM_AnyError): string[] => 
-            (errorItem as DyFM_Error)?._messages ?? [ (errorItem as Error)?.message ]
-        )?.join?.('\n') ?? 
-        error?.message ?? 
-        'UNKNOWN';
+    this.asyncConstruct(/* extended */).catch((error: unknown): void => {
+      const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+        'DYNTS-AS0-BOOTSTRAP-FAILED',
+        DyNTS_SafeDiagnosticStage_Type.bootstrap,
+        error
+      );
 
-      DyFM_Log.testError('Application start failed:\n', message);
+      this.forwardSafeDiagnostic(diagnostic);
 
       process.exit(1);
     });
@@ -580,9 +556,14 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
       }
       
       if (this.postProcess) {
-        await this.postProcess().catch((error: any): void => {
-          DyFM_Error.logSimple(`"${this._params.name}" postProcess failed:`, error);
-          DyNTS_GlobalService.globalErrorHandler?.(error);
+        await this.postProcess().catch((error: unknown): void => {
+          const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+            'DYNTS-AS0-POST-PROCESS-FAILED',
+            DyNTS_SafeDiagnosticStage_Type.postProcess,
+            error
+          );
+
+          this.forwardSafeDiagnostic(diagnostic);
         });
       }
 
@@ -595,7 +576,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           DyNTS_MemoryGuard.getInstance().install();
         }
       } catch (memoryGuardError: unknown) {
-        DyFM_Log.warn('[DyNTS_MemoryGuard] auto-install skipped (non-fatal):', memoryGuardError);
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-MEMORY-GUARD-SKIPPED',
+          DyNTS_SafeDiagnosticStage_Type.memoryGuard,
+          memoryGuardError
+        );
       }
 
       // BFR-OVERSEER-007 — event-loop-lag diag a MemoryGuard MELLÉ: a „process él, HTTP néma" wedge
@@ -603,7 +588,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
       try {
         DyNTS_EventLoopDiag.getInstance().install();
       } catch (eventLoopDiagError: unknown) {
-        DyFM_Log.warn('[DyNTS_EventLoopDiag] auto-install skipped (non-fatal):', eventLoopDiagError);
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-EVENT-LOOP-DIAG-SKIPPED',
+          DyNTS_SafeDiagnosticStage_Type.eventLoopDiagnostic,
+          eventLoopDiagError
+        );
       }
 
       // FR-258 / SR-4 — proactive collection-growth monitor (companion to the MemoryGuard). Warns
@@ -614,7 +603,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           DyNTS_CollectionGrowthMonitor.getInstance().install();
         }
       } catch (cgmError: unknown) {
-        DyFM_Log.warn('[DyNTS_CollectionGrowthMonitor] auto-install skipped (non-fatal):', cgmError);
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-COLLECTION-GROWTH-MONITOR-SKIPPED',
+          DyNTS_SafeDiagnosticStage_Type.collectionGrowthMonitor,
+          cgmError
+        );
       }
 
       if (!extended) {
@@ -630,22 +623,6 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     } catch (error) {
       this.constructErrors.push(error);
 
-      if (this.deepLog) {
-        if (DyNTS_global_settings.log_settings.highDetailedLogs) {
-          DyFM_Log.H_error(
-            `"${this._params.name}" start failed (in asyncConstruct (highDetailedLog)). `,
-            `\n\n    construct ERRORS:`, this.constructErrors,
-            '\n\nlast error:', error
-          );
-        } else {
-          DyFM_Log.H_error(
-            `"${this._params.name}" start failed (in asyncConstruct). `,
-            `\n\n    construct ERRORS:`, this.getSimplifiedConstructErrors(),
-            '\n\nlast error:', error instanceof DyFM_Error ? error.getErrorSimplified() : error
-          );
-        }
-      }
-
       throw new DyFM_Error({
         ...this._getDefaultErrorSettings('asyncConstruct', error),
         
@@ -674,19 +651,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
       const start: number = +new Date();
 
       if (this.constructErrors.length) {
-        if (this.deepLog) {
-          if (DyNTS_global_settings.log_settings.highDetailedLogs) {
-            DyFM_Log.H_error(
-              `"${this._params.name}" start failed. (ready; constructErrors check 1)`,
-              `\n    construct ERRORS:`, this.constructErrors
-            );
-          } else {
-            DyFM_Log.H_error(
-              `"${this._params.name}" start failed. (ready; constructErrors check 1)`,
-              `\n    construct ERRORS:`, this.getSimplifiedConstructErrors(),
-            );
-          }
-        }
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-READINESS-CONSTRUCT-ERROR',
+          DyNTS_SafeDiagnosticStage_Type.readiness,
+          this.constructErrors[0]
+        );
 
         throw new DyFM_Error({ 
           ...this._getDefaultErrorSettings(
@@ -709,8 +678,6 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
             this.systemControls.httpServer.getIsReady() &&
             this.systemControls.httpsServer.getIsReady()
           );
-        } else {
-          DyFM_Log.error(`"${this._params.name}" APP NOT INITIALIZED while trying to get ready.`);
         }
 
         if (!ready) {
@@ -719,19 +686,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
       }
 
       if (timeout < +new Date() - start) {
-        if (this.deepLog) {
-          if (DyNTS_global_settings.log_settings.highDetailedLogs) {
-            DyFM_Log.H_error(
-              `"${this._params.name}" start failed. (ready; TIMEOUT check)`,
-              `\n    construct ERRORS:`, this.constructErrors
-            );
-          } else {
-            DyFM_Log.H_error(
-              `"${this._params.name}" start failed. (ready; TIMEOUT check)`, 
-              `\n    construct ERRORS:`, this.getSimplifiedConstructErrors(),
-            );
-          }
-        }
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-READINESS-TIMEOUT',
+          DyNTS_SafeDiagnosticStage_Type.readiness,
+          this.constructErrors[0] ?? new Error('readiness-timeout')
+        );
 
         throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
@@ -753,19 +712,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
       }
 
       if (this.constructErrors.length) {
-        if (this.deepLog) {
-          if (DyNTS_global_settings.log_settings.highDetailedLogs) {
-            DyFM_Log.H_error(
-              `"${this._params.name}" start failed. (ready; constructErrors check 2)`,
-              `\n    construct ERRORS:`, this.constructErrors
-            );
-          } else {
-            DyFM_Log.H_error(
-              `"${this._params.name}" start failed. (ready; constructErrors check 2)`,
-              `\n    construct ERRORS:`, this.getSimplifiedConstructErrors(),
-            );
-          }
-        }
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-READINESS-LATE-CONSTRUCT-ERROR',
+          DyNTS_SafeDiagnosticStage_Type.readiness,
+          this.constructErrors[0]
+        );
         
         throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
@@ -802,7 +753,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         msg += `\nHTTPS Server start failed.`;
       }
 
-      DyFM_Log.error(msg, this.constructErrors);
+      this.reportSafeDiagnostic(
+        'DYNTS-AS0-READINESS-UNKNOWN',
+        DyNTS_SafeDiagnosticStage_Type.readiness,
+        this.constructErrors[0] ?? new Error('readiness-unknown')
+      );
 
       throw new DyFM_Error({ 
         ...this._getDefaultErrorSettings('ready', new Error(msg)),
@@ -975,7 +930,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           this.mongoose.connection
             .once('open', (): void => {
               this.systemControls.mongoose.started = true;
-              DyFM_Log.success(`\nConnected to MongoDB (${this._params.dbUri})\n`);
+              DyFM_Log.success('\nConnected to MongoDB.\n');
 
               resolve();
 
@@ -1000,42 +955,26 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
                 // beállítja a started flag-et, így a runtime DB-műveletek elindulnak.
                 this.systemControls.mongoose.init = false;
 
-                const d_error: DyFM_Error = new DyFM_Error({
-                  ...this._getDefaultErrorSettings('startDB', error),
-    
-                  errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-SDB1`,
-                  message: `Unable to connect to MongoDB server (${this._params.dbUri}), ` +
-                    `ERROR: ${error}`,
-                  level: DyFM_ErrorLevel.serious,
-                });
-
-                DyFM_Log.H_error(
-                  `\nUnable to connect to MongoDB server (${this._params.dbUri}).` +
-                  `\nServer will continue WITHOUT DB connection.` +
-                  `\nDB-using endpoints will fail at runtime until connection recovers.`
+                const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                  'DYNTS-AS0-SDB1',
+                  DyNTS_SafeDiagnosticStage_Type.databaseConnect,
+                  error,
+                  503
                 );
 
-                if (this.debugLog) DyFM_Log.S_error(
-                  `\nMongoDB connect ERROR: `, 
-                  error
-                );
-
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+                this.forwardSafeDiagnostic(diagnostic);
 
                 resolve();
 
               } else {  
-                if (this.debugLog) DyFM_Log.error('\nMongoDB ERROR: ', error);
-
-                const d_error: DyFM_Error = new DyFM_Error({
-                  ...this._getDefaultErrorSettings('mongoose.connection.on(error)', error),
-    
-                  errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-SDB2`,
-                  message: `MongoDB ERROR: ${error}`,
-                  level: DyFM_ErrorLevel.critical,
-                });
+                const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                  'DYNTS-AS0-SDB2',
+                  DyNTS_SafeDiagnosticStage_Type.databaseRuntime,
+                  error,
+                  503
+                );
 
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+                this.forwardSafeDiagnostic(diagnostic);
               }
             });
 
@@ -1078,10 +1017,22 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           await this.mongoose.disconnect().catch((): void => undefined);
           await this.mongoose.connect(this._params.dbUri, this._params.dbOptions);
         },
-        log: (msg: string): void => DyFM_Log.warn(msg),
+        log: (msg: string): void => {
+          this.reportSafeDiagnostic(
+            'DYNTS-AS0-MONGO-RECONNECT-EVENT',
+            DyNTS_SafeDiagnosticStage_Type.mongoReconnectGuard,
+            msg,
+            503
+          );
+        },
       });
     } catch (guardErr) {
-      DyFM_Log.warn(`[mongo-reconnect-guard] failed to start (non-fatal): ${guardErr instanceof Error ? guardErr.message : String(guardErr)}`);
+      this.reportSafeDiagnostic(
+        'DYNTS-AS0-MONGO-RECONNECT-FAILED',
+        DyNTS_SafeDiagnosticStage_Type.mongoReconnectGuard,
+        guardErr,
+        503
+      );
     }
   }
 
@@ -1127,16 +1078,17 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
             }
           } else if (action === 'differs') {
             // Live index has a different TTL — left untouched at boot (see ensureRetentionTtlIndex doc).
-            DyFM_Log.warn(
-              `[FR-258 retention] "${dataName}" already has a {__created} index with a DIFFERENT TTL than the ` +
-              `declared ${Math.round(ttlSeconds / 86400)}d (${ttlSeconds}s) — left as-is (no boot-time rebuild). ` +
-              `Apply the change via maintenance if intended.`,
+            this.reportSafeDiagnostic(
+              'DYNTS-AS0-RETENTION-INDEX-DIFFERS',
+              DyNTS_SafeDiagnosticStage_Type.retention,
+              new Error('retention-index-differs')
             );
           }
         } catch (idxErr: unknown) {
-          DyFM_Log.warn(
-            `[FR-258 retention] TTL index on "${dataName}" failed (non-fatal): ` +
-            `${idxErr instanceof Error ? idxErr.message : String(idxErr)}`,
+          this.reportSafeDiagnostic(
+            'DYNTS-AS0-RETENTION-INDEX-FAILED',
+            DyNTS_SafeDiagnosticStage_Type.retention,
+            idxErr
           );
         }
       }
@@ -1145,9 +1097,10 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         DyFM_Log.success(`[FR-258 retention] ${ensured} TTL index(es) ensured (auto-retention active).`);
       }
     } catch (err: unknown) {
-      DyFM_Log.warn(
-        `[FR-258 retention] TTL-installer failed (non-fatal): ` +
-        `${err instanceof Error ? err.message : String(err)}`,
+      this.reportSafeDiagnostic(
+        'DYNTS-AS0-RETENTION-INSTALLER-FAILED',
+        DyNTS_SafeDiagnosticStage_Type.retention,
+        err
       );
     }
   }
@@ -1223,7 +1176,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           errorStack.splice(1, 2);
           error.stack = errorStack.join('\n');
 
-          DyFM_Log.error(errorMsg);
+          this.reportSafeDiagnostic(
+            'DYNTS-AS0-OPEN-ROUTE-CONFIGURATION',
+            DyNTS_SafeDiagnosticStage_Type.routing,
+            error
+          );
 
           throw error;
         }
@@ -1269,7 +1226,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           errorStack.splice(1, 2);
           error.stack = errorStack.join('\n');
 
-          DyFM_Log.error(errorMsg);
+          this.reportSafeDiagnostic(
+            'DYNTS-AS0-SECURE-ROUTE-CONFIGURATION',
+            DyNTS_SafeDiagnosticStage_Type.routing,
+            error
+          );
 
           throw error;
         }
@@ -1359,8 +1320,13 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
 
               resolve();
             })
-            .on('error', (error): void => {
-              if (this.debugLog) DyFM_Log.error(`\nHTTPS (secure) server ERROR`, error);
+            .on('error', (error: unknown): void => {
+              const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                'DYNTS-AS0-HTTPS-ERROR',
+                DyNTS_SafeDiagnosticStage_Type.httpsServer,
+                error,
+                503
+              );
               
               if (!this.systemControls.httpsServer.started) {
                 const d_error: DyFM_Error = new DyFM_Error({
@@ -1371,37 +1337,22 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
                 });
 
                 this.constructErrors.push(d_error);
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+                this.forwardSafeDiagnostic(diagnostic);
 
                 reject(d_error);
 
               } else {
-                const d_error: DyFM_Error = new DyFM_Error({
-                  ...this._getDefaultErrorSettings('httpsServer.on(error)', error),
-
-                  errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-SE2`,
-                  message: `HTTPS (secure) server ERROR`,
-                  level: DyFM_ErrorLevel.serious,
-                });
-
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+                this.forwardSafeDiagnostic(diagnostic);
               }
             })
             .on('uncaughtException', (exception): void => {
-              const d_error: DyFM_Error = new DyFM_Error({
-                ...this._getDefaultErrorSettings('httpsServer.on(uncaughtException)', exception),
-
-                errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-SE3`,
-                message: `HTTPS (secure) server uncaughtException`,
-                level: DyFM_ErrorLevel.critical,
-              });
-
-              if (this.debugLog) DyFM_Log.warn(
-                `\nHTTPS (secure) server uncaughtException`, 
-                d_error
+              const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                'DYNTS-AS0-HTTPS-UNCAUGHT',
+                DyNTS_SafeDiagnosticStage_Type.httpsServer,
+                exception
               );
 
-              DyNTS_GlobalService.globalErrorHandler?.(d_error);
+              this.forwardSafeDiagnostic(diagnostic);
             });
         });
       }
@@ -1434,8 +1385,13 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
                 resolve();
               }
             )
-            .on('error', (error): void => {
-              if (this.debugLog) DyFM_Log.error(`\nHTTP (open) server ERROR`, error);
+            .on('error', (error: unknown): void => {
+              const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                'DYNTS-AS0-HTTP-ERROR',
+                DyNTS_SafeDiagnosticStage_Type.httpServer,
+                error,
+                503
+              );
 
               if (!this.systemControls.httpServer.started) {
                 const d_error: DyFM_Error = new DyFM_Error({
@@ -1446,36 +1402,22 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
                 });
                 
                 this.constructErrors.push(d_error);
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+                this.forwardSafeDiagnostic(diagnostic);
 
                 reject(d_error);
 
               } else {
-                const d_error: DyFM_Error = new DyFM_Error({
-                  ...this._getDefaultErrorSettings('httpServer.on(error)', error),
-
-                  errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-SE4`,
-                  message: `HTTP (open) server ERROR`,
-                  level: DyFM_ErrorLevel.serious,
-                });
-
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+                this.forwardSafeDiagnostic(diagnostic);
               }
             })
             .on('uncaughtException', (exception): void => {
-              const d_error: DyFM_Error = new DyFM_Error({
-                ...this._getDefaultErrorSettings('httpServer.on(uncaughtException)', exception),
-
-                errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-SE5`,
-                message: `HTTP (open) server uncaughtException`,
-                level: DyFM_ErrorLevel.critical,
-              });
-
-              if (this.debugLog) {
-                DyFM_Log.warn(`\nHTTP (open) server uncaughtException`, d_error);
-              }
+              const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                'DYNTS-AS0-HTTP-UNCAUGHT',
+                DyNTS_SafeDiagnosticStage_Type.httpServer,
+                exception
+              );
 
-              DyNTS_GlobalService.globalErrorHandler?.(d_error);
+              this.forwardSafeDiagnostic(diagnostic);
             });
         });
       }
@@ -1494,37 +1436,34 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
   private async expressErrorHandling(error, req, res, next): Promise<void> {
     try {
       if (error) {
-        const d_error: DyFM_Error = new DyFM_Error({
-          ...this._getDefaultErrorSettings('expressErrorHandling', error),
-
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-EEH1`,
-          message: `Express ERROR`,
-          additionalContent: {
-            req,
-            res,
-          },
-          level: DyFM_ErrorLevel.error,
-        });
+        const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+          'DYNTS-AS0-EXPRESS-ERROR',
+          DyNTS_SafeDiagnosticStage_Type.expressFallback,
+          error
+        );
 
-        await DyNTS_GlobalService.globalErrorHandler?.(d_error, req, res);
+        this.forwardSafeDiagnostic(diagnostic);
 
         // Kliens-safe strip (BFR-FDPAUTHSERVICE-002): az express-error út eddig NYERS error-t küldött
         // (0 strip) — DyFM-nél belső stack/verzió/issuer, axios-jellegű error-nál akár auth-header is
         // kimehetett. A strip-szabályok SSOT-ja a DyNTS_ClientSafeError_Util.
         res.send(DyNTS_ClientSafeError_Util.toClientSafe(error))
       } else {
-        DyFM_Log.H_error(
-          'WTF??? express error; without error?...' + 
-          '\nerr:', error,
-          '\nreq:', req,
-          '\nres:', res
+        const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+          'DYNTS-AS0-EXPRESS-MISSING-ERROR',
+          DyNTS_SafeDiagnosticStage_Type.expressFallback
         );
+
+        this.forwardSafeDiagnostic(diagnostic);
       }
     } catch (error) {
-      DyFM_Log.H_error(
-        'MULTILEVEL ERROR (expressErrorHandling)....' +
-        '\n', error
+      const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+        'DYNTS-AS0-EXPRESS-MULTILEVEL',
+        DyNTS_SafeDiagnosticStage_Type.expressFallback,
+        error
       );
+
+      this.forwardSafeDiagnostic(diagnostic);
     }
   }
 
@@ -1568,7 +1507,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
               error.stack = errorStack.join('\n'); */
               error.stack = module.stackLocation;
       
-              DyFM_Log.S_error(`ROUTE DUPLICATION: ${module.route}`, error);
+              this.reportSafeDiagnostic(
+                'DYNTS-AS0-SECURE-ROUTE-DUPLICATION',
+                DyNTS_SafeDiagnosticStage_Type.routing,
+                error
+              );
 
               throw new DyFM_Error({
                 ...this._getDefaultErrorSettings('mountSecureRoutes', error),
@@ -1629,7 +1572,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
               error.stack = errorStack.join('\n'); */
               error.stack = module.stackLocation;
       
-              DyFM_Log.S_error(`ROUTE DUPLICATION: ${module.route}`, error);
+              this.reportSafeDiagnostic(
+                'DYNTS-AS0-OPEN-ROUTE-DUPLICATION',
+                DyNTS_SafeDiagnosticStage_Type.routing,
+                error
+              );
   
               throw new DyFM_Error({
                 ...this._getDefaultErrorSettings('mountOpenRoutes', error),