@futdevpro/nts-dynamo 1.15.151 → 1.15.154

package/src/_services/core/db-stats.service.ts

@@ -1,104 +1,104 @@
-import * as mongoose from 'mongoose';
-
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-/**
- * BFR-OVERSEER-004 — stats-only DB-diagnosztika (NO direct data read).
- *
- * Per-collection rekordszám + adat-méret + index-méret (a `$collStats` aggregation-stage-en át —
- * metaadat-olvasás, SOHA nem dokumentum-tartalom) + összesített DB-méret. A 2026-06-23 overseer-incidens
- * (3 GB-ra hízott archív-collection, csak kézi mongosh-sal látszott) proaktív early-warningja: minden
- * NTS-szerver default megkapja a `/server/db-stats` endpointon (app-auth-tal gate-elhető).
- */
-
-export interface DyNTS_CollectionStats {
-  name: string;
-  documentCount: number;
-  sizeMB: number;
-  indexSizeMB: number;
-}
-
-export interface DyNTS_DbStats {
-  dbName: string;
-  collections: DyNTS_CollectionStats[];
-  totalSizeMB: number;
-  totalIndexSizeMB: number;
-  totalDocumentCount: number;
-  /** A gyűjtés közben elhasalt collection-ök (never-silent — a kihagyás látható). */
-  failedCollections: string[];
-}
-
-const BYTES_PER_MB: number = 1024 * 1024;
-
-export class DyNTS_DbStats_Util {
-
-  /**
-   * A teljes stats-only pillanatkép. Hibatűrő: egy-egy collection statjának elhasalása NEM
-   * borítja a többit (failedCollections-be kerül, warn-nal — no-silent-skip).
-   */
-  static async collect(connection: mongoose.Connection): Promise<DyNTS_DbStats> {
-    const db: typeof connection.db = connection?.db;
-    if (!db) {
-      return {
-        dbName: connection?.name ?? '-no-connection-',
-        collections: [],
-        totalSizeMB: 0,
-        totalIndexSizeMB: 0,
-        totalDocumentCount: 0,
-        failedCollections: [],
-      };
-    }
-
-    const collectionInfos: { name: string }[] = await db.listCollections({}, { nameOnly: true }).toArray();
-    const collections: DyNTS_CollectionStats[] = [];
-    const failedCollections: string[] = [];
-
-    for (const info of collectionInfos) {
-      try {
-        // $collStats storageStats: metaadat-only (size/count/totalIndexSize) — nincs dokumentum-olvasás.
-        const statsCursor = db.collection(info.name).aggregate([
-          { $collStats: { storageStats: {} } },
-        ]);
-        const statsDocs: Record<string, unknown>[] = await statsCursor.toArray();
-        const storage: Record<string, unknown> =
-          (statsDocs[0]?.['storageStats'] ?? {}) as Record<string, unknown>;
-
-        collections.push({
-          name: info.name,
-          documentCount: Number(storage['count'] ?? 0),
-          sizeMB: DyNTS_DbStats_Util.toMB(Number(storage['size'] ?? 0)),
-          indexSizeMB: DyNTS_DbStats_Util.toMB(Number(storage['totalIndexSize'] ?? 0)),
-        });
-      } catch (error) {
-        failedCollections.push(info.name);
-        DyFM_Log.warn(`(DyNTS_DbStats) collStats failed for "${info.name}" (non-fatal)`, error);
-      }
-    }
-
-    // Méret szerint csökkenő — a bloat-gyanús collection legyen elöl.
-    collections.sort((a: DyNTS_CollectionStats, b: DyNTS_CollectionStats): number => b.sizeMB - a.sizeMB);
-
-    return {
-      dbName: connection.name,
-      collections: collections,
-      totalSizeMB: DyNTS_DbStats_Util.round2(
-        collections.reduce((sum: number, c: DyNTS_CollectionStats): number => sum + c.sizeMB, 0)
-      ),
-      totalIndexSizeMB: DyNTS_DbStats_Util.round2(
-        collections.reduce((sum: number, c: DyNTS_CollectionStats): number => sum + c.indexSizeMB, 0)
-      ),
-      totalDocumentCount: collections.reduce(
-        (sum: number, c: DyNTS_CollectionStats): number => sum + c.documentCount, 0
-      ),
-      failedCollections: failedCollections,
-    };
-  }
-
-  static toMB(bytes: number): number {
-    return DyNTS_DbStats_Util.round2(bytes / BYTES_PER_MB);
-  }
-
-  static round2(value: number): number {
-    return Math.round(value * 100) / 100;
-  }
-}
+import * as mongoose from 'mongoose';
+
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+/**
+ * BFR-OVERSEER-004 — stats-only DB-diagnosztika (NO direct data read).
+ *
+ * Per-collection rekordszám + adat-méret + index-méret (a `$collStats` aggregation-stage-en át —
+ * metaadat-olvasás, SOHA nem dokumentum-tartalom) + összesített DB-méret. A 2026-06-23 overseer-incidens
+ * (3 GB-ra hízott archív-collection, csak kézi mongosh-sal látszott) proaktív early-warningja: minden
+ * NTS-szerver default megkapja a `/server/db-stats` endpointon (app-auth-tal gate-elhető).
+ */
+
+export interface DyNTS_CollectionStats {
+  name: string;
+  documentCount: number;
+  sizeMB: number;
+  indexSizeMB: number;
+}
+
+export interface DyNTS_DbStats {
+  dbName: string;
+  collections: DyNTS_CollectionStats[];
+  totalSizeMB: number;
+  totalIndexSizeMB: number;
+  totalDocumentCount: number;
+  /** A gyűjtés közben elhasalt collection-ök (never-silent — a kihagyás látható). */
+  failedCollections: string[];
+}
+
+const BYTES_PER_MB: number = 1024 * 1024;
+
+export class DyNTS_DbStats_Util {
+
+  /**
+   * A teljes stats-only pillanatkép. Hibatűrő: egy-egy collection statjának elhasalása NEM
+   * borítja a többit (failedCollections-be kerül, warn-nal — no-silent-skip).
+   */
+  static async collect(connection: mongoose.Connection): Promise<DyNTS_DbStats> {
+    const db: typeof connection.db = connection?.db;
+    if (!db) {
+      return {
+        dbName: connection?.name ?? '-no-connection-',
+        collections: [],
+        totalSizeMB: 0,
+        totalIndexSizeMB: 0,
+        totalDocumentCount: 0,
+        failedCollections: [],
+      };
+    }
+
+    const collectionInfos: { name: string }[] = await db.listCollections({}, { nameOnly: true }).toArray();
+    const collections: DyNTS_CollectionStats[] = [];
+    const failedCollections: string[] = [];
+
+    for (const info of collectionInfos) {
+      try {
+        // $collStats storageStats: metaadat-only (size/count/totalIndexSize) — nincs dokumentum-olvasás.
+        const statsCursor = db.collection(info.name).aggregate([
+          { $collStats: { storageStats: {} } },
+        ]);
+        const statsDocs: Record<string, unknown>[] = await statsCursor.toArray();
+        const storage: Record<string, unknown> =
+          (statsDocs[0]?.['storageStats'] ?? {}) as Record<string, unknown>;
+
+        collections.push({
+          name: info.name,
+          documentCount: Number(storage['count'] ?? 0),
+          sizeMB: DyNTS_DbStats_Util.toMB(Number(storage['size'] ?? 0)),
+          indexSizeMB: DyNTS_DbStats_Util.toMB(Number(storage['totalIndexSize'] ?? 0)),
+        });
+      } catch (error) {
+        failedCollections.push(info.name);
+        DyFM_Log.warn(`(DyNTS_DbStats) collStats failed for "${info.name}" (non-fatal)`, error);
+      }
+    }
+
+    // Méret szerint csökkenő — a bloat-gyanús collection legyen elöl.
+    collections.sort((a: DyNTS_CollectionStats, b: DyNTS_CollectionStats): number => b.sizeMB - a.sizeMB);
+
+    return {
+      dbName: connection.name,
+      collections: collections,
+      totalSizeMB: DyNTS_DbStats_Util.round2(
+        collections.reduce((sum: number, c: DyNTS_CollectionStats): number => sum + c.sizeMB, 0)
+      ),
+      totalIndexSizeMB: DyNTS_DbStats_Util.round2(
+        collections.reduce((sum: number, c: DyNTS_CollectionStats): number => sum + c.indexSizeMB, 0)
+      ),
+      totalDocumentCount: collections.reduce(
+        (sum: number, c: DyNTS_CollectionStats): number => sum + c.documentCount, 0
+      ),
+      failedCollections: failedCollections,
+    };
+  }
+
+  static toMB(bytes: number): number {
+    return DyNTS_DbStats_Util.round2(bytes / BYTES_PER_MB);
+  }
+
+  static round2(value: number): number {
+    return Math.round(value * 100) / 100;
+  }
+}

package/src/_services/core/diagnostics.service.spec.ts

@@ -1,44 +1,44 @@
-import { DyNTS_DbStats_Util } from './db-stats.service';
-import { DyNTS_Diagnostics, DyNTS_DoctorCheck } from './diagnostics.service';
-
-/**
- * BFR-AM-015 / BFR-OVERSEER-004 — a diagnosztika PURE részeinek unit-tesztjei
- * (interpretHealth / buildSummary / MB-kerekítés).
- */
-describe('| DyNTS_Diagnostics (pure)', () => {
-
-  const ok: DyNTS_DoctorCheck = { name: 'a', health: 'ok' };
-  const warn: DyNTS_DoctorCheck = { name: 'b', health: 'warn', fixHint: 'do b' };
-  const fail: DyNTS_DoctorCheck = { name: 'c', health: 'fail', fixHint: 'do c' };
-
-  it('| interpretHealth: fail dominál, aztán warn, különben ok', () => {
-    expect(DyNTS_Diagnostics.interpretHealth([ ok, ok ])).toBe('ok');
-    expect(DyNTS_Diagnostics.interpretHealth([ ok, warn ])).toBe('warn');
-    expect(DyNTS_Diagnostics.interpretHealth([ warn, fail, ok ])).toBe('fail');
-    expect(DyNTS_Diagnostics.interpretHealth([])).toBe('ok');
-  });
-
-  it('| buildSummary: all-ok → "all checks ok"; nem-ok check-ek fixHint-tel listázva', () => {
-    expect(DyNTS_Diagnostics.buildSummary([ ok ])).toBe('all checks ok');
-    const summary: string = DyNTS_Diagnostics.buildSummary([ ok, warn, fail ]);
-    expect(summary).toContain('b: warn — do b');
-    expect(summary).toContain('c: fail — do c');
-    expect(summary).not.toContain('a:');
-  });
-});
-
-describe('| DyNTS_DbStats_Util (pure)', () => {
-
-  it('| toMB: byte → MB két tizedesre', () => {
-    expect(DyNTS_DbStats_Util.toMB(1024 * 1024)).toBe(1);
-    expect(DyNTS_DbStats_Util.toMB(1536 * 1024)).toBe(1.5);
-    expect(DyNTS_DbStats_Util.toMB(0)).toBe(0);
-  });
-
-  it('| collect: kapcsolat nélkül üres, nem-dobó eredmény', async () => {
-    const stats = await DyNTS_DbStats_Util.collect(undefined as never);
-    expect(stats.collections).toEqual([]);
-    expect(stats.totalSizeMB).toBe(0);
-    expect(stats.failedCollections).toEqual([]);
-  });
-});
+import { DyNTS_DbStats_Util } from './db-stats.service';
+import { DyNTS_Diagnostics, DyNTS_DoctorCheck } from './diagnostics.service';
+
+/**
+ * BFR-AM-015 / BFR-OVERSEER-004 — a diagnosztika PURE részeinek unit-tesztjei
+ * (interpretHealth / buildSummary / MB-kerekítés).
+ */
+describe('| DyNTS_Diagnostics (pure)', () => {
+
+  const ok: DyNTS_DoctorCheck = { name: 'a', health: 'ok' };
+  const warn: DyNTS_DoctorCheck = { name: 'b', health: 'warn', fixHint: 'do b' };
+  const fail: DyNTS_DoctorCheck = { name: 'c', health: 'fail', fixHint: 'do c' };
+
+  it('| interpretHealth: fail dominál, aztán warn, különben ok', () => {
+    expect(DyNTS_Diagnostics.interpretHealth([ ok, ok ])).toBe('ok');
+    expect(DyNTS_Diagnostics.interpretHealth([ ok, warn ])).toBe('warn');
+    expect(DyNTS_Diagnostics.interpretHealth([ warn, fail, ok ])).toBe('fail');
+    expect(DyNTS_Diagnostics.interpretHealth([])).toBe('ok');
+  });
+
+  it('| buildSummary: all-ok → "all checks ok"; nem-ok check-ek fixHint-tel listázva', () => {
+    expect(DyNTS_Diagnostics.buildSummary([ ok ])).toBe('all checks ok');
+    const summary: string = DyNTS_Diagnostics.buildSummary([ ok, warn, fail ]);
+    expect(summary).toContain('b: warn — do b');
+    expect(summary).toContain('c: fail — do c');
+    expect(summary).not.toContain('a:');
+  });
+});
+
+describe('| DyNTS_DbStats_Util (pure)', () => {
+
+  it('| toMB: byte → MB két tizedesre', () => {
+    expect(DyNTS_DbStats_Util.toMB(1024 * 1024)).toBe(1);
+    expect(DyNTS_DbStats_Util.toMB(1536 * 1024)).toBe(1.5);
+    expect(DyNTS_DbStats_Util.toMB(0)).toBe(0);
+  });
+
+  it('| collect: kapcsolat nélkül üres, nem-dobó eredmény', async () => {
+    const stats = await DyNTS_DbStats_Util.collect(undefined as never);
+    expect(stats.collections).toEqual([]);
+    expect(stats.totalSizeMB).toBe(0);
+    expect(stats.failedCollections).toEqual([]);
+  });
+});

package/src/_services/core/diagnostics.service.ts

@@ -1,158 +1,158 @@
-import * as mongoose from 'mongoose';
-
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_DbStats, DyNTS_DbStats_Util } from './db-stats.service';
-import { DyNTS_EventLoopDiag } from './event-loop-diag.service';
-import { DyNTS_MemoryGuard } from './memory-guard.service';
-
-/**
- * BFR-AM-015 (+ BFR-OVERSEER-004 aggregátor-fele) — generikus, újrahasználható diagnosztikai
- * aggregátor MINDEN `DyNTS_App`-hoz: a `GET /server/doctor` endpoint forrása.
- *
- * Check-ek (mind SAJÁT try-ban — egy elhasaló check nem borítja a doctort, néma hiba TILOS):
- *  - mongo: kapcsolat + ping (readiness-minta);
- *  - memory: MemoryGuard pressure-snapshot;
- *  - eventLoop: EventLoopDiag snapshot;
- *  - dbStats: stats-only collection-méretek + küszöb-warn a bloat-gyanúra.
- * Az app APP-SPECIFIKUS check-eket regisztrálhat (`registerCheck`) — pl. env-validáció,
- * provider-probe (a FAM `FAM_Doctor` mintája bedrock-magként).
- */
-
-export interface DyNTS_DoctorCheck {
-  name: string;
-  health: 'ok' | 'warn' | 'fail';
-  detail?: unknown;
-  /** Mit tegyen az operátor, ha nem ok (néma hiba tilos — a hint kötelező nem-ok esetén). */
-  fixHint?: string;
-}
-
-export interface DyNTS_DoctorReport {
-  health: 'ok' | 'warn' | 'fail';
-  checks: DyNTS_DoctorCheck[];
-  summary: string;
-  uptimeSec: number;
-}
-
-/** App-specifikus check-függvény (a doctor futtatja, saját try-ban). */
-export type DyNTS_DoctorCheckFn = () => Promise<DyNTS_DoctorCheck>;
-
-/** Collection-méret warn-küszöb (MB) — e fölött a dbStats-check warn-ra vált. */
-const DEFAULT_COLLECTION_WARN_MB: number = 512;
-
-export class DyNTS_Diagnostics {
-
-  private static readonly customChecks: DyNTS_DoctorCheckFn[] = [];
-
-  /** App-specifikus check regisztrálása (pl. env-validáció, provider-probe). */
-  static registerCheck(check: DyNTS_DoctorCheckFn): void {
-    DyNTS_Diagnostics.customChecks.push(check);
-  }
-
-  /** A teljes doctor-riport. SOSEM dob — a hibás check `fail`-ként jelenik meg. */
-  static async runDoctor(set: {
-    connection: mongoose.Connection,
-    collectionWarnMB?: number,
-  }): Promise<DyNTS_DoctorReport> {
-    const checks: DyNTS_DoctorCheck[] = [];
-
-    // 1) Mongo-probe (readiness-minta: readyState + admin ping).
-    try {
-      const readyState: number = set.connection?.readyState ?? 0;
-      let pingOk: boolean = false;
-      if (readyState === 1) {
-        await set.connection.db?.admin().ping();
-        pingOk = true;
-      }
-      checks.push({
-        name: 'mongo',
-        health: readyState === 1 && pingOk ? 'ok' : 'fail',
-        detail: { readyState: readyState, pingOk: pingOk },
-        fixHint: readyState === 1 && pingOk ? undefined
-          : 'Check MONGO_URL + DB container/network reachability (readyState 1 + ping expected).',
-      });
-    } catch (error) {
-      checks.push({
-        name: 'mongo', health: 'fail', detail: String(error),
-        fixHint: 'Mongo ping threw — check DB availability/credentials.',
-      });
-    }
-
-    // 2) Memória (MemoryGuard pressure).
-    try {
-      const pressure: unknown = DyNTS_MemoryGuard.getInstance().pressure();
-      const level: string = String((pressure as { level?: string })?.level ?? 'ok');
-      checks.push({
-        name: 'memory',
-        health: level === 'critical' ? 'fail' : level === 'warning' ? 'warn' : 'ok',
-        detail: pressure,
-        fixHint: level === 'ok' ? undefined
-          : 'Heap pressure — check collection sizes (/server/db-stats) + recent load; consider retention.',
-      });
-    } catch (error) {
-      checks.push({ name: 'memory', health: 'warn', detail: String(error), fixHint: 'MemoryGuard snapshot failed.' });
-    }
-
-    // 3) Event-loop lag.
-    try {
-      const snapshot: unknown = DyNTS_EventLoopDiag.getInstance().getSnapshot();
-      checks.push({ name: 'eventLoop', health: 'ok', detail: snapshot });
-    } catch (error) {
-      checks.push({ name: 'eventLoop', health: 'warn', detail: String(error), fixHint: 'EventLoopDiag snapshot failed.' });
-    }
-
-    // 4) DB-stats + bloat-küszöb (BFR-OVERSEER-004 early-warning).
-    try {
-      const stats: DyNTS_DbStats = await DyNTS_DbStats_Util.collect(set.connection);
-      const warnMB: number = set.collectionWarnMB ?? DEFAULT_COLLECTION_WARN_MB;
-      const bloated: string[] = stats.collections
-        .filter((c): boolean => c.sizeMB + c.indexSizeMB > warnMB)
-        .map((c): string => `${c.name} (${c.sizeMB}MB + ${c.indexSizeMB}MB idx)`);
-      checks.push({
-        name: 'dbStats',
-        health: bloated.length ? 'warn' : 'ok',
-        detail: { totalSizeMB: stats.totalSizeMB, collectionCount: stats.collections.length, bloated: bloated },
-        fixHint: bloated.length
-          ? `Collections over ${warnMB}MB — add dataParams.retention (TTL) or prune: ${bloated.join(', ')}`
-          : undefined,
-      });
-    } catch (error) {
-      checks.push({ name: 'dbStats', health: 'warn', detail: String(error), fixHint: 'db-stats collection failed.' });
-    }
-
-    // 5) App-specifikus check-ek.
-    for (const customCheck of DyNTS_Diagnostics.customChecks) {
-      try {
-        checks.push(await customCheck());
-      } catch (error) {
-        DyFM_Log.warn('(DyNTS_Diagnostics) custom check threw (reported as fail)', error);
-        checks.push({ name: 'custom', health: 'fail', detail: String(error), fixHint: 'Custom check threw — see detail.' });
-      }
-    }
-
-    return {
-      health: DyNTS_Diagnostics.interpretHealth(checks),
-      checks: checks,
-      summary: DyNTS_Diagnostics.buildSummary(checks),
-      uptimeSec: Math.round(process.uptime()),
-    };
-  }
-
-  /** Aggregált health: bármely fail → fail; különben bármely warn → warn; különben ok. Pure (unit-tesztelt). */
-  static interpretHealth(checks: DyNTS_DoctorCheck[]): 'ok' | 'warn' | 'fail' {
-    if (checks.some((c: DyNTS_DoctorCheck): boolean => c.health === 'fail')) { return 'fail'; }
-    if (checks.some((c: DyNTS_DoctorCheck): boolean => c.health === 'warn')) { return 'warn'; }
-    return 'ok';
-  }
-
-  /** Ember-olvasható összegzés a nem-ok check-ekből. Pure (unit-tesztelt). */
-  static buildSummary(checks: DyNTS_DoctorCheck[]): string {
-    const notOk: DyNTS_DoctorCheck[] = checks.filter((c: DyNTS_DoctorCheck): boolean => c.health !== 'ok');
-    if (!notOk.length) {
-      return 'all checks ok';
-    }
-    return notOk
-      .map((c: DyNTS_DoctorCheck): string => `${c.name}: ${c.health}${c.fixHint ? ` — ${c.fixHint}` : ''}`)
-      .join(' | ');
-  }
-}
+import * as mongoose from 'mongoose';
+
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_DbStats, DyNTS_DbStats_Util } from './db-stats.service';
+import { DyNTS_EventLoopDiag } from './event-loop-diag.service';
+import { DyNTS_MemoryGuard } from './memory-guard.service';
+
+/**
+ * BFR-AM-015 (+ BFR-OVERSEER-004 aggregátor-fele) — generikus, újrahasználható diagnosztikai
+ * aggregátor MINDEN `DyNTS_App`-hoz: a `GET /server/doctor` endpoint forrása.
+ *
+ * Check-ek (mind SAJÁT try-ban — egy elhasaló check nem borítja a doctort, néma hiba TILOS):
+ *  - mongo: kapcsolat + ping (readiness-minta);
+ *  - memory: MemoryGuard pressure-snapshot;
+ *  - eventLoop: EventLoopDiag snapshot;
+ *  - dbStats: stats-only collection-méretek + küszöb-warn a bloat-gyanúra.
+ * Az app APP-SPECIFIKUS check-eket regisztrálhat (`registerCheck`) — pl. env-validáció,
+ * provider-probe (a FAM `FAM_Doctor` mintája bedrock-magként).
+ */
+
+export interface DyNTS_DoctorCheck {
+  name: string;
+  health: 'ok' | 'warn' | 'fail';
+  detail?: unknown;
+  /** Mit tegyen az operátor, ha nem ok (néma hiba tilos — a hint kötelező nem-ok esetén). */
+  fixHint?: string;
+}
+
+export interface DyNTS_DoctorReport {
+  health: 'ok' | 'warn' | 'fail';
+  checks: DyNTS_DoctorCheck[];
+  summary: string;
+  uptimeSec: number;
+}
+
+/** App-specifikus check-függvény (a doctor futtatja, saját try-ban). */
+export type DyNTS_DoctorCheckFn = () => Promise<DyNTS_DoctorCheck>;
+
+/** Collection-méret warn-küszöb (MB) — e fölött a dbStats-check warn-ra vált. */
+const DEFAULT_COLLECTION_WARN_MB: number = 512;
+
+export class DyNTS_Diagnostics {
+
+  private static readonly customChecks: DyNTS_DoctorCheckFn[] = [];
+
+  /** App-specifikus check regisztrálása (pl. env-validáció, provider-probe). */
+  static registerCheck(check: DyNTS_DoctorCheckFn): void {
+    DyNTS_Diagnostics.customChecks.push(check);
+  }
+
+  /** A teljes doctor-riport. SOSEM dob — a hibás check `fail`-ként jelenik meg. */
+  static async runDoctor(set: {
+    connection: mongoose.Connection,
+    collectionWarnMB?: number,
+  }): Promise<DyNTS_DoctorReport> {
+    const checks: DyNTS_DoctorCheck[] = [];
+
+    // 1) Mongo-probe (readiness-minta: readyState + admin ping).
+    try {
+      const readyState: number = set.connection?.readyState ?? 0;
+      let pingOk: boolean = false;
+      if (readyState === 1) {
+        await set.connection.db?.admin().ping();
+        pingOk = true;
+      }
+      checks.push({
+        name: 'mongo',
+        health: readyState === 1 && pingOk ? 'ok' : 'fail',
+        detail: { readyState: readyState, pingOk: pingOk },
+        fixHint: readyState === 1 && pingOk ? undefined
+          : 'Check MONGO_URL + DB container/network reachability (readyState 1 + ping expected).',
+      });
+    } catch (error) {
+      checks.push({
+        name: 'mongo', health: 'fail', detail: String(error),
+        fixHint: 'Mongo ping threw — check DB availability/credentials.',
+      });
+    }
+
+    // 2) Memória (MemoryGuard pressure).
+    try {
+      const pressure: unknown = DyNTS_MemoryGuard.getInstance().pressure();
+      const level: string = String((pressure as { level?: string })?.level ?? 'ok');
+      checks.push({
+        name: 'memory',
+        health: level === 'critical' ? 'fail' : level === 'warning' ? 'warn' : 'ok',
+        detail: pressure,
+        fixHint: level === 'ok' ? undefined
+          : 'Heap pressure — check collection sizes (/server/db-stats) + recent load; consider retention.',
+      });
+    } catch (error) {
+      checks.push({ name: 'memory', health: 'warn', detail: String(error), fixHint: 'MemoryGuard snapshot failed.' });
+    }
+
+    // 3) Event-loop lag.
+    try {
+      const snapshot: unknown = DyNTS_EventLoopDiag.getInstance().getSnapshot();
+      checks.push({ name: 'eventLoop', health: 'ok', detail: snapshot });
+    } catch (error) {
+      checks.push({ name: 'eventLoop', health: 'warn', detail: String(error), fixHint: 'EventLoopDiag snapshot failed.' });
+    }
+
+    // 4) DB-stats + bloat-küszöb (BFR-OVERSEER-004 early-warning).
+    try {
+      const stats: DyNTS_DbStats = await DyNTS_DbStats_Util.collect(set.connection);
+      const warnMB: number = set.collectionWarnMB ?? DEFAULT_COLLECTION_WARN_MB;
+      const bloated: string[] = stats.collections
+        .filter((c): boolean => c.sizeMB + c.indexSizeMB > warnMB)
+        .map((c): string => `${c.name} (${c.sizeMB}MB + ${c.indexSizeMB}MB idx)`);
+      checks.push({
+        name: 'dbStats',
+        health: bloated.length ? 'warn' : 'ok',
+        detail: { totalSizeMB: stats.totalSizeMB, collectionCount: stats.collections.length, bloated: bloated },
+        fixHint: bloated.length
+          ? `Collections over ${warnMB}MB — add dataParams.retention (TTL) or prune: ${bloated.join(', ')}`
+          : undefined,
+      });
+    } catch (error) {
+      checks.push({ name: 'dbStats', health: 'warn', detail: String(error), fixHint: 'db-stats collection failed.' });
+    }
+
+    // 5) App-specifikus check-ek.
+    for (const customCheck of DyNTS_Diagnostics.customChecks) {
+      try {
+        checks.push(await customCheck());
+      } catch (error) {
+        DyFM_Log.warn('(DyNTS_Diagnostics) custom check threw (reported as fail)', error);
+        checks.push({ name: 'custom', health: 'fail', detail: String(error), fixHint: 'Custom check threw — see detail.' });
+      }
+    }
+
+    return {
+      health: DyNTS_Diagnostics.interpretHealth(checks),
+      checks: checks,
+      summary: DyNTS_Diagnostics.buildSummary(checks),
+      uptimeSec: Math.round(process.uptime()),
+    };
+  }
+
+  /** Aggregált health: bármely fail → fail; különben bármely warn → warn; különben ok. Pure (unit-tesztelt). */
+  static interpretHealth(checks: DyNTS_DoctorCheck[]): 'ok' | 'warn' | 'fail' {
+    if (checks.some((c: DyNTS_DoctorCheck): boolean => c.health === 'fail')) { return 'fail'; }
+    if (checks.some((c: DyNTS_DoctorCheck): boolean => c.health === 'warn')) { return 'warn'; }
+    return 'ok';
+  }
+
+  /** Ember-olvasható összegzés a nem-ok check-ekből. Pure (unit-tesztelt). */
+  static buildSummary(checks: DyNTS_DoctorCheck[]): string {
+    const notOk: DyNTS_DoctorCheck[] = checks.filter((c: DyNTS_DoctorCheck): boolean => c.health !== 'ok');
+    if (!notOk.length) {
+      return 'all checks ok';
+    }
+    return notOk
+      .map((c: DyNTS_DoctorCheck): string => `${c.name}: ${c.health}${c.fixHint ? ` — ${c.fixHint}` : ''}`)
+      .join(' | ');
+  }
+}