@frontmcp/testing 0.7.2 → 0.8.0

package/perf/jest-perf-reporter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file jest-perf-reporter.ts
+ * @description Custom Jest reporter for collecting and outputting performance measurements
+ */
+export {};
+//# sourceMappingURL=jest-perf-reporter.d.ts.map

package/perf/jest-perf-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-perf-reporter.d.ts","sourceRoot":"","sources":["../../src/perf/jest-perf-reporter.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/perf/leak-detector.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @file leak-detector.ts
+ * @description Memory leak detection using iterative measurement and linear regression
+ */
+import type { LeakDetectionOptions, LeakDetectionResult, ParallelLeakDetectionOptions, ParallelLeakDetectionResult, ParallelTestClient } from './types';
+/**
+ * Detects memory leaks by running an operation multiple times
+ * and analyzing heap growth using linear regression.
+ */
+export declare class LeakDetector {
+    /**
+     * Run leak detection on an async operation.
+     *
+     * @param operation - The operation to test for leaks
+     * @param options - Detection options
+     * @returns Leak detection result
+     *
+     * @example
+     * ```typescript
+     * const detector = new LeakDetector();
+     * const result = await detector.detectLeak(
+     *   async () => mcp.tools.call('my-tool', {}),
+     *   { iterations: 50, threshold: 5 * 1024 * 1024 }
+     * );
+     * expect(result.hasLeak).toBe(false);
+     * ```
+     */
+    detectLeak(operation: () => Promise<void>, options?: LeakDetectionOptions): Promise<LeakDetectionResult>;
+    /**
+     * Run leak detection on a sync operation.
+     */
+    detectLeakSync(operation: () => void, options?: LeakDetectionOptions): LeakDetectionResult;
+    /**
+     * Run parallel leak detection using multiple clients.
+     * Each worker gets its own client for true parallel HTTP requests.
+     *
+     * @param operationFactory - Factory that receives a client and worker index, returns an operation function
+     * @param options - Detection options including worker count and client factory
+     * @returns Combined leak detection result with per-worker statistics
+     *
+     * @example
+     * ```typescript
+     * const detector = new LeakDetector();
+     * const result = await detector.detectLeakParallel(
+     *   (client, workerId) => async () => client.tools.call('my-tool', {}),
+     *   {
+     *     iterations: 1000,
+     *     workers: 5,
+     *     clientFactory: () => server.createClient(),
+     *   }
+     * );
+     * // 5 workers × ~80 req/s = ~400 req/s total
+     * console.log(result.totalRequestsPerSecond);
+     * ```
+     */
+    detectLeakParallel(operationFactory: (client: ParallelTestClient, workerId: number) => () => Promise<void>, options: ParallelLeakDetectionOptions & {
+        clientFactory: () => Promise<ParallelTestClient>;
+    }): Promise<ParallelLeakDetectionResult>;
+    /**
+     * Analyze heap samples for leak patterns using linear regression.
+     */
+    private analyzeLeakPattern;
+    /**
+     * Generate interval-based measurements for detailed analysis.
+     */
+    private generateIntervals;
+    /**
+     * Generate graph data points for visualization.
+     */
+    private generateGraphData;
+}
+/**
+ * Quick leak check helper function.
+ * Returns true if no leak detected, throws if leak detected.
+ */
+export declare function assertNoLeak(operation: () => Promise<void>, options?: LeakDetectionOptions): Promise<LeakDetectionResult>;
+/**
+ * Create a LeakDetector instance.
+ */
+export declare function createLeakDetector(): LeakDetector;
+//# sourceMappingURL=leak-detector.d.ts.map

package/perf/leak-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leak-detector.d.ts","sourceRoot":"","sources":["../../src/perf/leak-detector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EAGnB,4BAA4B,EAC5B,2BAA2B,EAE3B,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAkFjB;;;GAGG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;;OAgBG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA6C9G;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,mBAAmB;IAsC1F;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,kBAAkB,CACtB,gBAAgB,EAAE,CAAC,MAAM,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,OAAO,CAAC,IAAI,CAAC,EACvF,OAAO,EAAE,4BAA4B,GAAG;QAAE,aAAa,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAA;KAAE,GAC3F,OAAO,CAAC,2BAA2B,CAAC;IAiIvC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwF1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgCzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAa1B;AAaD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC9B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,mBAAmB,CAAC,CAS9B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAEjD"}

package/perf/metrics-collector.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @file metrics-collector.ts
+ * @description Memory and CPU metrics collection utilities
+ */
+import type { MemoryMetrics, CpuMetrics, PerfSnapshot } from './types';
+/**
+ * Check if manual GC is available (requires --expose-gc flag)
+ */
+export declare function isGcAvailable(): boolean;
+/**
+ * Force garbage collection if available.
+ * Requires Node.js to be started with --expose-gc flag.
+ */
+export declare function forceGc(): void;
+/**
+ * Force multiple GC cycles to ensure thorough cleanup.
+ * V8 may need multiple passes to collect all garbage.
+ */
+export declare function forceFullGc(cycles?: number, delayMs?: number): Promise<void>;
+/**
+ * Collects memory and CPU metrics for performance testing
+ */
+export declare class MetricsCollector {
+    private cpuStartUsage;
+    private baseline;
+    private measurements;
+    /**
+     * Capture the baseline snapshot.
+     * Forces GC to get a clean memory state.
+     */
+    captureBaseline(forceGcCycles?: number): Promise<PerfSnapshot>;
+    /**
+     * Capture a snapshot of current memory and CPU state.
+     */
+    captureSnapshot(label?: string): PerfSnapshot;
+    /**
+     * Start CPU tracking from this point.
+     */
+    startCpuTracking(): void;
+    /**
+     * Get CPU usage since tracking started.
+     */
+    getCpuUsage(): CpuMetrics;
+    /**
+     * Get current memory metrics.
+     */
+    getMemoryMetrics(): MemoryMetrics;
+    /**
+     * Get the baseline snapshot if captured.
+     */
+    getBaseline(): PerfSnapshot | null;
+    /**
+     * Get all measurement snapshots.
+     */
+    getMeasurements(): PerfSnapshot[];
+    /**
+     * Calculate memory delta from baseline.
+     */
+    calculateMemoryDelta(current: MemoryMetrics): {
+        heapUsed: number;
+        heapTotal: number;
+        rss: number;
+    } | null;
+    /**
+     * Reset the collector state.
+     */
+    reset(): void;
+}
+/**
+ * Format bytes to human readable string.
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Format microseconds to human readable string.
+ */
+export declare function formatMicroseconds(us: number): string;
+/**
+ * Format milliseconds to human readable string.
+ */
+export declare function formatDuration(ms: number): string;
+export declare function getGlobalCollector(): MetricsCollector;
+export declare function resetGlobalCollector(): void;
+//# sourceMappingURL=metrics-collector.d.ts.map

package/perf/metrics-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics-collector.d.ts","sourceRoot":"","sources":["../../src/perf/metrics-collector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAMvE;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAI9B;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,MAAM,SAAI,EAAE,OAAO,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAWzE;AAMD;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,aAAa,CAAgC;IACrD,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,YAAY,CAAsB;IAE1C;;;OAGG;IACG,eAAe,CAAC,aAAa,SAAI,GAAG,OAAO,CAAC,YAAY,CAAC;IAc/D;;OAEG;IACH,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY;IA4B7C;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAIxB;;OAEG;IACH,WAAW,IAAI,UAAU;IAUzB;;OAEG;IACH,gBAAgB,IAAI,aAAa;IAWjC;;OAEG;IACH,WAAW,IAAI,YAAY,GAAG,IAAI;IAIlC;;OAEG;IACH,eAAe,IAAI,YAAY,EAAE;IAIjC;;OAEG;IACH,oBAAoB,CAAC,OAAO,EAAE,aAAa,GAAG;QAC5C,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,GAAG,EAAE,MAAM,CAAC;KACb,GAAG,IAAI;IAYR;;OAEG;IACH,KAAK,IAAI,IAAI;CAKd;AAMD;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAcjD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQrD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQjD;AAcD,wBAAgB,kBAAkB,IAAI,gBAAgB,CAKrD;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C"}

package/perf/perf-fixtures.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @file perf-fixtures.ts
+ * @description Performance testing fixtures implementation
+ */
+import type { PerfFixtures, PerfSnapshot, PerfThresholds, LeakDetectionOptions, LeakDetectionResult, PerfMeasurement, PerfIssue, ParallelLeakDetectionOptions, ParallelLeakDetectionResult, ParallelTestClient } from './types';
+/**
+ * Creates a PerfFixtures instance for a test.
+ */
+export declare function createPerfFixtures(testName: string, project: string): PerfFixturesImpl;
+/**
+ * Implementation of PerfFixtures interface.
+ */
+export declare class PerfFixturesImpl implements PerfFixtures {
+    private readonly testName;
+    private readonly project;
+    private collector;
+    private leakDetector;
+    private baselineSnapshot;
+    private startTime;
+    private issues;
+    private leakResults;
+    constructor(testName: string, project: string);
+    /**
+     * Capture baseline snapshot with GC.
+     */
+    baseline(): Promise<PerfSnapshot>;
+    /**
+     * Capture a measurement snapshot.
+     */
+    measure(label?: string): PerfSnapshot;
+    /**
+     * Run leak detection on an operation.
+     */
+    checkLeak(operation: () => Promise<void>, options?: LeakDetectionOptions): Promise<LeakDetectionResult>;
+    /**
+     * Run parallel leak detection using multiple clients.
+     * Each worker gets its own client for true parallel HTTP requests.
+     *
+     * @param operationFactory - Factory that receives a client and worker index, returns an operation function
+     * @param options - Detection options including worker count and client factory
+     * @returns Combined leak detection result with per-worker statistics
+     *
+     * @example
+     * ```typescript
+     * const result = await perf.checkLeakParallel(
+     *   (client, workerId) => async () => {
+     *     await client.tools.call('loadSkills', { skillIds: ['review-pr'] });
+     *   },
+     *   {
+     *     iterations: 1000,
+     *     workers: 5,
+     *     clientFactory: () => server.createClient(),
+     *   }
+     * );
+     * // 5 workers × ~80 req/s = ~400 req/s total
+     * expect(result.totalRequestsPerSecond).toBeGreaterThan(300);
+     * ```
+     */
+    checkLeakParallel(operationFactory: (client: ParallelTestClient, workerId: number) => () => Promise<void>, options: ParallelLeakDetectionOptions & {
+        clientFactory: () => Promise<ParallelTestClient>;
+    }): Promise<ParallelLeakDetectionResult>;
+    /**
+     * Assert that metrics are within thresholds.
+     */
+    assertThresholds(thresholds: PerfThresholds): void;
+    /**
+     * Get all measurements so far.
+     */
+    getMeasurements(): PerfSnapshot[];
+    /**
+     * Get the current test name.
+     */
+    getTestName(): string;
+    /**
+     * Get the project name.
+     */
+    getProject(): string;
+    /**
+     * Get all detected issues.
+     */
+    getIssues(): PerfIssue[];
+    /**
+     * Build a complete PerfMeasurement for this test.
+     */
+    buildMeasurement(): PerfMeasurement;
+    /**
+     * Reset the fixture state.
+     */
+    reset(): void;
+}
+/**
+ * Add a measurement to the global collection.
+ */
+export declare function addGlobalMeasurement(measurement: PerfMeasurement): void;
+/**
+ * Get all global measurements.
+ */
+export declare function getGlobalMeasurements(): PerfMeasurement[];
+/**
+ * Clear all global measurements.
+ */
+export declare function clearGlobalMeasurements(): void;
+/**
+ * Get measurements for a specific project.
+ */
+export declare function getMeasurementsForProject(project: string): PerfMeasurement[];
+//# sourceMappingURL=perf-fixtures.d.ts.map

package/perf/perf-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf-fixtures.d.ts","sourceRoot":"","sources":["../../src/perf/perf-fixtures.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,SAAS,EACT,4BAA4B,EAC5B,2BAA2B,EAC3B,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAQjB;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAEtF;AAED;;GAEG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IASjD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAT1B,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,gBAAgB,CAA6B;IACrD,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,WAAW,CAA6B;gBAG7B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM;IAMlC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC;IAMvC;;OAEG;IACH,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY;IAIrC;;OAEG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAoB7G;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,iBAAiB,CACrB,gBAAgB,EAAE,CAAC,MAAM,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,OAAO,CAAC,IAAI,CAAC,EACvF,OAAO,EAAE,4BAA4B,GAAG;QAAE,aAAa,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAA;KAAE,GAC3F,OAAO,CAAC,2BAA2B,CAAC;IAoBvC;;OAEG;IACH,gBAAgB,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;IA6ElD;;OAEG;IACH,eAAe,IAAI,YAAY,EAAE;IAIjC;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;OAEG;IACH,SAAS,IAAI,SAAS,EAAE;IAIxB;;OAEG;IACH,gBAAgB,IAAI,eAAe;IAuBnC;;OAEG;IACH,KAAK,IAAI,IAAI;CAOd;AAiBD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI,CAEvE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,eAAe,EAAE,CAEzD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CAE5E"}

package/perf/perf-setup.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file perf-setup.ts
+ * @description Jest setup file for performance tests
+ *
+ * This file is loaded via setupFilesAfterEnv in jest.perf.config.ts.
+ * It sets up the environment for performance testing.
+ */
+export {};
+//# sourceMappingURL=perf-setup.d.ts.map

package/perf/perf-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf-setup.d.ts","sourceRoot":"","sources":["../../src/perf/perf-setup.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA0DH,OAAO,EAAE,CAAC"}

package/perf/perf-setup.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/testing/src/perf/perf-setup.ts
+var perf_setup_exports = {};
+module.exports = __toCommonJS(perf_setup_exports);
+
+// libs/testing/src/perf/metrics-collector.ts
+function isGcAvailable() {
+  return typeof global.gc === "function";
+}
+
+// libs/testing/src/perf/perf-setup.ts
+if (!isGcAvailable()) {
+  console.warn(
+    '\n[PerfSetup] WARNING: Manual garbage collection is not available.\nFor accurate memory measurements, run Node.js with --expose-gc flag:\n  node --expose-gc ./node_modules/.bin/jest\nor add to jest.perf.config.ts:\n  "testEnvironmentOptions": { "execArgv": ["--expose-gc"] }\n'
+  );
+}
+jest.setTimeout(12e4);
+if (process.env["DEBUG"] !== "1" && process.env["PERF_VERBOSE"] !== "1") {
+  const originalLog = console.log;
+  const originalInfo = console.info;
+  const originalDebug = console.debug;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  beforeAll(() => {
+    console.log = jest.fn();
+    console.info = jest.fn();
+    console.debug = jest.fn();
+    console.warn = originalWarn;
+    console.error = originalError;
+  });
+  afterAll(() => {
+    console.log = originalLog;
+    console.info = originalInfo;
+    console.debug = originalDebug;
+  });
+}

package/perf/perf-test.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @file perf-test.ts
+ * @description Performance test fixture extending the standard test fixture
+ *
+ * Provides a Playwright-like fixture API for performance testing:
+ *
+ * @example
+ * ```typescript
+ * import { perfTest, expect } from '@frontmcp/testing';
+ *
+ * perfTest.describe('Cache Performance', () => {
+ *   perfTest.use({
+ *     server: 'apps/e2e/demo-e2e-cache/src/main.ts',
+ *     project: 'demo-e2e-cache',
+ *     publicMode: true,
+ *   });
+ *
+ *   perfTest('cache operations memory overhead', async ({ mcp, perf }) => {
+ *     await perf.baseline();
+ *
+ *     for (let i = 0; i < 100; i++) {
+ *       await mcp.tools.call('expensive-operation', { operationId: `test-${i}` });
+ *     }
+ *
+ *     perf.assertThresholds({ maxHeapDelta: 10 * 1024 * 1024 });
+ *   });
+ * });
+ * ```
+ */
+import type { TestConfig, TestFixtures } from '../fixtures/fixture-types';
+import type { PerfFixtures, PerfTestConfig } from './types';
+/**
+ * Extended fixtures including performance testing
+ */
+export interface PerfTestFixtures extends TestFixtures {
+    /** Performance fixture */
+    perf: PerfFixtures;
+}
+/**
+ * Test function that receives extended fixtures
+ */
+export type PerfTestFn = (fixtures: PerfTestFixtures) => Promise<void> | void;
+/**
+ * Enhanced test function with perf fixture support
+ */
+export interface PerfTestWithFixtures {
+    (name: string, fn: PerfTestFn): void;
+    /** Configure fixtures for this test file/suite */
+    use(config: TestConfig & PerfTestConfig): void;
+    /** Create a describe block */
+    describe: typeof describe;
+    /** Run before all tests in the file */
+    beforeAll: typeof beforeAll;
+    /** Run before each test */
+    beforeEach: typeof beforeEach;
+    /** Run after each test */
+    afterEach: typeof afterEach;
+    /** Run after all tests in the file */
+    afterAll: typeof afterAll;
+    /** Skip a test */
+    skip(name: string, fn: PerfTestFn): void;
+    /** Run only this test */
+    only(name: string, fn: PerfTestFn): void;
+    /** Mark test as todo (not implemented) */
+    todo(name: string): void;
+}
+declare const perfTest: PerfTestWithFixtures;
+export { perfTest };
+//# sourceMappingURL=perf-test.d.ts.map

package/perf/perf-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf-test.d.ts","sourceRoot":"","sources":["../../src/perf/perf-test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAwC,MAAM,2BAA2B,CAAC;AAChH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAO5D;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,0BAA0B;IAC1B,IAAI,EAAE,YAAY,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE9E;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,IAAI,CAAC;IAErC,kDAAkD;IAClD,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,cAAc,GAAG,IAAI,CAAC;IAE/C,8BAA8B;IAC9B,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAE1B,uCAAuC;IACvC,SAAS,EAAE,OAAO,SAAS,CAAC;IAE5B,2BAA2B;IAC3B,UAAU,EAAE,OAAO,UAAU,CAAC;IAE9B,0BAA0B;IAC1B,SAAS,EAAE,OAAO,SAAS,CAAC;IAE5B,sCAAsC;IACtC,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAE1B,kBAAkB;IAClB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,IAAI,CAAC;IAEzC,yBAAyB;IACzB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,IAAI,CAAC;IAEzC,0CAA0C;IAC1C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAgTD,QAAA,MAAM,QAAQ,EAA2B,oBAAoB,CAAC;AAgB9D,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/perf/regression-detector.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @file regression-detector.ts
+ * @description Performance regression detection by comparing current metrics to baseline
+ */
+import type { RegressionConfig, RegressionResult, MetricRegression, PerfMeasurement, TestBaseline, PerfBaseline } from './types';
+/**
+ * Detects performance regressions by comparing current metrics to baseline.
+ */
+export declare class RegressionDetector {
+    private readonly config;
+    constructor(config?: RegressionConfig);
+    /**
+     * Detect regressions in a measurement compared to baseline.
+     */
+    detectRegression(measurement: PerfMeasurement, baseline: TestBaseline): RegressionResult;
+    /**
+     * Detect regressions for multiple measurements.
+     */
+    detectRegressions(measurements: PerfMeasurement[], baselines: PerfBaseline): RegressionResult[];
+    /**
+     * Check a single metric for regression.
+     */
+    private checkMetric;
+    /**
+     * Build a human-readable message for regression result.
+     */
+    private buildMessage;
+}
+/**
+ * Summarize regression results.
+ */
+export declare function summarizeRegressions(results: RegressionResult[]): {
+    total: number;
+    ok: number;
+    warnings: number;
+    regressions: number;
+    summary: string;
+};
+/**
+ * Filter regressions by status.
+ */
+export declare function filterByStatus(results: RegressionResult[], status: 'ok' | 'warning' | 'regression'): RegressionResult[];
+/**
+ * Get the most severe metric regression from a result.
+ */
+export declare function getMostSevereMetric(result: RegressionResult): MetricRegression | null;
+/**
+ * Get the global regression detector instance.
+ */
+export declare function getRegressionDetector(config?: RegressionConfig): RegressionDetector;
+/**
+ * Reset the global regression detector.
+ */
+export declare function resetRegressionDetector(): void;
+//# sourceMappingURL=regression-detector.d.ts.map

package/perf/regression-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regression-detector.d.ts","sourceRoot":"","sources":["../../src/perf/regression-detector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,YAAY,EACb,MAAM,SAAS,CAAC;AAiBjB;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;gBAExC,MAAM,CAAC,EAAE,gBAAgB;IAIrC;;OAEG;IACH,gBAAgB,CAAC,WAAW,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,gBAAgB;IAuCxF;;OAEG;IACH,iBAAiB,CAAC,YAAY,EAAE,eAAe,EAAE,EAAE,SAAS,EAAE,YAAY,GAAG,gBAAgB,EAAE;IAe/F;;OAEG;IACH,OAAO,CAAC,WAAW;IA8BnB;;OAEG;IACH,OAAO,CAAC,YAAY;CAerB;AAMD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAgBA;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,gBAAgB,EAAE,EAC3B,MAAM,EAAE,IAAI,GAAG,SAAS,GAAG,YAAY,GACtC,gBAAgB,EAAE,CAEpB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,IAAI,CAYrF;AAQD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,kBAAkB,CAKnF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C"}

package/perf/report-generator.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @file report-generator.ts
+ * @description Generate JSON and Markdown reports from performance measurements
+ */
+import type { PerfReport, PerfMeasurement, PerfBaseline } from './types';
+/**
+ * Generates performance reports in JSON and Markdown formats.
+ */
+export declare class ReportGenerator {
+    private readonly detector;
+    constructor();
+    /**
+     * Generate a complete performance report.
+     */
+    generateReport(measurements: PerfMeasurement[], baseline?: PerfBaseline, gitInfo?: {
+        commitHash?: string;
+        branch?: string;
+    }): PerfReport;
+    /**
+     * Generate Markdown report for PR comments.
+     */
+    generateMarkdownReport(report: PerfReport): string;
+    /**
+     * Generate JSON report.
+     */
+    generateJsonReport(report: PerfReport): string;
+    /**
+     * Calculate summary statistics for measurements.
+     */
+    private calculateSummary;
+    /**
+     * Get status emoji based on summary.
+     */
+    private getStatusEmoji;
+    /**
+     * Get summary text.
+     */
+    private getSummaryText;
+    /**
+     * Generate markdown table for project measurements.
+     */
+    private generateProjectTable;
+    /**
+     * Get test status indicator.
+     */
+    private getTestStatus;
+    /**
+     * Check if a leak detection result is a parallel result.
+     */
+    private isParallelResult;
+}
+/**
+ * Generate and save reports to files.
+ */
+export declare function saveReports(measurements: PerfMeasurement[], outputDir: string, baseline?: PerfBaseline, gitInfo?: {
+    commitHash?: string;
+    branch?: string;
+}): Promise<{
+    jsonPath: string;
+    markdownPath: string;
+}>;
+/**
+ * Create a report generator instance.
+ */
+export declare function createReportGenerator(): ReportGenerator;
+//# sourceMappingURL=report-generator.d.ts.map

package/perf/report-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-generator.d.ts","sourceRoot":"","sources":["../../src/perf/report-generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,UAAU,EAGV,eAAe,EACf,YAAY,EAEb,MAAM,SAAS,CAAC;AAQjB;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;;IAM9C;;OAEG;IACH,cAAc,CACZ,YAAY,EAAE,eAAe,EAAE,EAC/B,QAAQ,CAAC,EAAE,YAAY,EACvB,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GACjD,UAAU;IAwCb;;OAEG;IACH,sBAAsB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAuIlD;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAI9C;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAiCxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAUtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAatB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAiB5B;;OAEG;IACH,OAAO,CAAC,aAAa;IAiBrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CASzB;AAMD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,YAAY,EAAE,eAAe,EAAE,EAC/B,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,YAAY,EACvB,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACjD,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CAerD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,eAAe,CAEvD"}