@frontmcp/testing 0.7.1 → 0.8.0

package/esm/perf/index.mjs

@@ -0,0 +1,4334 @@
+// libs/testing/src/perf/metrics-collector.ts
+function isGcAvailable() {
+  return typeof global.gc === "function";
+}
+function forceGc() {
+  if (typeof global.gc === "function") {
+    global.gc();
+  }
+}
+async function forceFullGc(cycles = 3, delayMs = 10) {
+  if (!isGcAvailable()) {
+    return;
+  }
+  for (let i = 0; i < cycles; i++) {
+    forceGc();
+    if (i < cycles - 1 && delayMs > 0) {
+      await sleep(delayMs);
+    }
+  }
+}
+var MetricsCollector = class {
+  cpuStartUsage = null;
+  baseline = null;
+  measurements = [];
+  /**
+   * Capture the baseline snapshot.
+   * Forces GC to get a clean memory state.
+   */
+  async captureBaseline(forceGcCycles = 3) {
+    await forceFullGc(forceGcCycles);
+    this.cpuStartUsage = process.cpuUsage();
+    const snapshot = this.captureSnapshot("baseline");
+    this.baseline = snapshot;
+    return snapshot;
+  }
+  /**
+   * Capture a snapshot of current memory and CPU state.
+   */
+  captureSnapshot(label) {
+    const memUsage = process.memoryUsage();
+    const cpuUsage = this.cpuStartUsage ? process.cpuUsage(this.cpuStartUsage) : process.cpuUsage();
+    const snapshot = {
+      memory: {
+        heapUsed: memUsage.heapUsed,
+        heapTotal: memUsage.heapTotal,
+        external: memUsage.external,
+        rss: memUsage.rss,
+        arrayBuffers: memUsage.arrayBuffers
+      },
+      cpu: {
+        user: cpuUsage.user,
+        system: cpuUsage.system,
+        total: cpuUsage.user + cpuUsage.system
+      },
+      timestamp: Date.now(),
+      label
+    };
+    if (label !== "baseline") {
+      this.measurements.push(snapshot);
+    }
+    return snapshot;
+  }
+  /**
+   * Start CPU tracking from this point.
+   */
+  startCpuTracking() {
+    this.cpuStartUsage = process.cpuUsage();
+  }
+  /**
+   * Get CPU usage since tracking started.
+   */
+  getCpuUsage() {
+    const usage = this.cpuStartUsage ? process.cpuUsage(this.cpuStartUsage) : process.cpuUsage();
+    return {
+      user: usage.user,
+      system: usage.system,
+      total: usage.user + usage.system
+    };
+  }
+  /**
+   * Get current memory metrics.
+   */
+  getMemoryMetrics() {
+    const memUsage = process.memoryUsage();
+    return {
+      heapUsed: memUsage.heapUsed,
+      heapTotal: memUsage.heapTotal,
+      external: memUsage.external,
+      rss: memUsage.rss,
+      arrayBuffers: memUsage.arrayBuffers
+    };
+  }
+  /**
+   * Get the baseline snapshot if captured.
+   */
+  getBaseline() {
+    return this.baseline;
+  }
+  /**
+   * Get all measurement snapshots.
+   */
+  getMeasurements() {
+    return [...this.measurements];
+  }
+  /**
+   * Calculate memory delta from baseline.
+   */
+  calculateMemoryDelta(current) {
+    if (!this.baseline) {
+      return null;
+    }
+    return {
+      heapUsed: current.heapUsed - this.baseline.memory.heapUsed,
+      heapTotal: current.heapTotal - this.baseline.memory.heapTotal,
+      rss: current.rss - this.baseline.memory.rss
+    };
+  }
+  /**
+   * Reset the collector state.
+   */
+  reset() {
+    this.cpuStartUsage = null;
+    this.baseline = null;
+    this.measurements = [];
+  }
+};
+function formatBytes(bytes) {
+  const absBytes = Math.abs(bytes);
+  const sign = bytes < 0 ? "-" : "";
+  if (absBytes < 1024) {
+    return `${sign}${absBytes} B`;
+  }
+  if (absBytes < 1024 * 1024) {
+    return `${sign}${(absBytes / 1024).toFixed(2)} KB`;
+  }
+  if (absBytes < 1024 * 1024 * 1024) {
+    return `${sign}${(absBytes / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  return `${sign}${(absBytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function formatMicroseconds(us) {
+  if (us < 1e3) {
+    return `${us.toFixed(2)} \xB5s`;
+  }
+  if (us < 1e6) {
+    return `${(us / 1e3).toFixed(2)} ms`;
+  }
+  return `${(us / 1e6).toFixed(2)} s`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms.toFixed(2)} ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)} s`;
+  }
+  return `${(ms / 6e4).toFixed(2)} min`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var globalCollector = null;
+function getGlobalCollector() {
+  if (!globalCollector) {
+    globalCollector = new MetricsCollector();
+  }
+  return globalCollector;
+}
+function resetGlobalCollector() {
+  if (globalCollector) {
+    globalCollector.reset();
+  }
+  globalCollector = null;
+}
+
+// libs/testing/src/perf/leak-detector.ts
+var DEFAULT_OPTIONS = {
+  iterations: 20,
+  threshold: 1024 * 1024,
+  // 1 MB
+  warmupIterations: 3,
+  forceGc: true,
+  delayMs: 10,
+  intervalSize: 10
+  // Default interval size for measurements
+};
+var DEFAULT_PARALLEL_OPTIONS = {
+  ...DEFAULT_OPTIONS,
+  workers: 5
+  // Default number of parallel workers
+};
+function linearRegression(samples) {
+  const n = samples.length;
+  if (n < 2) {
+    return { slope: 0, intercept: samples[0] ?? 0, rSquared: 0 };
+  }
+  let sumX = 0;
+  let sumY = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += i;
+    sumY += samples[i];
+  }
+  const meanX = sumX / n;
+  const meanY = sumY / n;
+  let numerator = 0;
+  let denominator = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = i - meanX;
+    const dy = samples[i] - meanY;
+    numerator += dx * dy;
+    denominator += dx * dx;
+  }
+  const slope = denominator !== 0 ? numerator / denominator : 0;
+  const intercept = meanY - slope * meanX;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (let i = 0; i < n; i++) {
+    const predicted = intercept + slope * i;
+    const residual = samples[i] - predicted;
+    ssRes += residual * residual;
+    ssTot += (samples[i] - meanY) * (samples[i] - meanY);
+  }
+  const rSquared = ssTot !== 0 ? 1 - ssRes / ssTot : 0;
+  return { slope, intercept, rSquared };
+}
+var LeakDetector = class {
+  /**
+   * 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);
+   * ```
+   */
+  async detectLeak(operation, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const { iterations, threshold, warmupIterations, forceGc: forceGc2, delayMs, intervalSize } = opts;
+    if (forceGc2 && !isGcAvailable()) {
+      console.warn("[LeakDetector] Manual GC not available. Run Node.js with --expose-gc for accurate results.");
+    }
+    for (let i = 0; i < warmupIterations; i++) {
+      await operation();
+    }
+    if (forceGc2) {
+      await forceFullGc();
+    }
+    const samples = [];
+    const startTime = Date.now();
+    for (let i = 0; i < iterations; i++) {
+      await operation();
+      if (forceGc2) {
+        await forceFullGc(2, 5);
+      }
+      samples.push(process.memoryUsage().heapUsed);
+      if (delayMs > 0) {
+        await sleep2(delayMs);
+      }
+    }
+    const durationMs = Date.now() - startTime;
+    return this.analyzeLeakPattern(samples, threshold, intervalSize, durationMs);
+  }
+  /**
+   * Run leak detection on a sync operation.
+   */
+  detectLeakSync(operation, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const { iterations, threshold, warmupIterations, forceGc: forceGc2, intervalSize } = opts;
+    if (forceGc2 && !isGcAvailable()) {
+      console.warn("[LeakDetector] Manual GC not available. Run Node.js with --expose-gc for accurate results.");
+    }
+    for (let i = 0; i < warmupIterations; i++) {
+      operation();
+    }
+    if (forceGc2 && isGcAvailable() && global.gc) {
+      global.gc();
+      global.gc();
+      global.gc();
+    }
+    const samples = [];
+    for (let i = 0; i < iterations; i++) {
+      operation();
+      if (forceGc2 && isGcAvailable() && global.gc) {
+        global.gc();
+        global.gc();
+      }
+      samples.push(process.memoryUsage().heapUsed);
+    }
+    return this.analyzeLeakPattern(samples, threshold, intervalSize);
+  }
+  /**
+   * 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);
+   * ```
+   */
+  async detectLeakParallel(operationFactory, options) {
+    const opts = { ...DEFAULT_PARALLEL_OPTIONS, ...options };
+    const { iterations, threshold, warmupIterations, forceGc: forceGc2, workers, intervalSize, clientFactory } = opts;
+    const safeIntervalSize = Math.max(1, intervalSize);
+    if (forceGc2 && !isGcAvailable()) {
+      console.warn("[LeakDetector] Manual GC not available. Run Node.js with --expose-gc for accurate results.");
+    }
+    const clients = [];
+    let workerResults;
+    let globalDurationMs;
+    try {
+      console.log(`[LeakDetector] Creating ${workers} clients sequentially...`);
+      for (let i = 0; i < workers; i++) {
+        console.log(`[LeakDetector] Creating client ${i + 1}/${workers}...`);
+        const client = await clientFactory();
+        clients.push(client);
+      }
+      console.log(`[LeakDetector] All ${workers} clients connected`);
+      const operations = clients.map((client, workerId) => operationFactory(client, workerId));
+      console.log(`[LeakDetector] Running ${warmupIterations} warmup iterations per worker...`);
+      await Promise.all(
+        operations.map(async (operation) => {
+          for (let i = 0; i < warmupIterations; i++) {
+            await operation();
+          }
+        })
+      );
+      if (forceGc2) {
+        await forceFullGc();
+      }
+      console.log(`[LeakDetector] Starting parallel stress test: ${workers} workers \xD7 ${iterations} iterations`);
+      const globalStartTime = Date.now();
+      workerResults = await Promise.all(
+        operations.map(async (operation, workerId) => {
+          const samples = [];
+          const workerStartTime = Date.now();
+          for (let i = 0; i < iterations; i++) {
+            await operation();
+            if (forceGc2 && i > 0 && i % safeIntervalSize === 0) {
+              await forceFullGc(1, 2);
+            }
+            samples.push(process.memoryUsage().heapUsed);
+          }
+          const workerDurationMs = Date.now() - workerStartTime;
+          const requestsPerSecond = iterations / workerDurationMs * 1e3;
+          return {
+            workerId,
+            samples,
+            durationMs: workerDurationMs,
+            requestsPerSecond,
+            iterationsCompleted: iterations
+          };
+        })
+      );
+      globalDurationMs = Date.now() - globalStartTime;
+    } finally {
+      await Promise.all(
+        clients.map(async (client) => {
+          if (client.disconnect) {
+            await client.disconnect();
+          }
+        })
+      );
+    }
+    const allSamples = workerResults.flatMap((w) => w.samples);
+    const totalIterations = workers * iterations;
+    const totalRequestsPerSecond = totalIterations / globalDurationMs * 1e3;
+    const baseResult = this.analyzeLeakPattern(allSamples, threshold, intervalSize, globalDurationMs);
+    const workerSummary = workerResults.map((w) => `  Worker ${w.workerId}: ${w.requestsPerSecond.toFixed(1)} req/s`).join("\n");
+    const parallelMessage = `${baseResult.message}
+
+Parallel execution summary:
+  Workers: ${workers}
+  Total iterations: ${totalIterations}
+  Combined throughput: ${totalRequestsPerSecond.toFixed(1)} req/s
+  Duration: ${(globalDurationMs / 1e3).toFixed(2)}s
+Per-worker throughput:
+${workerSummary}`;
+    return {
+      ...baseResult,
+      message: parallelMessage,
+      workersUsed: workers,
+      totalRequestsPerSecond,
+      perWorkerStats: workerResults,
+      totalIterations,
+      durationMs: globalDurationMs,
+      requestsPerSecond: totalRequestsPerSecond
+    };
+  }
+  /**
+   * Analyze heap samples for leak patterns using linear regression.
+   */
+  analyzeLeakPattern(samples, threshold, intervalSize = 10, durationMs) {
+    if (samples.length < 2) {
+      return {
+        hasLeak: false,
+        leakSizePerIteration: 0,
+        totalGrowth: 0,
+        growthRate: 0,
+        rSquared: 0,
+        samples,
+        message: "Insufficient samples for leak detection",
+        intervals: [],
+        graphData: [],
+        durationMs,
+        requestsPerSecond: 0
+      };
+    }
+    const { slope, rSquared } = linearRegression(samples);
+    const totalGrowth = samples[samples.length - 1] - samples[0];
+    const growthRate = slope;
+    const requestsPerSecond = durationMs && durationMs > 0 ? samples.length / durationMs * 1e3 : 0;
+    const intervals = this.generateIntervals(samples, intervalSize);
+    const graphData = this.generateGraphData(samples);
+    const isSignificantGrowth = totalGrowth > threshold;
+    const isLinearGrowth = rSquared > 0.7;
+    const isHighGrowthRate = growthRate > threshold / samples.length;
+    const hasLeak = isSignificantGrowth && (isLinearGrowth || isHighGrowthRate);
+    const intervalSummary = intervals.map((i) => `  ${i.startIteration}-${i.endIteration}: ${i.deltaFormatted}`).join("\n");
+    const perfStats = durationMs ? `
+Performance: ${samples.length} iterations in ${(durationMs / 1e3).toFixed(2)}s (${requestsPerSecond.toFixed(1)} req/s)` : "";
+    let message;
+    if (hasLeak) {
+      message = `Memory leak detected: ${formatBytes(totalGrowth)} total growth, ${formatBytes(growthRate)}/iteration, R\xB2=${rSquared.toFixed(3)}
+Interval breakdown:
+${intervalSummary}${perfStats}`;
+    } else if (isSignificantGrowth) {
+      message = `Memory growth detected (${formatBytes(totalGrowth)}) but not linear (R\xB2=${rSquared.toFixed(3)}), may be normal allocation
+Interval breakdown:
+${intervalSummary}${perfStats}`;
+    } else {
+      message = `No leak detected: ${formatBytes(totalGrowth)} total, ${formatBytes(growthRate)}/iteration
+Interval breakdown:
+${intervalSummary}${perfStats}`;
+    }
+    return {
+      hasLeak,
+      leakSizePerIteration: hasLeak ? growthRate : 0,
+      totalGrowth,
+      growthRate,
+      rSquared,
+      samples,
+      message,
+      intervals,
+      graphData,
+      durationMs,
+      requestsPerSecond
+    };
+  }
+  /**
+   * Generate interval-based measurements for detailed analysis.
+   */
+  generateIntervals(samples, intervalSize) {
+    const intervals = [];
+    const safeIntervalSize = intervalSize <= 0 ? 1 : intervalSize;
+    const numIntervals = Math.ceil(samples.length / safeIntervalSize);
+    for (let i = 0; i < numIntervals; i++) {
+      const startIdx = i * safeIntervalSize;
+      const endIdx = Math.min((i + 1) * safeIntervalSize - 1, samples.length - 1);
+      if (startIdx >= samples.length) break;
+      const heapAtStart = samples[startIdx];
+      const heapAtEnd = samples[endIdx];
+      const delta = heapAtEnd - heapAtStart;
+      const iterationsInInterval = endIdx - startIdx + 1;
+      const growthRatePerIteration = iterationsInInterval > 1 ? delta / (iterationsInInterval - 1) : 0;
+      intervals.push({
+        startIteration: startIdx,
+        endIteration: endIdx,
+        heapAtStart,
+        heapAtEnd,
+        delta,
+        deltaFormatted: formatBytes(delta),
+        growthRatePerIteration
+      });
+    }
+    return intervals;
+  }
+  /**
+   * Generate graph data points for visualization.
+   */
+  generateGraphData(samples) {
+    if (samples.length === 0) return [];
+    const baselineHeap = samples[0];
+    return samples.map((heapUsed, iteration) => ({
+      iteration,
+      heapUsed,
+      heapUsedFormatted: formatBytes(heapUsed),
+      cumulativeDelta: heapUsed - baselineHeap,
+      cumulativeDeltaFormatted: formatBytes(heapUsed - baselineHeap)
+    }));
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function assertNoLeak(operation, options) {
+  const detector = new LeakDetector();
+  const result = await detector.detectLeak(operation, options);
+  if (result.hasLeak) {
+    throw new Error(`Memory leak detected: ${result.message}`);
+  }
+  return result;
+}
+function createLeakDetector() {
+  return new LeakDetector();
+}
+
+// libs/testing/src/perf/perf-fixtures.ts
+function createPerfFixtures(testName, project) {
+  return new PerfFixturesImpl(testName, project);
+}
+var PerfFixturesImpl = class {
+  constructor(testName, project) {
+    this.testName = testName;
+    this.project = project;
+    this.collector = new MetricsCollector();
+    this.leakDetector = new LeakDetector();
+  }
+  collector;
+  leakDetector;
+  baselineSnapshot = null;
+  startTime = 0;
+  issues = [];
+  leakResults = [];
+  /**
+   * Capture baseline snapshot with GC.
+   */
+  async baseline() {
+    this.startTime = Date.now();
+    this.baselineSnapshot = await this.collector.captureBaseline();
+    return this.baselineSnapshot;
+  }
+  /**
+   * Capture a measurement snapshot.
+   */
+  measure(label) {
+    return this.collector.captureSnapshot(label);
+  }
+  /**
+   * Run leak detection on an operation.
+   */
+  async checkLeak(operation, options) {
+    const result = await this.leakDetector.detectLeak(operation, options);
+    this.leakResults.push(result);
+    if (result.hasLeak) {
+      this.issues.push({
+        type: "memory-leak",
+        severity: "error",
+        message: result.message,
+        metric: "heapUsed",
+        actual: result.totalGrowth,
+        expected: options?.threshold ?? 1024 * 1024
+      });
+    }
+    return result;
+  }
+  /**
+   * 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);
+   * ```
+   */
+  async checkLeakParallel(operationFactory, options) {
+    const result = await this.leakDetector.detectLeakParallel(operationFactory, options);
+    this.leakResults.push(result);
+    if (result.hasLeak) {
+      this.issues.push({
+        type: "memory-leak",
+        severity: "error",
+        message: result.message,
+        metric: "heapUsed",
+        actual: result.totalGrowth,
+        expected: options?.threshold ?? 1024 * 1024
+      });
+    }
+    return result;
+  }
+  /**
+   * Assert that metrics are within thresholds.
+   */
+  assertThresholds(thresholds) {
+    const finalSnapshot = this.collector.captureSnapshot("final");
+    const baseline = this.collector.getBaseline();
+    if (!baseline) {
+      throw new Error("Cannot assert thresholds without baseline. Call baseline() first.");
+    }
+    const duration = Date.now() - this.startTime;
+    const memoryDelta = this.collector.calculateMemoryDelta(finalSnapshot.memory);
+    if (thresholds.maxHeapDelta !== void 0 && memoryDelta) {
+      if (memoryDelta.heapUsed > thresholds.maxHeapDelta) {
+        const issue = {
+          type: "threshold-exceeded",
+          severity: "error",
+          message: `Heap delta ${formatBytes(memoryDelta.heapUsed)} exceeds threshold ${formatBytes(thresholds.maxHeapDelta)}`,
+          metric: "heapUsed",
+          actual: memoryDelta.heapUsed,
+          expected: thresholds.maxHeapDelta
+        };
+        this.issues.push(issue);
+        throw new Error(issue.message);
+      }
+    }
+    if (thresholds.maxDurationMs !== void 0) {
+      if (duration > thresholds.maxDurationMs) {
+        const issue = {
+          type: "threshold-exceeded",
+          severity: "error",
+          message: `Duration ${formatDuration(duration)} exceeds threshold ${formatDuration(thresholds.maxDurationMs)}`,
+          metric: "durationMs",
+          actual: duration,
+          expected: thresholds.maxDurationMs
+        };
+        this.issues.push(issue);
+        throw new Error(issue.message);
+      }
+    }
+    if (thresholds.maxCpuTime !== void 0) {
+      const cpuUsage = this.collector.getCpuUsage();
+      if (cpuUsage.total > thresholds.maxCpuTime) {
+        const issue = {
+          type: "threshold-exceeded",
+          severity: "error",
+          message: `CPU time ${cpuUsage.total}\xB5s exceeds threshold ${thresholds.maxCpuTime}\xB5s`,
+          metric: "cpuTime",
+          actual: cpuUsage.total,
+          expected: thresholds.maxCpuTime
+        };
+        this.issues.push(issue);
+        throw new Error(issue.message);
+      }
+    }
+    if (thresholds.maxRssDelta !== void 0 && memoryDelta) {
+      if (memoryDelta.rss > thresholds.maxRssDelta) {
+        const issue = {
+          type: "threshold-exceeded",
+          severity: "error",
+          message: `RSS delta ${formatBytes(memoryDelta.rss)} exceeds threshold ${formatBytes(thresholds.maxRssDelta)}`,
+          metric: "rss",
+          actual: memoryDelta.rss,
+          expected: thresholds.maxRssDelta
+        };
+        this.issues.push(issue);
+        throw new Error(issue.message);
+      }
+    }
+  }
+  /**
+   * Get all measurements so far.
+   */
+  getMeasurements() {
+    return this.collector.getMeasurements();
+  }
+  /**
+   * Get the current test name.
+   */
+  getTestName() {
+    return this.testName;
+  }
+  /**
+   * Get the project name.
+   */
+  getProject() {
+    return this.project;
+  }
+  /**
+   * Get all detected issues.
+   */
+  getIssues() {
+    return [...this.issues];
+  }
+  /**
+   * Build a complete PerfMeasurement for this test.
+   */
+  buildMeasurement() {
+    const endTime = Date.now();
+    const finalSnapshot = this.collector.captureSnapshot("final");
+    const baseline = this.collector.getBaseline();
+    const memoryDelta = baseline ? this.collector.calculateMemoryDelta(finalSnapshot.memory) : void 0;
+    return {
+      name: this.testName,
+      project: this.project,
+      baseline: baseline ?? finalSnapshot,
+      measurements: this.collector.getMeasurements(),
+      final: finalSnapshot,
+      timing: {
+        startTime: this.startTime || endTime,
+        endTime,
+        durationMs: endTime - (this.startTime || endTime)
+      },
+      memoryDelta: memoryDelta ?? void 0,
+      issues: this.getIssues(),
+      leakDetectionResults: this.leakResults.length > 0 ? this.leakResults : void 0
+    };
+  }
+  /**
+   * Reset the fixture state.
+   */
+  reset() {
+    this.collector.reset();
+    this.baselineSnapshot = null;
+    this.startTime = 0;
+    this.issues = [];
+    this.leakResults = [];
+  }
+};
+var MEASUREMENTS_KEY = "__FRONTMCP_PERF_MEASUREMENTS__";
+function getGlobalMeasurementsArray() {
+  if (!globalThis[MEASUREMENTS_KEY]) {
+    globalThis[MEASUREMENTS_KEY] = [];
+  }
+  return globalThis[MEASUREMENTS_KEY];
+}
+function addGlobalMeasurement(measurement) {
+  getGlobalMeasurementsArray().push(measurement);
+}
+function getGlobalMeasurements() {
+  return [...getGlobalMeasurementsArray()];
+}
+function clearGlobalMeasurements() {
+  const arr = getGlobalMeasurementsArray();
+  arr.length = 0;
+}
+function getMeasurementsForProject(project) {
+  return getGlobalMeasurementsArray().filter((m) => m.project === project);
+}
+
+// libs/testing/src/platform/platform-client-info.ts
+var MCP_APPS_EXTENSION_KEY = "io.modelcontextprotocol/ui";
+function getPlatformClientInfo(platform) {
+  switch (platform) {
+    case "openai":
+      return {
+        name: "ChatGPT",
+        version: "1.0"
+      };
+    case "ext-apps":
+      return {
+        name: "mcp-ext-apps",
+        version: "1.0"
+      };
+    case "claude":
+      return {
+        name: "claude-desktop",
+        version: "1.0"
+      };
+    case "cursor":
+      return {
+        name: "cursor",
+        version: "1.0"
+      };
+    case "continue":
+      return {
+        name: "continue",
+        version: "1.0"
+      };
+    case "cody":
+      return {
+        name: "cody",
+        version: "1.0"
+      };
+    case "gemini":
+      return {
+        name: "gemini",
+        version: "1.0"
+      };
+    case "generic-mcp":
+      return {
+        name: "generic-mcp-client",
+        version: "1.0"
+      };
+    case "unknown":
+    default:
+      return {
+        name: "mcp-test-client",
+        version: "1.0"
+      };
+  }
+}
+function getPlatformCapabilities(platform) {
+  const baseCapabilities = {
+    sampling: {},
+    // Include elicitation.form by default for testing elicitation workflows
+    // Note: MCP SDK expects form to be an object, not boolean
+    elicitation: {
+      form: {}
+    }
+  };
+  if (platform === "ext-apps") {
+    return {
+      ...baseCapabilities,
+      experimental: {
+        [MCP_APPS_EXTENSION_KEY]: {
+          mimeTypes: ["text/html+mcp"]
+        }
+      }
+    };
+  }
+  return baseCapabilities;
+}
+
+// libs/testing/src/client/mcp-test-client.builder.ts
+var McpTestClientBuilder = class {
+  config;
+  constructor(config) {
+    this.config = { ...config };
+  }
+  /**
+   * Set the authentication configuration
+   */
+  withAuth(auth) {
+    this.config.auth = { ...this.config.auth, ...auth };
+    return this;
+  }
+  /**
+   * Set the bearer token for authentication
+   */
+  withToken(token) {
+    this.config.auth = { ...this.config.auth, token };
+    return this;
+  }
+  /**
+   * Add custom headers to all requests
+   */
+  withHeaders(headers) {
+    this.config.auth = {
+      ...this.config.auth,
+      headers: { ...this.config.auth?.headers, ...headers }
+    };
+    return this;
+  }
+  /**
+   * Set the transport type
+   */
+  withTransport(transport) {
+    this.config.transport = transport;
+    return this;
+  }
+  /**
+   * Set the request timeout in milliseconds
+   */
+  withTimeout(timeoutMs) {
+    this.config.timeout = timeoutMs;
+    return this;
+  }
+  /**
+   * Enable debug logging
+   */
+  withDebug(enabled = true) {
+    this.config.debug = enabled;
+    return this;
+  }
+  /**
+   * Enable public mode - skip authentication entirely.
+   * When true, no Authorization header is sent and anonymous token is not requested.
+   * Use this for testing public/unauthenticated endpoints in CI/CD pipelines.
+   */
+  withPublicMode(enabled = true) {
+    this.config.publicMode = enabled;
+    return this;
+  }
+  /**
+   * Set the MCP protocol version to request
+   */
+  withProtocolVersion(version) {
+    this.config.protocolVersion = version;
+    return this;
+  }
+  /**
+   * Set the client info sent during initialization
+   */
+  withClientInfo(info) {
+    this.config.clientInfo = info;
+    return this;
+  }
+  /**
+   * Set the platform type for testing platform-specific meta keys.
+   * Automatically configures clientInfo and capabilities for platform detection.
+   *
+   * Platform-specific behavior:
+   * - `openai`: Uses openai/* meta keys, sets User-Agent to "ChatGPT/1.0"
+   * - `ext-apps`: Uses ui/* meta keys per SEP-1865, sets io.modelcontextprotocol/ui capability
+   * - `claude`: Uses frontmcp/* + ui/* keys, sets User-Agent to "claude-desktop/1.0"
+   * - `cursor`: Uses frontmcp/* + ui/* keys, sets User-Agent to "cursor/1.0"
+   * - Other platforms follow similar patterns
+   *
+   * @example
+   * ```typescript
+   * const client = await McpTestClient.create({ baseUrl })
+   *   .withPlatform('openai')
+   *   .buildAndConnect();
+   *
+   * // ext-apps automatically sets the io.modelcontextprotocol/ui capability
+   * const extAppsClient = await McpTestClient.create({ baseUrl })
+   *   .withPlatform('ext-apps')
+   *   .buildAndConnect();
+   * ```
+   */
+  withPlatform(platform) {
+    this.config.platform = platform;
+    this.config.clientInfo = getPlatformClientInfo(platform);
+    this.config.capabilities = getPlatformCapabilities(platform);
+    return this;
+  }
+  /**
+   * Set custom client capabilities for MCP initialization.
+   * Use this for fine-grained control over capabilities sent during initialization.
+   *
+   * @example
+   * ```typescript
+   * const client = await McpTestClient.create({ baseUrl })
+   *   .withCapabilities({
+   *     sampling: {},
+   *     experimental: {
+   *       'io.modelcontextprotocol/ui': { mimeTypes: ['text/html+mcp'] }
+   *     }
+   *   })
+   *   .buildAndConnect();
+   * ```
+   */
+  withCapabilities(capabilities) {
+    this.config.capabilities = capabilities;
+    return this;
+  }
+  /**
+   * Set query parameters to append to the connection URL.
+   * Useful for testing mode switches like `?mode=skills_only`.
+   *
+   * @example
+   * ```typescript
+   * const client = await McpTestClient.create({ baseUrl })
+   *   .withQueryParams({ mode: 'skills_only' })
+   *   .buildAndConnect();
+   * ```
+   */
+  withQueryParams(params) {
+    this.config.queryParams = { ...this.config.queryParams, ...params };
+    return this;
+  }
+  /**
+   * Build the McpTestClient instance (does not connect)
+   */
+  build() {
+    return new McpTestClient(this.config);
+  }
+  /**
+   * Build the McpTestClient and connect to the server
+   */
+  async buildAndConnect() {
+    const client = this.build();
+    await client.connect();
+    return client;
+  }
+};
+
+// libs/testing/src/transport/streamable-http.transport.ts
+var DEFAULT_TIMEOUT = 3e4;
+var StreamableHttpTransport = class {
+  config;
+  state = "disconnected";
+  sessionId;
+  authToken;
+  connectionCount = 0;
+  reconnectCount = 0;
+  lastRequestHeaders = {};
+  interceptors;
+  publicMode;
+  elicitationHandler;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl.replace(/\/$/, ""),
+      // Remove trailing slash
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      auth: config.auth ?? {},
+      publicMode: config.publicMode ?? false,
+      debug: config.debug ?? false,
+      interceptors: config.interceptors,
+      clientInfo: config.clientInfo
+    };
+    this.authToken = config.auth?.token;
+    this.interceptors = config.interceptors;
+    this.publicMode = config.publicMode ?? false;
+    this.elicitationHandler = config.elicitationHandler;
+  }
+  async connect() {
+    this.state = "connecting";
+    this.connectionCount++;
+    try {
+      if (this.publicMode) {
+        this.log("Public mode: connecting without authentication");
+        this.state = "connected";
+        return;
+      }
+      if (!this.authToken) {
+        await this.requestAnonymousToken();
+      }
+      this.state = "connected";
+      this.log("Connected to StreamableHTTP transport");
+    } catch (error) {
+      this.state = "error";
+      throw error;
+    }
+  }
+  /**
+   * Request an anonymous token from the FrontMCP OAuth endpoint
+   * This allows the test client to authenticate without user interaction
+   */
+  async requestAnonymousToken() {
+    const clientId = crypto.randomUUID();
+    const tokenUrl = `${this.config.baseUrl}/oauth/token`;
+    this.log(`Requesting anonymous token from ${tokenUrl}`);
+    try {
+      const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          grant_type: "anonymous",
+          client_id: clientId,
+          resource: this.config.baseUrl
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.log(`Failed to get anonymous token: ${response.status} ${errorText}`);
+        return;
+      }
+      const tokenResponse = await response.json();
+      if (tokenResponse.access_token) {
+        this.authToken = tokenResponse.access_token;
+        this.log("Anonymous token acquired successfully");
+      }
+    } catch (error) {
+      this.log(`Error requesting anonymous token: ${error}`);
+    }
+  }
+  async request(message) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    if (this.interceptors) {
+      const interceptResult = await this.interceptors.processRequest(message, {
+        timestamp: /* @__PURE__ */ new Date(),
+        transport: "streamable-http",
+        sessionId: this.sessionId
+      });
+      switch (interceptResult.type) {
+        case "mock": {
+          const mockResponse2 = await this.interceptors.processResponse(
+            message,
+            interceptResult.response,
+            Date.now() - startTime
+          );
+          return mockResponse2;
+        }
+        case "error":
+          throw interceptResult.error;
+        case "continue":
+          message = interceptResult.request;
+          break;
+      }
+    }
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    const url = `${this.config.baseUrl}/`;
+    this.log(`POST ${url}`, message);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      const newSessionId = response.headers.get("mcp-session-id");
+      if (newSessionId) {
+        this.sessionId = newSessionId;
+      }
+      let jsonResponse;
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.log(`HTTP Error ${response.status}: ${errorText}`);
+        jsonResponse = {
+          jsonrpc: "2.0",
+          id: message.id ?? null,
+          error: {
+            code: -32e3,
+            message: `HTTP ${response.status}: ${response.statusText}`,
+            data: errorText
+          }
+        };
+      } else {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("text/event-stream")) {
+          jsonResponse = await this.handleSSEResponseWithElicitation(response, message);
+        } else {
+          const text = await response.text();
+          this.log("Response:", text);
+          if (!text.trim()) {
+            jsonResponse = {
+              jsonrpc: "2.0",
+              id: message.id ?? null,
+              result: void 0
+            };
+          } else {
+            jsonResponse = JSON.parse(text);
+          }
+        }
+      }
+      if (this.interceptors) {
+        jsonResponse = await this.interceptors.processResponse(message, jsonResponse, Date.now() - startTime);
+      }
+      clearTimeout(timeoutId);
+      return jsonResponse;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        return {
+          jsonrpc: "2.0",
+          id: message.id ?? null,
+          error: {
+            code: -32e3,
+            message: `Request timeout after ${this.config.timeout}ms`
+          }
+        };
+      }
+      throw error;
+    }
+  }
+  async notify(message) {
+    this.ensureConnected();
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    const url = `${this.config.baseUrl}/`;
+    this.log(`POST ${url} (notification)`, message);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const newSessionId = response.headers.get("mcp-session-id");
+      if (newSessionId) {
+        this.sessionId = newSessionId;
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.log(`HTTP Error ${response.status} on notification: ${errorText}`);
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name !== "AbortError") {
+        throw error;
+      }
+    }
+  }
+  async sendRaw(data) {
+    this.ensureConnected();
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    const url = `${this.config.baseUrl}/`;
+    this.log(`POST ${url} (raw)`, data);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: data,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const text = await response.text();
+      if (!text.trim()) {
+        return {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32700,
+            message: "Parse error"
+          }
+        };
+      }
+      return JSON.parse(text);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      return {
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32700,
+          message: "Parse error",
+          data: error instanceof Error ? error.message : "Unknown error"
+        }
+      };
+    }
+  }
+  async close() {
+    this.state = "disconnected";
+    this.sessionId = void 0;
+    this.log("StreamableHTTP transport closed");
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  getState() {
+    return this.state;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  setTimeout(ms) {
+    this.config.timeout = ms;
+  }
+  setInterceptors(interceptors2) {
+    this.interceptors = interceptors2;
+  }
+  getInterceptors() {
+    return this.interceptors;
+  }
+  setElicitationHandler(handler) {
+    this.elicitationHandler = handler;
+  }
+  getConnectionCount() {
+    return this.connectionCount;
+  }
+  getReconnectCount() {
+    return this.reconnectCount;
+  }
+  getLastRequestHeaders() {
+    return { ...this.lastRequestHeaders };
+  }
+  async simulateDisconnect() {
+    this.state = "disconnected";
+    this.sessionId = void 0;
+  }
+  async waitForReconnect(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    this.reconnectCount++;
+    await this.connect();
+    while (Date.now() < deadline) {
+      if (this.state === "connected") {
+        return;
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    throw new Error("Timeout waiting for reconnection");
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE HELPERS
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * Handle SSE response with elicitation support.
+   *
+   * Streams the SSE response, detects elicitation/create requests, and handles them
+   * by calling the registered handler and sending the response back to the server.
+   */
+  async handleSSEResponseWithElicitation(response, originalRequest) {
+    this.log("handleSSEResponseWithElicitation: starting", { requestId: originalRequest.id });
+    const reader = response.body?.getReader();
+    if (!reader) {
+      this.log("handleSSEResponseWithElicitation: no response body");
+      return {
+        jsonrpc: "2.0",
+        id: originalRequest.id ?? null,
+        error: { code: -32e3, message: "No response body" }
+      };
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let finalResponse = null;
+    let sseSessionId;
+    try {
+      let readCount = 0;
+      while (true) {
+        readCount++;
+        this.log(`handleSSEResponseWithElicitation: reading chunk ${readCount}`);
+        const { done, value } = await reader.read();
+        this.log(`handleSSEResponseWithElicitation: read result`, { done, valueLength: value?.length });
+        if (done) {
+          if (buffer.trim()) {
+            const parsed = this.parseSSEEvents(buffer, originalRequest.id);
+            for (const event of parsed.events) {
+              const handled = await this.handleSSEEvent(event);
+              if (handled.isFinal) {
+                finalResponse = handled.response;
+              }
+            }
+            if (parsed.sessionId && !sseSessionId) {
+              sseSessionId = parsed.sessionId;
+            }
+          }
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const eventEndPattern = /\n\n/g;
+        let lastEventEnd = 0;
+        let match;
+        while ((match = eventEndPattern.exec(buffer)) !== null) {
+          const eventText = buffer.slice(lastEventEnd, match.index);
+          lastEventEnd = match.index + 2;
+          if (eventText.trim()) {
+            const parsed = this.parseSSEEvents(eventText, originalRequest.id);
+            for (const event of parsed.events) {
+              const handled = await this.handleSSEEvent(event);
+              if (handled.isFinal) {
+                finalResponse = handled.response;
+              }
+            }
+            if (parsed.sessionId && !sseSessionId) {
+              sseSessionId = parsed.sessionId;
+            }
+          }
+        }
+        buffer = buffer.slice(lastEventEnd);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (sseSessionId && !this.sessionId) {
+      this.sessionId = sseSessionId;
+      this.log("Session ID from SSE:", this.sessionId);
+    }
+    if (finalResponse) {
+      return finalResponse;
+    }
+    return {
+      jsonrpc: "2.0",
+      id: originalRequest.id ?? null,
+      error: { code: -32e3, message: "No final response received in SSE stream" }
+    };
+  }
+  /**
+   * Parse SSE event text into structured events
+   */
+  parseSSEEvents(text, _requestId) {
+    const lines = text.split("\n");
+    const events = [];
+    let currentEvent = { type: "message", data: [] };
+    let sessionId;
+    for (const line of lines) {
+      if (line.startsWith("event: ")) {
+        currentEvent.type = line.slice(7);
+      } else if (line.startsWith("data: ")) {
+        currentEvent.data.push(line.slice(6));
+      } else if (line === "data:") {
+        currentEvent.data.push("");
+      } else if (line.startsWith("id: ")) {
+        const idValue = line.slice(4);
+        currentEvent.id = idValue;
+        const colonIndex = idValue.lastIndexOf(":");
+        if (colonIndex > 0) {
+          sessionId = idValue.substring(0, colonIndex);
+        } else {
+          sessionId = idValue;
+        }
+      } else if (line === "" && currentEvent.data.length > 0) {
+        events.push({
+          type: currentEvent.type,
+          data: currentEvent.data.join("\n"),
+          id: currentEvent.id
+        });
+        currentEvent = { type: "message", data: [] };
+      }
+    }
+    if (currentEvent.data.length > 0) {
+      events.push({
+        type: currentEvent.type,
+        data: currentEvent.data.join("\n"),
+        id: currentEvent.id
+      });
+    }
+    return { events, sessionId };
+  }
+  /**
+   * Handle a single SSE event, including elicitation requests
+   */
+  async handleSSEEvent(event) {
+    this.log("SSE Event:", { type: event.type, data: event.data.slice(0, 200) });
+    try {
+      const parsed = JSON.parse(event.data);
+      if ("method" in parsed && parsed.method === "elicitation/create") {
+        await this.handleElicitationRequest(parsed);
+        return {
+          isFinal: false,
+          response: { jsonrpc: "2.0", id: null, result: void 0 }
+        };
+      }
+      if ("result" in parsed || "error" in parsed) {
+        return { isFinal: true, response: parsed };
+      }
+      return {
+        isFinal: false,
+        response: { jsonrpc: "2.0", id: null, result: void 0 }
+      };
+    } catch {
+      this.log("Failed to parse SSE event data:", event.data);
+      return {
+        isFinal: false,
+        response: { jsonrpc: "2.0", id: null, result: void 0 }
+      };
+    }
+  }
+  /**
+   * Handle an elicitation/create request from the server
+   */
+  async handleElicitationRequest(request) {
+    const params = request.params;
+    this.log("Elicitation request received:", {
+      mode: params?.mode,
+      message: params?.message?.slice(0, 100)
+    });
+    const requestId = request.id;
+    if (requestId === void 0 || requestId === null) {
+      this.log("Elicitation request has no ID, cannot respond");
+      return;
+    }
+    if (!this.elicitationHandler) {
+      this.log("No elicitation handler registered, sending error");
+      await this.sendElicitationResponse(requestId, {
+        action: "decline"
+      });
+      return;
+    }
+    try {
+      const response = await this.elicitationHandler(params);
+      this.log("Elicitation handler response:", response);
+      await this.sendElicitationResponse(requestId, response);
+    } catch (error) {
+      this.log("Elicitation handler error:", error);
+      await this.sendElicitationResponse(requestId, {
+        action: "cancel"
+      });
+    }
+  }
+  /**
+   * Send an elicitation response back to the server
+   */
+  async sendElicitationResponse(requestId, response) {
+    const headers = this.buildHeaders();
+    const url = `${this.config.baseUrl}/`;
+    const rpcResponse = {
+      jsonrpc: "2.0",
+      id: requestId,
+      result: response
+    };
+    this.log("Sending elicitation response:", rpcResponse);
+    try {
+      const fetchResponse = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(rpcResponse)
+      });
+      if (!fetchResponse.ok) {
+        this.log(`Elicitation response HTTP error: ${fetchResponse.status}`);
+      }
+    } catch (error) {
+      this.log("Failed to send elicitation response:", error);
+    }
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream"
+    };
+    if (this.config.clientInfo) {
+      headers["User-Agent"] = `${this.config.clientInfo.name}/${this.config.clientInfo.version}`;
+    }
+    if (this.authToken && !this.publicMode) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    if (this.config.auth.headers) {
+      Object.assign(headers, this.config.auth.headers);
+    }
+    return headers;
+  }
+  ensureConnected() {
+    if (this.state !== "connected") {
+      throw new Error("Transport not connected. Call connect() first.");
+    }
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.log(`[StreamableHTTP] ${message}`, data ?? "");
+    }
+  }
+  /**
+   * Parse SSE (Server-Sent Events) response format with session ID extraction
+   * SSE format is:
+   * event: message
+   * id: sessionId:messageId
+   * data: {"jsonrpc":"2.0",...}
+   *
+   * The id field contains the session ID followed by a colon and the message ID.
+   *
+   * @param text - The raw SSE response text
+   * @param requestId - The original request ID
+   * @returns Object with parsed JSON-RPC response and session ID (if found)
+   */
+  parseSSEResponseWithSession(text, requestId) {
+    const lines = text.split("\n");
+    const dataLines = [];
+    let sseSessionId;
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        dataLines.push(line.slice(6));
+      } else if (line === "data:") {
+        dataLines.push("");
+      } else if (line.startsWith("id: ")) {
+        const idValue = line.slice(4);
+        const colonIndex = idValue.lastIndexOf(":");
+        if (colonIndex > 0) {
+          sseSessionId = idValue.substring(0, colonIndex);
+        } else {
+          sseSessionId = idValue;
+        }
+      }
+    }
+    if (dataLines.length > 0) {
+      const jsonData = dataLines.join("\n");
+      try {
+        return {
+          response: JSON.parse(jsonData),
+          sseSessionId
+        };
+      } catch {
+        this.log("Failed to parse SSE data as JSON:", jsonData);
+      }
+    }
+    return {
+      response: {
+        jsonrpc: "2.0",
+        id: requestId ?? null,
+        error: {
+          code: -32700,
+          message: "Failed to parse SSE response",
+          data: text
+        }
+      },
+      sseSessionId
+    };
+  }
+};
+
+// libs/testing/src/interceptor/mock-registry.ts
+var DefaultMockRegistry = class {
+  mocks = [];
+  add(mock) {
+    const entry = {
+      definition: mock,
+      callCount: 0,
+      calls: [],
+      remainingUses: mock.times ?? Infinity
+    };
+    this.mocks.push(entry);
+    return {
+      remove: () => {
+        const index = this.mocks.indexOf(entry);
+        if (index !== -1) {
+          this.mocks.splice(index, 1);
+        }
+      },
+      callCount: () => entry.callCount,
+      calls: () => [...entry.calls]
+    };
+  }
+  clear() {
+    this.mocks = [];
+  }
+  getAll() {
+    return this.mocks.map((e) => e.definition);
+  }
+  match(request) {
+    for (const entry of this.mocks) {
+      if (entry.remainingUses <= 0) continue;
+      const { definition } = entry;
+      if (definition.method !== request.method) continue;
+      if (definition.params !== void 0) {
+        const params = request.params ?? {};
+        if (typeof definition.params === "function") {
+          if (!definition.params(params)) continue;
+        } else {
+          if (!this.paramsMatch(definition.params, params)) continue;
+        }
+      }
+      entry.callCount++;
+      entry.calls.push(request);
+      entry.remainingUses--;
+      return definition;
+    }
+    return void 0;
+  }
+  /**
+   * Check if request params match the mock params definition
+   */
+  paramsMatch(expected, actual) {
+    for (const [key, value] of Object.entries(expected)) {
+      if (!(key in actual)) return false;
+      const actualValue = actual[key];
+      if (Array.isArray(value)) {
+        if (!Array.isArray(actualValue)) return false;
+        if (value.length !== actualValue.length) return false;
+        for (let i = 0; i < value.length; i++) {
+          const expectedItem = value[i];
+          const actualItem = actualValue[i];
+          if (typeof expectedItem === "object" && expectedItem !== null) {
+            if (typeof actualItem !== "object" || actualItem === null) return false;
+            if (!this.paramsMatch(expectedItem, actualItem)) {
+              return false;
+            }
+          } else if (actualItem !== expectedItem) {
+            return false;
+          }
+        }
+      } else if (typeof value === "object" && value !== null) {
+        if (typeof actualValue !== "object" || actualValue === null) return false;
+        if (!this.paramsMatch(value, actualValue)) {
+          return false;
+        }
+      } else if (actualValue !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+var mockResponse = {
+  /**
+   * Create a successful JSON-RPC response
+   */
+  success(result, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result
+    };
+  },
+  /**
+   * Create an error JSON-RPC response
+   */
+  error(code, message, data, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: { code, message, data }
+    };
+  },
+  /**
+   * Create a tool result response
+   */
+  toolResult(content, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { content }
+    };
+  },
+  /**
+   * Create a tools/list response
+   */
+  toolsList(tools, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { tools }
+    };
+  },
+  /**
+   * Create a resources/list response
+   */
+  resourcesList(resources, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { resources }
+    };
+  },
+  /**
+   * Create a resources/read response
+   */
+  resourceRead(contents, id = 1) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { contents }
+    };
+  },
+  /**
+   * Common MCP errors
+   */
+  errors: {
+    methodNotFound: (method, id = 1) => mockResponse.error(-32601, `Method not found: ${method}`, void 0, id),
+    invalidParams: (message, id = 1) => mockResponse.error(-32602, message, void 0, id),
+    internalError: (message, id = 1) => mockResponse.error(-32603, message, void 0, id),
+    resourceNotFound: (uri, id = 1) => mockResponse.error(-32002, `Resource not found: ${uri}`, { uri }, id),
+    toolNotFound: (name, id = 1) => mockResponse.error(-32601, `Tool not found: ${name}`, { name }, id),
+    unauthorized: (id = 1) => mockResponse.error(-32001, "Unauthorized", void 0, id),
+    forbidden: (id = 1) => mockResponse.error(-32003, "Forbidden", void 0, id)
+  }
+};
+
+// libs/testing/src/interceptor/interceptor-chain.ts
+var DefaultInterceptorChain = class {
+  request = [];
+  response = [];
+  mocks;
+  constructor() {
+    this.mocks = new DefaultMockRegistry();
+  }
+  /**
+   * Add a request interceptor
+   */
+  addRequestInterceptor(interceptor) {
+    this.request.push(interceptor);
+    return () => {
+      const index = this.request.indexOf(interceptor);
+      if (index !== -1) {
+        this.request.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Add a response interceptor
+   */
+  addResponseInterceptor(interceptor) {
+    this.response.push(interceptor);
+    return () => {
+      const index = this.response.indexOf(interceptor);
+      if (index !== -1) {
+        this.response.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Process a request through the interceptor chain
+   * Returns either:
+   * - { type: 'continue', request } - continue with (possibly modified) request
+   * - { type: 'mock', response } - return mock response immediately
+   * - { type: 'error', error } - throw error
+   */
+  async processRequest(request, meta) {
+    let currentRequest = request;
+    const mockDef = this.mocks.match(request);
+    if (mockDef) {
+      if (mockDef.delay && mockDef.delay > 0) {
+        await sleep3(mockDef.delay);
+      }
+      let mockResponse2;
+      if (typeof mockDef.response === "function") {
+        mockResponse2 = await mockDef.response(request);
+      } else {
+        mockResponse2 = mockDef.response;
+      }
+      return {
+        type: "mock",
+        response: { ...mockResponse2, id: request.id ?? mockResponse2.id }
+      };
+    }
+    for (const interceptor of this.request) {
+      const ctx = {
+        request: currentRequest,
+        meta
+      };
+      const result = await interceptor(ctx);
+      switch (result.action) {
+        case "passthrough":
+          break;
+        case "modify":
+          currentRequest = result.request;
+          break;
+        case "mock":
+          return {
+            type: "mock",
+            response: { ...result.response, id: request.id ?? result.response.id }
+          };
+        case "error":
+          return { type: "error", error: result.error };
+      }
+    }
+    return { type: "continue", request: currentRequest };
+  }
+  /**
+   * Process a response through the interceptor chain
+   */
+  async processResponse(request, response, durationMs) {
+    let currentResponse = response;
+    for (const interceptor of this.response) {
+      const ctx = {
+        request,
+        response: currentResponse,
+        durationMs
+      };
+      const result = await interceptor(ctx);
+      switch (result.action) {
+        case "passthrough":
+          break;
+        case "modify":
+          currentResponse = result.response;
+          break;
+      }
+    }
+    return currentResponse;
+  }
+  /**
+   * Clear all interceptors and mocks
+   */
+  clear() {
+    this.request = [];
+    this.response = [];
+    this.mocks.clear();
+  }
+};
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// libs/testing/src/client/mcp-test-client.ts
+var DEFAULT_TIMEOUT2 = 3e4;
+var DEFAULT_PROTOCOL_VERSION = "2025-06-18";
+var DEFAULT_CLIENT_INFO = {
+  name: "@frontmcp/testing",
+  version: "0.4.0"
+};
+var McpTestClient = class {
+  // Platform, capabilities, and queryParams are optional - only set when needed
+  config;
+  transport = null;
+  initResult = null;
+  requestIdCounter = 0;
+  _lastRequestId = 0;
+  _sessionId;
+  _sessionInfo = null;
+  _authState = { isAnonymous: true, scopes: [] };
+  // Logging and tracing
+  _logs = [];
+  _traces = [];
+  _notifications = [];
+  _progressUpdates = [];
+  // Interceptor chain
+  _interceptors;
+  // Elicitation handler for server→client elicit requests
+  _elicitationHandler;
+  // ═══════════════════════════════════════════════════════════════════
+  // CONSTRUCTOR & FACTORY
+  // ═══════════════════════════════════════════════════════════════════
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      transport: config.transport ?? "streamable-http",
+      auth: config.auth ?? {},
+      publicMode: config.publicMode ?? false,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT2,
+      debug: config.debug ?? false,
+      protocolVersion: config.protocolVersion ?? DEFAULT_PROTOCOL_VERSION,
+      clientInfo: config.clientInfo ?? DEFAULT_CLIENT_INFO,
+      platform: config.platform,
+      capabilities: config.capabilities,
+      queryParams: config.queryParams
+    };
+    if (config.auth?.token) {
+      this._authState = {
+        isAnonymous: false,
+        token: config.auth.token,
+        scopes: this.parseScopesFromToken(config.auth.token),
+        user: this.parseUserFromToken(config.auth.token)
+      };
+    }
+    this._interceptors = new DefaultInterceptorChain();
+  }
+  /**
+   * Create a new McpTestClientBuilder for fluent configuration
+   */
+  static create(config) {
+    return new McpTestClientBuilder(config);
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // CONNECTION & LIFECYCLE
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * Connect to the MCP server and perform initialization
+   */
+  async connect() {
+    this.log("debug", `Connecting to ${this.config.baseUrl}...`);
+    this.transport = this.createTransport();
+    await this.transport.connect();
+    const initResponse = await this.initialize();
+    if (!initResponse.success || !initResponse.data) {
+      throw new Error(`Failed to initialize MCP connection: ${initResponse.error?.message ?? "Unknown error"}`);
+    }
+    this.initResult = initResponse.data;
+    this._sessionId = this.transport.getSessionId();
+    this._sessionInfo = {
+      id: this._sessionId ?? `session-${Date.now()}`,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastActivityAt: /* @__PURE__ */ new Date(),
+      requestCount: 1
+    };
+    await this.transport.notify({
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    });
+    this.log("info", `Connected to ${this.initResult.serverInfo?.name ?? "MCP Server"}`);
+    return this.initResult;
+  }
+  /**
+   * Disconnect from the MCP server
+   */
+  async disconnect() {
+    if (this.transport) {
+      await this.transport.close();
+      this.transport = null;
+    }
+    this.initResult = null;
+    this.log("info", "Disconnected from MCP server");
+  }
+  /**
+   * Reconnect to the server, optionally with an existing session ID
+   */
+  async reconnect(options) {
+    await this.disconnect();
+    if (options?.sessionId && this.transport) {
+      this._sessionId = options.sessionId;
+    }
+    await this.connect();
+  }
+  /**
+   * Check if the client is currently connected
+   */
+  isConnected() {
+    return this.transport?.isConnected() ?? false;
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // SESSION & AUTH PROPERTIES
+  // ═══════════════════════════════════════════════════════════════════
+  get sessionId() {
+    return this._sessionId ?? "";
+  }
+  get session() {
+    const info = this._sessionInfo ?? {
+      id: "",
+      createdAt: /* @__PURE__ */ new Date(),
+      lastActivityAt: /* @__PURE__ */ new Date(),
+      requestCount: 0
+    };
+    return {
+      ...info,
+      expire: async () => {
+        this._sessionId = void 0;
+        this._sessionInfo = null;
+      }
+    };
+  }
+  get auth() {
+    return this._authState;
+  }
+  /**
+   * Authenticate with a token
+   */
+  async authenticate(token) {
+    this._authState = {
+      isAnonymous: false,
+      token,
+      scopes: this.parseScopesFromToken(token),
+      user: this.parseUserFromToken(token)
+    };
+    if (this.transport) {
+      this.transport.setAuthToken(token);
+    }
+    this.log("debug", "Authentication updated");
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // SERVER INFO & CAPABILITIES
+  // ═══════════════════════════════════════════════════════════════════
+  get serverInfo() {
+    return {
+      name: this.initResult?.serverInfo?.name ?? "",
+      version: this.initResult?.serverInfo?.version ?? ""
+    };
+  }
+  get protocolVersion() {
+    return this.initResult?.protocolVersion ?? "";
+  }
+  get instructions() {
+    return this.initResult?.instructions ?? "";
+  }
+  get capabilities() {
+    return this.initResult?.capabilities ?? {};
+  }
+  /**
+   * Check if server has a specific capability
+   */
+  hasCapability(name) {
+    return !!this.capabilities[name];
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // TOOLS API
+  // ═══════════════════════════════════════════════════════════════════
+  tools = {
+    /**
+     * List all available tools
+     */
+    list: async () => {
+      const response = await this.listTools();
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list tools: ${response.error?.message}`);
+      }
+      return response.data.tools;
+    },
+    /**
+     * Call a tool by name with arguments
+     */
+    call: async (name, args) => {
+      const response = await this.callTool(name, args);
+      return this.wrapToolResult(response);
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // RESOURCES API
+  // ═══════════════════════════════════════════════════════════════════
+  resources = {
+    /**
+     * List all static resources
+     */
+    list: async () => {
+      const response = await this.listResources();
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list resources: ${response.error?.message}`);
+      }
+      return response.data.resources;
+    },
+    /**
+     * List all resource templates
+     */
+    listTemplates: async () => {
+      const response = await this.listResourceTemplates();
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list resource templates: ${response.error?.message}`);
+      }
+      return response.data.resourceTemplates;
+    },
+    /**
+     * Read a resource by URI
+     */
+    read: async (uri) => {
+      const response = await this.readResource(uri);
+      return this.wrapResourceContent(response);
+    },
+    /**
+     * Subscribe to resource changes (placeholder for future implementation)
+     */
+    subscribe: async (_uri) => {
+      this.log("warn", "Resource subscription not yet implemented");
+    },
+    /**
+     * Unsubscribe from resource changes (placeholder for future implementation)
+     */
+    unsubscribe: async (_uri) => {
+      this.log("warn", "Resource unsubscription not yet implemented");
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // PROMPTS API
+  // ═══════════════════════════════════════════════════════════════════
+  prompts = {
+    /**
+     * List all available prompts
+     */
+    list: async () => {
+      const response = await this.listPrompts();
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list prompts: ${response.error?.message}`);
+      }
+      return response.data.prompts;
+    },
+    /**
+     * Get a prompt with arguments
+     */
+    get: async (name, args) => {
+      const response = await this.getPrompt(name, args);
+      return this.wrapPromptResult(response);
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // RAW PROTOCOL ACCESS
+  // ═══════════════════════════════════════════════════════════════════
+  raw = {
+    /**
+     * Send any JSON-RPC request
+     */
+    request: async (message) => {
+      const transport = this.getConnectedTransport();
+      const start = Date.now();
+      const response = await transport.request(message);
+      this.traceRequest(message.method, message.params, message.id, response, Date.now() - start);
+      return response;
+    },
+    /**
+     * Send a notification (no response expected)
+     */
+    notify: async (message) => {
+      const transport = this.getConnectedTransport();
+      await transport.notify(message);
+    },
+    /**
+     * Send raw string data (for error testing)
+     */
+    sendRaw: async (data) => {
+      const transport = this.getConnectedTransport();
+      return transport.sendRaw(data);
+    }
+  };
+  get lastRequestId() {
+    return this._lastRequestId;
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // TRANSPORT INFO
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * Get transport information and utilities
+   */
+  get transport_info() {
+    return {
+      type: this.config.transport,
+      isConnected: () => this.transport?.isConnected() ?? false,
+      messageEndpoint: this.transport?.getMessageEndpoint?.(),
+      connectionCount: this.transport?.getConnectionCount?.() ?? 0,
+      reconnectCount: this.transport?.getReconnectCount?.() ?? 0,
+      lastRequestHeaders: this.transport?.getLastRequestHeaders?.() ?? {},
+      simulateDisconnect: async () => {
+        await this.transport?.simulateDisconnect?.();
+      },
+      waitForReconnect: async (timeoutMs) => {
+        await this.transport?.waitForReconnect?.(timeoutMs);
+      }
+    };
+  }
+  // Alias for transport info
+  get transport_() {
+    return this.transport_info;
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // NOTIFICATIONS
+  // ═══════════════════════════════════════════════════════════════════
+  notifications = {
+    /**
+     * Start collecting server notifications
+     */
+    collect: () => {
+      return new NotificationCollector(this._notifications);
+    },
+    /**
+     * Collect progress notifications specifically
+     */
+    collectProgress: () => {
+      return new ProgressCollector(this._progressUpdates);
+    },
+    /**
+     * Send a notification to the server
+     */
+    send: async (method, params) => {
+      await this.raw.notify({ jsonrpc: "2.0", method, params });
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // ELICITATION
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * Register a handler for elicitation requests from the server.
+   *
+   * When a tool calls `this.elicit()` during execution, the server sends an
+   * `elicitation/create` request to the client. This handler is called to
+   * provide the response that would normally come from user interaction.
+   *
+   * @param handler - Function that receives the elicitation request and returns a response
+   *
+   * @example
+   * ```typescript
+   * // Simple acceptance
+   * mcp.onElicitation(async () => ({
+   *   action: 'accept',
+   *   content: { confirmed: true }
+   * }));
+   *
+   * // Conditional response based on request
+   * mcp.onElicitation(async (request) => {
+   *   if (request.message.includes('delete')) {
+   *     return { action: 'decline' };
+   *   }
+   *   return { action: 'accept', content: { approved: true } };
+   * });
+   *
+   * // Multi-step wizard
+   * let step = 0;
+   * mcp.onElicitation(async () => {
+   *   step++;
+   *   if (step === 1) return { action: 'accept', content: { name: 'Alice' } };
+   *   return { action: 'accept', content: { color: 'blue' } };
+   * });
+   * ```
+   */
+  onElicitation(handler) {
+    this._elicitationHandler = handler;
+    if (this.transport?.setElicitationHandler) {
+      this.transport.setElicitationHandler(handler);
+    }
+    this.log("debug", "Elicitation handler registered");
+  }
+  /**
+   * Clear the elicitation handler.
+   *
+   * After calling this, elicitation requests from the server will not be
+   * handled automatically. This can be used to test timeout scenarios.
+   */
+  clearElicitationHandler() {
+    this._elicitationHandler = void 0;
+    if (this.transport?.setElicitationHandler) {
+      this.transport.setElicitationHandler(void 0);
+    }
+    this.log("debug", "Elicitation handler cleared");
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // LOGGING & DEBUGGING
+  // ═══════════════════════════════════════════════════════════════════
+  logs = {
+    all: () => [...this._logs],
+    filter: (level) => this._logs.filter((l) => l.level === level),
+    search: (text) => this._logs.filter((l) => l.message.includes(text)),
+    last: () => this._logs[this._logs.length - 1],
+    clear: () => {
+      this._logs = [];
+    }
+  };
+  trace = {
+    all: () => [...this._traces],
+    last: () => this._traces[this._traces.length - 1],
+    clear: () => {
+      this._traces = [];
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // MOCKING & INTERCEPTION
+  // ═══════════════════════════════════════════════════════════════════
+  /**
+   * API for mocking MCP requests
+   *
+   * @example
+   * ```typescript
+   * // Mock a specific tool call
+   * const handle = mcp.mock.tool('my-tool', { result: 'mocked!' });
+   *
+   * // Mock with params matching
+   * mcp.mock.add({
+   *   method: 'tools/call',
+   *   params: { name: 'my-tool' },
+   *   response: mockResponse.toolResult([{ type: 'text', text: 'mocked' }]),
+   * });
+   *
+   * // Clear all mocks after test
+   * mcp.mock.clear();
+   * ```
+   */
+  mock = {
+    /**
+     * Add a mock definition
+     */
+    add: (mock) => {
+      return this._interceptors.mocks.add(mock);
+    },
+    /**
+     * Mock a tools/call request for a specific tool
+     */
+    tool: (name, result, options) => {
+      return this._interceptors.mocks.add({
+        method: "tools/call",
+        params: { name },
+        response: mockResponse.toolResult([
+          { type: "text", text: typeof result === "string" ? result : JSON.stringify(result) }
+        ]),
+        times: options?.times,
+        delay: options?.delay
+      });
+    },
+    /**
+     * Mock a tools/call request to return an error
+     */
+    toolError: (name, code, message, options) => {
+      return this._interceptors.mocks.add({
+        method: "tools/call",
+        params: { name },
+        response: mockResponse.error(code, message),
+        times: options?.times
+      });
+    },
+    /**
+     * Mock a resources/read request
+     */
+    resource: (uri, content, options) => {
+      const contentObj = typeof content === "string" ? { uri, text: content } : { uri, ...content };
+      return this._interceptors.mocks.add({
+        method: "resources/read",
+        params: { uri },
+        response: mockResponse.resourceRead([contentObj]),
+        times: options?.times,
+        delay: options?.delay
+      });
+    },
+    /**
+     * Mock a resources/read request to return an error
+     */
+    resourceError: (uri, options) => {
+      return this._interceptors.mocks.add({
+        method: "resources/read",
+        params: { uri },
+        response: mockResponse.errors.resourceNotFound(uri),
+        times: options?.times
+      });
+    },
+    /**
+     * Mock the tools/list response
+     */
+    toolsList: (tools, options) => {
+      return this._interceptors.mocks.add({
+        method: "tools/list",
+        response: mockResponse.toolsList(tools),
+        times: options?.times
+      });
+    },
+    /**
+     * Mock the resources/list response
+     */
+    resourcesList: (resources, options) => {
+      return this._interceptors.mocks.add({
+        method: "resources/list",
+        response: mockResponse.resourcesList(resources),
+        times: options?.times
+      });
+    },
+    /**
+     * Clear all mocks
+     */
+    clear: () => {
+      this._interceptors.mocks.clear();
+    },
+    /**
+     * Get all active mocks
+     */
+    all: () => {
+      return this._interceptors.mocks.getAll();
+    }
+  };
+  /**
+   * API for intercepting requests and responses
+   *
+   * @example
+   * ```typescript
+   * // Log all requests
+   * const remove = mcp.intercept.request((ctx) => {
+   *   console.log('Request:', ctx.request.method);
+   *   return { action: 'passthrough' };
+   * });
+   *
+   * // Modify requests
+   * mcp.intercept.request((ctx) => {
+   *   if (ctx.request.method === 'tools/call') {
+   *     return {
+   *       action: 'modify',
+   *       request: { ...ctx.request, params: { ...ctx.request.params, extra: true } },
+   *     };
+   *   }
+   *   return { action: 'passthrough' };
+   * });
+   *
+   * // Add latency to all requests
+   * mcp.intercept.delay(100);
+   *
+   * // Clean up
+   * remove();
+   * mcp.intercept.clear();
+   * ```
+   */
+  intercept = {
+    /**
+     * Add a request interceptor
+     * @returns Function to remove the interceptor
+     */
+    request: (interceptor) => {
+      return this._interceptors.addRequestInterceptor(interceptor);
+    },
+    /**
+     * Add a response interceptor
+     * @returns Function to remove the interceptor
+     */
+    response: (interceptor) => {
+      return this._interceptors.addResponseInterceptor(interceptor);
+    },
+    /**
+     * Add latency to all requests
+     * @returns Function to remove the interceptor
+     */
+    delay: (ms) => {
+      return this._interceptors.addRequestInterceptor(async () => {
+        await new Promise((r) => setTimeout(r, ms));
+        return { action: "passthrough" };
+      });
+    },
+    /**
+     * Fail requests matching a method
+     * @returns Function to remove the interceptor
+     */
+    failMethod: (method, error) => {
+      return this._interceptors.addRequestInterceptor((ctx) => {
+        if (ctx.request.method === method) {
+          return { action: "error", error: new Error(error ?? `Intercepted: ${method}`) };
+        }
+        return { action: "passthrough" };
+      });
+    },
+    /**
+     * Clear all interceptors (but not mocks)
+     */
+    clear: () => {
+      this._interceptors.request = [];
+      this._interceptors.response = [];
+    },
+    /**
+     * Clear everything (interceptors and mocks)
+     */
+    clearAll: () => {
+      this._interceptors.clear();
+    }
+  };
+  // ═══════════════════════════════════════════════════════════════════
+  // TIMEOUT
+  // ═══════════════════════════════════════════════════════════════════
+  setTimeout(ms) {
+    this.config.timeout = ms;
+    if (this.transport) {
+      this.transport.setTimeout(ms);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: MCP OPERATIONS
+  // ═══════════════════════════════════════════════════════════════════
+  async initialize() {
+    const capabilities = this.config.capabilities ?? {
+      sampling: {},
+      elicitation: {
+        form: {}
+      }
+    };
+    return this.request("initialize", {
+      protocolVersion: this.config.protocolVersion,
+      capabilities,
+      clientInfo: this.config.clientInfo
+    });
+  }
+  async listTools() {
+    return this.request("tools/list", {});
+  }
+  async callTool(name, args) {
+    return this.request("tools/call", {
+      name,
+      arguments: args ?? {}
+    });
+  }
+  async listResources() {
+    return this.request("resources/list", {});
+  }
+  async listResourceTemplates() {
+    return this.request("resources/templates/list", {});
+  }
+  async readResource(uri) {
+    return this.request("resources/read", { uri });
+  }
+  async listPrompts() {
+    return this.request("prompts/list", {});
+  }
+  async getPrompt(name, args) {
+    return this.request("prompts/get", {
+      name,
+      arguments: args ?? {}
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: TRANSPORT & REQUEST HELPERS
+  // ═══════════════════════════════════════════════════════════════════
+  createTransport() {
+    let baseUrl = this.config.baseUrl;
+    if (this.config.queryParams && Object.keys(this.config.queryParams).length > 0) {
+      const url = new URL(baseUrl);
+      Object.entries(this.config.queryParams).forEach(([key, value]) => {
+        url.searchParams.set(key, String(value));
+      });
+      baseUrl = url.toString();
+    }
+    switch (this.config.transport) {
+      case "streamable-http":
+        return new StreamableHttpTransport({
+          baseUrl,
+          timeout: this.config.timeout,
+          auth: this.config.auth,
+          publicMode: this.config.publicMode,
+          debug: this.config.debug,
+          interceptors: this._interceptors,
+          clientInfo: this.config.clientInfo,
+          elicitationHandler: this._elicitationHandler
+        });
+      case "sse":
+        throw new Error("SSE transport not yet implemented");
+      default:
+        throw new Error(`Unknown transport type: ${this.config.transport}`);
+    }
+  }
+  async request(method, params) {
+    const transport = this.getConnectedTransport();
+    const id = ++this.requestIdCounter;
+    this._lastRequestId = id;
+    const start = Date.now();
+    try {
+      const response = await transport.request({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      });
+      const durationMs = Date.now() - start;
+      this.updateSessionActivity();
+      if ("error" in response && response.error) {
+        const error = response.error;
+        this.traceRequest(method, params, id, response, durationMs);
+        return {
+          success: false,
+          error,
+          durationMs,
+          requestId: id
+        };
+      }
+      this.traceRequest(method, params, id, response, durationMs);
+      return {
+        success: true,
+        data: response.result,
+        durationMs,
+        requestId: id
+      };
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      const error = {
+        code: -32603,
+        message: err instanceof Error ? err.message : "Unknown error"
+      };
+      return {
+        success: false,
+        error,
+        durationMs,
+        requestId: id
+      };
+    }
+  }
+  /**
+   * Get the transport, throwing if not connected.
+   */
+  getConnectedTransport() {
+    if (!this.transport || !this.transport.isConnected()) {
+      throw new Error("Not connected to MCP server. Call connect() first.");
+    }
+    return this.transport;
+  }
+  updateSessionActivity() {
+    if (this._sessionInfo) {
+      this._sessionInfo.lastActivityAt = /* @__PURE__ */ new Date();
+      this._sessionInfo.requestCount++;
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: RESULT WRAPPERS
+  // ═══════════════════════════════════════════════════════════════════
+  wrapToolResult(response) {
+    const raw = response.data ?? { content: [] };
+    const isError = !response.success || raw.isError === true;
+    const meta = raw._meta;
+    const hasUI = meta?.["ui/html"] !== void 0 || meta?.["ui/component"] !== void 0 || meta?.["openai/html"] !== void 0 || meta?.["frontmcp/html"] !== void 0;
+    const structuredContent = raw["structuredContent"];
+    return {
+      raw,
+      isSuccess: !isError,
+      isError,
+      error: response.error,
+      durationMs: response.durationMs,
+      json() {
+        if (hasUI && structuredContent !== void 0) {
+          return structuredContent;
+        }
+        const textContent = raw.content?.find((c) => c.type === "text");
+        if (textContent && "text" in textContent) {
+          return JSON.parse(textContent.text);
+        }
+        throw new Error("No text content to parse as JSON");
+      },
+      text() {
+        const textContent = raw.content?.find((c) => c.type === "text");
+        if (textContent && "text" in textContent) {
+          return textContent.text;
+        }
+        return void 0;
+      },
+      hasTextContent() {
+        return raw.content?.some((c) => c.type === "text") ?? false;
+      },
+      hasImageContent() {
+        return raw.content?.some((c) => c.type === "image") ?? false;
+      },
+      hasResourceContent() {
+        return raw.content?.some((c) => c.type === "resource") ?? false;
+      },
+      hasToolUI() {
+        return hasUI;
+      }
+    };
+  }
+  wrapResourceContent(response) {
+    const raw = response.data ?? { contents: [] };
+    const isError = !response.success;
+    const firstContent = raw.contents?.[0];
+    return {
+      raw,
+      isSuccess: !isError,
+      isError,
+      error: response.error,
+      durationMs: response.durationMs,
+      json() {
+        if (firstContent && "text" in firstContent) {
+          return JSON.parse(firstContent.text);
+        }
+        throw new Error("No text content to parse as JSON");
+      },
+      text() {
+        if (firstContent && "text" in firstContent) {
+          return firstContent.text;
+        }
+        return void 0;
+      },
+      mimeType() {
+        return firstContent?.mimeType;
+      },
+      hasMimeType(type) {
+        return firstContent?.mimeType === type;
+      }
+    };
+  }
+  wrapPromptResult(response) {
+    const raw = response.data ?? { messages: [] };
+    const isError = !response.success;
+    return {
+      raw,
+      isSuccess: !isError,
+      isError,
+      error: response.error,
+      durationMs: response.durationMs,
+      messages: raw.messages ?? [],
+      description: raw.description
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: LOGGING & TRACING
+  // ═══════════════════════════════════════════════════════════════════
+  log(level, message, data) {
+    const entry = {
+      level,
+      message,
+      timestamp: /* @__PURE__ */ new Date(),
+      data
+    };
+    this._logs.push(entry);
+    if (this.config.debug) {
+      console.log(`[${level.toUpperCase()}] ${message}`, data ?? "");
+    }
+  }
+  traceRequest(method, params, id, response, durationMs) {
+    this._traces.push({
+      request: { method, params, id },
+      response: {
+        result: "result" in response ? response.result : void 0,
+        error: "error" in response ? response.error : void 0
+      },
+      durationMs,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE: TOKEN PARSING
+  // ═══════════════════════════════════════════════════════════════════
+  parseScopesFromToken(token) {
+    try {
+      const payload = this.decodeJwtPayload(token);
+      if (!payload) return [];
+      const scope = payload["scope"];
+      const scopes = payload["scopes"];
+      if (typeof scope === "string") {
+        return scope.split(" ");
+      }
+      if (Array.isArray(scopes)) {
+        return scopes;
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  parseUserFromToken(token) {
+    try {
+      const payload = this.decodeJwtPayload(token);
+      const sub = payload?.["sub"];
+      if (!sub || typeof sub !== "string") return void 0;
+      return {
+        sub,
+        email: payload["email"],
+        name: payload["name"]
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  decodeJwtPayload(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) return null;
+      const payload = Buffer.from(parts[1], "base64url").toString("utf-8");
+      return JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+};
+var NotificationCollector = class {
+  constructor(notifications) {
+    this.notifications = notifications;
+  }
+  get received() {
+    return [...this.notifications];
+  }
+  has(method) {
+    return this.notifications.some((n) => n.method === method);
+  }
+  async waitFor(method, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const found = this.notifications.find((n) => n.method === method);
+      if (found) return found;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    throw new Error(`Timeout waiting for notification: ${method}`);
+  }
+};
+var ProgressCollector = class {
+  constructor(updates) {
+    this.updates = updates;
+  }
+  get all() {
+    return [...this.updates];
+  }
+  async waitForComplete(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const last = this.updates[this.updates.length - 1];
+      if (last && last.total !== void 0 && last.progress >= last.total) {
+        return;
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    throw new Error("Timeout waiting for progress to complete");
+  }
+};
+
+// libs/testing/src/auth/token-factory.ts
+import { SignJWT, generateKeyPair, exportJWK } from "jose";
+var TestTokenFactory = class {
+  issuer;
+  audience;
+  privateKey = null;
+  publicKey = null;
+  jwk = null;
+  keyId;
+  constructor(options = {}) {
+    this.issuer = options.issuer ?? "https://test.frontmcp.local";
+    this.audience = options.audience ?? "frontmcp-test";
+    this.keyId = `test-key-${Date.now()}`;
+  }
+  /**
+   * Initialize the key pair (called automatically on first use)
+   */
+  async ensureKeys() {
+    if (this.privateKey && this.publicKey) return;
+    const { publicKey, privateKey } = await generateKeyPair("RS256", {
+      extractable: true
+    });
+    this.privateKey = privateKey;
+    this.publicKey = publicKey;
+    this.jwk = await exportJWK(publicKey);
+    this.jwk.kid = this.keyId;
+    this.jwk.use = "sig";
+    this.jwk.alg = "RS256";
+  }
+  /**
+   * Create a JWT token with the specified claims
+   */
+  async createTestToken(options) {
+    await this.ensureKeys();
+    const now = Math.floor(Date.now() / 1e3);
+    const exp = options.exp ?? 3600;
+    const payload = {
+      iss: options.iss ?? this.issuer,
+      sub: options.sub,
+      aud: options.aud ?? this.audience,
+      iat: now,
+      exp: now + exp,
+      scope: options.scopes?.join(" "),
+      ...options.claims
+    };
+    if (!this.privateKey) {
+      throw new Error("Private key not initialized");
+    }
+    const token = await new SignJWT(payload).setProtectedHeader({ alg: "RS256", kid: this.keyId }).sign(this.privateKey);
+    return token;
+  }
+  /**
+   * Create an admin token with full access
+   */
+  async createAdminToken(sub = "admin-001") {
+    return this.createTestToken({
+      sub,
+      scopes: ["admin:*", "read", "write", "delete"],
+      claims: {
+        email: "admin@test.local",
+        name: "Test Admin",
+        role: "admin"
+      }
+    });
+  }
+  /**
+   * Create a regular user token
+   */
+  async createUserToken(sub = "user-001", scopes = ["read", "write"]) {
+    return this.createTestToken({
+      sub,
+      scopes,
+      claims: {
+        email: "user@test.local",
+        name: "Test User",
+        role: "user"
+      }
+    });
+  }
+  /**
+   * Create an anonymous user token
+   */
+  async createAnonymousToken() {
+    return this.createTestToken({
+      sub: `anon:${Date.now()}`,
+      scopes: ["anonymous"],
+      claims: {
+        name: "Anonymous",
+        role: "anonymous"
+      }
+    });
+  }
+  /**
+   * Create an expired token (for testing token expiration)
+   */
+  async createExpiredToken(options) {
+    await this.ensureKeys();
+    const now = Math.floor(Date.now() / 1e3);
+    const payload = {
+      iss: this.issuer,
+      sub: options.sub,
+      aud: this.audience,
+      iat: now - 7200,
+      // 2 hours ago
+      exp: now - 3600
+      // Expired 1 hour ago
+    };
+    if (!this.privateKey) {
+      throw new Error("Private key not initialized");
+    }
+    const token = await new SignJWT(payload).setProtectedHeader({ alg: "RS256", kid: this.keyId }).sign(this.privateKey);
+    return token;
+  }
+  /**
+   * Create a token with an invalid signature (for testing signature validation)
+   */
+  createTokenWithInvalidSignature(options) {
+    const now = Math.floor(Date.now() / 1e3);
+    const header = Buffer.from(JSON.stringify({ alg: "RS256", kid: this.keyId })).toString("base64url");
+    const payload = Buffer.from(
+      JSON.stringify({
+        iss: this.issuer,
+        sub: options.sub,
+        aud: this.audience,
+        iat: now,
+        exp: now + 3600
+      })
+    ).toString("base64url");
+    const signature = Buffer.from("invalid-signature-" + Date.now()).toString("base64url");
+    return `${header}.${payload}.${signature}`;
+  }
+  /**
+   * Get the public JWKS for verifying tokens
+   */
+  async getPublicJwks() {
+    await this.ensureKeys();
+    if (!this.jwk) {
+      throw new Error("JWK not initialized");
+    }
+    return {
+      keys: [this.jwk]
+    };
+  }
+  /**
+   * Get the issuer URL
+   */
+  getIssuer() {
+    return this.issuer;
+  }
+  /**
+   * Get the audience
+   */
+  getAudience() {
+    return this.audience;
+  }
+};
+
+// libs/testing/src/server/test-server.ts
+import { spawn } from "child_process";
+
+// libs/testing/src/errors/index.ts
+var TestClientError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TestClientError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ServerStartError = class extends TestClientError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ServerStartError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// libs/testing/src/server/port-registry.ts
+import { createServer } from "net";
+var E2E_PORT_RANGES = {
+  // Core E2E tests (50000-50099)
+  "demo-e2e-public": { start: 5e4, size: 10 },
+  "demo-e2e-cache": { start: 50010, size: 10 },
+  "demo-e2e-config": { start: 50020, size: 10 },
+  "demo-e2e-direct": { start: 50030, size: 10 },
+  "demo-e2e-errors": { start: 50040, size: 10 },
+  "demo-e2e-hooks": { start: 50050, size: 10 },
+  "demo-e2e-multiapp": { start: 50060, size: 10 },
+  "demo-e2e-notifications": { start: 50070, size: 10 },
+  "demo-e2e-providers": { start: 50080, size: 10 },
+  "demo-e2e-standalone": { start: 50090, size: 10 },
+  // Auth E2E tests (50100-50199)
+  "demo-e2e-orchestrated": { start: 50100, size: 10 },
+  "demo-e2e-transparent": { start: 50110, size: 10 },
+  "demo-e2e-cimd": { start: 50120, size: 10 },
+  // Feature E2E tests (50200-50299)
+  "demo-e2e-skills": { start: 50200, size: 10 },
+  "demo-e2e-remote": { start: 50210, size: 10 },
+  "demo-e2e-openapi": { start: 50220, size: 10 },
+  "demo-e2e-ui": { start: 50230, size: 10 },
+  "demo-e2e-codecall": { start: 50240, size: 10 },
+  "demo-e2e-remember": { start: 50250, size: 10 },
+  "demo-e2e-elicitation": { start: 50260, size: 10 },
+  "demo-e2e-agents": { start: 50270, size: 10 },
+  "demo-e2e-transport-recreation": { start: 50280, size: 10 },
+  // Infrastructure E2E tests (50300-50399)
+  "demo-e2e-redis": { start: 50300, size: 10 },
+  "demo-e2e-serverless": { start: 50310, size: 10 },
+  // Mock servers and utilities (50900-50999)
+  "mock-oauth": { start: 50900, size: 10 },
+  "mock-api": { start: 50910, size: 10 },
+  "mock-cimd": { start: 50920, size: 10 },
+  // Dynamic/unknown projects (51000+)
+  default: { start: 51e3, size: 100 }
+};
+var reservedPorts = /* @__PURE__ */ new Map();
+var projectPortIndex = /* @__PURE__ */ new Map();
+function getPortRange(project) {
+  const key = project;
+  if (key in E2E_PORT_RANGES) {
+    return E2E_PORT_RANGES[key];
+  }
+  return E2E_PORT_RANGES.default;
+}
+async function reservePort(project, preferredPort) {
+  const range = getPortRange(project);
+  if (preferredPort !== void 0) {
+    const reservation = await tryReservePort(preferredPort, project);
+    if (reservation) {
+      return {
+        port: preferredPort,
+        release: async () => {
+          await releasePort(preferredPort);
+        }
+      };
+    }
+    console.warn(`[PortRegistry] Preferred port ${preferredPort} not available for ${project}, allocating from range`);
+  }
+  let index = projectPortIndex.get(project) ?? 0;
+  const maxAttempts = range.size;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const port = range.start + index % range.size;
+    index = (index + 1) % range.size;
+    if (reservedPorts.has(port)) {
+      continue;
+    }
+    const reservation = await tryReservePort(port, project);
+    if (reservation) {
+      projectPortIndex.set(project, index);
+      return {
+        port,
+        release: async () => {
+          await releasePort(port);
+        }
+      };
+    }
+  }
+  const dynamicPort = await findAvailablePortInRange(51e3, 52e3);
+  if (dynamicPort) {
+    const reservation = await tryReservePort(dynamicPort, project);
+    if (reservation) {
+      return {
+        port: dynamicPort,
+        release: async () => {
+          await releasePort(dynamicPort);
+        }
+      };
+    }
+  }
+  throw new Error(
+    `[PortRegistry] Could not reserve a port for ${project}. Range: ${range.start}-${range.start + range.size - 1}. Currently reserved: ${Array.from(reservedPorts.keys()).join(", ")}`
+  );
+}
+async function tryReservePort(port, project) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", () => {
+      resolve(false);
+    });
+    server.listen(port, "::", () => {
+      reservedPorts.set(port, {
+        port,
+        project,
+        holder: server,
+        reservedAt: Date.now()
+      });
+      resolve(true);
+    });
+  });
+}
+async function releasePort(port) {
+  const reservation = reservedPorts.get(port);
+  if (!reservation) {
+    return;
+  }
+  return new Promise((resolve) => {
+    reservation.holder.close(() => {
+      reservedPorts.delete(port);
+      resolve();
+    });
+  });
+}
+async function findAvailablePortInRange(start, end) {
+  for (let port = start; port < end; port++) {
+    if (reservedPorts.has(port)) {
+      continue;
+    }
+    const available = await isPortAvailable(port);
+    if (available) {
+      return port;
+    }
+  }
+  return null;
+}
+async function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", () => {
+      resolve(false);
+    });
+    server.listen(port, "::", () => {
+      server.close(() => {
+        resolve(true);
+      });
+    });
+  });
+}
+
+// libs/testing/src/server/test-server.ts
+var DEBUG_SERVER = process.env["DEBUG_SERVER"] === "1" || process.env["DEBUG"] === "1";
+var TestServer = class _TestServer {
+  process = null;
+  options;
+  _info;
+  logs = [];
+  portRelease = null;
+  constructor(options, port, portRelease) {
+    this.options = {
+      port,
+      project: options.project,
+      command: options.command ?? "",
+      cwd: options.cwd ?? process.cwd(),
+      env: options.env ?? {},
+      startupTimeout: options.startupTimeout ?? 3e4,
+      healthCheckPath: options.healthCheckPath ?? "/health",
+      debug: options.debug ?? DEBUG_SERVER
+    };
+    this.portRelease = portRelease ?? null;
+    this._info = {
+      baseUrl: `http://localhost:${port}`,
+      port
+    };
+  }
+  /**
+   * Start a test server with custom command
+   */
+  static async start(options) {
+    const project = options.project ?? "default";
+    const { port, release } = await reservePort(project, options.port);
+    await release();
+    const server = new _TestServer(options, port);
+    try {
+      await server.startProcess();
+    } catch (error) {
+      await server.stop();
+      throw error;
+    }
+    return server;
+  }
+  /**
+   * Start an Nx project as test server
+   */
+  static async startNx(project, options = {}) {
+    if (!/^[\w-]+$/.test(project)) {
+      throw new Error(
+        `Invalid project name: ${project}. Must contain only alphanumeric, underscore, and hyphen characters.`
+      );
+    }
+    const { port, release } = await reservePort(project, options.port);
+    await release();
+    const serverOptions = {
+      ...options,
+      port,
+      project,
+      command: `npx nx serve ${project} --port ${port}`,
+      cwd: options.cwd ?? process.cwd()
+    };
+    const server = new _TestServer(serverOptions, port);
+    try {
+      await server.startProcess();
+    } catch (error) {
+      await server.stop();
+      throw error;
+    }
+    return server;
+  }
+  /**
+   * Create a test server connected to an already running server
+   */
+  static connect(baseUrl) {
+    const url = new URL(baseUrl);
+    const port = parseInt(url.port, 10) || (url.protocol === "https:" ? 443 : 80);
+    const server = new _TestServer(
+      {
+        command: "",
+        port
+      },
+      port
+    );
+    server._info = {
+      baseUrl: baseUrl.replace(/\/$/, ""),
+      port
+    };
+    return server;
+  }
+  /**
+   * Get server information
+   */
+  get info() {
+    return { ...this._info };
+  }
+  /**
+   * Stop the test server
+   */
+  async stop() {
+    if (this.process) {
+      this.log("Stopping server...");
+      this.process.kill("SIGTERM");
+      const exitPromise = new Promise((resolve) => {
+        if (this.process) {
+          this.process.once("exit", () => resolve());
+        } else {
+          resolve();
+        }
+      });
+      const killTimeout = setTimeout(() => {
+        if (this.process) {
+          this.log("Force killing server after timeout...");
+          this.process.kill("SIGKILL");
+        }
+      }, 5e3);
+      await exitPromise;
+      clearTimeout(killTimeout);
+      this.process = null;
+      this.log("Server stopped");
+    }
+  }
+  /**
+   * Wait for server to be ready
+   */
+  async waitForReady(timeout) {
+    const timeoutMs = timeout ?? this.options.startupTimeout;
+    const deadline = Date.now() + timeoutMs;
+    const checkInterval = 100;
+    while (Date.now() < deadline) {
+      try {
+        const response = await fetch(`${this._info.baseUrl}${this.options.healthCheckPath}`, {
+          method: "GET",
+          signal: AbortSignal.timeout(1e3)
+        });
+        if (response.ok || response.status === 404) {
+          this.log("Server is ready");
+          return;
+        }
+      } catch {
+      }
+      await sleep4(checkInterval);
+    }
+    throw new Error(`Server did not become ready within ${timeoutMs}ms`);
+  }
+  /**
+   * Restart the server
+   */
+  async restart() {
+    await this.stop();
+    await this.startProcess();
+  }
+  /**
+   * Get captured server logs
+   */
+  getLogs() {
+    return [...this.logs];
+  }
+  /**
+   * Clear captured logs
+   */
+  clearLogs() {
+    this.logs = [];
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // PRIVATE METHODS
+  // ═══════════════════════════════════════════════════════════════════
+  async startProcess() {
+    if (!this.options.command) {
+      await this.waitForReady();
+      return;
+    }
+    this.log(`Starting server: ${this.options.command}`);
+    const env = {
+      ...process.env,
+      ...this.options.env,
+      PORT: String(this.options.port)
+    };
+    this.process = spawn(this.options.command, [], {
+      cwd: this.options.cwd,
+      env,
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (this.process.pid !== void 0) {
+      this._info.pid = this.process.pid;
+    }
+    let processExited = false;
+    let exitCode = null;
+    let exitError = null;
+    this.process.stdout?.on("data", (data) => {
+      const text = data.toString();
+      this.logs.push(text);
+      if (this.options.debug) {
+        console.log("[SERVER]", text);
+      }
+    });
+    this.process.stderr?.on("data", (data) => {
+      const text = data.toString();
+      this.logs.push(`[ERROR] ${text}`);
+      if (this.options.debug) {
+        console.error("[SERVER ERROR]", text);
+      }
+    });
+    this.process.on("error", (err) => {
+      this.logs.push(`[SPAWN ERROR] ${err.message}`);
+      exitError = err;
+      if (this.options.debug) {
+        console.error("[SERVER SPAWN ERROR]", err);
+      }
+    });
+    this.process.once("exit", (code) => {
+      processExited = true;
+      exitCode = code;
+      this.log(`Server process exited with code ${code}`);
+    });
+    try {
+      await this.waitForReadyWithExitDetection(() => {
+        if (exitError) {
+          return { exited: true, error: exitError };
+        }
+        if (processExited) {
+          const allLogs = this.logs.join("\n");
+          const errorLogs = this.logs.filter((l) => l.includes("[ERROR]") || l.toLowerCase().includes("error")).join("\n");
+          return {
+            exited: true,
+            error: new ServerStartError(
+              `Server process exited unexpectedly with code ${exitCode}.
+
+Command: ${this.options.command}
+CWD: ${this.options.cwd}
+Port: ${this.options.port}
+
+=== Error Logs ===
+${errorLogs || "No error logs captured"}
+
+=== Full Logs ===
+${allLogs || "No logs captured"}`
+            )
+          };
+        }
+        return { exited: false };
+      });
+    } catch (error) {
+      this.printLogsOnFailure("Server startup failed");
+      throw error;
+    }
+  }
+  /**
+   * Print server logs on failure for debugging
+   */
+  printLogsOnFailure(context) {
+    const allLogs = this.logs.join("\n");
+    if (allLogs) {
+      console.error(`
+[TestServer] ${context}`);
+      console.error(`[TestServer] Command: ${this.options.command}`);
+      console.error(`[TestServer] Port: ${this.options.port}`);
+      console.error(`[TestServer] CWD: ${this.options.cwd}`);
+      console.error(`[TestServer] === Server Logs ===
+${allLogs}`);
+      console.error(`[TestServer] === End Logs ===
+`);
+    }
+  }
+  /**
+   * Wait for server to be ready, but also detect early process exit
+   */
+  async waitForReadyWithExitDetection(checkExit) {
+    const timeoutMs = this.options.startupTimeout;
+    const deadline = Date.now() + timeoutMs;
+    const checkInterval = 100;
+    let lastHealthCheckError = null;
+    let healthCheckAttempts = 0;
+    this.log(`Waiting for server to be ready (timeout: ${timeoutMs}ms)...`);
+    while (Date.now() < deadline) {
+      const exitStatus = checkExit();
+      if (exitStatus.exited) {
+        throw exitStatus.error ?? new ServerStartError("Server process exited unexpectedly");
+      }
+      healthCheckAttempts++;
+      try {
+        const healthUrl = `${this._info.baseUrl}${this.options.healthCheckPath}`;
+        const response = await fetch(healthUrl, {
+          method: "GET",
+          signal: AbortSignal.timeout(1e3)
+        });
+        if (response.ok || response.status === 404) {
+          this.log(`Server is ready after ${healthCheckAttempts} health check attempts`);
+          return;
+        }
+        lastHealthCheckError = `HTTP ${response.status}: ${response.statusText}`;
+      } catch (err) {
+        lastHealthCheckError = err instanceof Error ? err.message : String(err);
+      }
+      const elapsed = Date.now() - (deadline - timeoutMs);
+      if (elapsed > 0 && elapsed % 5e3 < checkInterval) {
+        this.log(
+          `Still waiting for server... (${Math.round(elapsed / 1e3)}s elapsed, last error: ${lastHealthCheckError})`
+        );
+      }
+      await sleep4(checkInterval);
+    }
+    const finalExitStatus = checkExit();
+    if (finalExitStatus.exited) {
+      throw finalExitStatus.error ?? new ServerStartError("Server process exited unexpectedly");
+    }
+    const allLogs = this.logs.join("\n");
+    throw new ServerStartError(
+      `Server did not become ready within ${timeoutMs}ms.
+
+Command: ${this.options.command}
+CWD: ${this.options.cwd}
+Port: ${this.options.port}
+Health check URL: ${this._info.baseUrl}${this.options.healthCheckPath}
+Health check attempts: ${healthCheckAttempts}
+Last health check error: ${lastHealthCheckError ?? "none"}
+
+=== Server Logs ===
+${allLogs || "No logs captured"}
+
+TIP: Set DEBUG_SERVER=1 or DEBUG=1 environment variable for verbose output`
+    );
+  }
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[TestServer] ${message}`);
+    }
+  }
+};
+function sleep4(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// libs/testing/src/perf/perf-test.ts
+var currentConfig = {};
+var serverInstance = null;
+var tokenFactory = null;
+var serverStartedByUs = false;
+async function initializeSharedResources() {
+  if (!tokenFactory) {
+    tokenFactory = new TestTokenFactory();
+  }
+  if (!serverInstance) {
+    if (currentConfig.baseUrl) {
+      serverInstance = TestServer.connect(currentConfig.baseUrl);
+      serverStartedByUs = false;
+    } else if (currentConfig.server) {
+      const serverCommand = resolveServerCommand(currentConfig.server);
+      const isDebug = process.env["DEBUG"] === "1" || process.env["DEBUG_SERVER"] === "1";
+      if (isDebug) {
+        console.log(`[PerfTest] Starting server: ${serverCommand}`);
+      }
+      try {
+        serverInstance = await TestServer.start({
+          project: currentConfig.project,
+          port: currentConfig.port,
+          command: serverCommand,
+          env: currentConfig.env,
+          startupTimeout: currentConfig.startupTimeout ?? 3e4,
+          debug: isDebug
+        });
+        serverStartedByUs = true;
+        if (isDebug) {
+          console.log(`[PerfTest] Server started at ${serverInstance.info.baseUrl}`);
+        }
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `Failed to start test server.
+
+Server entry: ${currentConfig.server}
+Project: ${currentConfig.project ?? "default"}
+Command: ${serverCommand}
+
+Error: ${errMsg}`
+        );
+      }
+    } else {
+      throw new Error('perfTest.use() requires either "server" (entry file path) or "baseUrl" option');
+    }
+  }
+}
+async function createTestFixtures(testName) {
+  await initializeSharedResources();
+  if (!serverInstance) {
+    throw new Error("Server instance not initialized");
+  }
+  if (!tokenFactory) {
+    throw new Error("Token factory not initialized");
+  }
+  const clientInstance = await McpTestClient.create({
+    baseUrl: serverInstance.info.baseUrl,
+    transport: currentConfig.transport ?? "streamable-http",
+    publicMode: currentConfig.publicMode
+  }).buildAndConnect();
+  const auth = createAuthFixture(tokenFactory);
+  const server = createServerFixture(serverInstance);
+  const perfImpl = createPerfFixtures(testName, currentConfig.project ?? "unknown");
+  if (currentConfig.forceGcOnBaseline !== false) {
+    await perfImpl.baseline();
+  }
+  return {
+    fixtures: {
+      mcp: clientInstance,
+      auth,
+      server,
+      perf: perfImpl
+    },
+    perfImpl
+  };
+}
+async function cleanupTestFixtures(fixtures, perfImpl, testFailed = false) {
+  const measurement = perfImpl.buildMeasurement();
+  addGlobalMeasurement(measurement);
+  if (testFailed && serverInstance) {
+    const logs = serverInstance.getLogs();
+    if (logs.length > 0) {
+      console.error("\n[PerfTest] === Server Logs (test failed) ===");
+      const recentLogs = logs.slice(-50);
+      if (logs.length > 50) {
+        console.error(`[PerfTest] (showing last 50 of ${logs.length} log entries)`);
+      }
+      console.error(recentLogs.join("\n"));
+      console.error("[PerfTest] === End Server Logs ===\n");
+    }
+  }
+  if (fixtures.mcp.isConnected()) {
+    await fixtures.mcp.disconnect();
+  }
+}
+async function cleanupSharedResources() {
+  if (serverInstance && serverStartedByUs) {
+    await serverInstance.stop();
+  }
+  serverInstance = null;
+  tokenFactory = null;
+  serverStartedByUs = false;
+}
+function createAuthFixture(factory) {
+  const users = {
+    admin: {
+      sub: "admin-001",
+      scopes: ["admin:*", "read", "write", "delete"],
+      email: "admin@test.local",
+      name: "Test Admin"
+    },
+    user: {
+      sub: "user-001",
+      scopes: ["read", "write"],
+      email: "user@test.local",
+      name: "Test User"
+    },
+    readOnly: {
+      sub: "readonly-001",
+      scopes: ["read"],
+      email: "readonly@test.local",
+      name: "Read Only User"
+    }
+  };
+  return {
+    createToken: (opts) => factory.createTestToken({
+      sub: opts.sub,
+      scopes: opts.scopes,
+      claims: {
+        email: opts.email,
+        name: opts.name,
+        ...opts.claims
+      },
+      exp: opts.expiresIn
+    }),
+    createExpiredToken: (opts) => factory.createExpiredToken(opts),
+    createInvalidToken: (opts) => factory.createTokenWithInvalidSignature(opts),
+    users: {
+      admin: users["admin"],
+      user: users["user"],
+      readOnly: users["readOnly"]
+    },
+    getJwks: () => factory.getPublicJwks(),
+    getIssuer: () => factory.getIssuer(),
+    getAudience: () => factory.getAudience()
+  };
+}
+function createServerFixture(server) {
+  return {
+    info: server.info,
+    createClient: async (opts) => {
+      return McpTestClient.create({
+        baseUrl: server.info.baseUrl,
+        transport: opts?.transport ?? "streamable-http",
+        auth: opts?.token ? { token: opts.token } : void 0,
+        clientInfo: opts?.clientInfo,
+        publicMode: currentConfig.publicMode
+      }).buildAndConnect();
+    },
+    createClientBuilder: () => {
+      return new McpTestClientBuilder({
+        baseUrl: server.info.baseUrl,
+        publicMode: currentConfig.publicMode
+      });
+    },
+    restart: () => server.restart(),
+    getLogs: () => server.getLogs(),
+    clearLogs: () => server.clearLogs()
+  };
+}
+function resolveServerCommand(server) {
+  if (server.includes(" ")) {
+    return server;
+  }
+  return `npx tsx ${server}`;
+}
+function perfTestWithFixtures(name, fn) {
+  it(name, async () => {
+    const { fixtures, perfImpl } = await createTestFixtures(name);
+    let testFailed = false;
+    try {
+      await fn(fixtures);
+    } catch (error) {
+      testFailed = true;
+      throw error;
+    } finally {
+      await cleanupTestFixtures(fixtures, perfImpl, testFailed);
+    }
+  });
+}
+function use(config) {
+  currentConfig = { ...currentConfig, ...config };
+  afterAll(async () => {
+    await cleanupSharedResources();
+  });
+}
+function skip(name, fn) {
+  it.skip(name, async () => {
+    const { fixtures, perfImpl } = await createTestFixtures(name);
+    let testFailed = false;
+    try {
+      await fn(fixtures);
+    } catch (error) {
+      testFailed = true;
+      throw error;
+    } finally {
+      await cleanupTestFixtures(fixtures, perfImpl, testFailed);
+    }
+  });
+}
+function only(name, fn) {
+  it.only(name, async () => {
+    const { fixtures, perfImpl } = await createTestFixtures(name);
+    let testFailed = false;
+    try {
+      await fn(fixtures);
+    } catch (error) {
+      testFailed = true;
+      throw error;
+    } finally {
+      await cleanupTestFixtures(fixtures, perfImpl, testFailed);
+    }
+  });
+}
+function todo(name) {
+  it.todo(name);
+}
+var perfTest = perfTestWithFixtures;
+perfTest.use = use;
+perfTest.describe = describe;
+perfTest.beforeAll = beforeAll;
+perfTest.beforeEach = beforeEach;
+perfTest.afterEach = afterEach;
+perfTest.afterAll = afterAll;
+perfTest.skip = skip;
+perfTest.only = only;
+perfTest.todo = todo;
+
+// libs/testing/src/perf/baseline-store.ts
+var BASELINE_START_MARKER = "<!-- PERF_BASELINE_START -->";
+var BASELINE_END_MARKER = "<!-- PERF_BASELINE_END -->";
+var DEFAULT_BASELINE_PATH = "perf-results/baseline.json";
+var BaselineStore = class {
+  baseline = null;
+  baselinePath;
+  constructor(baselinePath = DEFAULT_BASELINE_PATH) {
+    this.baselinePath = baselinePath;
+  }
+  /**
+   * Load baseline from local file.
+   */
+  async load() {
+    try {
+      const { readFile, fileExists } = await import("@frontmcp/utils");
+      if (!await fileExists(this.baselinePath)) {
+        return null;
+      }
+      const content = await readFile(this.baselinePath);
+      this.baseline = JSON.parse(content);
+      return this.baseline;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save baseline to local file.
+   */
+  async save(baseline) {
+    const { writeFile, ensureDir } = await import("@frontmcp/utils");
+    const dir = this.baselinePath.substring(0, this.baselinePath.lastIndexOf("/"));
+    await ensureDir(dir);
+    await writeFile(this.baselinePath, JSON.stringify(baseline, null, 2));
+    this.baseline = baseline;
+  }
+  /**
+   * Get a test baseline by ID.
+   */
+  getTestBaseline(testId) {
+    if (!this.baseline) {
+      return null;
+    }
+    return this.baseline.tests[testId] ?? null;
+  }
+  /**
+   * Check if baseline is loaded.
+   */
+  isLoaded() {
+    return this.baseline !== null;
+  }
+  /**
+   * Get the loaded baseline.
+   */
+  getBaseline() {
+    return this.baseline;
+  }
+  /**
+   * Create a baseline from measurements.
+   */
+  static createFromMeasurements(measurements, release, commitHash) {
+    const tests = {};
+    const grouped = /* @__PURE__ */ new Map();
+    for (const m of measurements) {
+      const key = `${m.project}::${m.name}`;
+      if (!grouped.has(key)) {
+        grouped.set(key, []);
+      }
+      const group = grouped.get(key);
+      if (group) {
+        group.push(m);
+      }
+    }
+    for (const [key, testMeasurements] of grouped) {
+      const [project] = key.split("::");
+      const heapSamples = testMeasurements.map((m) => m.final?.memory.heapUsed ?? 0);
+      const durationSamples = testMeasurements.map((m) => m.timing.durationMs);
+      const cpuSamples = testMeasurements.map((m) => m.final?.cpu.total ?? 0);
+      tests[key] = {
+        testId: key,
+        project,
+        heapUsed: calculateMetricBaseline(heapSamples),
+        durationMs: calculateMetricBaseline(durationSamples),
+        cpuTime: calculateMetricBaseline(cpuSamples),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        commitHash
+      };
+    }
+    return {
+      release,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      commitHash,
+      tests
+    };
+  }
+};
+function parseBaselineFromComment(commentBody) {
+  const startIdx = commentBody.indexOf(BASELINE_START_MARKER);
+  const endIdx = commentBody.indexOf(BASELINE_END_MARKER);
+  if (startIdx === -1 || endIdx === -1 || startIdx >= endIdx) {
+    return null;
+  }
+  const content = commentBody.substring(startIdx + BASELINE_START_MARKER.length, endIdx);
+  const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/);
+  if (!jsonMatch) {
+    return null;
+  }
+  try {
+    return JSON.parse(jsonMatch[1]);
+  } catch {
+    return null;
+  }
+}
+function formatBaselineAsComment(baseline) {
+  const json = JSON.stringify(baseline, null, 2);
+  return `## Performance Baseline
+
+This comment contains the performance baseline for release ${baseline.release}.
+
+${BASELINE_START_MARKER}
+\`\`\`json
+${json}
+\`\`\`
+${BASELINE_END_MARKER}
+
+Generated at: ${baseline.timestamp}
+${baseline.commitHash ? `Commit: ${baseline.commitHash}` : ""}
+`;
+}
+function buildReleaseCommentsUrl(owner, repo, releaseId) {
+  return `https://api.github.com/repos/${owner}/${repo}/releases/${releaseId}/comments`;
+}
+function calculateMetricBaseline(samples) {
+  if (samples.length === 0) {
+    return {
+      mean: 0,
+      stdDev: 0,
+      min: 0,
+      max: 0,
+      p95: 0,
+      sampleCount: 0
+    };
+  }
+  const sorted = [...samples].sort((a, b) => a - b);
+  const n = sorted.length;
+  const sum = sorted.reduce((a, b) => a + b, 0);
+  const mean = sum / n;
+  const squaredDiffs = sorted.map((x) => Math.pow(x - mean, 2));
+  const variance = squaredDiffs.reduce((a, b) => a + b, 0) / n;
+  const stdDev = Math.sqrt(variance);
+  const min = sorted[0];
+  const max = sorted[n - 1];
+  const p95Index = Math.ceil(n * 0.95) - 1;
+  const p95 = sorted[Math.min(p95Index, n - 1)];
+  return {
+    mean,
+    stdDev,
+    min,
+    max,
+    p95,
+    sampleCount: n
+  };
+}
+var globalBaselineStore = null;
+function getBaselineStore(baselinePath) {
+  if (!globalBaselineStore || baselinePath) {
+    globalBaselineStore = new BaselineStore(baselinePath);
+  }
+  return globalBaselineStore;
+}
+function resetBaselineStore() {
+  globalBaselineStore = null;
+}
+
+// libs/testing/src/perf/regression-detector.ts
+var DEFAULT_CONFIG = {
+  warningThresholdPercent: 10,
+  errorThresholdPercent: 25,
+  minAbsoluteChange: 1024
+  // 1KB minimum to avoid noise
+};
+var RegressionDetector = class {
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Detect regressions in a measurement compared to baseline.
+   */
+  detectRegression(measurement, baseline) {
+    const testId = `${measurement.project}::${measurement.name}`;
+    const metrics = [];
+    const currentHeap = measurement.final?.memory.heapUsed ?? 0;
+    const heapRegression = this.checkMetric("heapUsed", baseline.heapUsed.mean, currentHeap, formatBytes);
+    metrics.push(heapRegression);
+    const durationRegression = this.checkMetric(
+      "durationMs",
+      baseline.durationMs.mean,
+      measurement.timing.durationMs,
+      formatDuration
+    );
+    metrics.push(durationRegression);
+    const currentCpu = measurement.final?.cpu.total ?? 0;
+    const cpuRegression = this.checkMetric("cpuTime", baseline.cpuTime.mean, currentCpu, formatMicroseconds);
+    metrics.push(cpuRegression);
+    const hasRegression = metrics.some((m) => m.status === "regression");
+    const hasWarning = metrics.some((m) => m.status === "warning");
+    const status = hasRegression ? "regression" : hasWarning ? "warning" : "ok";
+    const message = this.buildMessage(testId, metrics, status);
+    return {
+      testId,
+      status,
+      metrics,
+      message
+    };
+  }
+  /**
+   * Detect regressions for multiple measurements.
+   */
+  detectRegressions(measurements, baselines) {
+    const results = [];
+    for (const measurement of measurements) {
+      const testId = `${measurement.project}::${measurement.name}`;
+      const baseline = baselines.tests[testId];
+      if (baseline) {
+        results.push(this.detectRegression(measurement, baseline));
+      }
+    }
+    return results;
+  }
+  /**
+   * Check a single metric for regression.
+   */
+  checkMetric(name, baseline, current, _formatter) {
+    const absoluteChange = current - baseline;
+    const changePercent = baseline > 0 ? absoluteChange / baseline * 100 : 0;
+    let status = "ok";
+    if (Math.abs(absoluteChange) > this.config.minAbsoluteChange) {
+      if (changePercent >= this.config.errorThresholdPercent) {
+        status = "regression";
+      } else if (changePercent >= this.config.warningThresholdPercent) {
+        status = "warning";
+      }
+    }
+    return {
+      metric: name,
+      baseline,
+      current,
+      changePercent,
+      absoluteChange,
+      status
+    };
+  }
+  /**
+   * Build a human-readable message for regression result.
+   */
+  buildMessage(testId, metrics, status) {
+    if (status === "ok") {
+      return `${testId}: All metrics within acceptable range`;
+    }
+    const issues = metrics.filter((m) => m.status !== "ok").map((m) => {
+      const direction = m.absoluteChange > 0 ? "+" : "";
+      return `${m.metric}: ${direction}${m.changePercent.toFixed(1)}%`;
+    });
+    const statusText = status === "regression" ? "REGRESSION" : "WARNING";
+    return `${testId}: ${statusText} - ${issues.join(", ")}`;
+  }
+};
+function summarizeRegressions(results) {
+  const total = results.length;
+  const ok = results.filter((r) => r.status === "ok").length;
+  const warnings = results.filter((r) => r.status === "warning").length;
+  const regressions = results.filter((r) => r.status === "regression").length;
+  let summary;
+  if (regressions > 0) {
+    summary = `${regressions} regression(s) detected out of ${total} tests`;
+  } else if (warnings > 0) {
+    summary = `${warnings} warning(s) detected out of ${total} tests`;
+  } else {
+    summary = `All ${total} tests within acceptable range`;
+  }
+  return { total, ok, warnings, regressions, summary };
+}
+function filterByStatus(results, status) {
+  return results.filter((r) => r.status === status);
+}
+function getMostSevereMetric(result) {
+  const regressions = result.metrics.filter((m) => m.status === "regression");
+  if (regressions.length > 0) {
+    return regressions.reduce((max, m) => m.changePercent > max.changePercent ? m : max);
+  }
+  const warnings = result.metrics.filter((m) => m.status === "warning");
+  if (warnings.length > 0) {
+    return warnings.reduce((max, m) => m.changePercent > max.changePercent ? m : max);
+  }
+  return null;
+}
+var globalDetector = null;
+function getRegressionDetector(config) {
+  if (!globalDetector || config) {
+    globalDetector = new RegressionDetector(config);
+  }
+  return globalDetector;
+}
+function resetRegressionDetector() {
+  globalDetector = null;
+}
+
+// libs/testing/src/perf/report-generator.ts
+var ReportGenerator = class {
+  detector;
+  constructor() {
+    this.detector = new RegressionDetector();
+  }
+  /**
+   * Generate a complete performance report.
+   */
+  generateReport(measurements, baseline, gitInfo) {
+    const projectGroups = /* @__PURE__ */ new Map();
+    for (const m of measurements) {
+      if (!projectGroups.has(m.project)) {
+        projectGroups.set(m.project, []);
+      }
+      const group = projectGroups.get(m.project);
+      if (group) {
+        group.push(m);
+      }
+    }
+    const projects = [];
+    for (const [projectName, projectMeasurements] of projectGroups) {
+      const summary = this.calculateSummary(projectMeasurements);
+      const regressions = baseline ? this.detector.detectRegressions(projectMeasurements, baseline) : void 0;
+      projects.push({
+        project: projectName,
+        summary,
+        measurements: projectMeasurements,
+        regressions
+      });
+    }
+    const overallSummary = this.calculateSummary(measurements);
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      commitHash: gitInfo?.commitHash,
+      branch: gitInfo?.branch,
+      summary: overallSummary,
+      projects,
+      baseline: baseline ? { release: baseline.release, timestamp: baseline.timestamp } : void 0
+    };
+  }
+  /**
+   * Generate Markdown report for PR comments.
+   */
+  generateMarkdownReport(report) {
+    const lines = [];
+    lines.push("## Performance Test Results");
+    lines.push("");
+    const statusEmoji = this.getStatusEmoji(report.summary);
+    lines.push(`**Status:** ${statusEmoji} ${this.getSummaryText(report.summary)}`);
+    lines.push("");
+    lines.push("### Summary");
+    lines.push("");
+    lines.push("| Metric | Value |");
+    lines.push("|--------|-------|");
+    lines.push(`| Total Tests | ${report.summary.totalTests} |`);
+    lines.push(`| Passed | ${report.summary.passedTests} |`);
+    lines.push(`| Warnings | ${report.summary.warningTests} |`);
+    lines.push(`| Failed | ${report.summary.failedTests} |`);
+    lines.push(`| Memory Leaks | ${report.summary.leakTests} |`);
+    lines.push("");
+    if (report.baseline) {
+      lines.push(`**Baseline:** ${report.baseline.release} (${report.baseline.timestamp})`);
+      lines.push("");
+    }
+    lines.push("### Project Breakdown");
+    lines.push("");
+    for (const project of report.projects) {
+      lines.push(`#### ${project.project}`);
+      lines.push("");
+      lines.push(this.generateProjectTable(project));
+      lines.push("");
+      const leakTests = project.measurements.filter((m) => m.leakDetectionResults && m.leakDetectionResults.length > 0);
+      if (leakTests.length > 0) {
+        const parallelTests = leakTests.filter((m) => m.leakDetectionResults?.some((r) => this.isParallelResult(r)));
+        if (parallelTests.length > 0) {
+          lines.push("**Parallel Stress Test Results:**");
+          lines.push("");
+          lines.push("| Test | Workers | Iterations | Duration | Total req/s |");
+          lines.push("|------|---------|------------|----------|-------------|");
+          for (const m of parallelTests) {
+            for (const result of m.leakDetectionResults || []) {
+              if (this.isParallelResult(result)) {
+                const parallelResult = result;
+                const durationStr = parallelResult.durationMs ? `${(parallelResult.durationMs / 1e3).toFixed(2)}s` : "N/A";
+                lines.push(
+                  `| ${m.name} | ${parallelResult.workersUsed} | ${parallelResult.totalIterations} | ${durationStr} | ${parallelResult.totalRequestsPerSecond.toFixed(1)} |`
+                );
+              }
+            }
+          }
+          lines.push("");
+        }
+        lines.push("**Memory Interval Analysis:**");
+        lines.push("");
+        for (const m of leakTests) {
+          for (const result of m.leakDetectionResults || []) {
+            if (result.intervals && result.intervals.length > 0) {
+              lines.push(`*${m.name}:*`);
+              lines.push("");
+              if (this.isParallelResult(result)) {
+                const parallelResult = result;
+                lines.push("| Worker | req/s | Iterations |");
+                lines.push("|--------|-------|------------|");
+                for (const worker of parallelResult.perWorkerStats) {
+                  lines.push(
+                    `| ${worker.workerId} | ${worker.requestsPerSecond.toFixed(1)} | ${worker.iterationsCompleted} |`
+                  );
+                }
+                lines.push("");
+              }
+              lines.push("| Interval | Heap Start | Heap End | Delta | Rate/iter |");
+              lines.push("|----------|------------|----------|-------|-----------|");
+              for (const interval of result.intervals) {
+                lines.push(
+                  `| ${interval.startIteration}-${interval.endIteration} | ${formatBytes(interval.heapAtStart)} | ${formatBytes(interval.heapAtEnd)} | ${interval.deltaFormatted} | ${formatBytes(interval.growthRatePerIteration)}/iter |`
+                );
+              }
+              lines.push("");
+              const durationStr = result.durationMs ? `${(result.durationMs / 1e3).toFixed(2)}s` : "N/A";
+              const rpsStr = result.requestsPerSecond ? `${result.requestsPerSecond.toFixed(1)} req/s` : "N/A";
+              lines.push(
+                `Total: ${formatBytes(result.totalGrowth)}, R\xB2=${result.rSquared.toFixed(3)} | ${result.samples.length} iterations in ${durationStr} (${rpsStr})`
+              );
+              lines.push("");
+            }
+          }
+        }
+      }
+      if (project.regressions && project.regressions.length > 0) {
+        const regressionsWithIssues = project.regressions.filter((r) => r.status !== "ok");
+        if (regressionsWithIssues.length > 0) {
+          lines.push("**Regressions:**");
+          for (const r of regressionsWithIssues) {
+            const emoji = r.status === "regression" ? "\u274C" : "\u26A0\uFE0F";
+            lines.push(`- ${emoji} ${r.message}`);
+          }
+          lines.push("");
+        }
+      }
+    }
+    lines.push("---");
+    lines.push(`Generated at: ${report.timestamp}`);
+    if (report.commitHash) {
+      lines.push(`Commit: \`${report.commitHash.substring(0, 8)}\``);
+    }
+    if (report.branch) {
+      lines.push(`Branch: \`${report.branch}\``);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generate JSON report.
+   */
+  generateJsonReport(report) {
+    return JSON.stringify(report, null, 2);
+  }
+  /**
+   * Calculate summary statistics for measurements.
+   */
+  calculateSummary(measurements) {
+    let passedTests = 0;
+    let warningTests = 0;
+    let failedTests = 0;
+    let leakTests = 0;
+    for (const m of measurements) {
+      const hasError = m.issues.some((i) => i.severity === "error");
+      const hasWarning = m.issues.some((i) => i.severity === "warning");
+      const hasLeak = m.issues.some((i) => i.type === "memory-leak");
+      if (hasLeak) {
+        leakTests++;
+      }
+      if (hasError) {
+        failedTests++;
+      } else if (hasWarning) {
+        warningTests++;
+      } else {
+        passedTests++;
+      }
+    }
+    return {
+      totalTests: measurements.length,
+      passedTests,
+      warningTests,
+      failedTests,
+      leakTests
+    };
+  }
+  /**
+   * Get status emoji based on summary.
+   */
+  getStatusEmoji(summary) {
+    if (summary.failedTests > 0 || summary.leakTests > 0) {
+      return "X";
+    }
+    if (summary.warningTests > 0) {
+      return "!";
+    }
+    return "OK";
+  }
+  /**
+   * Get summary text.
+   */
+  getSummaryText(summary) {
+    if (summary.failedTests > 0) {
+      return `${summary.failedTests} test(s) failed`;
+    }
+    if (summary.leakTests > 0) {
+      return `${summary.leakTests} memory leak(s) detected`;
+    }
+    if (summary.warningTests > 0) {
+      return `${summary.warningTests} warning(s)`;
+    }
+    return "All tests passed";
+  }
+  /**
+   * Generate markdown table for project measurements.
+   */
+  generateProjectTable(project) {
+    const lines = [];
+    lines.push("| Test | Duration | Heap Delta | CPU Time | Status |");
+    lines.push("|------|----------|------------|----------|--------|");
+    for (const m of project.measurements) {
+      const status = this.getTestStatus(m);
+      const heapDelta = m.memoryDelta ? formatBytes(m.memoryDelta.heapUsed) : "N/A";
+      const cpuTime = m.final?.cpu.total ? formatMicroseconds(m.final.cpu.total) : "N/A";
+      lines.push(`| ${m.name} | ${formatDuration(m.timing.durationMs)} | ${heapDelta} | ${cpuTime} | ${status} |`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get test status indicator.
+   */
+  getTestStatus(m) {
+    const hasError = m.issues.some((i) => i.severity === "error");
+    const hasLeak = m.issues.some((i) => i.type === "memory-leak");
+    const hasWarning = m.issues.some((i) => i.severity === "warning");
+    if (hasLeak) {
+      return "LEAK";
+    }
+    if (hasError) {
+      return "FAIL";
+    }
+    if (hasWarning) {
+      return "WARN";
+    }
+    return "OK";
+  }
+  /**
+   * Check if a leak detection result is a parallel result.
+   */
+  isParallelResult(result) {
+    return typeof result === "object" && result !== null && "workersUsed" in result && "perWorkerStats" in result && "totalRequestsPerSecond" in result;
+  }
+};
+async function saveReports(measurements, outputDir, baseline, gitInfo) {
+  const { writeFile, ensureDir } = await import("@frontmcp/utils");
+  await ensureDir(outputDir);
+  const generator = new ReportGenerator();
+  const report = generator.generateReport(measurements, baseline, gitInfo);
+  const jsonPath = `${outputDir}/report.json`;
+  const markdownPath = `${outputDir}/report.md`;
+  await writeFile(jsonPath, generator.generateJsonReport(report));
+  await writeFile(markdownPath, generator.generateMarkdownReport(report));
+  return { jsonPath, markdownPath };
+}
+function createReportGenerator() {
+  return new ReportGenerator();
+}
+export {
+  BaselineStore,
+  LeakDetector,
+  MetricsCollector,
+  PerfFixturesImpl,
+  RegressionDetector,
+  ReportGenerator,
+  addGlobalMeasurement,
+  assertNoLeak,
+  buildReleaseCommentsUrl,
+  clearGlobalMeasurements,
+  createLeakDetector,
+  createPerfFixtures,
+  createReportGenerator,
+  filterByStatus,
+  forceFullGc,
+  forceGc,
+  formatBaselineAsComment,
+  formatBytes,
+  formatDuration,
+  formatMicroseconds,
+  getBaselineStore,
+  getGlobalCollector,
+  getGlobalMeasurements,
+  getMeasurementsForProject,
+  getMostSevereMetric,
+  getRegressionDetector,
+  isGcAvailable,
+  parseBaselineFromComment,
+  perfTest,
+  resetBaselineStore,
+  resetGlobalCollector,
+  resetRegressionDetector,
+  saveReports,
+  summarizeRegressions
+};