Class PerformanceProfiler

constructor

• new PerformanceProfiler(
      config?: Partial<PerformanceProfilerConfig>,
  ): PerformanceProfiler

  Parameters

  • config: Partial<PerformanceProfilerConfig> = {}

  Returns PerformanceProfiler

config

monitoringInterval

baselineEstablished

init

• init(): void

  Returns void

startMonitoring

• startMonitoring(): void

  Returns void

stopMonitoring

• stopMonitoring(): void

  Returns void

mark

• mark(name: string): void

  Parameters

  • name: string

  Returns void

measure

• measure(name: string, startMark: string, endMark?: string): number

  Parameters

  • name: string
  • startMark: string
  • OptionalendMark: string

  Returns number

getMemoryUsage

• getMemoryUsage(): MemorySnapshot

  Reads the browser's JS heap counters at this instant.

  ⚠️ The only source is the non-standard performance.memory, which Chrome quantises and then caches for the lifetime of the page unless the browser was started with --enable-precise-memory-info. Two consequences a caller must know before trusting the numbers:

  • Two snapshots taken seconds apart from the same page are normally identical to the byte, whatever the page did in between. Measured on 13 fresh pages against the demo build: equal at five instants of a page and at 0, 10 000 and 30 000 features added (scripts/probe-heap-metrics.mjs).
  • Where performance.memory is absent (every non-Chromium browser), every field stays 0 — an absent measurement, not an empty heap.

  A caller that needs a real figure must measure from outside the page (DevTools, or CDP Runtime.getHeapUsage after HeapProfiler.collectGarbage, which is what the repository's own heap gate does).

  Returns MemorySnapshot

  A snapshot whose used/total/available are bytes, or 0 when the browser exposes no heap counters.

analyzeMemoryLeaks

• analyzeMemoryLeaks(): {
      status: string;
      growthRate?: number;
      memoryTrend?: string;
      recommendation?: string;
      reason?: string;
  }

  Judges the sampled heap history for abnormal growth.

  Samples come from getMemoryUsage while monitoring is running, so the verdict is only as good as that instrument — and on stock Chrome that instrument does not move. The method therefore refuses to answer when its own input carries no information, instead of returning a reassuring "normal".

  status is one of:

  value	meaning
  insufficient_data	fewer than 10 samples collected — start monitoring for longer
  unavailable	no verdict is computable; see reason
  normal	the heap moved, and grew by 20 % or less over the window
  warning	growth above 20 %
  critical	growth above 50 %

  reason accompanies unavailable only, and is either "heap-api-unavailable" (the window opens on a zero reading, so no growth rate is defined — the usual case outside Chromium) or "heap-readings-constant" (every sample in the window is identical to the byte, which is what Chrome's cached performance.memory produces — see getMemoryUsage).

  ⚠️ unavailable is not a failure and it is not normal. It says the browser gave nothing to judge. Treating it as "no leak" reinstates the defect this distinction exists to remove: a diagnosis that cannot come out bad closes the question instead of answering it.

  📌 A window that ends where it started is not the same thing: if the readings varied and simply came back, status is normal with growthRate at 0. The difference between the two is whether the input moved at all.

  Returns {
      status: string;
      growthRate?: number;
      memoryTrend?: string;
      recommendation?: string;
      reason?: string;
  }

  The verdict; growthRate, memoryTrend and recommendation are present only when a growth figure was actually computed.

generateReport

• generateReport(): Record<string, unknown>

  Returns Record<string, unknown>

establishBaseline

• establishBaseline(): Record<string, unknown>

  Returns Record<string, unknown>

exportForDevTools

• exportForDevTools(): {
      traceEvents: DevToolsTraceEvent[];
      metadata: {
          "cpu-family": number;
          "cpu-model": number;
          "cpu-stepping": number;
          "field-name-mappings": {};
          "os-name": string;
          "trace-capture-datetime": string;
          "user-agent": string;
      };
  }

  Returns {
      traceEvents: DevToolsTraceEvent[];
      metadata: {
          "cpu-family": number;
          "cpu-model": number;
          "cpu-stepping": number;
          "field-name-mappings": {};
          "os-name": string;
          "trace-capture-datetime": string;
          "user-agent": string;
      };
  }