@futdevpro/nts-dynamo 1.15.68 → 1.15.70

package/build/_services/core/memory-guard.service.d.ts

@@ -1,111 +1,111 @@
-import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
-/**
- * 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';
-export declare class DyNTS_MemoryGuard extends DyNTS_SingletonServiceBase {
-    static getInstance(): DyNTS_MemoryGuard;
-    private timer;
-    private installed;
-    private state;
-    private pollIntervalMs;
-    private warnPct;
-    private critPct;
-    private recoveryMargin;
-    private maxHistoryCount;
-    private onCritical?;
-    private readonly history;
-    private peakHeapPct;
-    private peakRssMb;
-    protected constructor();
-    /**
-     * 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;
-    /** A heap-plafon byte-ban (`--max-old-space-size`). Külön metódus a spec-mockoláshoz. */
-    private getHeapLimitBytes;
-    /**
-     * 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;
-    /** Esemény ring-bufferbe + log + (warning/critical esetén) tartós error-sink. */
-    private recordEvent;
-    /** A megőrzött események (legrégebbi → legújabb). Csak olvasásra. */
-    getHistory(): DyNTS_MemoryGuard_Event[];
-    /** Pillanatnyi állapot + csúcsok diagnosztikához (pl. egy status-endpoint). */
-    getStatus(): {
-        installed: boolean;
-        state: DyNTS_MemoryGuard_State;
-        peakHeapPct: number;
-        peakRssMb: number;
-        eventCount: number;
-    };
-    /** Telepítve van-e a watchdog. */
-    isInstalled(): boolean;
-    /**
-     * 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;
-}
-export {};
+import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
+/**
+ * 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';
+export declare class DyNTS_MemoryGuard extends DyNTS_SingletonServiceBase {
+    static getInstance(): DyNTS_MemoryGuard;
+    private timer;
+    private installed;
+    private state;
+    private pollIntervalMs;
+    private warnPct;
+    private critPct;
+    private recoveryMargin;
+    private maxHistoryCount;
+    private onCritical?;
+    private readonly history;
+    private peakHeapPct;
+    private peakRssMb;
+    protected constructor();
+    /**
+     * 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;
+    /** A heap-plafon byte-ban (`--max-old-space-size`). Külön metódus a spec-mockoláshoz. */
+    private getHeapLimitBytes;
+    /**
+     * 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;
+    /** Esemény ring-bufferbe + log + (warning/critical esetén) tartós error-sink. */
+    private recordEvent;
+    /** A megőrzött események (legrégebbi → legújabb). Csak olvasásra. */
+    getHistory(): DyNTS_MemoryGuard_Event[];
+    /** Pillanatnyi állapot + csúcsok diagnosztikához (pl. egy status-endpoint). */
+    getStatus(): {
+        installed: boolean;
+        state: DyNTS_MemoryGuard_State;
+        peakHeapPct: number;
+        peakRssMb: number;
+        eventCount: number;
+    };
+    /** Telepítve van-e a watchdog. */
+    isInstalled(): boolean;
+    /**
+     * 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;
+}
+export {};
 //# sourceMappingURL=memory-guard.service.d.ts.map

package/build/_services/core/memory-guard.service.js

@@ -1,198 +1,198 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_MemoryGuard = void 0;
-const tslib_1 = require("tslib");
-const v8 = tslib_1.__importStar(require("v8"));
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const global_settings_const_1 = require("../../_collections/global-settings.const");
-const singleton_service_base_1 = require("../base/singleton.service-base");
-const global_service_1 = require("./global.service");
-const BYTES_PER_MB = 1024 * 1024;
-class DyNTS_MemoryGuard extends singleton_service_base_1.DyNTS_SingletonServiceBase {
-    static getInstance() {
-        return DyNTS_MemoryGuard.getSingletonInstance();
-    }
-    timer = null;
-    installed = false;
-    state = 'normal';
-    // Feloldott (effektív) konfiguráció — install()-kor töltjük.
-    pollIntervalMs = 10000;
-    warnPct = 85;
-    critPct = 95;
-    recoveryMargin = 10;
-    maxHistoryCount = 100;
-    onCritical;
-    history = [];
-    peakHeapPct = 0;
-    peakRssMb = 0;
-    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) {
-        if (this.installed) {
-            return;
-        }
-        try {
-            const g = global_settings_const_1.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(() => { 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();
-            }
-            fsm_dynamo_1.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) {
-            // Telepítési hiba SEM lehet fatal — a guard hiánya nem ér annyit, hogy a
-            // szerver-indulást megakassza.
-            fsm_dynamo_1.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. */
-    getHeapLimitBytes() {
-        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.
-     */
-    poll() {
-        try {
-            const limitBytes = this.getHeapLimitBytes();
-            if (!limitBytes || limitBytes <= 0) {
-                return;
-            }
-            const mu = process.memoryUsage();
-            const pct = (mu.heapUsed / limitBytes) * 100;
-            const rssMb = 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 = this.state;
-            let next = 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 = {
-                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) {
-            // Poll-hiba sosem fatal — a következő tick újrapróbálja.
-            fsm_dynamo_1.DyFM_Log.warn('[DyNTS_MemoryGuard] poll error (non-fatal):', err);
-        }
-    }
-    /** Esemény ring-bufferbe + log + (warning/critical esetén) tartós error-sink. */
-    recordEvent(event) {
-        this.history.push(event);
-        while (this.history.length > this.maxHistoryCount) {
-            this.history.shift();
-        }
-        const summary = `heap ${event.heapPct}% (${event.heapUsedMb}/${event.heapLimitMb}MB), rss ${event.rssMb}MB`;
-        if (event.level === 'recovered') {
-            fsm_dynamo_1.DyFM_Log.success(`[DyNTS_MemoryGuard] RECOVERED — ${summary}`);
-            return;
-        }
-        if (event.level === 'critical') {
-            fsm_dynamo_1.DyFM_Log.H_error(`[DyNTS_MemoryGuard] CRITICAL heap pressure — ${summary} — OOM imminent`);
-        }
-        else {
-            fsm_dynamo_1.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 {
-            global_service_1.DyNTS_GlobalService.globalErrorHandler?.(new fsm_dynamo_1.DyFM_Error({
-                errorCode: `${global_settings_const_1.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: global_settings_const_1.DyNTS_global_settings.systemVersion,
-                level: event.level === 'critical' ? fsm_dynamo_1.DyFM_ErrorLevel.critical : fsm_dynamo_1.DyFM_ErrorLevel.warning,
-            }));
-        }
-        catch (sinkErr) {
-            fsm_dynamo_1.DyFM_Log.warn('[DyNTS_MemoryGuard] error-sink record failed (non-fatal):', sinkErr);
-        }
-        if (event.level === 'critical' && this.onCritical) {
-            try {
-                this.onCritical(event);
-            }
-            catch (hookErr) {
-                fsm_dynamo_1.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() {
-        return this.history.slice();
-    }
-    /** Pillanatnyi állapot + csúcsok diagnosztikához (pl. egy status-endpoint). */
-    getStatus() {
-        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() {
-        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() {
-        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;
-    }
-}
-exports.DyNTS_MemoryGuard = DyNTS_MemoryGuard;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_MemoryGuard = void 0;
+const tslib_1 = require("tslib");
+const v8 = tslib_1.__importStar(require("v8"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const global_settings_const_1 = require("../../_collections/global-settings.const");
+const singleton_service_base_1 = require("../base/singleton.service-base");
+const global_service_1 = require("./global.service");
+const BYTES_PER_MB = 1024 * 1024;
+class DyNTS_MemoryGuard extends singleton_service_base_1.DyNTS_SingletonServiceBase {
+    static getInstance() {
+        return DyNTS_MemoryGuard.getSingletonInstance();
+    }
+    timer = null;
+    installed = false;
+    state = 'normal';
+    // Feloldott (effektív) konfiguráció — install()-kor töltjük.
+    pollIntervalMs = 10000;
+    warnPct = 85;
+    critPct = 95;
+    recoveryMargin = 10;
+    maxHistoryCount = 100;
+    onCritical;
+    history = [];
+    peakHeapPct = 0;
+    peakRssMb = 0;
+    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) {
+        if (this.installed) {
+            return;
+        }
+        try {
+            const g = global_settings_const_1.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(() => { 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();
+            }
+            fsm_dynamo_1.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) {
+            // Telepítési hiba SEM lehet fatal — a guard hiánya nem ér annyit, hogy a
+            // szerver-indulást megakassza.
+            fsm_dynamo_1.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. */
+    getHeapLimitBytes() {
+        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.
+     */
+    poll() {
+        try {
+            const limitBytes = this.getHeapLimitBytes();
+            if (!limitBytes || limitBytes <= 0) {
+                return;
+            }
+            const mu = process.memoryUsage();
+            const pct = (mu.heapUsed / limitBytes) * 100;
+            const rssMb = 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 = this.state;
+            let next = 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 = {
+                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) {
+            // Poll-hiba sosem fatal — a következő tick újrapróbálja.
+            fsm_dynamo_1.DyFM_Log.warn('[DyNTS_MemoryGuard] poll error (non-fatal):', err);
+        }
+    }
+    /** Esemény ring-bufferbe + log + (warning/critical esetén) tartós error-sink. */
+    recordEvent(event) {
+        this.history.push(event);
+        while (this.history.length > this.maxHistoryCount) {
+            this.history.shift();
+        }
+        const summary = `heap ${event.heapPct}% (${event.heapUsedMb}/${event.heapLimitMb}MB), rss ${event.rssMb}MB`;
+        if (event.level === 'recovered') {
+            fsm_dynamo_1.DyFM_Log.success(`[DyNTS_MemoryGuard] RECOVERED — ${summary}`);
+            return;
+        }
+        if (event.level === 'critical') {
+            fsm_dynamo_1.DyFM_Log.H_error(`[DyNTS_MemoryGuard] CRITICAL heap pressure — ${summary} — OOM imminent`);
+        }
+        else {
+            fsm_dynamo_1.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 {
+            global_service_1.DyNTS_GlobalService.globalErrorHandler?.(new fsm_dynamo_1.DyFM_Error({
+                errorCode: `${global_settings_const_1.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: global_settings_const_1.DyNTS_global_settings.systemVersion,
+                level: event.level === 'critical' ? fsm_dynamo_1.DyFM_ErrorLevel.critical : fsm_dynamo_1.DyFM_ErrorLevel.warning,
+            }));
+        }
+        catch (sinkErr) {
+            fsm_dynamo_1.DyFM_Log.warn('[DyNTS_MemoryGuard] error-sink record failed (non-fatal):', sinkErr);
+        }
+        if (event.level === 'critical' && this.onCritical) {
+            try {
+                this.onCritical(event);
+            }
+            catch (hookErr) {
+                fsm_dynamo_1.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() {
+        return this.history.slice();
+    }
+    /** Pillanatnyi állapot + csúcsok diagnosztikához (pl. egy status-endpoint). */
+    getStatus() {
+        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() {
+        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() {
+        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;
+    }
+}
+exports.DyNTS_MemoryGuard = DyNTS_MemoryGuard;
 //# sourceMappingURL=memory-guard.service.js.map

package/build/_services/core/service-collection.service.d.ts

@@ -1,5 +1,5 @@
-import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
-export declare class DyNTS_Service_Collection<T> extends DyNTS_SingletonServiceBase {
-    [service: string]: T;
-}
+import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
+export declare class DyNTS_Service_Collection<T> extends DyNTS_SingletonServiceBase {
+    [service: string]: T;
+}
 //# sourceMappingURL=service-collection.service.d.ts.map

package/build/_services/core/service-collection.service.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_Service_Collection = void 0;
-const singleton_service_base_1 = require("../base/singleton.service-base");
-class DyNTS_Service_Collection extends singleton_service_base_1.DyNTS_SingletonServiceBase {
-}
-exports.DyNTS_Service_Collection = DyNTS_Service_Collection;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_Service_Collection = void 0;
+const singleton_service_base_1 = require("../base/singleton.service-base");
+class DyNTS_Service_Collection extends singleton_service_base_1.DyNTS_SingletonServiceBase {
+}
+exports.DyNTS_Service_Collection = DyNTS_Service_Collection;
 //# sourceMappingURL=service-collection.service.js.map