@usefy/use-memory-monitor 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1077 @@
+// src/useMemoryMonitor.ts
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useSyncExternalStore
+} from "react";
+
+// src/constants.ts
+var DEFAULT_INTERVAL = 5e3;
+var DEFAULT_HISTORY_SIZE = 50;
+var DEFAULT_WARNING_THRESHOLD = 70;
+var DEFAULT_CRITICAL_THRESHOLD = 90;
+var DEFAULT_LEAK_WINDOW_SIZE = 10;
+var MIN_LEAK_DETECTION_SAMPLES = 5;
+var LEAK_SENSITIVITY_CONFIG = {
+  low: {
+    minSlope: 1e5,
+    // 100KB/sample
+    minR2: 0.7,
+    probabilityMultiplier: 0.8
+  },
+  medium: {
+    minSlope: 5e4,
+    // 50KB/sample
+    minR2: 0.6,
+    probabilityMultiplier: 1
+  },
+  high: {
+    minSlope: 1e4,
+    // 10KB/sample
+    minR2: 0.5,
+    probabilityMultiplier: 1.2
+  }
+};
+var TREND_THRESHOLDS = {
+  increasing: 0.01,
+  // Slope > 0.01 = increasing
+  decreasing: -0.01
+  // Slope < -0.01 = decreasing
+};
+var DEFAULT_OPTIONS = {
+  interval: DEFAULT_INTERVAL,
+  autoStart: true,
+  enabled: true,
+  enableHistory: false,
+  historySize: DEFAULT_HISTORY_SIZE,
+  thresholds: {
+    warning: DEFAULT_WARNING_THRESHOLD,
+    critical: DEFAULT_CRITICAL_THRESHOLD
+  },
+  leakDetection: {
+    enabled: false,
+    sensitivity: "medium",
+    windowSize: DEFAULT_LEAK_WINDOW_SIZE,
+    threshold: void 0
+  },
+  devMode: false,
+  trackDOMNodes: false,
+  trackEventListeners: false,
+  logToConsole: false,
+  disableInProduction: false,
+  fallbackStrategy: "dom-only"
+};
+var DEFAULT_SEVERITY = "normal";
+var DEFAULT_TREND = "stable";
+var SSR_INITIAL_STATE = {
+  memory: null,
+  domNodes: null,
+  eventListeners: null,
+  isMonitoring: false,
+  severity: DEFAULT_SEVERITY,
+  lastUpdated: 0
+};
+var SSR_FORMATTED_MEMORY = {
+  heapUsed: "N/A",
+  heapTotal: "N/A",
+  heapLimit: "N/A",
+  domNodes: void 0,
+  eventListeners: void 0
+};
+var BYTE_UNITS = ["B", "KB", "MB", "GB", "TB"];
+var BYTES_PER_UNIT = 1024;
+
+// src/utils/detection.ts
+function isServer() {
+  return typeof window === "undefined";
+}
+function isClient() {
+  return typeof window !== "undefined";
+}
+function hasLegacyMemoryAPI() {
+  if (isServer()) return false;
+  return "memory" in performance;
+}
+function hasPreciseMemoryAPI() {
+  if (isServer()) return false;
+  return "measureUserAgentSpecificMemory" in performance;
+}
+function isSecureContext() {
+  if (isServer()) return false;
+  return window.isSecureContext ?? false;
+}
+function isCrossOriginIsolated() {
+  if (isServer()) return false;
+  return window.crossOriginIsolated ?? false;
+}
+function detectBrowser() {
+  if (isServer()) return void 0;
+  const userAgent = navigator.userAgent;
+  if (userAgent.includes("Chrome") && !userAgent.includes("Edg")) {
+    return "Chrome";
+  }
+  if (userAgent.includes("Edg")) {
+    return "Edge";
+  }
+  if (userAgent.includes("Firefox")) {
+    return "Firefox";
+  }
+  if (userAgent.includes("Safari") && !userAgent.includes("Chrome")) {
+    return "Safari";
+  }
+  return void 0;
+}
+function determineSupportLevel() {
+  if (isServer()) return "none";
+  if (hasLegacyMemoryAPI()) {
+    return "full";
+  }
+  return "partial";
+}
+function getAvailableMetrics() {
+  if (isServer()) return [];
+  const metrics = [];
+  if (hasLegacyMemoryAPI()) {
+    metrics.push("heapUsed", "heapTotal", "heapLimit");
+  }
+  metrics.push("domNodes");
+  metrics.push("eventListeners");
+  return metrics;
+}
+function getLimitations() {
+  const limitations = [];
+  if (isServer()) {
+    limitations.push("Running in server-side environment");
+    return limitations;
+  }
+  if (!hasLegacyMemoryAPI()) {
+    limitations.push("performance.memory API not available (not Chrome/Edge)");
+  }
+  if (!isSecureContext()) {
+    limitations.push("Not running in secure context (HTTPS required for precise API)");
+  }
+  if (!isCrossOriginIsolated()) {
+    limitations.push(
+      "Not cross-origin isolated (COOP/COEP headers required for precise API)"
+    );
+  }
+  return limitations;
+}
+function detectSupport() {
+  return {
+    level: determineSupportLevel(),
+    availableMetrics: getAvailableMetrics(),
+    limitations: getLimitations(),
+    isSecureContext: isSecureContext(),
+    isCrossOriginIsolated: isCrossOriginIsolated(),
+    hasPreciseMemoryAPI: hasPreciseMemoryAPI()
+  };
+}
+function getUnsupportedReason() {
+  if (isServer()) {
+    return "server-side";
+  }
+  if (!isSecureContext() && hasPreciseMemoryAPI()) {
+    return "insecure-context";
+  }
+  if (!hasLegacyMemoryAPI() && !hasPreciseMemoryAPI()) {
+    return "no-api";
+  }
+  return "browser-restriction";
+}
+function getAvailableFallbacks() {
+  if (isServer()) {
+    return ["none"];
+  }
+  const fallbacks = ["none"];
+  fallbacks.push("dom-only");
+  fallbacks.push("estimation");
+  return fallbacks;
+}
+function createUnsupportedInfo() {
+  return {
+    reason: getUnsupportedReason(),
+    browser: detectBrowser(),
+    availableFallbacks: getAvailableFallbacks()
+  };
+}
+function canMonitorMemory() {
+  return isClient() && (hasLegacyMemoryAPI() || hasPreciseMemoryAPI());
+}
+
+// src/store.ts
+function createMemoryStore() {
+  let state = { ...SSR_INITIAL_STATE };
+  const listeners = /* @__PURE__ */ new Set();
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  function getSnapshot() {
+    return state;
+  }
+  function getServerSnapshot() {
+    return SSR_INITIAL_STATE;
+  }
+  function notify() {
+    listeners.forEach((listener) => listener());
+  }
+  function updateMemory(memory) {
+    if (state.memory === memory) return;
+    state = {
+      ...state,
+      memory,
+      lastUpdated: Date.now()
+    };
+    notify();
+  }
+  function updateDOMNodes(count) {
+    if (state.domNodes === count) return;
+    state = {
+      ...state,
+      domNodes: count,
+      lastUpdated: Date.now()
+    };
+    notify();
+  }
+  function updateEventListeners(count) {
+    if (state.eventListeners === count) return;
+    state = {
+      ...state,
+      eventListeners: count,
+      lastUpdated: Date.now()
+    };
+    notify();
+  }
+  function updateMonitoringStatus(isMonitoring) {
+    if (state.isMonitoring === isMonitoring) return;
+    state = {
+      ...state,
+      isMonitoring,
+      lastUpdated: Date.now()
+    };
+    notify();
+  }
+  function updateSeverity(severity) {
+    if (state.severity === severity) return;
+    state = {
+      ...state,
+      severity,
+      lastUpdated: Date.now()
+    };
+    notify();
+  }
+  function batchUpdate(updates) {
+    const newState = { ...state, ...updates, lastUpdated: Date.now() };
+    const hasChanges = Object.keys(updates).some(
+      (key) => state[key] !== updates[key]
+    );
+    if (!hasChanges) return;
+    state = newState;
+    notify();
+  }
+  function reset() {
+    state = { ...SSR_INITIAL_STATE };
+    notify();
+  }
+  function getSubscriberCount() {
+    return listeners.size;
+  }
+  return {
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+    updateMemory,
+    updateDOMNodes,
+    updateEventListeners,
+    updateMonitoringStatus,
+    updateSeverity,
+    batchUpdate,
+    reset,
+    getSubscriberCount
+  };
+}
+function createStore() {
+  return createMemoryStore();
+}
+function readMemoryFromAPI() {
+  if (isServer()) return null;
+  const memory = performance.memory;
+  if (!memory) return null;
+  return {
+    heapUsed: Math.max(0, memory.usedJSHeapSize),
+    heapTotal: Math.max(0, memory.totalJSHeapSize),
+    heapLimit: Math.max(0, memory.jsHeapSizeLimit),
+    timestamp: Date.now()
+  };
+}
+function countDOMNodes() {
+  if (isServer()) return null;
+  try {
+    return document.querySelectorAll("*").length;
+  } catch {
+    return null;
+  }
+}
+function estimateEventListeners() {
+  if (isServer()) return null;
+  try {
+    const interactiveElements = document.querySelectorAll(
+      "button, a, input, select, textarea, [onclick], [onchange], [onkeydown], [onkeyup], [onmouseover], [onmouseout], [onfocus], [onblur], [tabindex]"
+    );
+    return Math.round(interactiveElements.length * 1.5);
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/formatting.ts
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === null || bytes === void 0) {
+    return "N/A";
+  }
+  if (bytes === 0) {
+    return "0 B";
+  }
+  if (bytes < 0) {
+    return `-${formatBytes(Math.abs(bytes), decimals)}`;
+  }
+  const unitIndex = Math.max(
+    0,
+    Math.min(
+      Math.floor(Math.log(bytes) / Math.log(BYTES_PER_UNIT)),
+      BYTE_UNITS.length - 1
+    )
+  );
+  const value = bytes / Math.pow(BYTES_PER_UNIT, unitIndex);
+  const unit = BYTE_UNITS[unitIndex];
+  const formatted = value.toFixed(decimals);
+  const trimmed = parseFloat(formatted).toString();
+  return `${trimmed} ${unit}`;
+}
+function formatPercentage(percentage, decimals = 1) {
+  if (percentage === null || percentage === void 0) {
+    return "N/A";
+  }
+  return `${percentage.toFixed(decimals)}%`;
+}
+function formatNumber(value) {
+  if (value === null || value === void 0) {
+    return "N/A";
+  }
+  return value.toLocaleString();
+}
+function createFormattedMemory(memory, domNodes, eventListeners) {
+  return {
+    heapUsed: formatBytes(memory?.heapUsed),
+    heapTotal: formatBytes(memory?.heapTotal),
+    heapLimit: formatBytes(memory?.heapLimit),
+    domNodes: domNodes != null ? formatNumber(domNodes) : void 0,
+    eventListeners: eventListeners != null ? formatNumber(eventListeners) : void 0
+  };
+}
+function calculateUsagePercentage(heapUsed, heapLimit) {
+  if (heapUsed == null || heapLimit == null || heapLimit <= 0) {
+    return null;
+  }
+  const percentage = heapUsed / heapLimit * 100;
+  return Math.min(100, Math.max(0, percentage));
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  if (ms < 36e5) {
+    return `${(ms / 6e4).toFixed(1)}m`;
+  }
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+
+// src/utils/circularBuffer.ts
+var CircularBuffer = class {
+  /**
+   * Create a new circular buffer with the specified capacity
+   *
+   * @param capacity - Maximum number of items the buffer can hold
+   * @throws Error if capacity is less than 1
+   */
+  constructor(capacity) {
+    this.head = 0;
+    this.tail = 0;
+    this._size = 0;
+    if (capacity < 1) {
+      throw new Error("CircularBuffer capacity must be at least 1");
+    }
+    this._capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  /**
+   * Add an item to the buffer.
+   * If the buffer is full, the oldest item will be overwritten.
+   *
+   * @param item - Item to add
+   */
+  push(item) {
+    this.buffer[this.tail] = item;
+    this.tail = (this.tail + 1) % this._capacity;
+    if (this._size < this._capacity) {
+      this._size++;
+    } else {
+      this.head = (this.head + 1) % this._capacity;
+    }
+  }
+  /**
+   * Get all items in the buffer as an array, from oldest to newest.
+   *
+   * @returns Array of items in insertion order (oldest first)
+   */
+  toArray() {
+    const result = [];
+    for (let i = 0; i < this._size; i++) {
+      const index = (this.head + i) % this._capacity;
+      result.push(this.buffer[index]);
+    }
+    return result;
+  }
+  /**
+   * Get the most recent N items from the buffer.
+   *
+   * @param count - Number of items to retrieve
+   * @returns Array of most recent items (oldest first within the slice)
+   */
+  getRecent(count) {
+    const actualCount = Math.min(count, this._size);
+    const result = [];
+    const startOffset = this._size - actualCount;
+    for (let i = 0; i < actualCount; i++) {
+      const index = (this.head + startOffset + i) % this._capacity;
+      result.push(this.buffer[index]);
+    }
+    return result;
+  }
+  /**
+   * Get the most recently added item.
+   *
+   * @returns The most recent item, or undefined if buffer is empty
+   */
+  get last() {
+    if (this._size === 0) {
+      return void 0;
+    }
+    const lastIndex = (this.tail - 1 + this._capacity) % this._capacity;
+    return this.buffer[lastIndex];
+  }
+  /**
+   * Get the oldest item in the buffer.
+   *
+   * @returns The oldest item, or undefined if buffer is empty
+   */
+  get first() {
+    if (this._size === 0) {
+      return void 0;
+    }
+    return this.buffer[this.head];
+  }
+  /**
+   * Get an item at a specific index (0 = oldest).
+   *
+   * @param index - Index of the item to retrieve
+   * @returns The item at the index, or undefined if out of bounds
+   */
+  at(index) {
+    if (index < 0 || index >= this._size) {
+      return void 0;
+    }
+    const bufferIndex = (this.head + index) % this._capacity;
+    return this.buffer[bufferIndex];
+  }
+  /**
+   * Current number of items in the buffer.
+   */
+  get size() {
+    return this._size;
+  }
+  /**
+   * Maximum capacity of the buffer.
+   */
+  get capacity() {
+    return this._capacity;
+  }
+  /**
+   * Check if the buffer is empty.
+   */
+  get isEmpty() {
+    return this._size === 0;
+  }
+  /**
+   * Check if the buffer is full.
+   */
+  get isFull() {
+    return this._size === this._capacity;
+  }
+  /**
+   * Clear all items from the buffer.
+   */
+  clear() {
+    this.buffer = new Array(this._capacity);
+    this.head = 0;
+    this.tail = 0;
+    this._size = 0;
+  }
+  /**
+   * Iterate over all items in the buffer (oldest to newest).
+   */
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this._size; i++) {
+      const index = (this.head + i) % this._capacity;
+      yield this.buffer[index];
+    }
+  }
+  /**
+   * Apply a function to each item in the buffer.
+   *
+   * @param callback - Function to call for each item
+   */
+  forEach(callback) {
+    for (let i = 0; i < this._size; i++) {
+      const bufferIndex = (this.head + i) % this._capacity;
+      callback(this.buffer[bufferIndex], i);
+    }
+  }
+  /**
+   * Map items to a new array.
+   *
+   * @param callback - Function to transform each item
+   * @returns Array of transformed items
+   */
+  map(callback) {
+    const result = [];
+    for (let i = 0; i < this._size; i++) {
+      const bufferIndex = (this.head + i) % this._capacity;
+      result.push(callback(this.buffer[bufferIndex], i));
+    }
+    return result;
+  }
+  /**
+   * Filter items based on a predicate.
+   *
+   * @param predicate - Function to test each item
+   * @returns Array of items that pass the test
+   */
+  filter(predicate) {
+    const result = [];
+    for (let i = 0; i < this._size; i++) {
+      const bufferIndex = (this.head + i) % this._capacity;
+      const item = this.buffer[bufferIndex];
+      if (predicate(item, i)) {
+        result.push(item);
+      }
+    }
+    return result;
+  }
+};
+
+// src/utils/leakDetection.ts
+function linearRegression(points) {
+  const n = points.length;
+  if (n < 2) {
+    return { slope: 0, intercept: 0, rSquared: 0 };
+  }
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumX2 = 0;
+  let sumY2 = 0;
+  for (const [x, y] of points) {
+    sumX += x;
+    sumY += y;
+    sumXY += x * y;
+    sumX2 += x * x;
+    sumY2 += y * y;
+  }
+  const denominator = n * sumX2 - sumX * sumX;
+  if (denominator === 0) {
+    return { slope: 0, intercept: sumY / n, rSquared: 0 };
+  }
+  const slope = (n * sumXY - sumX * sumY) / denominator;
+  const intercept = (sumY - slope * sumX) / n;
+  const meanY = sumY / n;
+  let ssTotal = 0;
+  let ssResidual = 0;
+  for (const [x, y] of points) {
+    const predicted = slope * x + intercept;
+    ssTotal += Math.pow(y - meanY, 2);
+    ssResidual += Math.pow(y - predicted, 2);
+  }
+  const rSquared = ssTotal === 0 ? 0 : 1 - ssResidual / ssTotal;
+  return {
+    slope,
+    intercept,
+    rSquared: Math.max(0, Math.min(1, rSquared))
+    // Clamp to [0, 1]
+  };
+}
+function calculateTrend(samples) {
+  if (samples.length < 2) {
+    return "stable";
+  }
+  const points = samples.map((s, i) => [i, s.heapUsed]);
+  const { slope } = linearRegression(points);
+  const avgHeap = samples.reduce((sum, s) => sum + s.heapUsed, 0) / samples.length;
+  const normalizedSlope = avgHeap > 0 ? slope / avgHeap : 0;
+  if (normalizedSlope > TREND_THRESHOLDS.increasing) {
+    return "increasing";
+  }
+  if (normalizedSlope < TREND_THRESHOLDS.decreasing) {
+    return "decreasing";
+  }
+  return "stable";
+}
+function calculateAverageGrowth(samples) {
+  if (samples.length < 2) {
+    return 0;
+  }
+  const points = samples.map((s, i) => [i, s.heapUsed]);
+  const { slope } = linearRegression(points);
+  return slope;
+}
+function generateRecommendation(probability, trend, averageGrowth) {
+  if (probability < 30) {
+    return void 0;
+  }
+  if (probability >= 80) {
+    return `Critical: High probability of memory leak detected. Memory is growing at ${formatGrowthRate(averageGrowth)} per sample. Consider profiling with browser DevTools.`;
+  }
+  if (probability >= 60) {
+    return `Warning: Possible memory leak detected. Memory trend is ${trend}. Monitor closely and check for retained references.`;
+  }
+  if (probability >= 30 && trend === "increasing") {
+    return `Note: Memory usage is trending upward. This may be normal for your application, but consider monitoring.`;
+  }
+  return void 0;
+}
+function formatGrowthRate(bytesPerSample) {
+  const absBytes = Math.abs(bytesPerSample);
+  if (absBytes >= 1024 * 1024) {
+    return `${(bytesPerSample / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  if (absBytes >= 1024) {
+    return `${(bytesPerSample / 1024).toFixed(2)} KB`;
+  }
+  return `${bytesPerSample.toFixed(0)} bytes`;
+}
+function analyzeLeakProbability(samples, sensitivity = "medium", customThreshold) {
+  if (samples.length < MIN_LEAK_DETECTION_SAMPLES) {
+    return {
+      isLeaking: false,
+      probability: 0,
+      trend: calculateTrend(samples),
+      averageGrowth: calculateAverageGrowth(samples),
+      rSquared: 0,
+      samples,
+      recommendation: void 0
+    };
+  }
+  const config = LEAK_SENSITIVITY_CONFIG[sensitivity];
+  const threshold = customThreshold ?? config.minSlope;
+  const points = samples.map((s, i) => [i, s.heapUsed]);
+  const { slope, rSquared } = linearRegression(points);
+  let probability = 0;
+  if (slope > 0 && rSquared >= config.minR2) {
+    const slopeRatio = slope / threshold;
+    probability = Math.min(100, slopeRatio * 50 * rSquared * config.probabilityMultiplier);
+  }
+  const trend = calculateTrend(samples);
+  const averageGrowth = slope;
+  if (trend === "increasing" && rSquared > 0.7 && probability < 60) {
+    probability = Math.max(probability, 40);
+  }
+  probability = Math.min(100, Math.max(0, probability));
+  const isLeaking = probability > 50;
+  return {
+    isLeaking,
+    probability: Math.round(probability),
+    trend,
+    averageGrowth,
+    rSquared,
+    samples,
+    recommendation: generateRecommendation(probability, trend, averageGrowth)
+  };
+}
+
+// src/useMemoryMonitor.ts
+function useMemoryMonitor(options = {}) {
+  const mergedOptions = useMemo(
+    () => ({
+      ...DEFAULT_OPTIONS,
+      ...options,
+      thresholds: {
+        ...DEFAULT_OPTIONS.thresholds,
+        ...options.thresholds
+      },
+      leakDetection: {
+        ...DEFAULT_OPTIONS.leakDetection,
+        ...options.leakDetection
+      }
+    }),
+    [options]
+  );
+  const {
+    interval,
+    autoStart,
+    enabled,
+    enableHistory,
+    historySize,
+    thresholds,
+    leakDetection,
+    devMode,
+    trackDOMNodes,
+    trackEventListeners,
+    logToConsole,
+    disableInProduction,
+    fallbackStrategy
+  } = mergedOptions;
+  const shouldDisable = disableInProduction && typeof globalThis.process !== "undefined" && globalThis.process?.env?.NODE_ENV === "production";
+  const onUpdateRef = useRef(options.onUpdate);
+  const onWarningRef = useRef(options.onWarning);
+  const onCriticalRef = useRef(options.onCritical);
+  const onLeakDetectedRef = useRef(options.onLeakDetected);
+  const onUnsupportedRef = useRef(options.onUnsupported);
+  useEffect(() => {
+    onUpdateRef.current = options.onUpdate;
+    onWarningRef.current = options.onWarning;
+    onCriticalRef.current = options.onCritical;
+    onLeakDetectedRef.current = options.onLeakDetected;
+    onUnsupportedRef.current = options.onUnsupported;
+  }, [options.onUpdate, options.onWarning, options.onCritical, options.onLeakDetected, options.onUnsupported]);
+  const browserSupport = useMemo(() => detectSupport(), []);
+  const storeRef = useRef(null);
+  if (!storeRef.current) {
+    storeRef.current = createStore();
+  }
+  const store = storeRef.current;
+  const storeState = useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getServerSnapshot
+  );
+  const historyBufferRef = useRef(null);
+  if (enableHistory && !historyBufferRef.current) {
+    historyBufferRef.current = new CircularBuffer(historySize);
+  }
+  const snapshotsRef = useRef(/* @__PURE__ */ new Map());
+  const intervalIdRef = useRef(null);
+  const prevSeverityRef = useRef(DEFAULT_SEVERITY);
+  const prevLeakDetectedRef = useRef(false);
+  const isMonitoringRef = useRef(false);
+  const isSupported = useMemo(() => {
+    if (isServer()) return false;
+    if (shouldDisable) return false;
+    if (fallbackStrategy === "none") {
+      return hasLegacyMemoryAPI();
+    }
+    return true;
+  }, [shouldDisable, fallbackStrategy]);
+  const supportLevel = useMemo(() => {
+    if (!isSupported) return "none";
+    return browserSupport.level;
+  }, [isSupported, browserSupport.level]);
+  const availableMetrics = useMemo(() => {
+    if (!isSupported) return [];
+    return browserSupport.availableMetrics;
+  }, [isSupported, browserSupport.availableMetrics]);
+  const memory = storeState.memory;
+  const heapUsed = memory?.heapUsed ?? null;
+  const heapTotal = memory?.heapTotal ?? null;
+  const heapLimit = memory?.heapLimit ?? null;
+  const usagePercentage = calculateUsagePercentage(heapUsed, heapLimit);
+  const domNodes = storeState.domNodes;
+  const eventListeners = storeState.eventListeners;
+  const severity = useMemo(() => {
+    if (usagePercentage === null) return DEFAULT_SEVERITY;
+    if (usagePercentage >= (thresholds.critical ?? 90)) {
+      return "critical";
+    }
+    if (usagePercentage >= (thresholds.warning ?? 70)) {
+      return "warning";
+    }
+    return "normal";
+  }, [usagePercentage, thresholds.critical, thresholds.warning]);
+  const history = useMemo(() => {
+    if (!enableHistory || !historyBufferRef.current) return [];
+    return historyBufferRef.current.toArray();
+  }, [enableHistory, storeState.lastUpdated]);
+  const trend = useMemo(() => {
+    if (!enableHistory || history.length < 3) return DEFAULT_TREND;
+    return calculateTrend(history);
+  }, [enableHistory, history]);
+  const leakAnalysis = useMemo(() => {
+    if (!leakDetection.enabled || !enableHistory) return null;
+    const windowSize = leakDetection.windowSize ?? 10;
+    const samples = historyBufferRef.current?.getRecent(windowSize) ?? [];
+    if (samples.length < 5) return null;
+    return analyzeLeakProbability(
+      samples,
+      leakDetection.sensitivity ?? "medium",
+      leakDetection.threshold
+    );
+  }, [
+    leakDetection.enabled,
+    leakDetection.sensitivity,
+    leakDetection.windowSize,
+    leakDetection.threshold,
+    enableHistory,
+    history
+  ]);
+  const isLeakDetected = leakAnalysis?.isLeaking ?? false;
+  const leakProbability = leakAnalysis?.probability ?? 0;
+  const formatted = useMemo(() => {
+    if (!isSupported) return SSR_FORMATTED_MEMORY;
+    return createFormattedMemory(memory, domNodes, eventListeners);
+  }, [isSupported, memory, domNodes, eventListeners]);
+  const poll = useCallback(() => {
+    if (!isSupported || !enabled) return;
+    const newMemory = readMemoryFromAPI();
+    if (newMemory) {
+      store.updateMemory(newMemory);
+      if (enableHistory && historyBufferRef.current) {
+        historyBufferRef.current.push(newMemory);
+      }
+      onUpdateRef.current?.(newMemory);
+      if (logToConsole && devMode) {
+        console.log("[useMemoryMonitor]", {
+          heapUsed: newMemory.heapUsed,
+          heapTotal: newMemory.heapTotal,
+          heapLimit: newMemory.heapLimit
+        });
+      }
+    }
+    if (trackDOMNodes) {
+      const nodeCount = countDOMNodes();
+      store.updateDOMNodes(nodeCount);
+    }
+    if (trackEventListeners) {
+      const listenerCount = estimateEventListeners();
+      store.updateEventListeners(listenerCount);
+    }
+  }, [
+    isSupported,
+    enabled,
+    store,
+    enableHistory,
+    trackDOMNodes,
+    trackEventListeners,
+    logToConsole,
+    devMode
+  ]);
+  const start = useCallback(() => {
+    if (!isSupported || !enabled || isMonitoringRef.current) return;
+    isMonitoringRef.current = true;
+    store.updateMonitoringStatus(true);
+    poll();
+    intervalIdRef.current = setInterval(poll, interval);
+    if (devMode && logToConsole) {
+      console.log("[useMemoryMonitor] Monitoring started");
+    }
+  }, [isSupported, enabled, store, poll, interval, devMode, logToConsole]);
+  const stop = useCallback(() => {
+    if (!isMonitoringRef.current) return;
+    isMonitoringRef.current = false;
+    store.updateMonitoringStatus(false);
+    if (intervalIdRef.current) {
+      clearInterval(intervalIdRef.current);
+      intervalIdRef.current = null;
+    }
+    if (devMode && logToConsole) {
+      console.log("[useMemoryMonitor] Monitoring stopped");
+    }
+  }, [store, devMode, logToConsole]);
+  const takeSnapshot = useCallback(
+    (id) => {
+      if (!isSupported || !memory) return null;
+      const snapshot = {
+        id,
+        memory: { ...memory },
+        domNodes: domNodes ?? void 0,
+        eventListeners: eventListeners ?? void 0,
+        timestamp: Date.now()
+      };
+      snapshotsRef.current.set(id, snapshot);
+      return snapshot;
+    },
+    [isSupported, memory, domNodes, eventListeners]
+  );
+  const compareSnapshots = useCallback(
+    (id1, id2) => {
+      const snapshot1 = snapshotsRef.current.get(id1);
+      const snapshot2 = snapshotsRef.current.get(id2);
+      if (!snapshot1 || !snapshot2) return null;
+      return {
+        heapDelta: snapshot2.memory.heapUsed - snapshot1.memory.heapUsed,
+        heapPercentChange: snapshot1.memory.heapUsed > 0 ? (snapshot2.memory.heapUsed - snapshot1.memory.heapUsed) / snapshot1.memory.heapUsed * 100 : 0,
+        domNodesDelta: snapshot1.domNodes != null && snapshot2.domNodes != null ? snapshot2.domNodes - snapshot1.domNodes : void 0,
+        eventListenersDelta: snapshot1.eventListeners != null && snapshot2.eventListeners != null ? snapshot2.eventListeners - snapshot1.eventListeners : void 0,
+        timeDelta: snapshot2.timestamp - snapshot1.timestamp
+      };
+    },
+    []
+  );
+  const clearHistory = useCallback(() => {
+    if (historyBufferRef.current) {
+      historyBufferRef.current.clear();
+    }
+  }, []);
+  const requestGC = useCallback(() => {
+    if (isServer()) return;
+    try {
+      const pressure = new Array(1e6).fill(0);
+      pressure.length = 0;
+    } catch {
+    }
+    if (devMode && logToConsole) {
+      console.log("[useMemoryMonitor] GC hint requested");
+    }
+  }, [devMode, logToConsole]);
+  useEffect(() => {
+    if (autoStart && isSupported && enabled && !shouldDisable) {
+      start();
+    }
+    return () => {
+      stop();
+    };
+  }, [autoStart, isSupported, enabled, shouldDisable, start, stop]);
+  useEffect(() => {
+    if (isServer()) return;
+    const handleVisibilityChange = () => {
+      if (document.hidden) {
+        stop();
+      } else if (autoStart && isSupported && enabled) {
+        start();
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [autoStart, isSupported, enabled, start, stop]);
+  useEffect(() => {
+    if (severity === prevSeverityRef.current) return;
+    const prevSeverity = prevSeverityRef.current;
+    prevSeverityRef.current = severity;
+    if (!memory || !usagePercentage) return;
+    const callbackData = {
+      memory,
+      usagePercentage,
+      threshold: severity === "critical" ? thresholds.critical ?? 90 : thresholds.warning ?? 70,
+      timestamp: Date.now()
+    };
+    if (severity === "warning" && prevSeverity === "normal") {
+      onWarningRef.current?.(callbackData);
+    } else if (severity === "critical") {
+      onCriticalRef.current?.(callbackData);
+    }
+  }, [severity, memory, usagePercentage, thresholds.warning, thresholds.critical]);
+  useEffect(() => {
+    if (!leakAnalysis) return;
+    if (isLeakDetected && !prevLeakDetectedRef.current) {
+      onLeakDetectedRef.current?.(leakAnalysis);
+    }
+    prevLeakDetectedRef.current = isLeakDetected;
+  }, [isLeakDetected, leakAnalysis]);
+  useEffect(() => {
+    if (!isSupported && onUnsupportedRef.current) {
+      const unsupportedInfo = createUnsupportedInfo();
+      onUnsupportedRef.current(unsupportedInfo);
+    }
+  }, [isSupported]);
+  if (isServer()) {
+    return {
+      memory: null,
+      heapUsed: null,
+      heapTotal: null,
+      heapLimit: null,
+      usagePercentage: null,
+      domNodes: null,
+      eventListeners: null,
+      isSupported: false,
+      isMonitoring: false,
+      isLeakDetected: false,
+      severity: DEFAULT_SEVERITY,
+      supportLevel: "none",
+      availableMetrics: [],
+      history: [],
+      trend: DEFAULT_TREND,
+      leakProbability: 0,
+      start: () => {
+      },
+      stop: () => {
+      },
+      takeSnapshot: () => null,
+      compareSnapshots: () => null,
+      clearHistory: () => {
+      },
+      requestGC: () => {
+      },
+      formatted: SSR_FORMATTED_MEMORY
+    };
+  }
+  return {
+    // Current State
+    memory,
+    heapUsed,
+    heapTotal,
+    heapLimit,
+    usagePercentage,
+    // DOM Related
+    domNodes,
+    eventListeners,
+    // Status Flags
+    isSupported,
+    isMonitoring: storeState.isMonitoring,
+    isLeakDetected,
+    severity,
+    // Support Details
+    supportLevel,
+    availableMetrics,
+    // Analysis Data
+    history,
+    trend,
+    leakProbability,
+    // Actions
+    start,
+    stop,
+    takeSnapshot,
+    compareSnapshots,
+    clearHistory,
+    requestGC,
+    // Formatting
+    formatted
+  };
+}
+export {
+  CircularBuffer,
+  analyzeLeakProbability,
+  calculateTrend,
+  calculateUsagePercentage,
+  canMonitorMemory,
+  detectBrowser,
+  detectSupport,
+  formatBytes,
+  formatDuration,
+  formatNumber,
+  formatPercentage,
+  hasLegacyMemoryAPI,
+  hasPreciseMemoryAPI,
+  isClient,
+  isServer,
+  linearRegression,
+  useMemoryMonitor
+};
+//# sourceMappingURL=index.mjs.map