@ooopsstudio/performance 0.9.0

package/dist/monitors-VNNUIKAK.js

@@ -0,0 +1,753 @@
+import { createPerformanceOnError, nsToMs } from './chunk-RY65GERM.js';
+import './chunk-RL2752FW.js';
+
+// src/performance/features/core/event-loop-monitor.ts
+function createEventLoopMonitor(options) {
+  const {
+    clock,
+    intervalMs = 1e3,
+    onSaturationAlert,
+    onPerfEvent,
+    thresholds = {}
+  } = options;
+  if (!Number.isSafeInteger(intervalMs) || intervalMs <= 0 || intervalMs > 2147483647) {
+    throw new Error("Event loop intervalMs must be between 1 and 2147483647");
+  }
+  const configuredThresholds = [thresholds.info, thresholds.warn, thresholds.critical].filter((value) => value !== void 0);
+  if (!configuredThresholds.every((value) => Number.isFinite(value) && value >= 0)) {
+    throw new Error("Event loop monitor thresholds must be non-negative finite numbers");
+  }
+  if (thresholds.info !== void 0 && thresholds.warn !== void 0 && thresholds.info > thresholds.warn || thresholds.warn !== void 0 && thresholds.critical !== void 0 && thresholds.warn > thresholds.critical || thresholds.info !== void 0 && thresholds.critical !== void 0 && thresholds.info > thresholds.critical) {
+    throw new Error("Event loop monitor thresholds must satisfy info <= warn <= critical");
+  }
+  const criticalThreshold = thresholds.critical ?? Math.max(100, thresholds.warn ?? thresholds.info ?? 0);
+  const warnThreshold = thresholds.warn ?? Math.min(Math.max(50, thresholds.info ?? 0), criticalThreshold);
+  const infoThreshold = thresholds.info ?? Math.min(20, warnThreshold);
+  let timeoutId = null;
+  let immediateId = null;
+  let running = false;
+  const lagSamples = [];
+  let currentLag = null;
+  const scheduleNext = () => {
+    if (!running) return;
+    running = false;
+    try {
+      timeoutId = setTimeout(scheduleMeasurement, intervalMs);
+      running = true;
+      timeoutId.unref?.();
+    } catch {
+    }
+  };
+  function measureLag() {
+    let scheduled;
+    try {
+      scheduled = clock.nowHr();
+    } catch {
+      scheduleNext();
+      return;
+    }
+    try {
+      immediateId = setImmediate(() => {
+        immediateId = null;
+        if (!running) {
+          return;
+        }
+        let executed;
+        try {
+          executed = clock.nowHr();
+        } catch {
+          scheduleNext();
+          return;
+        }
+        const lagMs = nsToMs(executed - scheduled);
+        if (!Number.isFinite(lagMs) || lagMs < 0) {
+          scheduleNext();
+          return;
+        }
+        currentLag = lagMs;
+        lagSamples.push(lagMs);
+        if (lagSamples.length > 100) {
+          lagSamples.shift();
+        }
+        if (onPerfEvent) {
+          try {
+            const end = clock.now();
+            onPerfEvent({
+              name: "event_loop_lag",
+              duration: lagMs,
+              start: end - lagMs,
+              end,
+              source: "runtime"
+            });
+          } catch {
+          }
+        }
+        if (onSaturationAlert) {
+          let severity = null;
+          let threshold = 0;
+          if (lagMs >= criticalThreshold) {
+            severity = "critical";
+            threshold = criticalThreshold;
+          } else if (lagMs >= warnThreshold) {
+            severity = "warn";
+            threshold = warnThreshold;
+          } else if (lagMs >= infoThreshold) {
+            severity = "info";
+            threshold = infoThreshold;
+          }
+          if (severity) {
+            try {
+              onSaturationAlert({
+                reason: "event_loop_lag",
+                severity,
+                value: lagMs,
+                threshold
+              });
+            } catch {
+            }
+          }
+        }
+        scheduleNext();
+      });
+    } catch {
+      running = false;
+    }
+  }
+  function scheduleMeasurement() {
+    if (!running) {
+      return;
+    }
+    measureLag();
+  }
+  function calculatePercentiles(sorted, percentile) {
+    if (sorted.length === 0) {
+      return 0;
+    }
+    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
+    return sorted[Math.max(0, index)] ?? 0;
+  }
+  return {
+    start() {
+      if (running) {
+        return;
+      }
+      running = true;
+      scheduleMeasurement();
+    },
+    stop() {
+      running = false;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (immediateId !== null) {
+        clearImmediate(immediateId);
+        immediateId = null;
+      }
+    },
+    getStats() {
+      if (lagSamples.length === 0) {
+        return null;
+      }
+      const sorted = [...lagSamples].sort((a, b) => a - b);
+      const mean = sorted.reduce((sum, val) => sum + val, 0) / sorted.length;
+      return {
+        mean,
+        p95: calculatePercentiles(sorted, 95),
+        p99: calculatePercentiles(sorted, 99),
+        max: sorted[sorted.length - 1] ?? 0,
+        sampleCount: sorted.length
+      };
+    },
+    getCurrentLag() {
+      return currentLag;
+    }
+  };
+}
+
+// src/performance/features/core/gc-monitor.ts
+var perfHooksModuleCache = null;
+var perfHooksLoadingPromise = null;
+var MAX_GC_ENTRIES_PER_CALLBACK = 256;
+function createGCMonitor(options) {
+  const {
+    clock,
+    errors,
+    onSaturationAlert,
+    onPerfEvent,
+    thresholds = {}
+  } = options;
+  const onError = createPerformanceOnError(errors, {
+    operation: "module-load",
+    monitor: "gc-monitor"
+  });
+  let perfHooks = null;
+  if (perfHooksModuleCache && perfHooksModuleCache.PerformanceObserver) {
+    const Observer = perfHooksModuleCache.PerformanceObserver;
+    perfHooks = {
+      PerformanceObserver: Observer
+    };
+  } else {
+    if (!perfHooksLoadingPromise) {
+      perfHooksLoadingPromise = import('perf_hooks').then((module) => {
+        perfHooksModuleCache = module;
+      }).catch((error) => {
+        perfHooksModuleCache = null;
+        perfHooksLoadingPromise = null;
+        onError(error, { module: "perf_hooks" });
+      });
+    }
+  }
+  const pauseTimeThresholds = { ...thresholds.pauseTime ?? {} };
+  const heapUsageThresholds = { ...thresholds.heapUsage ?? {} };
+  validatePair(pauseTimeThresholds, "GC pause-time");
+  validatePair(heapUsageThresholds, "GC heap-usage", 1);
+  let majorCount = 0;
+  let minorCount = 0;
+  const pauseTimes = [];
+  let observer = null;
+  let heapCheckIntervalId = null;
+  let running = false;
+  function startObserver() {
+    if (!perfHooks || observer || !running) {
+      return;
+    }
+    let candidate = null;
+    try {
+      candidate = new perfHooks.PerformanceObserver((list) => {
+        try {
+          let processed = 0;
+          for (const entry of list.getEntries()) {
+            if (processed >= MAX_GC_ENTRIES_PER_CALLBACK) {
+              onError(new Error("GC observer callback entry limit exceeded"), {
+                operation: "gc-monitor.entry-limit"
+              });
+              break;
+            }
+            processed += 1;
+            if (entry.entryType === "gc") {
+              handleGCEvent(entry.detail?.kind ?? 2, entry.duration);
+            }
+          }
+        } catch (error) {
+          onError(error, { operation: "gc-monitor.observer" });
+        }
+      });
+      candidate.observe({ entryTypes: ["gc"] });
+      observer = candidate;
+      heapCheckIntervalId = setInterval(safeCheckHeapUsage, 5e3);
+      heapCheckIntervalId.unref?.();
+    } catch (error) {
+      const partialObserver = candidate;
+      candidate = null;
+      observer = null;
+      if (heapCheckIntervalId !== null) {
+        clearInterval(heapCheckIntervalId);
+        heapCheckIntervalId = null;
+      }
+      try {
+        partialObserver?.disconnect();
+      } catch (cleanupError) {
+        onError(cleanupError, { operation: "gc-monitor.start-cleanup" });
+      }
+      running = false;
+      onError(error, { operation: "gc-monitor.start" });
+    }
+  }
+  if (!perfHooks && perfHooksLoadingPromise) {
+    void perfHooksLoadingPromise.then(() => {
+      if (!perfHooksModuleCache?.PerformanceObserver) {
+        return;
+      }
+      perfHooks = { PerformanceObserver: perfHooksModuleCache.PerformanceObserver };
+      startObserver();
+    });
+  }
+  function handleGCEvent(kind, pauseTimeMs) {
+    if (!running) {
+      return;
+    }
+    if (!Number.isFinite(pauseTimeMs) || pauseTimeMs < 0) {
+      onError(new Error("GC pause duration must be a non-negative finite number"), {
+        operation: "gc-monitor.invalid-entry"
+      });
+      return;
+    }
+    if (kind === 1) {
+      minorCount++;
+    } else {
+      majorCount++;
+    }
+    pauseTimes.push(pauseTimeMs);
+    if (pauseTimes.length > 100) {
+      pauseTimes.shift();
+    }
+    if (onPerfEvent) {
+      try {
+        const end = clock.now();
+        onPerfEvent({
+          name: `gc_${kind === 1 ? "minor" : "major"}`,
+          duration: pauseTimeMs,
+          start: end - pauseTimeMs,
+          end,
+          labels: {
+            kind: kind === 1 ? "minor" : "major"
+          },
+          source: "runtime"
+        });
+      } catch (error) {
+        onError(error, { operation: "gc-monitor.perf-event" });
+      }
+    }
+    if (onSaturationAlert) {
+      let severity = null;
+      let threshold = 0;
+      if (pauseTimeThresholds.critical !== void 0 && pauseTimeMs >= pauseTimeThresholds.critical) {
+        severity = "critical";
+        threshold = pauseTimeThresholds.critical;
+      } else if (pauseTimeThresholds.warn !== void 0 && pauseTimeMs >= pauseTimeThresholds.warn) {
+        severity = "warn";
+        threshold = pauseTimeThresholds.warn;
+      }
+      if (severity) {
+        try {
+          onSaturationAlert({
+            reason: `gc_pause_${kind === 1 ? "minor" : "major"}`,
+            severity,
+            value: pauseTimeMs,
+            threshold
+          });
+        } catch (error) {
+          onError(error, { operation: "gc-monitor.saturation-alert" });
+        }
+      }
+    }
+  }
+  function checkHeapUsage() {
+    if (!running) {
+      return;
+    }
+    if (!onSaturationAlert) {
+      return;
+    }
+    const usage = process.memoryUsage();
+    const heapLimit = usage.heapLimit ?? usage.heapTotal;
+    const heapUsed = usage.heapUsed;
+    if (heapLimit > 0) {
+      const utilization = heapUsed / heapLimit;
+      let severity = null;
+      let threshold = 0;
+      if (heapUsageThresholds.critical !== void 0 && utilization >= heapUsageThresholds.critical) {
+        severity = "critical";
+        threshold = heapUsageThresholds.critical;
+      } else if (heapUsageThresholds.warn !== void 0 && utilization >= heapUsageThresholds.warn) {
+        severity = "warn";
+        threshold = heapUsageThresholds.warn;
+      }
+      if (severity) {
+        try {
+          onSaturationAlert({
+            reason: "heap_usage",
+            severity,
+            value: utilization,
+            threshold
+          });
+        } catch (error) {
+          onError(error, { operation: "gc-monitor.saturation-alert" });
+        }
+      }
+    }
+  }
+  function safeCheckHeapUsage() {
+    try {
+      checkHeapUsage();
+    } catch (error) {
+      onError(error, { operation: "gc-monitor.heap-check" });
+    }
+  }
+  return {
+    start() {
+      if (running) {
+        return;
+      }
+      try {
+        running = true;
+        startObserver();
+      } catch (error) {
+        running = false;
+        onError(error, { operation: "gc-monitor.start" });
+      }
+    },
+    stop() {
+      running = false;
+      const activeObserver = observer;
+      observer = null;
+      try {
+        activeObserver?.disconnect();
+      } catch (error) {
+        onError(error, { operation: "gc-monitor.stop" });
+      }
+      const activeHeapCheckInterval = heapCheckIntervalId;
+      heapCheckIntervalId = null;
+      if (activeHeapCheckInterval !== null) {
+        clearInterval(activeHeapCheckInterval);
+      }
+    },
+    getStats() {
+      const totalPauseTimeMs = pauseTimes.reduce((sum, val) => sum + val, 0);
+      const avgPauseTimeMs = pauseTimes.length > 0 ? totalPauseTimeMs / pauseTimes.length : 0;
+      const maxPauseTimeMs = pauseTimes.length > 0 ? Math.max(...pauseTimes) : 0;
+      return {
+        majorCount,
+        minorCount,
+        totalPauseTimeMs,
+        avgPauseTimeMs,
+        maxPauseTimeMs
+      };
+    },
+    getHeapUsage() {
+      if (typeof process === "undefined" || !process.memoryUsage) {
+        return null;
+      }
+      const usage = process.memoryUsage();
+      const result = {
+        heapUsed: usage.heapUsed,
+        heapTotal: usage.heapTotal
+      };
+      const heapLimit = usage.heapLimit;
+      if (heapLimit !== void 0) {
+        result.heapLimit = heapLimit;
+      }
+      return result;
+    }
+  };
+}
+function validatePair(thresholds, name, max = Number.POSITIVE_INFINITY) {
+  const values = [thresholds.warn, thresholds.critical].filter((value) => value !== void 0);
+  if (!values.every((value) => Number.isFinite(value) && value >= 0 && value <= max)) {
+    throw new Error(`${name} thresholds must be finite numbers between 0 and ${max}`);
+  }
+  if (thresholds.warn !== void 0 && thresholds.critical !== void 0 && thresholds.warn > thresholds.critical) {
+    throw new Error(`${name} thresholds must satisfy warn <= critical`);
+  }
+}
+
+// src/performance/features/core/resource-load-average.ts
+var osModuleCache = null;
+var osModuleLoadingPromise = null;
+function getResourceLoadAverage(onError) {
+  if (typeof process === "undefined" || process.platform === "win32") return void 0;
+  try {
+    if (osModuleCache) {
+      return osModuleCache.loadavg();
+    }
+    if (osModuleLoadingPromise === null) {
+      osModuleLoadingPromise = import('os').then((module) => {
+        osModuleCache = { loadavg: () => {
+          const load = module.loadavg();
+          return [load[0] ?? 0, load[1] ?? 0, load[2] ?? 0];
+        } };
+      }).catch((error) => {
+        osModuleCache = null;
+        osModuleLoadingPromise = null;
+        onError(error, { module: "os" });
+      });
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/performance/features/core/resource-monitor.ts
+function createResourceMonitor(options) {
+  const {
+    clock,
+    errors,
+    intervalMs = 5e3,
+    onSaturationAlert,
+    onPerfEvent,
+    thresholds = {}
+  } = options;
+  const onError = createPerformanceOnError(errors, {
+    operation: "module-load",
+    monitor: "resource-monitor"
+  });
+  if (!Number.isSafeInteger(intervalMs) || intervalMs <= 0 || intervalMs > 2147483647) {
+    throw new Error("Resource monitor intervalMs must be between 1 and 2147483647");
+  }
+  const cpuThresholds = { ...thresholds.cpu ?? {} };
+  const memoryThresholds = { ...thresholds.memory ?? {} };
+  validateThresholds(cpuThresholds, "CPU");
+  validateThresholds(memoryThresholds, "memory", 1);
+  let intervalId = null;
+  let lastCPUUsage = null;
+  let lastCPUCollectedAt = null;
+  let running = false;
+  function safeCollectStats() {
+    if (!running) {
+      return;
+    }
+    try {
+      collectStats();
+    } catch (error) {
+      onError(error, { operation: "resource-monitor.tick" });
+    }
+  }
+  function collectStats() {
+    if (typeof process === "undefined" || typeof process.cpuUsage !== "function" || typeof process.memoryUsage !== "function") {
+      return;
+    }
+    const now = clock.now();
+    const cpuUsage = process.cpuUsage();
+    if (lastCPUUsage) {
+      const elapsedMs = lastCPUCollectedAt !== null && now > lastCPUCollectedAt ? now - lastCPUCollectedAt : intervalMs;
+      const userDelta = Math.max(0, cpuUsage.user - lastCPUUsage.user);
+      const systemDelta = Math.max(0, cpuUsage.system - lastCPUUsage.system);
+      const totalDelta = userDelta + systemDelta;
+      if (onPerfEvent) {
+        try {
+          onPerfEvent({
+            name: "cpu_usage",
+            duration: totalDelta / 1e3,
+            // Convert to ms
+            start: now - elapsedMs,
+            end: now,
+            labels: {
+              user: String(userDelta / 1e3),
+              system: String(systemDelta / 1e3),
+              utilization: String(totalDelta / (elapsedMs * 1e3))
+            },
+            source: "runtime"
+          });
+        } catch (error) {
+          onError(error, { operation: "resource-monitor.perf-event" });
+        }
+      }
+      const cpuUtilization = totalDelta / (elapsedMs * 1e3);
+      if (onSaturationAlert) {
+        let severity = null;
+        let threshold = 0;
+        if (cpuThresholds.critical !== void 0 && cpuUtilization >= cpuThresholds.critical) {
+          severity = "critical";
+          threshold = cpuThresholds.critical;
+        } else if (cpuThresholds.warn !== void 0 && cpuUtilization >= cpuThresholds.warn) {
+          severity = "warn";
+          threshold = cpuThresholds.warn;
+        } else if (cpuThresholds.info !== void 0 && cpuUtilization >= cpuThresholds.info) {
+          severity = "info";
+          threshold = cpuThresholds.info;
+        }
+        if (severity) {
+          try {
+            onSaturationAlert({
+              reason: "cpu_saturation",
+              severity,
+              value: cpuUtilization,
+              threshold
+            });
+          } catch (error) {
+            onError(error, { operation: "resource-monitor.saturation-alert" });
+          }
+        }
+      }
+    }
+    lastCPUUsage = cpuUsage;
+    lastCPUCollectedAt = now;
+    const memoryUsage = process.memoryUsage();
+    const memoryStats = {
+      rss: memoryUsage.rss,
+      heapUsed: memoryUsage.heapUsed,
+      heapTotal: memoryUsage.heapTotal,
+      external: memoryUsage.external
+    };
+    if (onPerfEvent) {
+      try {
+        onPerfEvent({
+          name: "memory_usage",
+          duration: 0,
+          // Memory is a snapshot, not a duration
+          start: now,
+          end: now,
+          labels: {
+            rss: String(memoryStats.rss),
+            heapUsed: String(memoryStats.heapUsed),
+            heapTotal: String(memoryStats.heapTotal),
+            external: String(memoryStats.external)
+          },
+          source: "runtime"
+        });
+      } catch (error) {
+        onError(error, { operation: "resource-monitor.perf-event" });
+      }
+    }
+    if (memoryStats.heapTotal > 0 && onSaturationAlert) {
+      const memoryUtilization = memoryStats.heapUsed / memoryStats.heapTotal;
+      let severity = null;
+      let threshold = 0;
+      if (memoryThresholds.critical !== void 0 && memoryUtilization >= memoryThresholds.critical) {
+        severity = "critical";
+        threshold = memoryThresholds.critical;
+      } else if (memoryThresholds.warn !== void 0 && memoryUtilization >= memoryThresholds.warn) {
+        severity = "warn";
+        threshold = memoryThresholds.warn;
+      } else if (memoryThresholds.info !== void 0 && memoryUtilization >= memoryThresholds.info) {
+        severity = "info";
+        threshold = memoryThresholds.info;
+      }
+      if (severity) {
+        try {
+          onSaturationAlert({
+            reason: "memory_pressure",
+            severity,
+            value: memoryUtilization,
+            threshold
+          });
+        } catch (error) {
+          onError(error, { operation: "resource-monitor.saturation-alert" });
+        }
+      }
+    }
+  }
+  return {
+    start() {
+      if (intervalId !== null) {
+        return;
+      }
+      if (typeof process !== "undefined" && typeof process.cpuUsage === "function") {
+        lastCPUUsage = process.cpuUsage();
+        lastCPUCollectedAt = clock.now();
+      }
+      running = true;
+      intervalId = setInterval(safeCollectStats, intervalMs);
+      intervalId.unref?.();
+    },
+    stop() {
+      running = false;
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      lastCPUUsage = null;
+      lastCPUCollectedAt = null;
+    },
+    getStats() {
+      if (typeof process === "undefined" || typeof process.cpuUsage !== "function" || typeof process.memoryUsage !== "function") {
+        return null;
+      }
+      const cpuUsage = process.cpuUsage();
+      const memoryUsage = process.memoryUsage();
+      const cpu = {
+        user: cpuUsage.user,
+        system: cpuUsage.system,
+        total: cpuUsage.user + cpuUsage.system
+      };
+      const memory = {
+        rss: memoryUsage.rss,
+        heapUsed: memoryUsage.heapUsed,
+        heapTotal: memoryUsage.heapTotal,
+        external: memoryUsage.external
+      };
+      const loadAverage = getResourceLoadAverage(onError);
+      const stats = {
+        cpu,
+        memory
+      };
+      if (loadAverage) {
+        stats.loadAverage = loadAverage;
+      }
+      return stats;
+    }
+  };
+}
+function validateThresholds(thresholds, name, max = Number.POSITIVE_INFINITY) {
+  const ordered = [thresholds.info, thresholds.warn, thresholds.critical].filter((value) => value !== void 0);
+  if (!ordered.every((value) => Number.isFinite(value) && value >= 0 && value <= max)) {
+    throw new Error(`${name} thresholds must be finite numbers between 0 and ${max}`);
+  }
+  if (thresholds.info !== void 0 && thresholds.warn !== void 0 && thresholds.info > thresholds.warn || thresholds.warn !== void 0 && thresholds.critical !== void 0 && thresholds.warn > thresholds.critical || thresholds.info !== void 0 && thresholds.critical !== void 0 && thresholds.info > thresholds.critical) {
+    throw new Error(`${name} thresholds must satisfy info <= warn <= critical`);
+  }
+}
+
+// src/performance/utils/error-boundary.ts
+function withErrorBoundary(fn, errors, context) {
+  const onError = createPerformanceOnError(errors, {
+    stage: "monitor",
+    ...context ? { step: Object.values(context)[0] } : {}
+  });
+  return ((...args) => {
+    try {
+      return fn(...args);
+    } catch (error) {
+      onError(error);
+      return void 0;
+    }
+  });
+}
+
+// src/performance/core/runtime/monitors.ts
+function createMonitors(options) {
+  const monitors = {};
+  const safelyEmitEvent = (event) => {
+    try {
+      options.onPerfEvent(event);
+    } catch {
+    }
+  };
+  const safelyEmitAlert = (alert) => {
+    try {
+      options.onSaturationAlert?.(alert);
+    } catch {
+    }
+  };
+  try {
+    if (options.enableEventLoopMonitor) {
+      monitors.eventLoopMonitor = createEventLoopMonitor({
+        clock: options.clock,
+        onPerfEvent: safelyEmitEvent,
+        onSaturationAlert: safelyEmitAlert
+      });
+      withErrorBoundary(() => monitors.eventLoopMonitor?.start(), options.errors, { operation: "eventLoopMonitor.start" })();
+    }
+    if (options.enableGCMonitor) {
+      monitors.gcMonitor = createGCMonitor({
+        clock: options.clock,
+        ...options.errors ? { errors: options.errors } : {},
+        onPerfEvent: safelyEmitEvent,
+        onSaturationAlert: safelyEmitAlert
+      });
+      withErrorBoundary(() => monitors.gcMonitor?.start(), options.errors, { operation: "gcMonitor.start" })();
+    }
+    if (options.enableResourceMonitor) {
+      monitors.resourceMonitor = createResourceMonitor({
+        clock: options.clock,
+        ...options.errors ? { errors: options.errors } : {},
+        onPerfEvent: safelyEmitEvent,
+        onSaturationAlert: safelyEmitAlert
+      });
+      withErrorBoundary(() => monitors.resourceMonitor?.start(), options.errors, { operation: "resourceMonitor.start" })();
+    }
+  } catch (error) {
+    stopAllMonitors(monitors);
+    throw error;
+  }
+  return monitors;
+}
+function stopAllMonitors(monitors) {
+  try {
+    monitors.eventLoopMonitor?.stop();
+  } catch {
+  }
+  try {
+    monitors.gcMonitor?.stop();
+  } catch {
+  }
+  try {
+    monitors.resourceMonitor?.stop();
+  } catch {
+  }
+}
+
+export { createMonitors, stopAllMonitors };
+//# sourceMappingURL=monitors-VNNUIKAK.js.map
+//# sourceMappingURL=monitors-VNNUIKAK.js.map