@futdevpro/nts-dynamo 1.15.103 → 1.15.104

package/spec/support/helpers/ts-node-helper.js

@@ -1,93 +1,93 @@
-require('ts-node').register({
-  transpileOnly: true,
-  compilerOptions: {
-    module: 'commonjs',
-    esModuleInterop: true,
-    allowSyntheticDefaultImports: true
-  }
-});
-
-// Set default timeout for all tests immediately
-// This ensures that failed tests timeout quickly (2 seconds) instead of running for too long
-// We set it both immediately and in a delayed callback to ensure it works even if spec files override it
-// NOTE: This is also set in jasmine.json and jasmine.coverage.json - keep all 3 in sync!
-const FORCE_TIMEOUT = 2000; // 2 seconds
-
-// Function to force timeout setting - agresszíven felülírja minden timeout beállítást
-const forceTimeout = () => {
-  if (typeof jasmine !== 'undefined') {
-    jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
-  }
-  if (typeof global !== 'undefined' && global.jasmine) {
-    global.jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
-  }
-  // Try to access jasmine through window if available (for browser environments)
-  if (typeof window !== 'undefined' && window.jasmine) {
-    window.jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
-  }
-};
-
-// Set timeout immediately if jasmine is available
-forceTimeout();
-
-// Agresszív timeout felülírás - folyamatosan felülírja minden 100ms-ben
-// Ez biztosítja, hogy még a spec fájlokban lévő timeout beállítások is felülírásra kerüljenek
-const aggressiveTimeoutInterval = setInterval(() => {
-  forceTimeout();
-}, 100);
-
-// Stop the aggressive interval after 10 seconds (enough time for all tests to start)
-setTimeout(() => {
-  clearInterval(aggressiveTimeoutInterval);
-}, 10000);
-
-// Hook into jasmine's environment if available
-const initTimeout = () => {
-  // Try both global and local jasmine
-  const jasmineObj = (typeof global !== 'undefined' && global.jasmine) || (typeof jasmine !== 'undefined' ? jasmine : null);
-  
-  if (jasmineObj && typeof jasmineObj.getEnv === 'function') {
-    try {
-      const env = jasmineObj.getEnv();
-      if (env) {
-        // Force timeout immediately
-        forceTimeout();
-        
-        // Add a global beforeEach that runs in every spec file to force timeout
-        env.beforeEach(() => {
-          forceTimeout();
-        });
-        // Also add afterEach to ensure timeout is set after each test
-        env.afterEach(() => {
-          forceTimeout();
-        });
-        // Add a reporter that forces timeout on every spec start and done
-        // This ensures that even if a spec file sets timeout, it gets overridden
-        env.addReporter({
-          specStarted: () => {
-            forceTimeout();
-          },
-          specDone: () => {
-            forceTimeout();
-          },
-          suiteStarted: () => {
-            forceTimeout();
-          },
-          suiteDone: () => {
-            forceTimeout();
-          }
-        });
-      }
-    } catch (e) {
-      // Ignore errors if jasmine is not fully initialized yet
-    }
-  }
-};
-
-// Try to initialize multiple times to catch late initialization
-initTimeout();
-setTimeout(initTimeout, 0);
-setTimeout(initTimeout, 50);
-setTimeout(initTimeout, 200);
-setTimeout(initTimeout, 1000);
-
+require('ts-node').register({
+  transpileOnly: true,
+  compilerOptions: {
+    module: 'commonjs',
+    esModuleInterop: true,
+    allowSyntheticDefaultImports: true
+  }
+});
+
+// Set default timeout for all tests immediately
+// This ensures that failed tests timeout quickly (2 seconds) instead of running for too long
+// We set it both immediately and in a delayed callback to ensure it works even if spec files override it
+// NOTE: This is also set in jasmine.json and jasmine.coverage.json - keep all 3 in sync!
+const FORCE_TIMEOUT = 2000; // 2 seconds
+
+// Function to force timeout setting - agresszíven felülírja minden timeout beállítást
+const forceTimeout = () => {
+  if (typeof jasmine !== 'undefined') {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
+  }
+  if (typeof global !== 'undefined' && global.jasmine) {
+    global.jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
+  }
+  // Try to access jasmine through window if available (for browser environments)
+  if (typeof window !== 'undefined' && window.jasmine) {
+    window.jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
+  }
+};
+
+// Set timeout immediately if jasmine is available
+forceTimeout();
+
+// Agresszív timeout felülírás - folyamatosan felülírja minden 100ms-ben
+// Ez biztosítja, hogy még a spec fájlokban lévő timeout beállítások is felülírásra kerüljenek
+const aggressiveTimeoutInterval = setInterval(() => {
+  forceTimeout();
+}, 100);
+
+// Stop the aggressive interval after 10 seconds (enough time for all tests to start)
+setTimeout(() => {
+  clearInterval(aggressiveTimeoutInterval);
+}, 10000);
+
+// Hook into jasmine's environment if available
+const initTimeout = () => {
+  // Try both global and local jasmine
+  const jasmineObj = (typeof global !== 'undefined' && global.jasmine) || (typeof jasmine !== 'undefined' ? jasmine : null);
+  
+  if (jasmineObj && typeof jasmineObj.getEnv === 'function') {
+    try {
+      const env = jasmineObj.getEnv();
+      if (env) {
+        // Force timeout immediately
+        forceTimeout();
+        
+        // Add a global beforeEach that runs in every spec file to force timeout
+        env.beforeEach(() => {
+          forceTimeout();
+        });
+        // Also add afterEach to ensure timeout is set after each test
+        env.afterEach(() => {
+          forceTimeout();
+        });
+        // Add a reporter that forces timeout on every spec start and done
+        // This ensures that even if a spec file sets timeout, it gets overridden
+        env.addReporter({
+          specStarted: () => {
+            forceTimeout();
+          },
+          specDone: () => {
+            forceTimeout();
+          },
+          suiteStarted: () => {
+            forceTimeout();
+          },
+          suiteDone: () => {
+            forceTimeout();
+          }
+        });
+      }
+    } catch (e) {
+      // Ignore errors if jasmine is not fully initialized yet
+    }
+  }
+};
+
+// Try to initialize multiple times to catch late initialization
+initTimeout();
+setTimeout(initTimeout, 0);
+setTimeout(initTimeout, 50);
+setTimeout(initTimeout, 200);
+setTimeout(initTimeout, 1000);
+

package/spec/support/jasmine.coverage.json

@@ -1,24 +1,24 @@
-{
-  "reporters": [
-    {
-      "name": "jasmine-json-reporter",
-      "options": {
-        "pretty": true
-      }
-    }
-  ],
-  "spec_dir": "src/",
-  "spec_files": [
-    "**/*.spec.ts",
-    "**/*[sS]pec.ts"
-  ],
-  "helpers": [
-    "../../spec/support/helpers/ts-node-helper.js"
-  ],
-  "env": {
-    "stopSpecOnExpectationFailure": false,
-    "random": true,
-    "defaultTimeoutInterval": 2000
-  }
-}
-
+{
+  "reporters": [
+    {
+      "name": "jasmine-json-reporter",
+      "options": {
+        "pretty": true
+      }
+    }
+  ],
+  "spec_dir": "src/",
+  "spec_files": [
+    "**/*.spec.ts",
+    "**/*[sS]pec.ts"
+  ],
+  "helpers": [
+    "../../spec/support/helpers/ts-node-helper.js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "random": true,
+    "defaultTimeoutInterval": 2000
+  }
+}
+

package/spec/support/jasmine.json

@@ -1,24 +1,24 @@
-{
-  "reporters": [
-    {
-      "name": "jasmine-json-reporter",
-      "options": {
-        "pretty": true
-      }
-    }
-  ],
-  "spec_dir": "build/",
-  "spec_files": [
-    "**/*.spec.ts",
-    "**/*.spec.js",
-    "**/*[sS]pec.ts"
-  ],
-  "helpers": [
-    "../spec/support/helpers/ts-node-helper.js"
-  ],
-  "env": {
-    "stopSpecOnExpectationFailure": false,
-    "random": true,
-    "defaultTimeoutInterval": 2000
-  }
-}
+{
+  "reporters": [
+    {
+      "name": "jasmine-json-reporter",
+      "options": {
+        "pretty": true
+      }
+    }
+  ],
+  "spec_dir": "build/",
+  "spec_files": [
+    "**/*.spec.ts",
+    "**/*.spec.js",
+    "**/*[sS]pec.ts"
+  ],
+  "helpers": [
+    "../spec/support/helpers/ts-node-helper.js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "random": true,
+    "defaultTimeoutInterval": 2000
+  }
+}

package/src/_collections/archive.util.spec.ts

@@ -1,57 +1,57 @@
-import { DyNTS_getArchivedDBName, DyNTS_archiveSuffix } from './archive.util';
-
-describe('| DyNTS_getArchivedDBName', () => {
-  it('| should append the archive suffix to the database name', () => {
-    const dbName = 'TestDB';
-    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
-    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
-  });
-
-  it('| should return only the archive suffix when the database name is an empty string', () => {
-    const dbName = '';
-    const expectedArchivedName = `_${DyNTS_archiveSuffix}`;
-    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
-  });
-
-  it('| should handle database names with special characters', () => {
-    const dbName = 'Test_DB-123!';
-    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
-    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
-  });
-
-  it('| should handle database names with spaces', () => {
-    const dbName = 'Test DB Name';
-    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
-    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
-  });
-
-  it('| should handle database names with numbers', () => {
-    const dbName = 'DB123';
-    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
-    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
-  });
-
-  it('| should handle very long database names', () => {
-    const dbName = 'A'.repeat(100);
-    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
-    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
-  });
-
-  it('| should use the correct archive suffix constant', () => {
-    expect(DyNTS_archiveSuffix).toBe('archived');
-    const dbName = 'TestDB';
-    const result = DyNTS_getArchivedDBName(dbName);
-    expect(result).toContain('archived');
-    expect(result).toBe('TestDB_archived');
-  });
-});
-
-describe('| DyNTS_archiveSuffix', () => {
-  it('| should have the correct value', () => {
-    expect(DyNTS_archiveSuffix).toBe('archived');
-  });
-
-  it('| should be a string', () => {
-    expect(typeof DyNTS_archiveSuffix).toBe('string');
-  });
-});
+import { DyNTS_getArchivedDBName, DyNTS_archiveSuffix } from './archive.util';
+
+describe('| DyNTS_getArchivedDBName', () => {
+  it('| should append the archive suffix to the database name', () => {
+    const dbName = 'TestDB';
+    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+
+  it('| should return only the archive suffix when the database name is an empty string', () => {
+    const dbName = '';
+    const expectedArchivedName = `_${DyNTS_archiveSuffix}`;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+
+  it('| should handle database names with special characters', () => {
+    const dbName = 'Test_DB-123!';
+    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+
+  it('| should handle database names with spaces', () => {
+    const dbName = 'Test DB Name';
+    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+
+  it('| should handle database names with numbers', () => {
+    const dbName = 'DB123';
+    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+
+  it('| should handle very long database names', () => {
+    const dbName = 'A'.repeat(100);
+    const expectedArchivedName = `${dbName}_${DyNTS_archiveSuffix}`;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+
+  it('| should use the correct archive suffix constant', () => {
+    expect(DyNTS_archiveSuffix).toBe('archived');
+    const dbName = 'TestDB';
+    const result = DyNTS_getArchivedDBName(dbName);
+    expect(result).toContain('archived');
+    expect(result).toBe('TestDB_archived');
+  });
+});
+
+describe('| DyNTS_archiveSuffix', () => {
+  it('| should have the correct value', () => {
+    expect(DyNTS_archiveSuffix).toBe('archived');
+  });
+
+  it('| should be a string', () => {
+    expect(typeof DyNTS_archiveSuffix).toBe('string');
+  });
+});

package/src/_collections/archive.util.ts

@@ -1,18 +1,18 @@
-
-
-/** Suffix appended to database names when archived. */
-export const DyNTS_archiveSuffix = 'archived';
-
-/**
- * Create the archive database name for a given base database.
- *
- * @example
- * ```ts
- * const name = DyNTS_getArchivedDBName('users');
- * // => 'users_archived'
- * ```
- */
-export function DyNTS_getArchivedDBName(dbName: string): string {
-  return `${dbName}_${DyNTS_archiveSuffix}`;
-}
-
+
+
+/** Suffix appended to database names when archived. */
+export const DyNTS_archiveSuffix = 'archived';
+
+/**
+ * Create the archive database name for a given base database.
+ *
+ * @example
+ * ```ts
+ * const name = DyNTS_getArchivedDBName('users');
+ * // => 'users_archived'
+ * ```
+ */
+export function DyNTS_getArchivedDBName(dbName: string): string {
+  return `${dbName}_${DyNTS_archiveSuffix}`;
+}
+

package/src/_collections/atlas-default-db-options.const.ts

@@ -1,10 +1,10 @@
-
-import { second } from '@futdevpro/fsm-dynamo';
-import { ConnectOptions } from 'mongoose';
-
-
-export const DyNTS_atlasDefaultDbOptions: ConnectOptions = {
-  directConnection: false,
-  serverSelectionTimeoutMS: 5 * second,
-  connectTimeoutMS: 10 * second,
+
+import { second } from '@futdevpro/fsm-dynamo';
+import { ConnectOptions } from 'mongoose';
+
+
+export const DyNTS_atlasDefaultDbOptions: ConnectOptions = {
+  directConnection: false,
+  serverSelectionTimeoutMS: 5 * second,
+  connectTimeoutMS: 10 * second,
 }

package/src/_collections/client-safe-error.util.spec.ts

@@ -43,18 +43,74 @@ describe('| DyNTS_ClientSafeError_Util', (): void => {
     expect(safe['errors']).toBeUndefined();
   });
 
-  it('| MEGTARTJA a kliens-fogyasztott mezőket (_message, _errorCodes, __userMessage)', (): void => {
+  it('| MEGTARTJA a kliens-fogyasztott mező-alakot (_message, _errorCodes, __userMessage)', (): void => {
     DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.local;
     const error: DyFM_Error = buildRichError();
 
     const safe: Record<string, unknown> = DyNTS_ClientSafeError_Util.toClientSafe(error) as Record<string, unknown>;
 
-    expect(safe['_message']).toBe('internal reason');
+    // QA2-005: a `_message` ALAKJA marad, de a TARTALMA a user-safe `__userMessage` —
+    // a technikai 'internal reason' (belső URL / nyers DB-hiba osztály) nem megy ki
+    expect(safe['_message']).toBe('user facing message');
     expect(safe['__userMessage']).toBe('user facing message');
     expect(Array.isArray(safe['_errorCodes'])).toBeTrue();
     expect((safe['_errorCodes'] as string[]).join(',')).toContain('DyNTS-TEST-CSE0');
   });
 
+  it('| QA2-005: a technikai _message / _messages NEM szivárog ki (test-env-ben sem)', (): void => {
+    DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.test;
+    const error: DyFM_Error = new DyFM_Error({
+      message: 'API call "registerAccount" failed on the other end!\nurl: http://auth-service:39005/api/account/register' +
+        '\nerror response found: E11000 duplicate key error collection',
+      userMessage: 'Registration failed!',
+      errorCode: 'DyNTS-TEST-CSE1',
+    });
+
+    const safe: Record<string, unknown> = DyNTS_ClientSafeError_Util.toClientSafe(error) as Record<string, unknown>;
+    const serialized: string = JSON.stringify(safe);
+
+    expect(safe['_message']).toBe('Registration failed!');
+    expect(safe['_messages']).toBeUndefined();
+    expect(serialized).not.toContain('auth-service:39005');
+    expect(serialized).not.toContain('E11000');
+  });
+
+  it('| QA2-005: __userMessage nélkül a _message generikus szövegre cserélődik (nem a technikai)', (): void => {
+    DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.test;
+    const error: DyFM_Error = new DyFM_Error({
+      message: 'raw internal detail: http://auth-service:39005/api',
+      errorCode: 'DyNTS-TEST-CSE2',
+    });
+    // a konstruktor default-userMessage viselkedésétől függetlenül: a technikai szöveg nem mehet ki
+    (error as unknown as Record<string, unknown>)['__userMessage'] = undefined;
+
+    const safe: Record<string, unknown> = DyNTS_ClientSafeError_Util.toClientSafe(error) as Record<string, unknown>;
+
+    expect(typeof safe['_message']).toBe('string');
+    expect(safe['_message'] as string).not.toContain('auth-service:39005');
+    expect((safe['_message'] as string).length).toBeGreaterThan(0);
+  });
+
+  it('| QA2-005: az additionalContent.requestDebug env-FÜGGETLENÜL strip-elve, a többi mező marad (non-prod)', (): void => {
+    DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.test;
+    const error: DyFM_Error = new DyFM_Error({
+      message: 'internal reason',
+      userMessage: 'user facing message',
+      errorCode: 'DyNTS-TEST-CSE3',
+      additionalContent: {
+        userId: 'u1',
+        requestDebug: { headerKeys: ['authorization', 'cookie'], remoteAddress: '172.18.0.5' },
+      },
+    });
+
+    const safe: Record<string, unknown> = DyNTS_ClientSafeError_Util.toClientSafe(error) as Record<string, unknown>;
+    const additionalContent: Record<string, unknown> = safe['additionalContent'] as Record<string, unknown>;
+
+    expect(additionalContent).toBeDefined();
+    expect(additionalContent['userId']).toBe('u1');
+    expect(additionalContent['requestDebug']).toBeUndefined();
+  });
+
   it('| nem-prod env: az additionalContent (diagnosztikai snapshot) MARAD', (): void => {
     DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.local;
     const error: DyFM_Error = buildRichError();

package/src/_collections/client-safe-error.util.ts

@@ -12,11 +12,15 @@ import { DyNTS_global_settings } from './global-settings.const';
  *   1. MINDIG ki (env-független, kliens sehol nem fogyasztja → 0 regresszió):
  *      `__localStack`, `stack`, `___systemVersion`, `___issuer`, `___issuerSystem`,
  *      `___issuerService`, `confidentialContent`, `error`, `errors` (a nyers belső error-lánc
- *      stack-eket hordoz).
+ *      stack-eket hordoz), `_messages` (QA2-005: technikai message-lánc — belső URL-ek, DB-hibák).
  *   2. CSAK prod-ban ki: `additionalContent` — test/dev környezetben a diagnosztikai state-snapshot
- *      szándékosan kimegy (a hibafelület-debug erre épül), prod-ban nem.
+ *      szándékosan kimegy (a hibafelület-debug erre épül), prod-ban nem. KIVÉTEL (QA2-005):
+ *      az `additionalContent.requestDebug` (FR-071 header-lista/belső-IP snapshot) env-FÜGGETLENÜL
+ *      strip-elve — csak az error-store-ba perzisztálódik.
  *   3. MARAD (kliens-kompatibilitás — a FDP-kliens error-interceptorok fogyasztják):
- *      `_message`, `_errorCodes`, `__userMessage`, `___status`, `level`.
+ *      `_message`, `_errorCodes`, `__userMessage`, `___status`, `level`. QA2-005: a `_message`
+ *      TARTALMA a user-safe `__userMessage`-re cserélve (a technikai üzenet — belső BE-BE URL,
+ *      nyers Mongo E11000 — nem hagyhatja el a szervert; a mező-ALAK a kliens-kompat miatt marad).
  *
  * NEM-DyFM error (plain Error / axios-error / bármi más): minimál `{ message }` shape — a plain
  * Error eddig is üres `{}`-ként szerializálódott (non-enumerable mezők), az axios-jellegű error-ok
@@ -38,8 +42,16 @@ export class DyNTS_ClientSafeError_Util {
     'confidentialContent',
     'error',
     'errors',
+    // QA2-005 (dynamo-builder MP-23 QA-gate, 2026-07-18): a technikai message-LÁNC — belső BE-BE
+    // URL-eket (pl. http://auth-service:39005/...), nyers DB-driver-hibákat (Mongo E11000) hordoz;
+    // a kliens nem fogyasztja (a display-lánc `__userMessage` → `_message`), az error-store-ban marad.
+    '_messages',
   ];
 
+  /** QA2-005 — generikus `_message` fallback, ha az errornak nincs `__userMessage`-e. */
+  private static readonly genericClientMessage: string =
+    'An internal error occurred.\nPlease contact the responsible development team.';
+
   /**
    * Az error kliens-safe formára hozása a HTTP-response-küldés előtt.
    * DyFM_Error: in-place strip (1-3. szabályok szerint); nem-DyFM object: minimál `{ message }`.
@@ -53,6 +65,29 @@ export class DyNTS_ClientSafeError_Util {
         delete dyError[key];
       }
 
+      // ═══════════════════════════════════════════════════════════════════════
+      // QA2-005 — info-disclosure vágás env-FÜGGETLENÜL (test-env-ben SEM mehet ki):
+      //   a) `_message` (technikai üzenet): belső BE-BE URL-t / nyers Mongo-hibát hordozhat →
+      //      a response-ban a user-safe `__userMessage`-dzsel helyettesítjük. A mező ALAKJA
+      //      megmarad (a kliens-interceptorok / `DyFM_extractErrorMessage` fallback-lánca és a
+      //      `_message`-jelenlét-heurisztikák változatlanul működnek); a TELJES technikai üzenet
+      //      az error-store-ban marad (a globalErrorHandler a strip ELŐTT perzisztál).
+      //   b) `additionalContent.requestDebug` (FR-071 request-snapshot: header-kulcs-lista,
+      //      belső IP, params/query): csak az error-store-ba — a response-ból mindig kimarad;
+      //      az additionalContent TÖBBI (app-szintű diagnosztikai) mezője non-prod env-ben marad.
+      // ═══════════════════════════════════════════════════════════════════════
+      const userMessage: unknown = dyError['__userMessage'];
+
+      dyError['_message'] = (typeof userMessage === 'string' && userMessage)
+        ? userMessage
+        : DyNTS_ClientSafeError_Util.genericClientMessage;
+
+      const additionalContent: unknown = dyError['additionalContent'];
+
+      if (additionalContent && typeof additionalContent === 'object') {
+        delete (additionalContent as Record<string, unknown>)['requestDebug'];
+      }
+
       // prod: a diagnosztikai state-snapshot sem megy ki; test/dev: szándékosan marad (debug-UX)
       if (DyNTS_global_settings.env_settings.environment === DyFM_EnvironmentFlag.prod) {
         delete dyError['additionalContent'];

package/src/_collections/default-fallback-cache-max-age.const.spec.ts

@@ -1,11 +1,11 @@
-import { DyNTS_defaultFallbackCacheMaxAge } from './default-fallback-cache-max-age.const';
-
-describe('| DyNTS_defaultFallbackCacheMaxAge', () => {
-  it('| should export default fallback cache max-age as 0', () => {
-    expect(DyNTS_defaultFallbackCacheMaxAge).toBe(0);
-  });
-
-  it('| should be a number', () => {
-    expect(typeof DyNTS_defaultFallbackCacheMaxAge).toBe('number');
-  });
-});
+import { DyNTS_defaultFallbackCacheMaxAge } from './default-fallback-cache-max-age.const';
+
+describe('| DyNTS_defaultFallbackCacheMaxAge', () => {
+  it('| should export default fallback cache max-age as 0', () => {
+    expect(DyNTS_defaultFallbackCacheMaxAge).toBe(0);
+  });
+
+  it('| should be a number', () => {
+    expect(typeof DyNTS_defaultFallbackCacheMaxAge).toBe('number');
+  });
+});

package/src/_collections/default-fallback-cache-max-age.const.ts

@@ -1,2 +1,2 @@
-/** SPA fallback (pl. index.html) alapértelmezett cache max-age másodpercben (0 = ne cache-eljük). */
-export const DyNTS_defaultFallbackCacheMaxAge: number = 0;
+/** SPA fallback (pl. index.html) alapértelmezett cache max-age másodpercben (0 = ne cache-eljük). */
+export const DyNTS_defaultFallbackCacheMaxAge: number = 0;