@futdevpro/nts-dynamo 1.15.155 → 1.15.156

package/src/_models/control-models/endpoint-params.control-model.spec.ts

@@ -438,14 +438,14 @@ describe('| DyNTS_Endpoint_Params', () => {
       expect(logInfoSpy).toHaveBeenCalled();
     });
 
-    it('| should handle issuer retrieval error', async () => {
-      (DyNTS_GlobalService.getAuthService as jasmine.Spy).and.returnValue({
-        getIssuerFromRequest: () => { throw new Error('Auth error'); },
-      } as any);
-      const logWarnSpy = spyOn(DyFM_Log, 'warn');
-      const taskSpy = jasmine.createSpy('task').and.callFake(async (req: Request, res: Response, issuer: string) => {
-        res.send({ success: true });
-      });
+    it('| should handle issuer retrieval error', async () => {
+      (DyNTS_GlobalService.getAuthService as jasmine.Spy).and.returnValue({
+        getIssuerFromRequest: () => { throw new Error('Auth error'); },
+      } as any);
+      const logErrorSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+      const taskSpy = jasmine.createSpy('task').and.callFake(async (req: Request, res: Response, issuer: string) => {
+        res.send({ success: true });
+      });
       const params = new DyNTS_Endpoint_Params({
         name: 'testEndpoint',
         type: DyFM_HttpCallType.get,
@@ -454,12 +454,15 @@ describe('| DyNTS_Endpoint_Params', () => {
         logRequest: false,
       });
 
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-
-      expect(logWarnSpy).toHaveBeenCalled();
-      expect(taskSpy).toHaveBeenCalledWith(mockRequest, mockResponse, 'unknown-issuer');
-    });
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+
+      expect(logErrorSpy).toHaveBeenCalledWith(
+        '[DyNTS safe diagnostic]',
+        jasmine.objectContaining({ code: 'DYNTS|ENDPOINT|ISSUER_RESOLUTION_FAILURE' })
+      );
+      expect(taskSpy).toHaveBeenCalledWith(mockRequest, mockResponse, 'unknown-issuer');
+    });
 
     it('| should handle DyFM_Error with status code', async () => {
       const error = new DyFM_Error({
@@ -541,7 +544,7 @@ describe('| DyNTS_Endpoint_Params', () => {
     });
 
     // FR-067: axios-style HTTP errors (with `status` field) — wrap-status onorzes.
-    it('| FR-067: should preserve downstream HTTP status when wrapping axios-style error', async () => {
+    it('| FR-067: should preserve downstream HTTP status when wrapping axios-style error', async () => {
       const error = Object.assign(new Error('Upstream 502'), { status: 502 });
       const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
       const params = new DyNTS_Endpoint_Params({
@@ -557,8 +560,90 @@ describe('| DyNTS_Endpoint_Params', () => {
       await execution(mockRequest as Request, mockResponse as Response);
       await new Promise(resolve => setTimeout(resolve, 50));
 
-      expect(statusSpy).toHaveBeenCalledWith(502);
-    });
+      expect(statusSpy).toHaveBeenCalledWith(502);
+    });
+
+    it(
+      '| BFR-CTM-018: projects endpoint and handler failures without logging or responding raw content',
+      async (): Promise<void> => {
+        const errorCanary: string = 'raw-message secret workbook-cell@example.test';
+        const handlerCanary: string = 'handler-stack bearer-private-token';
+        const requestCanary: string = 'private-sheet-name';
+        const originalHighDetailedLogs: boolean = DyNTS_global_settings.log_settings.highDetailedLogs;
+        const originalGlobalErrorHandler: typeof DyNTS_GlobalService.globalErrorHandler =
+          DyNTS_GlobalService.globalErrorHandler;
+        const logErrorSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+        const logSpies: jasmine.Spy[] = [
+          logErrorSpy,
+          spyOn(DyFM_Log, 'H_error'),
+          spyOn(DyFM_Log, 'info'),
+          spyOn(DyFM_Log, 'testError'),
+          spyOn(DyFM_Log, 'warn'),
+        ];
+        const endpointError: Error & { status: number } = Object.assign(new Error(errorCanary), { status: 503 });
+        const taskSpy: jasmine.Spy = jasmine.createSpy('task').and.rejectWith(endpointError);
+        const globalErrorHandlerSpy: jasmine.Spy = jasmine.createSpy('globalErrorHandler').and.rejectWith(
+          new Error(handlerCanary)
+        );
+        const params: DyNTS_Endpoint_Params = new DyNTS_Endpoint_Params({
+          name: 'privacyEndpoint',
+          type: DyFM_HttpCallType.post,
+          endpoint: '/private/:sheetId',
+          tasks: [taskSpy],
+          logRequest: true,
+          logRequestsParams: false,
+          logRequestsContent: false,
+          logResponseContent: true,
+        });
+        mockRequest = {
+          body: { workbookValue: requestCanary },
+          headers: { authorization: `Bearer ${requestCanary}` },
+          originalUrl: `/private/${requestCanary}?token=${requestCanary}`,
+          params: { sheetId: requestCanary },
+          query: { token: requestCanary },
+        };
+        DyNTS_GlobalService.globalErrorHandler = globalErrorHandlerSpy;
+        DyNTS_global_settings.log_settings.highDetailedLogs = true;
+
+        try {
+          await params.getFullExecution()(mockRequest as Request, mockResponse as Response);
+        } finally {
+          DyNTS_GlobalService.globalErrorHandler = originalGlobalErrorHandler;
+          DyNTS_global_settings.log_settings.highDetailedLogs = originalHighDetailedLogs;
+        }
+
+        const serializedLogs: string = JSON.stringify(
+          logSpies.flatMap((logSpy: jasmine.Spy): readonly unknown[][] => logSpy.calls.allArgs())
+        );
+        const serializedResponse: string = JSON.stringify(sendSpy.calls.mostRecent().args[0]);
+
+        expect(globalErrorHandlerSpy).toHaveBeenCalledWith(
+          endpointError,
+          mockRequest as Request,
+          mockResponse as Response,
+          'test-issuer'
+        );
+        expect(logErrorSpy).toHaveBeenCalledWith(
+          '[DyNTS safe diagnostic]',
+          jasmine.objectContaining({
+            code: 'DYNTS|ENDPOINT|FAILURE',
+            stage: 'endpoint',
+            status: 503,
+          })
+        );
+        expect(logErrorSpy).toHaveBeenCalledWith(
+          '[DyNTS safe diagnostic]',
+          jasmine.objectContaining({ code: 'DYNTS|ENDPOINT|GLOBAL_HANDLER_FAILURE' })
+        );
+        expect(statusSpy).toHaveBeenCalledWith(503);
+        expect(serializedLogs).not.toContain(errorCanary);
+        expect(serializedLogs).not.toContain(handlerCanary);
+        expect(serializedLogs).not.toContain(requestCanary);
+        expect(serializedResponse).not.toContain(errorCanary);
+        expect(serializedResponse).not.toContain(handlerCanary);
+        expect(serializedResponse).not.toContain(requestCanary);
+      }
+    );
 
     it('| should handle production environment error response', async () => {
       const originalEnv = DyNTS_global_settings.env_settings.environment;

package/src/_models/control-models/endpoint-params.control-model.ts

@@ -1,16 +1,22 @@
 import { Request, Response } from 'express';
 
-import {
-  DyFM_AnyError,
-  DyFM_Array, DyFM_Endpoint_SettingsBase, DyFM_EnvironmentFlag, DyFM_Error, DyFM_getConstructionStackLocation, DyFM_HttpCallType, 
-  DyFM_Log, DyFM_Object
-} from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-import { DyNTS_ClientSafeError_Util } from '../../_collections/client-safe-error.util';
-import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import { DyNTS_GlobalService } from '../../_services/core/global.service';
-import { DyNTS_RequestHunter } from '../../_services/core/request-hunter.service';
+import {
+  DyFM_AnyError, DyFM_Array, DyFM_Endpoint_SettingsBase, DyFM_Error, DyFM_getConstructionStackLocation,
+  DyFM_HttpCallType, DyFM_Log, DyFM_Object
+} from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_ClientSafeError_Util } from '../../_collections/client-safe-error.util';
+import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
+import {
+  DyNTS_SafeDiagnostic_ControlService
+} from '../../_modules/server/safe-diagnostic/safe-diagnostic.control-service';
+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_GlobalService } from '../../_services/core/global.service';
+import { DyNTS_RequestHunter } from '../../_services/core/request-hunter.service';
 
 /**
  * High level endpoint for API
@@ -166,13 +172,12 @@ export class DyNTS_Endpoint_Params<
       this.tasks = set.tasks ?? [];
       
       this.stackLocation = DyFM_getConstructionStackLocation();
-    } catch (error) {
-      DyFM_Log.error(
-        `\nEndpoint params setup failed: name: '${set.name}' ` +
-          `(security: ${set.security}) endpoint: ${set.endpoint}` +
-        `\nERROR:` +
-        `\n`, error
-      );
+    } catch (error) {
+      DyNTS_SafeDiagnostic_ControlService.report({
+        code: 'DYNTS|ENDPOINT|CONSTRUCTION_FAILURE',
+        stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
+        error: error,
+      });
 
       throw error;
     }
@@ -219,15 +224,18 @@ export class DyNTS_Endpoint_Params<
       // ISSUE-HUNTER (2026-08-05) — keres-szintu attribucio. Ez a KOZPONTI vegrehajtasi pont,
       // minden endpoint ezen megy at, ezert itt (es CSAK itt) merunk. Koltseg: egy Map-beszuras
       // + Date.now(). A `finally` garantalja, hogy hiba/early-return eseten se szivarogjon be-
-      // jegyzes. Reszletes indoklas: `DyNTS_RequestHunter`.
-      const hunterId: number = DyNTS_RequestHunter.getInstance().begin(this.name);
-      try {
-        let issuer: string;
-        try {
-          issuer = DyNTS_GlobalService?.getAuthService()?.getIssuerFromRequest(req);
-        } catch (error) {
-          DyFM_Log.warn(DyFM_Error.getAnyMessage(error));
-          issuer = 'unknown-issuer';
+      // jegyzes. Reszletes indoklas: `DyNTS_RequestHunter`.
+      const hunterId: number = DyNTS_RequestHunter.getInstance().begin(this.name);
+      try {
+        try {
+          issuer = DyNTS_GlobalService?.getAuthService()?.getIssuerFromRequest(req);
+        } catch (error) {
+          DyNTS_SafeDiagnostic_ControlService.report({
+            code: 'DYNTS|ENDPOINT|ISSUER_RESOLUTION_FAILURE',
+            stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
+            error: error,
+          });
+          issuer = 'unknown-issuer';
         }
         
         if (this.logRequest) {
@@ -293,9 +301,9 @@ export class DyNTS_Endpoint_Params<
             DyFM_Log.info(`              response: ${DyNTS_Endpoint_Params.previewBody(capturedResponseBody)}`);
           }
         }
-      } catch (error) {
-        this.error(req, res, error, issuer);
-      } finally {
+      } catch (error) {
+        await this.error(req, res, error, issuer);
+      } finally {
         DyNTS_RequestHunter.getInstance().end(hunterId);
       }
     };
@@ -334,134 +342,49 @@ export class DyNTS_Endpoint_Params<
     error: DyFM_AnyError, 
     issuer: string,
     autoSecondTry?: boolean
-  ): Promise<void> {
-    try {
-      let msg: string = `Endpoint caught an error. '${this.name}' (${this.endpoint})`;
-
-      msg += this.getPathParamsLogContent(req);
-      if (error instanceof DyFM_Error) {
-        msg += `\n  ErrorCode: ${error._errorCode}`;
-      }
-      msg += `\n  error: "${(error as DyFM_Error)?._message ?? (error as Error)?.message}"`;
-      msg += '\n  at ' + this.stackLocation;
-
-      DyFM_Log.testError(msg);
-
-      if (
-        DyNTS_global_settings.log_settings.highDetailedLogs ||
-        !(error instanceof DyFM_Error)
-      ) {
-        DyFM_Log.H_error(
-          `Endpoint "${this.endpoint}" caught an error. (${this.name})`,
-          '\n    ERROR:', error
-        );
-      } else if (DyNTS_global_settings.log_settings.api_errors) {
-        error.logSimple(`Endpoint "${this.endpoint}" caught an error. (${this.name})`);
-      }
-
-      if ((error as DyFM_Error)?.flag?.includes('DYNAMO')) {
-        if (!(error as DyFM_Error).additionalContent) {
-          (error as DyFM_Error).additionalContent = {};
-        }
-        (error as DyFM_Error).additionalContent.endpointInfo = msg;
-      }
-
-      // FR-071 (2026-06-06) — rich debug-descriptive request-context.
-      // Per memory [[feedback_rich_error_handling]] minden errornak debug-level
-      // descriptive-nek kell lennie + persisted to errors table. Az endpoint-
-      // params catch-blokkjaban minden errorhoz csatoljuk a request snapshot-ot
-      // (URL, method, headers KULCSAI ertek nelkul, query, params, origin,
-      // user-agent), igy a TEST environment-en a kliens-oldali fejleszto a
-      // response-bol latja MI hianyzott a request-bol, NEM csak az error-code-ot.
-      // Header-VALUEK nem szivarognak ki — csak a kulcs-listat es az auth-header
-      // alakjat (length + first 7 chars hogy lassek "Bearer "-rel kezd-e).
-      try {
-        const headerKeys: string[] = Object.keys(req?.headers ?? {});
-        const authHeader: unknown = req?.headers?.['authorization'];
-        const authHeaderShape: string = typeof authHeader === 'string'
-          ? `present (len=${authHeader.length}, startsWith="${authHeader.substring(0, 7)}")`
-          : 'MISSING';
-        const requestSnapshot: Record<string, unknown> = {
-          url: req?.originalUrl ?? req?.url,
-          method: req?.method,
-          origin: req?.headers?.origin ?? null,
-          referer: req?.headers?.referer ?? null,
-          userAgent: req?.headers?.['user-agent'] ?? null,
-          hostHeader: req?.headers?.host ?? null,
-          headerKeyCount: headerKeys.length,
-          headerKeys: headerKeys.sort(),
-          hasAuthorizationKey: headerKeys.includes('authorization'),
-          authHeaderShape: authHeaderShape,
-          hasSecretKeyKey: headerKeys.includes('secret-key'),
-          hasAdminKeyKey: headerKeys.includes('x-admin-key'),
-          hasContentTypeKey: headerKeys.includes('content-type'),
-          params: req?.params,
-          query: req?.query,
-          remoteAddress: req?.ip ?? null,
-        };
-        if (error instanceof DyFM_Error) {
-          if (!(error as DyFM_Error).additionalContent) {
-            (error as DyFM_Error).additionalContent = {};
-          }
-          (error as DyFM_Error).additionalContent.requestDebug = requestSnapshot;
-        }
-        // Plusz: 1-soros debug log a server-side log-buffer-ben.
-        DyFM_Log.warn(
-          `[FR-071 req-debug] ${req?.method ?? '?'} ${req?.originalUrl ?? req?.url ?? '?'} ` +
-          `(endpoint=${this.name}, origin=${req?.headers?.origin ?? 'none'}, ` +
-          `auth=${headerKeys.includes('authorization') ? 'yes' : 'NO'}, ` +
-          `secretKey=${headerKeys.includes('secret-key') ? 'yes' : 'no'}, ` +
-          `adminKey=${headerKeys.includes('x-admin-key') ? 'yes' : 'no'}, ` +
-          `errorCode=${(error as DyFM_Error)?._errorCode ?? '(raw)'})`
-        );
-      } catch /* (snapshotErr) */ {
-        // ha a snapshot kepzese maga is bukik, ne maszek bele az error-flow-ba.
-      }
-
-      await DyNTS_GlobalService.globalErrorHandler?.(
-        error, 
-        req, 
-        res, 
-        issuer
-      ).catch((err): void => {
-        DyFM_Log.warn(
-          'DyNTS_GlobalService.globalErrorHandler failed to handle error: ', 
-          err
-        );
-        DyFM_Log.warn('It will proceed as normal.');
-      });
+  ): Promise<void> {
+    try {
+      const status: number = DyNTS_Endpoint_Params.resolveErrorStatus(error);
+      const diagnostic: DyNTS_SafeDiagnostic_Interface = DyNTS_SafeDiagnostic_ControlService.report({
+        code: 'DYNTS|ENDPOINT|FAILURE',
+        stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
+        error: error,
+        status: status,
+      });
+
+      try {
+        await DyNTS_GlobalService.globalErrorHandler?.(
+          error,
+          req,
+          res,
+          issuer
+        );
+      } catch (handlerError) {
+        DyNTS_SafeDiagnostic_ControlService.report({
+          code: 'DYNTS|ENDPOINT|GLOBAL_HANDLER_FAILURE',
+          stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
+          error: handlerError,
+        });
+      }
       
       // FR-067 (2026-06-06): non-DyFM_Error wrap.
       // Korabban a plain Error / axios HTTP error nyersen ment kifele
       // -> kliens "[object Object]"-et latott, nem volt _errorCode, nem volt
       // userMessage, a kliens-oldali DyFM_Error pipeline ures error-t kapott.
-      // Most MINDEN non-DyFM_Error errort egy DyFM_Error-ba csomagolunk
+      // Most MINDEN non-DyFM_Error errort egy DyFM_Error-ba csomagolunk
       // az endpoint-nev-vel es a system short-code-jal egy felismerheto
       // `_errorCode`-szal: `<SYSTEM>|DyNTS-EPP-<endpointName>`.
       // Plusz a downstream HTTP-status-t (axios `status` / Express `statusCode`)
       // betesszuk a DyFM_Error `___status` mezojebe, igy a kovetkezo blokk
-      // mar konzekvensen olvasni tudja.
-      if (!(error instanceof DyFM_Error)) {
-        const errAny: { statusCode?: unknown; status?: unknown; message?: string } =
-          error as { statusCode?: unknown; status?: unknown; message?: string };
-        const downstreamRaw: unknown = errAny?.statusCode ?? errAny?.status;
-        const downstreamStatus: number | undefined = typeof downstreamRaw === 'number'
-          ? downstreamRaw
-          : (typeof downstreamRaw === 'string' && downstreamRaw !== '' && !isNaN(Number(downstreamRaw)))
-            ? Number(downstreamRaw)
-            : undefined;
-        const wrapStatus: number = (
-          downstreamStatus !== undefined &&
-          downstreamStatus >= 100 &&
-          downstreamStatus <= 599
-        ) ? downstreamStatus : 500;
-        error = new DyFM_Error({
-          error: error as Error,
-          message: errAny?.message ?? `Unhandled error in endpoint "${this.name}"`,
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EPP-${this.name ?? 'UNKNOWN'}`,
-          userMessage: 'An internal error occurred.\nPlease contact the responsible development team.',
-          status: wrapStatus,
-        });
+      // mar konzekvensen olvasni tudja.
+      if (!(error instanceof DyFM_Error)) {
+        error = new DyFM_Error({
+          message: 'Unhandled endpoint failure.',
+          errorCode: this.getClientErrorCode(),
+          userMessage: 'An internal error occurred.\nPlease contact the responsible development team.',
+          additionalContent: { diagnostic: diagnostic },
+          status: status,
+        });
       }
 
       if (error instanceof DyFM_Error) {
@@ -513,20 +436,7 @@ export class DyNTS_Endpoint_Params<
       // `___status`-en kívül a `statusCode` (Express convention) es `status`
       // (axios / general HTTP) mezőket is. Igy a downstream HTTP-hivasok
       // (pl. axios-bol jovo error) helyes HTTP-status-szal továbbítódnak.
-      const errorAny: { statusCode?: unknown; status?: unknown } = error as { statusCode?: unknown; status?: unknown };
-      const resolvedStatusRaw: unknown = (error as DyFM_Error)?.___status
-        ?? errorAny?.statusCode
-        ?? errorAny?.status;
-      const resolvedStatus: number | null = typeof resolvedStatusRaw === 'number'
-        ? resolvedStatusRaw
-        : (typeof resolvedStatusRaw === 'string' && !isNaN(Number(resolvedStatusRaw)))
-          ? Number(resolvedStatusRaw)
-          : null;
-      if (resolvedStatus !== null && resolvedStatus >= 100 && resolvedStatus <= 599) {
-        res.status(resolvedStatus);
-      } else {
-        res.status(500);
-      }
+      res.status(DyNTS_Endpoint_Params.resolveErrorStatus(error));
 
       // Kliens-safe strip ENV-FÜGGETLENÜL (BFR-FDPAUTHSERVICE-002): a korábbi prod-only blokk a
       // test/dev környezetben TELJES DyFM-leaket hagyott (__localStack + ___systemVersion + issuer).
@@ -536,16 +446,9 @@ export class DyNTS_Endpoint_Params<
       const clientSafeError: unknown = DyNTS_ClientSafeError_Util.toClientSafe(error);
       res.send(clientSafeError);
 
-      if (this.logRequest) {
-        DyFM_Log.error(
-          `  <<<=====   '${this.name}' error sent: ${(error as DyFM_Error)?._message ?? ''}`
-        );
-        if (this.logResponseContent) {
-          DyFM_Log.error(`              error response: ${DyNTS_Endpoint_Params.previewBody(clientSafeError)}`);
-        }
-      }
-
-      DyFM_Log.error('');
+      if (this.logRequest) {
+        DyFM_Log.error('[DyNTS endpoint error response sent]', diagnostic);
+      }
           
     } catch (errorLvl2) {
       this.multiLevelError(
@@ -570,34 +473,12 @@ export class DyNTS_Endpoint_Params<
       issuer: string,
       autoSecondTry: boolean
     }
-  ): void {
-    if (DyNTS_global_settings.log_settings.highDetailedLogs) {
-      const msg = 
-        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_Endpoint_Params: error: ` +
-          `(${this.name}, ${this.endpoint})` +
-        `\n(DYNAMO MULTILEVEL ERROR means, that the ERROR HANDLING is ALSO FAILED, ` +
-          `and the error message was not sent.)` + 
-        `\nthisEndpointStackLocation: ${this.stackLocation}`;
-
-      if (errorLvl2 instanceof DyFM_Error) {
-        errorLvl2.logSimple(msg);
-      } else {
-        DyFM_Log.H_error(msg, '\nERROR:', errorLvl2, '\n');
-      }
-    } else {
-      const msg = 
-        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_Endpoint_Params: error: ` +
-          `(${this.name}, ${this.endpoint})` +
-        `\nthisEndpointStackLocation: ${this.stackLocation}` +
-        `\n(DYNAMO MULTILEVEL ERROR means, that the ERROR HANDLING is ALSO FAILED, ` +
-          `and the error message was not sent.)`;
-
-      if (errorLvl2 instanceof DyFM_Error) {
-        errorLvl2.logSimple(msg);
-      } else {
-        DyFM_Log.H_error(msg, '\nERROR:', errorLvl2, '\n');
-      }
-    }
+  ): void {
+    DyNTS_SafeDiagnostic_ControlService.report({
+      code: 'DYNTS|ENDPOINT|ERROR_HANDLER_FAILURE',
+      stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
+      error: errorLvl2,
+    });
 
     try {
       JSON.stringify(errorInputs.error);
@@ -605,11 +486,14 @@ export class DyNTS_Endpoint_Params<
       DyFM_Log.error('  ...response object is not serializable!');
       let resolvedError: any;
 
-      try {
-        resolvedError = DyFM_Object.resolveCirculation(errorInputs.error);
-      } catch (errorLvl3) {
-        DyFM_Log.error('  ...response object is not resolvable!');
-        DyFM_Log.error('  ...', errorLvl3);
+      try {
+        resolvedError = DyFM_Object.resolveCirculation(errorInputs.error);
+      } catch (errorLvl3) {
+        DyNTS_SafeDiagnostic_ControlService.report({
+          code: 'DYNTS|ENDPOINT|CIRCULATION_RESOLUTION_FAILURE',
+          stage: DyNTS_SafeDiagnosticStage_Type.endpoint,
+          error: errorLvl3,
+        });
       }
       
       if (resolvedError) {
@@ -633,20 +517,47 @@ export class DyNTS_Endpoint_Params<
       }
     }
 
-    if (
-      DyNTS_global_settings.log_settings.highDetailedLogs ||
-      !(errorLvl2 instanceof DyFM_Error)
-    ) {
-      DyFM_Log.H_error(
-        `Endpoint "${this.endpoint}" caught an error and FAILED TO RESOLVE. (${this.name})`,
-        '\n    ERROR:', errorLvl2
-      );
-    } else {
-      errorLvl2.logSimple(
-        `Endpoint "${this.endpoint}" caught an error and FAILED TO RESOLVE. (${this.name})`
-      );
-    }
-  }
+  }
+
+  /** Resolves conventional HTTP status fields without inspecting raw error content. */
+  private static resolveErrorStatus(error: unknown): number {
+    try {
+      if (error === null || (typeof error !== 'object' && typeof error !== 'function')) {
+        return 500;
+      }
+
+      const statusRaw: unknown = Reflect.get(error, '___status')
+        ?? Reflect.get(error, 'statusCode')
+        ?? Reflect.get(error, 'status');
+      const status: number = typeof statusRaw === 'number' ? statusRaw : Number(statusRaw);
+
+      return Number.isInteger(status) && status >= 100 && status <= 599 ? status : 500;
+    } catch {
+      return 500;
+    }
+  }
+
+  /** Preserves the public error-code shape while excluding arbitrary endpoint-name characters. */
+  private getClientErrorCode(): string {
+    const systemCode: string = DyNTS_Endpoint_Params.sanitizeCodePart(
+      DyNTS_global_settings.systemShortCodeName,
+      'DYNTS'
+    );
+    const endpointCode: string = DyNTS_Endpoint_Params.sanitizeCodePart(this.name, 'UNKNOWN');
+
+    return `${systemCode}|DyNTS-EPP-${endpointCode}`;
+  }
+
+  /** Bounds developer-owned identifiers to the established error-code alphabet. */
+  private static sanitizeCodePart(value: unknown, fallback: string): string {
+    if (typeof value !== 'string') {
+      return fallback;
+    }
+
+    const sanitized: string = value.replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 64);
+
+    return sanitized || fallback;
+  }
 
   private getPathParamsLogContent(req: Request): string {
     let params: string = '';

package/src/_modules/server/safe-diagnostic/safe-diagnostic-stage.type-enum.ts

@@ -4,8 +4,9 @@ export enum DyNTS_SafeDiagnosticStage_Type {
   collectionGrowthMonitor = 'collection-growth-monitor',
   databaseConnect = 'database-connect',
   databaseRuntime = 'database-runtime',
-  eventLoopDiagnostic = 'event-loop-diagnostic',
-  expressFallback = 'express-fallback',
+  eventLoopDiagnostic = 'event-loop-diagnostic',
+  endpoint = 'endpoint',
+  expressFallback = 'express-fallback',
   globalErrorHandler = 'global-error-handler',
   httpServer = 'http-server',
   httpsServer = 'https-server',