@futdevpro/nts-dynamo 1.15.153 → 1.15.154

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

@@ -66,8 +66,13 @@ import { DyNTS_GlobalService } from '../core/global.service';
 import { DyNTS_CollectionGrowthMonitor } from '../core/collection-growth-monitor.service';
 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_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';
 
 /**
  * 
@@ -343,107 +348,78 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
   }
   get fnLogs(): boolean {
     return DyNTS_global_settings.log_settings.functions;
-  }
-  debugLog: boolean = DyNTS_global_settings.log_settings.server_debug;
-
-  constructor(/* extended?: boolean */){
+  }
+  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();
     
     /* dotenv.config() */
     
-    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'),
-          );
-        }
-
-        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.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';
-
-      DyFM_Log.testError('Application start failed:\n', message);
-
-      process.exit(1);
+    process.on(
+      'unhandledRejection', 
+      (reason: unknown): void => {
+        const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+          'DYNTS-AS0-BASE-UR',
+          DyNTS_SafeDiagnosticStage_Type.unhandledRejection,
+          reason
+        );
+
+        this.forwardSafeDiagnostic(diagnostic);
+      }
+    );
+
+    this.asyncConstruct(/* extended */).catch((error: unknown): void => {
+      const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+        'DYNTS-AS0-BOOTSTRAP-FAILED',
+        DyNTS_SafeDiagnosticStage_Type.bootstrap,
+        error
+      );
+
+      this.forwardSafeDiagnostic(diagnostic);
+
+      process.exit(1);
     });
   }
 
@@ -579,12 +555,17 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         this._rootServices = await this.getRootServices();
       }
       
-      if (this.postProcess) {
-        await this.postProcess().catch((error: any): void => {
-          DyFM_Error.logSimple(`"${this._params.name}" postProcess failed:`, error);
-          DyNTS_GlobalService.globalErrorHandler?.(error);
-        });
-      }
+      if (this.postProcess) {
+        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);
+        });
+      }
 
       // FR-193 — bedrock OOM korai-figyelmeztetés: feltelepítjük a heap-watchdogot, ha
       // engedélyezve (DyNTS_global_settings.memoryGuard.enabled, default true). Biztonságos:
@@ -594,17 +575,25 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         if (DyNTS_global_settings.memoryGuard?.enabled) {
           DyNTS_MemoryGuard.getInstance().install();
         }
-      } catch (memoryGuardError: unknown) {
-        DyFM_Log.warn('[DyNTS_MemoryGuard] auto-install skipped (non-fatal):', memoryGuardError);
-      }
+      } catch (memoryGuardError: unknown) {
+        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
       // belső mérése (natív histogram, olcsó). Observation-only, sosem dob; a /server/diag olvas belőle.
       try {
         DyNTS_EventLoopDiag.getInstance().install();
-      } catch (eventLoopDiagError: unknown) {
-        DyFM_Log.warn('[DyNTS_EventLoopDiag] auto-install skipped (non-fatal):', eventLoopDiagError);
-      }
+      } catch (eventLoopDiagError: unknown) {
+        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
       // into the Errors-sink when a collection grows unbounded, BEFORE it can be loaded into heap and
@@ -613,9 +602,13 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         if (DyNTS_global_settings.collectionGrowthMonitor?.enabled) {
           DyNTS_CollectionGrowthMonitor.getInstance().install();
         }
-      } catch (cgmError: unknown) {
-        DyFM_Log.warn('[DyNTS_CollectionGrowthMonitor] auto-install skipped (non-fatal):', cgmError);
-      }
+      } catch (cgmError: unknown) {
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-COLLECTION-GROWTH-MONITOR-SKIPPED',
+          DyNTS_SafeDiagnosticStage_Type.collectionGrowthMonitor,
+          cgmError
+        );
+      }
 
       if (!extended) {
         await this.ready();
@@ -627,26 +620,10 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         /* DyFM_Log.info(`NTS Version: ${this.ntsVersion}`); */
         DyFM_Log.H_success(`${this.params.name} started successfully.`);
       }
-    } 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({
+    } catch (error) {
+      this.constructErrors.push(error);
+
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings('asyncConstruct', error),
         
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-001`,
@@ -671,22 +648,14 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
       await DyFM_Async.delay(100);
 
       let ready: boolean = false;
-      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(),
-            );
-          }
-        }
+      const start: number = +new Date();
+
+      if (this.constructErrors.length) {
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-READINESS-CONSTRUCT-ERROR',
+          DyNTS_SafeDiagnosticStage_Type.readiness,
+          this.constructErrors[0]
+        );
 
         throw new DyFM_Error({ 
           ...this._getDefaultErrorSettings(
@@ -709,29 +678,19 @@ 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) {
           await DyFM_Async.wait(100);
         }
       }
 
-      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(),
-            );
-          }
-        }
+      if (timeout < +new Date() - start) {
+        this.reportSafeDiagnostic(
+          'DYNTS-AS0-READINESS-TIMEOUT',
+          DyNTS_SafeDiagnosticStage_Type.readiness,
+          this.constructErrors[0] ?? new Error('readiness-timeout')
+        );
 
         throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
@@ -752,20 +711,12 @@ 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(),
-            );
-          }
-        }
+      if (this.constructErrors.length) {
+        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)),
@@ -973,9 +928,9 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           this.systemControls.mongoose.init = true;
 
           this.mongoose.connection
-            .once('open', (): void => {
-              this.systemControls.mongoose.started = true;
-              DyFM_Log.success(`\nConnected to MongoDB (${this._params.dbUri})\n`);
+            .once('open', (): void => {
+              this.systemControls.mongoose.started = true;
+              DyFM_Log.success('\nConnected to MongoDB.\n');
 
               resolve();
 
@@ -1000,43 +955,27 @@ 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.`
-                );
-
-                if (this.debugLog) DyFM_Log.S_error(
-                  `\nMongoDB connect ERROR: `, 
-                  error
-                );
-
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
-
-                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,
-                });
-
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
-              }
+                const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                  'DYNTS-AS0-SDB1',
+                  DyNTS_SafeDiagnosticStage_Type.databaseConnect,
+                  error,
+                  503
+                );
+
+                this.forwardSafeDiagnostic(diagnostic);
+
+                resolve();
+
+              } else {  
+                const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                  'DYNTS-AS0-SDB2',
+                  DyNTS_SafeDiagnosticStage_Type.databaseRuntime,
+                  error,
+                  503
+                );
+
+                this.forwardSafeDiagnostic(diagnostic);
+              }
             });
 
           try {
@@ -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),
-      });
-    } catch (guardErr) {
-      DyFM_Log.warn(`[mongo-reconnect-guard] failed to start (non-fatal): ${guardErr instanceof Error ? guardErr.message : String(guardErr)}`);
+        log: (msg: string): void => {
+          this.reportSafeDiagnostic(
+            'DYNTS-AS0-MONGO-RECONNECT-EVENT',
+            DyNTS_SafeDiagnosticStage_Type.mongoReconnectGuard,
+            msg,
+            503
+          );
+        },
+      });
+    } catch (guardErr) {
+      this.reportSafeDiagnostic(
+        'DYNTS-AS0-MONGO-RECONNECT-FAILED',
+        DyNTS_SafeDiagnosticStage_Type.mongoReconnectGuard,
+        guardErr,
+        503
+      );
     }
   }
 
@@ -1125,30 +1076,32 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
                 `${Math.round(ttlSeconds / 86400)}d (${ttlSeconds}s)`,
               );
             }
-          } 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.`,
-            );
-          }
-        } catch (idxErr: unknown) {
-          DyFM_Log.warn(
-            `[FR-258 retention] TTL index on "${dataName}" failed (non-fatal): ` +
-            `${idxErr instanceof Error ? idxErr.message : String(idxErr)}`,
-          );
+          } else if (action === 'differs') {
+            // Live index has a different TTL — left untouched at boot (see ensureRetentionTtlIndex doc).
+            this.reportSafeDiagnostic(
+              'DYNTS-AS0-RETENTION-INDEX-DIFFERS',
+              DyNTS_SafeDiagnosticStage_Type.retention,
+              new Error('retention-index-differs')
+            );
+          }
+        } catch (idxErr: unknown) {
+          this.reportSafeDiagnostic(
+            'DYNTS-AS0-RETENTION-INDEX-FAILED',
+            DyNTS_SafeDiagnosticStage_Type.retention,
+            idxErr
+          );
         }
       }
 
       if (ensured > 0) {
         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)}`,
-      );
+    } catch (err: unknown) {
+      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;
         }
@@ -1358,9 +1319,14 @@ 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({
@@ -1368,41 +1334,26 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
 
                   errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-SE1`,
                   message: `HTTPS (secure) start server ERROR`,
-                });
-
-                this.constructErrors.push(d_error);
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+                });
+
+                this.constructErrors.push(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);
-              }
-            })
-            .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
-              );
-
-              DyNTS_GlobalService.globalErrorHandler?.(d_error);
-            });
+              } else {
+                this.forwardSafeDiagnostic(diagnostic);
+              }
+            })
+            .on('uncaughtException', (exception): void => {
+              const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                'DYNTS-AS0-HTTPS-UNCAUGHT',
+                DyNTS_SafeDiagnosticStage_Type.httpsServer,
+                exception
+              );
+
+              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({
@@ -1445,38 +1401,24 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
                   message: `HTTP (open) start server ERROR`,
                 });
                 
-                this.constructErrors.push(d_error);
-                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+                this.constructErrors.push(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);
-              }
-            })
-            .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);
-              }
-
-              DyNTS_GlobalService.globalErrorHandler?.(d_error);
-            });
+              } else {
+                this.forwardSafeDiagnostic(diagnostic);
+              }
+            })
+            .on('uncaughtException', (exception): void => {
+              const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+                'DYNTS-AS0-HTTP-UNCAUGHT',
+                DyNTS_SafeDiagnosticStage_Type.httpServer,
+                exception
+              );
+
+              this.forwardSafeDiagnostic(diagnostic);
+            });
         });
       }
     } catch (error) {
@@ -1491,42 +1433,39 @@ 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,
-        });
-
-        await DyNTS_GlobalService.globalErrorHandler?.(d_error, req, res);
+  private async expressErrorHandling(error, req, res, next): Promise<void> {
+    try {
+      if (error) {
+        const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+          'DYNTS-AS0-EXPRESS-ERROR',
+          DyNTS_SafeDiagnosticStage_Type.expressFallback,
+          error
+        );
+
+        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
-        );
-      }
-    } catch (error) {
-      DyFM_Log.H_error(
-        'MULTILEVEL ERROR (expressErrorHandling)....' +
-        '\n', error
-      );
-    }
-  }
+        // kimehetett. A strip-szabályok SSOT-ja a DyNTS_ClientSafeError_Util.
+        res.send(DyNTS_ClientSafeError_Util.toClientSafe(error))
+      } else {
+        const diagnostic: DyNTS_SafeDiagnostic_Interface = this.reportSafeDiagnostic(
+          'DYNTS-AS0-EXPRESS-MISSING-ERROR',
+          DyNTS_SafeDiagnosticStage_Type.expressFallback
+        );
+
+        this.forwardSafeDiagnostic(diagnostic);
+      }
+    } catch (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),