@futdevpro/nts-dynamo 1.15.55 → 1.15.56

package/src/_collections/global-settings.const.ts

@@ -66,5 +66,17 @@ export const DyNTS_global_settings: DyNTS_Global_Settings = {
     maxChunkSize: 1000,
     maxChunkCount: 1000,
   },
+
+  // FR-193 — bedrock OOM korai-figyelmeztető heap-watchdog. Default-on: minden nts-szerver
+  // megkapja a heap-nyomás-figyelést a base App startup-ban (lásd DyNTS_MemoryGuard). Csak
+  // MEGFIGYELÉS + tartós rögzítés a near-OOM küszöböknél — nem változtat a viselkedésen.
+  memoryGuard: {
+    enabled: true,
+    pollIntervalMs: 10000,
+    heapWarningThreshold: 85,
+    heapCriticalThreshold: 95,
+    recoveryMargin: 10,
+    maxHistoryCount: 100,
+  },
 };
 

package/src/_models/interfaces/global-settings.interface.ts

@@ -133,9 +133,31 @@ export interface DyNTS_Global_Settings {
   /**
    * this setting will set the messaging settings
    * (this will be set in the {@link DyNTS_Msg_Main_ControlService} constructor)
-   * 
+   *
    * {@link DyNTS_Msg_Global_Settings}
    * default settings: {@link DyNTS_Msg_global_settings}
    */
   messaging_settings?: any;
+
+  /**
+   * FR-193 — bedrock OOM korai-figyelmeztető heap-watchdog ({@link DyNTS_MemoryGuard}).
+   * Ha `enabled`, a base `App` startup automatikusan feltelepíti. Periodikusan figyeli a
+   * heap-kihasználtságot, és a `--max-old-space-size` plafonhoz közeledve TARTÓS rekordot
+   * hagy az error-sinkbe (Errors-rendszer + Discord) — mielőtt a fatal OOM megölné a
+   * process-t. Default: enabled, 10s poll, warn 85% / crit 95%.
+   */
+  memoryGuard?: {
+    /** Bekapcsolja a heap-watchdogot (a base App startup feltelepíti). Default: true. */
+    enabled: boolean;
+    /** Poll-intervallum ms-ben. Default: 10000. */
+    pollIntervalMs?: number;
+    /** Warning küszöb a heap-plafon %-ában. Default: 85. */
+    heapWarningThreshold?: number;
+    /** Critical küszöb a heap-plafon %-ában. Default: 95. */
+    heapCriticalThreshold?: number;
+    /** A warning küszöb ALATTI margó %-ban a 'recovered'-hez (hiszterézis). Default: 10. */
+    recoveryMargin?: number;
+    /** Megőrzött események max száma (ring-buffer). Default: 100. */
+    maxHistoryCount?: number;
+  };
 }

package/src/_services/core/memory-guard.service.spec.ts

@@ -0,0 +1,165 @@
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_GlobalService } from './global.service';
+import { DyNTS_MemoryGuard } from './memory-guard.service';
+
+/**
+ * FR-193 — a bedrock heap-watchdog spec-je. A `poll()`-t KÖZVETLENÜL hívjuk (nem
+ * az intervallumra várunk), mockolt heap-plafonnal + `process.memoryUsage`-dzsel,
+ * így determinisztikusan teszteljük a hiszterézis-állapotgépet + a tartós rögzítést.
+ */
+
+const MB: number = 1024 * 1024;
+
+/**
+ * A privát `getHeapLimitBytes` + `process.memoryUsage` mockolása adott heap-%-hoz.
+ * Visszaadja a memoryUsage-spy-t, hogy a hívó később átállíthassa (recovery-teszt).
+ * `process as any`: a `MemoryUsageFn` típus egy `.rss()` submetódust is hordoz, amit
+ * egy egyszerű return-value mock nem elégít ki — a cast kikerüli ezt a teszt-zajt.
+ */
+const mockHeap = (guard: DyNTS_MemoryGuard, limitMb: number, usedMb: number): jasmine.Spy => {
+  spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(limitMb * MB);
+  return spyOn(process as any, 'memoryUsage').and.returnValue({
+    heapUsed:      usedMb * MB,
+    heapTotal:     usedMb * MB,
+    rss:           (usedMb + 100) * MB,
+    external:      10 * MB,
+    arrayBuffers:  0,
+  } as NodeJS.MemoryUsage);
+};
+
+/** Egy poll-ciklus kézi kiváltása. */
+const poll = (guard: DyNTS_MemoryGuard): void => { (guard as any).poll(); };
+
+describe('| DyNTS_MemoryGuard (FR-193)', (): void => {
+
+  let guard: DyNTS_MemoryGuard;
+  let sinkSpy: jasmine.Spy;
+  let originalSink: typeof DyNTS_GlobalService.globalErrorHandler;
+  let originalSettings: typeof DyNTS_global_settings.memoryGuard;
+
+  beforeEach((): void => {
+    guard = DyNTS_MemoryGuard.getInstance();
+    guard._teardownForTesting();
+
+    originalSettings = DyNTS_global_settings.memoryGuard;
+    DyNTS_global_settings.memoryGuard = {
+      enabled: true,
+      pollIntervalMs: 999999,   // ne tüzeljen az intervallum a teszt alatt
+      heapWarningThreshold: 85,
+      heapCriticalThreshold: 95,
+      recoveryMargin: 10,
+      maxHistoryCount: 100,
+    };
+
+    originalSink = DyNTS_GlobalService.globalErrorHandler;
+    sinkSpy = jasmine.createSpy('globalErrorHandler');
+    (DyNTS_GlobalService as any).globalErrorHandler = sinkSpy;
+  });
+
+  afterEach((): void => {
+    guard._teardownForTesting();
+    (DyNTS_GlobalService as any).globalErrorHandler = originalSink;
+    DyNTS_global_settings.memoryGuard = originalSettings;
+  });
+
+  it('| install() idempotens — második hívás no-op', (): void => {
+    guard.install();
+    expect(guard.isInstalled()).toBe(true);
+    guard.install();  // nem dob, nem indít új timert
+    expect(guard.isInstalled()).toBe(true);
+  });
+
+  it('| install() SOHA nem dob, akkor sem ha a settings hiányos', (): void => {
+    DyNTS_global_settings.memoryGuard = undefined as any;
+    expect((): void => guard.install()).not.toThrow();
+    expect(guard.isInstalled()).toBe(true);
+  });
+
+  it('| warning küszöb alatt NINCS esemény', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 800);  // 80% < 85
+    poll(guard);
+    expect(guard.getHistory().length).toBe(0);
+    expect(sinkSpy).not.toHaveBeenCalled();
+  });
+
+  it('| warning küszöb átlépése → 1 warning esemény + tartós error-sink (level warning)', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 880);  // 88% ∈ [85, 95)
+    poll(guard);
+
+    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
+    expect(hist.length).toBe(1);
+    expect(hist[0].level).toBe('warning');
+    expect(hist[0].heapPct).toBe(88);
+    expect(sinkSpy).toHaveBeenCalledTimes(1);
+    expect(guard.getStatus().state).toBe('warning');
+  });
+
+  it('| warning-sávban maradva NINCS re-emit (hiszterézis)', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 880);  // 88% → warning
+    poll(guard);
+    poll(guard);  // még mindig 88% (ugyanaz a mock) → nincs új esemény
+    expect(guard.getHistory().length).toBe(1);
+  });
+
+  it('| critical küszöb átlépése → critical esemény + onCritical hook', (): void => {
+    const onCritical: jasmine.Spy = jasmine.createSpy('onCritical');
+    guard.install({ onCritical: onCritical });
+    mockHeap(guard, 1000, 970);  // 97% ≥ 95
+    poll(guard);
+
+    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
+    expect(hist[hist.length - 1].level).toBe('critical');
+    expect(onCritical).toHaveBeenCalledTimes(1);
+    expect(guard.getStatus().state).toBe('critical');
+  });
+
+  it('| helyreállás: a warning-margó alá esve → recovered esemény (sink NÉLKÜL)', (): void => {
+    guard.install();
+
+    const muSpy: jasmine.Spy = mockHeap(guard, 1000, 880);  // 88% → warning
+    poll(guard);
+    sinkSpy.calls.reset();
+    muSpy.and.returnValue({
+      heapUsed: 700 * MB, heapTotal: 700 * MB, rss: 800 * MB, external: 10 * MB, arrayBuffers: 0,
+    } as NodeJS.MemoryUsage);                 // 70% ≤ 85 - 10
+    poll(guard);
+
+    const hist: ReturnType<typeof guard.getHistory> = guard.getHistory();
+    expect(hist[hist.length - 1].level).toBe('recovered');
+    expect(guard.getStatus().state).toBe('normal');
+    expect(sinkSpy).not.toHaveBeenCalled();   // recovered NEM ír az error-sinkbe
+  });
+
+  it('| history ring-buffer a maxHistoryCount-ra van kapva', (): void => {
+    DyNTS_global_settings.memoryGuard!.maxHistoryCount = 3;
+    guard.install();
+    spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(1000 * MB);
+    const high: NodeJS.MemoryUsage =
+      { heapUsed: 880 * MB, heapTotal: 880 * MB, rss: 980 * MB, external: 0, arrayBuffers: 0 } as NodeJS.MemoryUsage;
+    const low: NodeJS.MemoryUsage =
+      { heapUsed: 700 * MB, heapTotal: 700 * MB, rss: 800 * MB, external: 0, arrayBuffers: 0 } as NodeJS.MemoryUsage;
+    let tick: number = 0;
+    // warning ↔ recovered oszcilláció: páros tick=high (warning), páratlan=low (recovered)
+    spyOn(process as any, 'memoryUsage').and.callFake((): NodeJS.MemoryUsage => (tick++ % 2 === 0 ? high : low));
+    for (let k: number = 0; k < 8; k++) { poll(guard); }  // 8 állapot-váltás, csak 3 marad
+    expect(guard.getHistory().length).toBe(3);
+  });
+
+  it('| poll() SOHA nem dob (heap limit 0 → no-op)', (): void => {
+    guard.install();
+    spyOn(guard as any, 'getHeapLimitBytes').and.returnValue(0);
+    expect((): void => poll(guard)).not.toThrow();
+    expect(guard.getHistory().length).toBe(0);
+  });
+
+  it('| getStatus a csúcsokat is követi', (): void => {
+    guard.install();
+    mockHeap(guard, 1000, 920);  // 92%
+    poll(guard);
+    expect(guard.getStatus().peakHeapPct).toBe(92);
+    expect(guard.getStatus().peakRssMb).toBeGreaterThan(0);
+  });
+});

package/src/_services/core/memory-guard.service.ts

@@ -0,0 +1,281 @@
+import * as v8 from 'v8';
+
+import { DyFM_Error, DyFM_ErrorLevel, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
+import { DyNTS_GlobalService } from './global.service';
+
+/**
+ * FR-193 (2026-06-15) — bedrock OOM korai-figyelmeztető heap-watchdog.
+ *
+ * MIÉRT: a Node heap-OOM (`--max-old-space-size` túllépés, pl. egy óriási JSON.parse)
+ * a process-t AZONNAL megöli — `process.on('uncaughtException')` NEM kapja el, így a
+ * crash pillanatában már nincs mód a hibát rögzíteni. Az EGYETLEN megbízható idő a
+ * rögzítésre a crash ELŐTT van. E watchdog periodikusan figyeli a heap-kihasználtságot,
+ * és amikor egy konfigurálható küszöböt átlép, TARTÓS rekordot hagy (DyFM_Log +
+ * `DyNTS_GlobalService.globalErrorHandler` → az Errors-sink, amit minden szerver megkap)
+ * — így egy OOM-hajlamos szerver NYOMOT hagy mielőtt elszáll, és a kuszob-atlepés
+ * lathato a dashboard-on / Discord-on.
+ *
+ * MIT NEM csinál: NEM állítja le/újraindítja a process-t (az a konténer-szintű
+ * `restart:` policy dolga), és NEM próbálja elkapni a fatal OOM-ot (nem lehet). Tisztán
+ * MEGFIGYELÉS + RÖGZÍTÉS + opcionális `onCritical` hook (amivel a fogyasztó terhet dobhat).
+ *
+ * Hiszterézis: a küszöböket CSAK állapot-VÁLTÁSkor jelzi (normal→warning→critical), és
+ * a `recoveryMargin`-nyit a warning ALÁ esve jelez 'recovered'-et — így nem spamel a
+ * küszöb körül oszcilláló heap.
+ *
+ * Használat (opt-in, mint a `DyNTS_Logs_Service`):
+ *   DyNTS_MemoryGuard.getInstance().install();              // default settings
+ *   DyNTS_MemoryGuard.getInstance().install({ onCritical }); // custom hook
+ * VAGY automatikusan: a base `App` startup feltelepíti, ha
+ *   `DyNTS_global_settings.memoryGuard.enabled === true` (alapértelmezés szerint igen).
+ */
+
+/** Egy MemoryGuard esemény — küszöb-átlépés vagy helyreállás. */
+export interface DyNTS_MemoryGuard_Event {
+  /** `warning` / `critical` küszöb-átlépés, vagy `recovered` (vissza normal-ba). */
+  level: 'warning' | 'critical' | 'recovered';
+  /** Heap használat MB-ban (`process.memoryUsage().heapUsed`). */
+  heapUsedMb: number;
+  /** Heap plafon MB-ban (`v8.getHeapStatistics().heap_size_limit` — a `--max-old-space-size`). */
+  heapLimitMb: number;
+  /** heapUsed / heapLimit * 100 (egész %-ra kerekítve). */
+  heapPct: number;
+  /** Resident Set Size MB-ban (teljes process-memória, heap + non-heap). */
+  rssMb: number;
+  /** External (C++ / Buffer) memória MB-ban. */
+  externalMb: number;
+  /** Esemény időbélyege (ISO). */
+  at: string;
+}
+
+/** `install()` opcionális override-jai (a `DyNTS_global_settings.memoryGuard` FÖLÉ). */
+export interface DyNTS_MemoryGuard_Config {
+  /** Poll-intervallum ms-ben. Default: 10000. */
+  pollIntervalMs?: number;
+  /** Warning küszöb a heap-plafon %-ában. Default: 85. */
+  heapWarningThreshold?: number;
+  /** Critical küszöb a heap-plafon %-ában. Default: 95. */
+  heapCriticalThreshold?: number;
+  /** A warning küszöb ALATTI margó %-ban a 'recovered'-hez (hiszterézis). Default: 10. */
+  recoveryMargin?: number;
+  /** Megőrzött események max száma (ring-buffer). Default: 100. */
+  maxHistoryCount?: number;
+  /** Hook, amit a `critical` küszöb átlépésekor hívunk (pl. terhelés-dobás). */
+  onCritical?: (event: DyNTS_MemoryGuard_Event) => void;
+}
+
+type DyNTS_MemoryGuard_State = 'normal' | 'warning' | 'critical';
+
+const BYTES_PER_MB: number = 1024 * 1024;
+
+export class DyNTS_MemoryGuard extends DyNTS_SingletonServiceBase {
+
+  static getInstance(): DyNTS_MemoryGuard {
+    return DyNTS_MemoryGuard.getSingletonInstance() as DyNTS_MemoryGuard;
+  }
+
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private installed: boolean = false;
+  private state: DyNTS_MemoryGuard_State = 'normal';
+
+  // Feloldott (effektív) konfiguráció — install()-kor töltjük.
+  private pollIntervalMs: number = 10000;
+  private warnPct: number = 85;
+  private critPct: number = 95;
+  private recoveryMargin: number = 10;
+  private maxHistoryCount: number = 100;
+  private onCritical?: (event: DyNTS_MemoryGuard_Event) => void;
+
+  private readonly history: DyNTS_MemoryGuard_Event[] = [];
+  private peakHeapPct: number = 0;
+  private peakRssMb: number = 0;
+
+  protected constructor() {
+    super();
+  }
+
+  /**
+   * Elindítja a heap-watchdogot. Idempotens (többszöri hívás no-op). A `config`
+   * felülírja a `DyNTS_global_settings.memoryGuard` értékeit, ami a beépített
+   * defaultokat írja felül. SOHA nem dob — egy figyelő-réteg nem dönthet be egy
+   * szervert (minden hiba try/catch-elt + descriptive-en logolt).
+   */
+  install(config?: DyNTS_MemoryGuard_Config): void {
+    if (this.installed) { return; }
+
+    try {
+      const g: NonNullable<typeof DyNTS_global_settings.memoryGuard> =
+        DyNTS_global_settings.memoryGuard ?? { enabled: true };
+
+      this.pollIntervalMs = config?.pollIntervalMs ?? g.pollIntervalMs ?? 10000;
+      this.warnPct = config?.heapWarningThreshold ?? g.heapWarningThreshold ?? 85;
+      this.critPct = config?.heapCriticalThreshold ?? g.heapCriticalThreshold ?? 95;
+      this.recoveryMargin = config?.recoveryMargin ?? g.recoveryMargin ?? 10;
+      this.maxHistoryCount = config?.maxHistoryCount ?? g.maxHistoryCount ?? 100;
+      this.onCritical = config?.onCritical;
+
+      this.installed = true;
+      this.timer = setInterval((): void => { this.poll(); }, this.pollIntervalMs);
+      // unref(): a watchdog-timer NE tartsa életben a process-t önmagában (graceful
+      // exit-kor a Node ki tud lépni a függő interval ellenére is).
+      if (typeof this.timer.unref === 'function') { this.timer.unref(); }
+
+      DyFM_Log.info(
+        `[DyNTS_MemoryGuard] installed — poll ${this.pollIntervalMs}ms, ` +
+        `warn ${this.warnPct}%, crit ${this.critPct}% (heap limit ` +
+        `${Math.round(this.getHeapLimitBytes() / BYTES_PER_MB)}MB)`,
+      );
+    } catch (err: unknown) {
+      // Telepítési hiba SEM lehet fatal — a guard hiánya nem ér annyit, hogy a
+      // szerver-indulást megakassza.
+      DyFM_Log.warn('[DyNTS_MemoryGuard] install failed (non-fatal):', err);
+    }
+  }
+
+  /** A heap-plafon byte-ban (`--max-old-space-size`). Külön metódus a spec-mockoláshoz. */
+  private getHeapLimitBytes(): number {
+    return v8.getHeapStatistics().heap_size_limit;
+  }
+
+  /**
+   * Egy poll-ciklus: kiolvassa a heap-kihasználtságot, frissíti a csúcsokat, és a
+   * hiszterézis-állapotgép szerint esemény-átlépéskor rögzít + logol. SOHA nem dob.
+   */
+  private poll(): void {
+    try {
+      const limitBytes: number = this.getHeapLimitBytes();
+      if (!limitBytes || limitBytes <= 0) { return; }
+
+      const mu: NodeJS.MemoryUsage = process.memoryUsage();
+      const pct: number = (mu.heapUsed / limitBytes) * 100;
+
+      const rssMb: number = mu.rss / BYTES_PER_MB;
+      if (pct > this.peakHeapPct) { this.peakHeapPct = pct; }
+      if (rssMb > this.peakRssMb) { this.peakRssMb = rssMb; }
+
+      // Hiszterézis-állapotgép — esemény CSAK állapot-váltáskor.
+      const prev: DyNTS_MemoryGuard_State = this.state;
+      let next: DyNTS_MemoryGuard_State = prev;
+
+      if (pct >= this.critPct) {
+        next = 'critical';
+      } else if (pct >= this.warnPct && prev === 'normal') {
+        next = 'warning';
+      } else if (pct <= this.warnPct - this.recoveryMargin) {
+        next = 'normal';
+      }
+      // Egyébként marad a jelenlegi állapot (hiszterézis-sáv) — nincs re-emit.
+
+      if (next === prev) { return; }
+      this.state = next;
+
+      const event: DyNTS_MemoryGuard_Event = {
+        level:       next === 'normal' ? 'recovered' : next,
+        heapUsedMb:  Math.round(mu.heapUsed / BYTES_PER_MB),
+        heapLimitMb: Math.round(limitBytes / BYTES_PER_MB),
+        heapPct:     Math.round(pct),
+        rssMb:       Math.round(rssMb),
+        externalMb:  Math.round((mu.external ?? 0) / BYTES_PER_MB),
+        at:          new Date().toISOString(),
+      };
+
+      this.recordEvent(event);
+    } catch (err: unknown) {
+      // Poll-hiba sosem fatal — a következő tick újrapróbálja.
+      DyFM_Log.warn('[DyNTS_MemoryGuard] poll error (non-fatal):', err);
+    }
+  }
+
+  /** Esemény ring-bufferbe + log + (warning/critical esetén) tartós error-sink. */
+  private recordEvent(event: DyNTS_MemoryGuard_Event): void {
+    this.history.push(event);
+    while (this.history.length > this.maxHistoryCount) { this.history.shift(); }
+
+    const summary: string =
+      `heap ${event.heapPct}% (${event.heapUsedMb}/${event.heapLimitMb}MB), rss ${event.rssMb}MB`;
+
+    if (event.level === 'recovered') {
+      DyFM_Log.success(`[DyNTS_MemoryGuard] RECOVERED — ${summary}`);
+      return;
+    }
+
+    if (event.level === 'critical') {
+      DyFM_Log.H_error(`[DyNTS_MemoryGuard] CRITICAL heap pressure — ${summary} — OOM imminent`);
+    } else {
+      DyFM_Log.warn(`[DyNTS_MemoryGuard] WARNING heap pressure — ${summary}`);
+    }
+
+    // Tartós rögzítés a központi error-sinkbe (Errors-rendszer + Discord, ha bekötve).
+    try {
+      DyNTS_GlobalService.globalErrorHandler?.(
+        new DyFM_Error({
+          errorCode:
+            `${DyNTS_global_settings.systemShortCodeName ?? 'DyNTS'}|DyNTS-MG0-HEAP-${event.level.toUpperCase()}`,
+          message:
+            `Heap pressure ${event.level.toUpperCase()}: ${summary}. ` +
+            `Process approaching the --max-old-space-size ceiling — OOM crash risk.`,
+          additionalContent: { memoryGuardEvent: event, peakHeapPct: Math.round(this.peakHeapPct) },
+          systemVersion: DyNTS_global_settings.systemVersion,
+          level: event.level === 'critical' ? DyFM_ErrorLevel.critical : DyFM_ErrorLevel.warning,
+        }),
+      );
+    } catch (sinkErr: unknown) {
+      DyFM_Log.warn('[DyNTS_MemoryGuard] error-sink record failed (non-fatal):', sinkErr);
+    }
+
+    if (event.level === 'critical' && this.onCritical) {
+      try {
+        this.onCritical(event);
+      } catch (hookErr: unknown) {
+        DyFM_Log.warn('[DyNTS_MemoryGuard] onCritical hook threw (non-fatal):', hookErr);
+      }
+    }
+  }
+
+  /** A megőrzött események (legrégebbi → legújabb). Csak olvasásra. */
+  getHistory(): DyNTS_MemoryGuard_Event[] {
+    return this.history.slice();
+  }
+
+  /** Pillanatnyi állapot + csúcsok diagnosztikához (pl. egy status-endpoint). */
+  getStatus(): {
+    installed: boolean;
+    state: DyNTS_MemoryGuard_State;
+    peakHeapPct: number;
+    peakRssMb: number;
+    eventCount: number;
+  } {
+    return {
+      installed:   this.installed,
+      state:       this.state,
+      peakHeapPct: Math.round(this.peakHeapPct),
+      peakRssMb:   Math.round(this.peakRssMb),
+      eventCount:  this.history.length,
+    };
+  }
+
+  /** Telepítve van-e a watchdog. */
+  isInstalled(): boolean {
+    return this.installed;
+  }
+
+  /**
+   * Leállítja a watchdogot + visszaállítja az állapotot. Graceful shutdown-hoz ÉS a
+   * spec-ek `afterEach`-éhez (a singleton-state ne szivárogjon a tesztek közt).
+   */
+  _teardownForTesting(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.installed = false;
+    this.state = 'normal';
+    this.history.length = 0;
+    this.peakHeapPct = 0;
+    this.peakRssMb = 0;
+    this.onCritical = undefined;
+  }
+}

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

@@ -52,6 +52,7 @@ import {
 } from '../../_models/interfaces/cors-settings.interface';
 import { DyNTS_SingletonService } from '../base/singleton.service';
 import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_MemoryGuard } from '../core/memory-guard.service';
 import { DyNTS_RoutingModule } from '../route/routing-module.service';
 import { DyNTS_getStarRoute } from '../../_collections/star.controller';
 
@@ -541,6 +542,18 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         });
       }
 
+      // 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:
+      // a guard egy könnyű setInterval, ami SOHA nem dob; csak near-OOM küszöböknél hagy
+      // tartós nyomot az error-sinkbe, mielőtt a fatal heap-OOM megölné a process-t.
+      try {
+        if (DyNTS_global_settings.memoryGuard?.enabled) {
+          DyNTS_MemoryGuard.getInstance().install();
+        }
+      } catch (memoryGuardError: unknown) {
+        DyFM_Log.warn('[DyNTS_MemoryGuard] auto-install skipped (non-fatal):', memoryGuardError);
+      }
+
       if (!extended) {
         await this.ready();
 

package/src/index.ts

@@ -72,6 +72,7 @@ export * from './_services/core/auth.service';
 
 export * from './_services/core/email.service';
 export * from './_services/core/global.service';
+export * from './_services/core/memory-guard.service';
 
 export * from './_services/core/service-collection.service';