@trillboards/edge-core 0.2.2 → 0.3.0

package/dist/MemoryAttenuationManager.d.ts

@@ -0,0 +1,164 @@
+/**
+ * MemoryAttenuationManager — Monitors V8 heap and OS memory, applies tiered
+ * shedding to keep edge devices stable under pressure.
+ *
+ * Port of CTV agent's MemoryAttenuationManager.kt, adapted for the V8 heap
+ * model. Uses `process.memoryUsage()` for heap metrics and `os.freemem()` /
+ * `os.totalmem()` for system-level awareness.
+ *
+ * Tiers (based on heap usage percentage = heapUsed / heapTotal):
+ *   GREEN    — Normal operation, all systems active
+ *   YELLOW   — >70% heap — disable cloud inference
+ *   ORANGE   — >80% heap — disable federated learning, reduce FPS
+ *   RED      — >90% heap — shed lowest-priority models (one per cycle)
+ *   CRITICAL — >95% heap — camera-only emergency mode, force GC
+ *
+ * Hysteresis prevents oscillation: a tier is only restored when usage drops
+ * a configurable percentage (default 15%) below the threshold that triggered
+ * escalation. For example, YELLOW triggers at 70% but only restores to GREEN
+ * when usage falls below 55%.
+ */
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export declare enum MemoryTier {
+    GREEN = "GREEN",
+    YELLOW = "YELLOW",
+    ORANGE = "ORANGE",
+    RED = "RED",
+    CRITICAL = "CRITICAL"
+}
+export interface MemorySnapshot {
+    heapUsedMb: number;
+    heapTotalMb: number;
+    heapUsedPercent: number;
+    rssUsedMb: number;
+    osFreeMemMb: number;
+    osTotalMemMb: number;
+    osUsedPercent: number;
+    tier: MemoryTier;
+    timestamp: number;
+}
+export interface AttenuationAction {
+    tier: MemoryTier;
+    action: string;
+    timestamp: number;
+}
+export interface AttenuationCallbacks {
+    onDisableCloudInference: () => void;
+    onEnableCloudInference: () => void;
+    onDisableFederatedLearning: () => void;
+    onEnableFederatedLearning: () => void;
+    onReduceSensingFps: (targetFps: number) => void;
+    onRestoreSensingFps: (targetFps: number) => void;
+    onShedModel: (modelName: string) => void;
+    onRestoreModel: (modelName: string) => void;
+    onForceGC: () => void;
+    onEmergencyMode: () => void;
+    onRestoreNormal: () => void;
+}
+export interface MemoryAttenuationManagerOptions {
+    callbacks: AttenuationCallbacks;
+    /** Polling interval in milliseconds. Default: 10000 (10s). */
+    checkIntervalMs?: number;
+    /** Heap usage fraction to enter YELLOW. Default: 0.70. */
+    yellowThreshold?: number;
+    /** Heap usage fraction to enter ORANGE. Default: 0.80. */
+    orangeThreshold?: number;
+    /** Heap usage fraction to enter RED. Default: 0.90. */
+    redThreshold?: number;
+    /** Heap usage fraction to enter CRITICAL. Default: 0.95. */
+    criticalThreshold?: number;
+    /** Fraction below threshold before restoring to a lower tier. Default: 0.15. */
+    hysteresisPercent?: number;
+    /** Normal sensing FPS, restored when dropping below ORANGE. Default: 8. */
+    normalFps?: number;
+    /** Reduced sensing FPS used at ORANGE and above. Default: 2. */
+    reducedFps?: number;
+    /**
+     * Model shed order from *least important* (index 0, shed first) to
+     * *most important* (last index, shed last). During RED, one model is shed
+     * per check cycle starting from the end of this array.
+     *
+     * Default: ['yamnet', 'whisperAsr', 'ferEmotion', 'poseEngagement', 'ageGender', 'gazeTracking']
+     */
+    shedOrder?: string[];
+}
+export declare class MemoryAttenuationManager extends EventEmitter {
+    private readonly callbacks;
+    private readonly checkIntervalMs;
+    private readonly yellowThreshold;
+    private readonly orangeThreshold;
+    private readonly redThreshold;
+    private readonly criticalThreshold;
+    private readonly hysteresisPercent;
+    private readonly normalFps;
+    private readonly reducedFps;
+    private readonly shedOrder;
+    private currentTier;
+    private intervalHandle;
+    private history;
+    private actions;
+    private cloudInferenceDisabled;
+    private federatedLearningDisabled;
+    private fpsReduced;
+    private shedModels;
+    private emergencyModeActive;
+    constructor(options: MemoryAttenuationManagerOptions);
+    /**
+     * Start the periodic memory monitoring interval. The timer is `unref()`'d
+     * so it will not keep the Node.js event loop alive on its own.
+     */
+    start(): void;
+    /** Stop the periodic monitoring interval. */
+    stop(): void;
+    /** Return the current memory tier. */
+    getCurrentTier(): MemoryTier;
+    /** Take a point-in-time memory snapshot (does NOT trigger actions). */
+    getSnapshot(): MemorySnapshot;
+    /** Return the last N snapshots (up to 100). */
+    getHistory(): MemorySnapshot[];
+    /** Return the list of model names currently shed. */
+    getShedModels(): string[];
+    /** Return the full log of attenuation actions taken. */
+    getActions(): AttenuationAction[];
+    /**
+     * Single check cycle. Exposed as package-internal so tests can drive it
+     * deterministically without timers.
+     */
+    check(): void;
+    /**
+     * Classify a heap usage percentage into a MemoryTier, applying hysteresis
+     * to prevent oscillation at tier boundaries.
+     *
+     * Escalation uses the raw threshold (jumps to the highest applicable tier).
+     * Restoration requires the usage to drop below `threshold - hysteresisPercent`
+     * at each boundary, and walks down through all qualifying tiers in a single
+     * check. For example with default settings:
+     *   - Escalate to YELLOW at 70%, restore to GREEN below 55% (70 - 15)
+     *   - Escalate to ORANGE at 80%, restore to YELLOW below 65% (80 - 15)
+     *   - Escalate to RED at 90%, restore to ORANGE below 75% (90 - 15)
+     *   - Escalate to CRITICAL at 95%, restore to RED below 80% (95 - 15)
+     */
+    private classifyTier;
+    /** Apply the actions for entering a given tier (escalating). */
+    private applyEscalation;
+    /**
+     * Apply the restoration actions for entering a given tier (de-escalating).
+     * `tier` is the tier we are *entering* on the way down.
+     */
+    private applyRestoration;
+    /**
+     * Shed the next model in the shed order. Models are shed from the *end*
+     * of `shedOrder` (lowest priority) toward the beginning (highest priority).
+     * One model per call.
+     */
+    private shedNextModel;
+    /**
+     * Restore all shed models in reverse order (highest priority first,
+     * i.e., from the beginning of `shedOrder`).
+     */
+    private restoreAllShedModels;
+    private takeSnapshot;
+    private recordAction;
+}
+//# sourceMappingURL=MemoryAttenuationManager.d.ts.map

package/dist/MemoryAttenuationManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryAttenuationManager.d.ts","sourceRoot":"","sources":["../src/MemoryAttenuationManager.ts"],"names":[],"mappings":"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"}

package/dist/MemoryAttenuationManager.js

@@ -0,0 +1,400 @@
+"use strict";
+/**
+ * MemoryAttenuationManager — Monitors V8 heap and OS memory, applies tiered
+ * shedding to keep edge devices stable under pressure.
+ *
+ * Port of CTV agent's MemoryAttenuationManager.kt, adapted for the V8 heap
+ * model. Uses `process.memoryUsage()` for heap metrics and `os.freemem()` /
+ * `os.totalmem()` for system-level awareness.
+ *
+ * Tiers (based on heap usage percentage = heapUsed / heapTotal):
+ *   GREEN    — Normal operation, all systems active
+ *   YELLOW   — >70% heap — disable cloud inference
+ *   ORANGE   — >80% heap — disable federated learning, reduce FPS
+ *   RED      — >90% heap — shed lowest-priority models (one per cycle)
+ *   CRITICAL — >95% heap — camera-only emergency mode, force GC
+ *
+ * Hysteresis prevents oscillation: a tier is only restored when usage drops
+ * a configurable percentage (default 15%) below the threshold that triggered
+ * escalation. For example, YELLOW triggers at 70% but only restores to GREEN
+ * when usage falls below 55%.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAttenuationManager = exports.MemoryTier = void 0;
+const events_1 = require("events");
+const os = __importStar(require("os"));
+// ─── Public Types ───────────────────────────────────────────────────────────
+var MemoryTier;
+(function (MemoryTier) {
+    MemoryTier["GREEN"] = "GREEN";
+    MemoryTier["YELLOW"] = "YELLOW";
+    MemoryTier["ORANGE"] = "ORANGE";
+    MemoryTier["RED"] = "RED";
+    MemoryTier["CRITICAL"] = "CRITICAL";
+})(MemoryTier || (exports.MemoryTier = MemoryTier = {}));
+// ─── Internal Constants ─────────────────────────────────────────────────────
+const MB = 1024 * 1024;
+const MAX_HISTORY = 100;
+const MAX_ACTIONS = 200;
+const DEFAULT_CHECK_INTERVAL_MS = 10000;
+const DEFAULT_YELLOW_THRESHOLD = 0.70;
+const DEFAULT_ORANGE_THRESHOLD = 0.80;
+const DEFAULT_RED_THRESHOLD = 0.90;
+const DEFAULT_CRITICAL_THRESHOLD = 0.95;
+const DEFAULT_HYSTERESIS_PERCENT = 0.15;
+const DEFAULT_NORMAL_FPS = 8;
+const DEFAULT_REDUCED_FPS = 2;
+const DEFAULT_SHED_ORDER = [
+    'yamnet',
+    'whisperAsr',
+    'ferEmotion',
+    'poseEngagement',
+    'ageGender',
+    'gazeTracking',
+];
+/**
+ * Ordered tier list from lowest severity to highest. Used for comparison
+ * and iteration when escalating or restoring.
+ */
+const TIER_SEVERITY = [
+    MemoryTier.GREEN,
+    MemoryTier.YELLOW,
+    MemoryTier.ORANGE,
+    MemoryTier.RED,
+    MemoryTier.CRITICAL,
+];
+function tierIndex(tier) {
+    return TIER_SEVERITY.indexOf(tier);
+}
+// ─── Implementation ─────────────────────────────────────────────────────────
+class MemoryAttenuationManager extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        // Runtime state
+        this.currentTier = MemoryTier.GREEN;
+        this.intervalHandle = null;
+        this.history = [];
+        this.actions = [];
+        // Tracked attenuation state — what we have already told callers to do
+        this.cloudInferenceDisabled = false;
+        this.federatedLearningDisabled = false;
+        this.fpsReduced = false;
+        this.shedModels = new Set();
+        this.emergencyModeActive = false;
+        this.callbacks = options.callbacks;
+        this.checkIntervalMs = options.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
+        this.yellowThreshold = options.yellowThreshold ?? DEFAULT_YELLOW_THRESHOLD;
+        this.orangeThreshold = options.orangeThreshold ?? DEFAULT_ORANGE_THRESHOLD;
+        this.redThreshold = options.redThreshold ?? DEFAULT_RED_THRESHOLD;
+        this.criticalThreshold = options.criticalThreshold ?? DEFAULT_CRITICAL_THRESHOLD;
+        this.hysteresisPercent = options.hysteresisPercent ?? DEFAULT_HYSTERESIS_PERCENT;
+        this.normalFps = options.normalFps ?? DEFAULT_NORMAL_FPS;
+        this.reducedFps = options.reducedFps ?? DEFAULT_REDUCED_FPS;
+        this.shedOrder = options.shedOrder ? [...options.shedOrder] : [...DEFAULT_SHED_ORDER];
+    }
+    // ─── Public API ─────────────────────────────────────────────────────────
+    /**
+     * Start the periodic memory monitoring interval. The timer is `unref()`'d
+     * so it will not keep the Node.js event loop alive on its own.
+     */
+    start() {
+        if (this.intervalHandle !== null)
+            return;
+        this.intervalHandle = setInterval(() => this.check(), this.checkIntervalMs);
+        this.intervalHandle.unref();
+    }
+    /** Stop the periodic monitoring interval. */
+    stop() {
+        if (this.intervalHandle !== null) {
+            clearInterval(this.intervalHandle);
+            this.intervalHandle = null;
+        }
+    }
+    /** Return the current memory tier. */
+    getCurrentTier() {
+        return this.currentTier;
+    }
+    /** Take a point-in-time memory snapshot (does NOT trigger actions). */
+    getSnapshot() {
+        return this.takeSnapshot();
+    }
+    /** Return the last N snapshots (up to 100). */
+    getHistory() {
+        return [...this.history];
+    }
+    /** Return the list of model names currently shed. */
+    getShedModels() {
+        return [...this.shedModels];
+    }
+    /** Return the full log of attenuation actions taken. */
+    getActions() {
+        return [...this.actions];
+    }
+    // ─── Core Check Loop ───────────────────────────────────────────────────
+    /**
+     * Single check cycle. Exposed as package-internal so tests can drive it
+     * deterministically without timers.
+     */
+    check() {
+        const snapshot = this.takeSnapshot();
+        // Record history (ring buffer, capped at MAX_HISTORY)
+        this.history.push(snapshot);
+        if (this.history.length > MAX_HISTORY) {
+            this.history.shift();
+        }
+        const newTier = this.classifyTier(snapshot.heapUsedPercent);
+        if (newTier !== this.currentTier) {
+            const previousTier = this.currentTier;
+            this.currentTier = newTier;
+            snapshot.tier = newTier;
+            // Apply actions for every step between old and new tier
+            const oldIdx = tierIndex(previousTier);
+            const newIdx = tierIndex(newTier);
+            if (newIdx > oldIdx) {
+                // Escalating — apply each step from old+1 up to new
+                for (let i = oldIdx + 1; i <= newIdx; i++) {
+                    this.applyEscalation(TIER_SEVERITY[i]);
+                }
+            }
+            else {
+                // Restoring — apply each step from old-1 down to new
+                for (let i = oldIdx - 1; i >= newIdx; i--) {
+                    this.applyRestoration(TIER_SEVERITY[i]);
+                }
+            }
+            this.emit('tierChanged', {
+                from: previousTier,
+                to: newTier,
+                snapshot,
+            });
+        }
+        else if (newTier === MemoryTier.RED) {
+            // While staying in RED, shed one more model per cycle if available
+            this.shedNextModel();
+        }
+    }
+    // ─── Tier Classification (with hysteresis) ─────────────────────────────
+    /**
+     * Classify a heap usage percentage into a MemoryTier, applying hysteresis
+     * to prevent oscillation at tier boundaries.
+     *
+     * Escalation uses the raw threshold (jumps to the highest applicable tier).
+     * Restoration requires the usage to drop below `threshold - hysteresisPercent`
+     * at each boundary, and walks down through all qualifying tiers in a single
+     * check. For example with default settings:
+     *   - Escalate to YELLOW at 70%, restore to GREEN below 55% (70 - 15)
+     *   - Escalate to ORANGE at 80%, restore to YELLOW below 65% (80 - 15)
+     *   - Escalate to RED at 90%, restore to ORANGE below 75% (90 - 15)
+     *   - Escalate to CRITICAL at 95%, restore to RED below 80% (95 - 15)
+     */
+    classifyTier(heapUsedPercent) {
+        const currentIdx = tierIndex(this.currentTier);
+        // Check for escalation (use raw thresholds, jump to highest applicable)
+        if (heapUsedPercent >= this.criticalThreshold * 100 && currentIdx < tierIndex(MemoryTier.CRITICAL)) {
+            return MemoryTier.CRITICAL;
+        }
+        if (heapUsedPercent >= this.redThreshold * 100 && currentIdx < tierIndex(MemoryTier.RED)) {
+            return MemoryTier.RED;
+        }
+        if (heapUsedPercent >= this.orangeThreshold * 100 && currentIdx < tierIndex(MemoryTier.ORANGE)) {
+            return MemoryTier.ORANGE;
+        }
+        if (heapUsedPercent >= this.yellowThreshold * 100 && currentIdx < tierIndex(MemoryTier.YELLOW)) {
+            return MemoryTier.YELLOW;
+        }
+        // Check for restoration — walk downward through each tier boundary,
+        // applying hysteresis at each step. This allows multi-step drops in a
+        // single check when memory falls far enough.
+        const hysteresisThresholds = [
+            { tier: MemoryTier.CRITICAL, restoreBelow: (this.criticalThreshold - this.hysteresisPercent) * 100 },
+            { tier: MemoryTier.RED, restoreBelow: (this.redThreshold - this.hysteresisPercent) * 100 },
+            { tier: MemoryTier.ORANGE, restoreBelow: (this.orangeThreshold - this.hysteresisPercent) * 100 },
+            { tier: MemoryTier.YELLOW, restoreBelow: (this.yellowThreshold - this.hysteresisPercent) * 100 },
+        ];
+        let resolvedTier = this.currentTier;
+        for (const { tier, restoreBelow } of hysteresisThresholds) {
+            if (resolvedTier === tier && heapUsedPercent < restoreBelow) {
+                // Drop one level
+                const idx = tierIndex(tier);
+                resolvedTier = TIER_SEVERITY[idx - 1];
+            }
+        }
+        return resolvedTier;
+    }
+    // ─── Escalation Actions ────────────────────────────────────────────────
+    /** Apply the actions for entering a given tier (escalating). */
+    applyEscalation(tier) {
+        switch (tier) {
+            case MemoryTier.YELLOW:
+                if (!this.cloudInferenceDisabled) {
+                    this.cloudInferenceDisabled = true;
+                    this.callbacks.onDisableCloudInference();
+                    this.recordAction(tier, 'disable_cloud_inference');
+                }
+                break;
+            case MemoryTier.ORANGE:
+                if (!this.federatedLearningDisabled) {
+                    this.federatedLearningDisabled = true;
+                    this.callbacks.onDisableFederatedLearning();
+                    this.recordAction(tier, 'disable_federated_learning');
+                }
+                if (!this.fpsReduced) {
+                    this.fpsReduced = true;
+                    this.callbacks.onReduceSensingFps(this.reducedFps);
+                    this.recordAction(tier, `reduce_fps_to_${this.reducedFps}`);
+                }
+                break;
+            case MemoryTier.RED:
+                this.shedNextModel();
+                break;
+            case MemoryTier.CRITICAL:
+                if (!this.emergencyModeActive) {
+                    this.emergencyModeActive = true;
+                    this.callbacks.onEmergencyMode();
+                    this.recordAction(tier, 'emergency_mode');
+                }
+                // Attempt GC if exposed via --expose-gc
+                if (typeof global.gc === 'function') {
+                    global.gc();
+                }
+                this.callbacks.onForceGC();
+                this.recordAction(tier, 'force_gc');
+                break;
+            case MemoryTier.GREEN:
+                // No escalation action for GREEN
+                break;
+        }
+    }
+    // ─── Restoration Actions ───────────────────────────────────────────────
+    /**
+     * Apply the restoration actions for entering a given tier (de-escalating).
+     * `tier` is the tier we are *entering* on the way down.
+     */
+    applyRestoration(tier) {
+        switch (tier) {
+            case MemoryTier.RED:
+                // Leaving CRITICAL → RED: restore emergency mode
+                if (this.emergencyModeActive) {
+                    this.emergencyModeActive = false;
+                    this.recordAction(tier, 'exit_emergency_mode');
+                }
+                break;
+            case MemoryTier.ORANGE:
+                // Leaving RED → ORANGE: restore all shed models in reverse order
+                this.restoreAllShedModels();
+                break;
+            case MemoryTier.YELLOW:
+                // Leaving ORANGE → YELLOW: restore FPS and federated learning
+                if (this.fpsReduced) {
+                    this.fpsReduced = false;
+                    this.callbacks.onRestoreSensingFps(this.normalFps);
+                    this.recordAction(tier, `restore_fps_to_${this.normalFps}`);
+                }
+                if (this.federatedLearningDisabled) {
+                    this.federatedLearningDisabled = false;
+                    this.callbacks.onEnableFederatedLearning();
+                    this.recordAction(tier, 'enable_federated_learning');
+                }
+                break;
+            case MemoryTier.GREEN:
+                // Leaving YELLOW → GREEN: restore cloud inference
+                if (this.cloudInferenceDisabled) {
+                    this.cloudInferenceDisabled = false;
+                    this.callbacks.onEnableCloudInference();
+                    this.recordAction(tier, 'enable_cloud_inference');
+                }
+                this.callbacks.onRestoreNormal();
+                this.recordAction(tier, 'restore_normal');
+                break;
+            case MemoryTier.CRITICAL:
+                // No restoration for entering CRITICAL (only escalation)
+                break;
+        }
+    }
+    // ─── Model Shedding ───────────────────────────────────────────────────
+    /**
+     * Shed the next model in the shed order. Models are shed from the *end*
+     * of `shedOrder` (lowest priority) toward the beginning (highest priority).
+     * One model per call.
+     */
+    shedNextModel() {
+        // Walk backwards from end of shedOrder, skipping already-shed models
+        for (let i = this.shedOrder.length - 1; i >= 0; i--) {
+            const model = this.shedOrder[i];
+            if (!this.shedModels.has(model)) {
+                this.shedModels.add(model);
+                this.callbacks.onShedModel(model);
+                this.recordAction(MemoryTier.RED, `shed_model_${model}`);
+                return;
+            }
+        }
+        // All models already shed — nothing more to do
+    }
+    /**
+     * Restore all shed models in reverse order (highest priority first,
+     * i.e., from the beginning of `shedOrder`).
+     */
+    restoreAllShedModels() {
+        // Restore in forward order through shedOrder (most important first)
+        for (const model of this.shedOrder) {
+            if (this.shedModels.has(model)) {
+                this.shedModels.delete(model);
+                this.callbacks.onRestoreModel(model);
+                this.recordAction(MemoryTier.ORANGE, `restore_model_${model}`);
+            }
+        }
+    }
+    // ─── Snapshot / Recording ──────────────────────────────────────────────
+    takeSnapshot() {
+        const mem = process.memoryUsage();
+        const osTotalBytes = os.totalmem();
+        const osFreeBytes = os.freemem();
+        const osUsedBytes = osTotalBytes - osFreeBytes;
+        return {
+            heapUsedMb: Math.round((mem.heapUsed / MB) * 100) / 100,
+            heapTotalMb: Math.round((mem.heapTotal / MB) * 100) / 100,
+            heapUsedPercent: Math.round((mem.heapUsed / mem.heapTotal) * 10000) / 100,
+            rssUsedMb: Math.round((mem.rss / MB) * 100) / 100,
+            osFreeMemMb: Math.round((osFreeBytes / MB) * 100) / 100,
+            osTotalMemMb: Math.round((osTotalBytes / MB) * 100) / 100,
+            osUsedPercent: Math.round((osUsedBytes / osTotalBytes) * 10000) / 100,
+            tier: this.currentTier,
+            timestamp: Date.now(),
+        };
+    }
+    recordAction(tier, action) {
+        this.actions.push({
+            tier,
+            action,
+            timestamp: Date.now(),
+        });
+        if (this.actions.length > MAX_ACTIONS) {
+            this.actions.shift();
+        }
+    }
+}
+exports.MemoryAttenuationManager = MemoryAttenuationManager;
+//# sourceMappingURL=MemoryAttenuationManager.js.map

package/dist/MemoryAttenuationManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryAttenuationManager.js","sourceRoot":"","sources":["../src/MemoryAttenuationManager.ts"],"names":[],"mappings":"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"}