@frontmcp/testing 1.8.6 → 1.9.0

package/index.js

@@ -60,6 +60,7 @@ __export(index_exports, {
   RegressionDetector: () => RegressionDetector,
   ReportGenerator: () => ReportGenerator,
   ServerStartError: () => ServerStartError,
+  SseTransport: () => SseTransport,
   StreamableHttpTransport: () => StreamableHttpTransport,
   TestClientError: () => TestClientError,
   TestServer: () => TestServer,
@@ -460,8 +461,479 @@ var interceptors = {
   }
 };
 
-// libs/testing/src/transport/streamable-http.transport.ts
+// libs/testing/src/transport/error-utils.ts
+function errorName(err) {
+  if (typeof err !== "object" || err === null) return void 0;
+  const name = err.name;
+  return typeof name === "string" ? name : void 0;
+}
+function isAbortError(err) {
+  return errorName(err) === "AbortError";
+}
+function errorMessage(err, fallback = "Unknown error") {
+  if (typeof err === "string" && err) return err;
+  if (typeof err === "object" && err !== null) {
+    const message = err.message;
+    if (typeof message === "string" && message) return message;
+  }
+  return fallback;
+}
+var interceptedErrors = /* @__PURE__ */ new WeakSet();
+function markInterceptedError(err) {
+  interceptedErrors.add(err);
+  return err;
+}
+function isInterceptedError(err) {
+  return typeof err === "object" && err !== null && interceptedErrors.has(err);
+}
+
+// libs/testing/src/transport/sse.transport.ts
 var DEFAULT_TIMEOUT = 3e4;
+var SseTransport = class {
+  baseUrl;
+  entryPath;
+  timeout;
+  authHeaders;
+  publicMode;
+  debug;
+  clientInfo;
+  notificationHandler;
+  interceptors;
+  elicitationHandler;
+  state = "disconnected";
+  authToken;
+  sessionId;
+  messageEndpoint;
+  stream;
+  pending = /* @__PURE__ */ new Map();
+  connectionCount = 0;
+  reconnectCount = 0;
+  lastRequestHeaders = {};
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.entryPath = config.entryPath;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.authHeaders = config.auth?.headers ?? {};
+    this.authToken = config.auth?.token;
+    this.publicMode = config.publicMode ?? false;
+    this.debug = config.debug ?? false;
+    this.clientInfo = config.clientInfo;
+    this.notificationHandler = config.notificationHandler;
+    this.interceptors = config.interceptors;
+    this.elicitationHandler = config.elicitationHandler;
+  }
+  async connect() {
+    this.state = "connecting";
+    this.connectionCount++;
+    try {
+      if (!this.publicMode && !this.authToken) {
+        await this.requestAnonymousToken();
+      }
+      await this.openStream();
+      this.state = "connected";
+      this.log(`Connected; messages go to ${this.messageEndpoint}`);
+    } catch (error) {
+      this.state = "error";
+      this.stream?.abort();
+      this.stream = void 0;
+      throw error;
+    }
+  }
+  async request(message) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    if (this.interceptors) {
+      const intercepted = await this.interceptors.processRequest(message, {
+        timestamp: /* @__PURE__ */ new Date(),
+        transport: "sse",
+        sessionId: this.sessionId
+      });
+      switch (intercepted.type) {
+        case "mock":
+          return await this.interceptors.processResponse(
+            message,
+            intercepted.response,
+            Date.now() - startTime
+          );
+        case "error":
+          throw markInterceptedError(intercepted.error);
+        case "continue":
+          message = intercepted.request;
+          break;
+      }
+    }
+    let response;
+    if (message.id === void 0) {
+      await this.post(JSON.stringify(message));
+      response = { jsonrpc: "2.0", id: null, result: void 0 };
+    } else {
+      response = await this.postAndAwait(message.id, JSON.stringify(message));
+    }
+    if (this.interceptors) {
+      response = await this.interceptors.processResponse(message, response, Date.now() - startTime);
+    }
+    return response;
+  }
+  async notify(message) {
+    this.ensureConnected();
+    const result = await this.post(JSON.stringify(message));
+    if (!result.ok) this.log(`HTTP ${result.status} on notification: ${result.body}`);
+  }
+  async sendRaw(data) {
+    this.ensureConnected();
+    let id;
+    try {
+      const parsed = JSON.parse(data);
+      if (typeof parsed.id === "string" || typeof parsed.id === "number") id = parsed.id;
+    } catch {
+    }
+    if (id !== void 0) return this.postAndAwait(id, data);
+    const result = await this.post(data);
+    if (!result.ok) {
+      return { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error", data: result.body } };
+    }
+    return { jsonrpc: "2.0", id: null, result: void 0 };
+  }
+  async close() {
+    this.closeStream("Transport closed");
+    this.state = "disconnected";
+    this.sessionId = void 0;
+    this.messageEndpoint = void 0;
+    this.log("SSE transport closed");
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  getState() {
+    return this.state;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  setTimeout(ms) {
+    this.timeout = ms;
+  }
+  getMessageEndpoint() {
+    return this.messageEndpoint;
+  }
+  getConnectionCount() {
+    return this.connectionCount;
+  }
+  getReconnectCount() {
+    return this.reconnectCount;
+  }
+  getLastRequestHeaders() {
+    return { ...this.lastRequestHeaders };
+  }
+  setInterceptors(interceptors2) {
+    this.interceptors = interceptors2;
+  }
+  getInterceptors() {
+    return this.interceptors;
+  }
+  setElicitationHandler(handler) {
+    this.elicitationHandler = handler;
+  }
+  async simulateDisconnect() {
+    this.closeStream("Simulated disconnect");
+    this.state = "disconnected";
+    this.sessionId = void 0;
+    this.messageEndpoint = void 0;
+  }
+  async waitForReconnect(timeoutMs) {
+    this.reconnectCount++;
+    let timer;
+    try {
+      await Promise.race([
+        this.connect(),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Timeout waiting for reconnection")), timeoutMs);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // STREAM
+  // ═══════════════════════════════════════════════════════════════════
+  /** Open `GET <entry>/sse` and wait for the `endpoint` event. */
+  async openStream() {
+    const controller = new AbortController();
+    this.stream = controller;
+    const url = this.sseUrl();
+    const { "Content-Type": _contentType, ...headers } = this.buildHeaders();
+    this.log(`GET ${url}`);
+    const connectTimer = setTimeout(() => controller.abort(), this.timeout);
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "GET",
+        headers: { ...headers, Accept: "text/event-stream" },
+        signal: controller.signal
+      });
+    } catch (error) {
+      clearTimeout(connectTimer);
+      throw new Error(
+        isAbortError(error) ? `SSE connection to ${url} timed out after ${this.timeout}ms` : `SSE connection to ${url} failed: ${errorMessage(error)}`,
+        { cause: error }
+      );
+    }
+    const isEventStream = response.headers.get("content-type")?.includes("text/event-stream") ?? false;
+    if (!response.ok || !response.body || !isEventStream) {
+      clearTimeout(connectTimer);
+      const body = await response.text().catch(() => "");
+      throw new Error(
+        `SSE connection to ${url} failed: HTTP ${response.status} ${response.statusText}${body ? ` \u2014 ${body}` : ""}. The legacy HTTP+SSE transport needs a server that serves it (@FrontMcp({ transport: { protocol: { legacy: true } } })).`
+      );
+    }
+    const endpoint = new Promise((resolve, reject) => {
+      const reader = response.body?.getReader();
+      if (!reader) {
+        reject(new Error(`SSE connection to ${url} has no body`));
+        return;
+      }
+      void this.readStream(controller, reader, resolve, reject);
+    });
+    try {
+      const data = await endpoint;
+      const messageUrl = new URL(data, url);
+      this.messageEndpoint = messageUrl.toString();
+      this.sessionId = messageUrl.searchParams.get("sessionId") ?? void 0;
+    } finally {
+      clearTimeout(connectTimer);
+    }
+  }
+  async readStream(controller, reader, onEndpoint, onEndpointError) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let endpointSeen = false;
+    try {
+      for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
+        const { completeEvents, remainder } = splitSSEEvents(buffer + decoder.decode(chunk.value, { stream: true }));
+        buffer = remainder;
+        for (const text of completeEvents) {
+          const event = parseSSEEvent(text);
+          if (!event) continue;
+          if (event.type === "endpoint") {
+            if (!endpointSeen) {
+              endpointSeen = true;
+              onEndpoint(event.data);
+            }
+            continue;
+          }
+          await this.handleMessage(event.data);
+        }
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) this.log("SSE stream failed:", error);
+    } finally {
+      reader.releaseLock();
+    }
+    if (!endpointSeen) {
+      onEndpointError(
+        new Error(
+          controller.signal.aborted ? `SSE stream at ${this.sseUrl()} sent no endpoint event within ${this.timeout}ms` : `SSE stream at ${this.sseUrl()} ended before the server sent its endpoint`
+        )
+      );
+    }
+    if (this.stream === controller) {
+      this.stream = void 0;
+      this.rejectPending("SSE stream closed by the server");
+      if (this.state === "connected") this.state = "disconnected";
+    }
+  }
+  async handleMessage(data) {
+    let message;
+    try {
+      message = JSON.parse(data);
+    } catch {
+      this.log("Ignoring SSE event that is not JSON:", data);
+      return;
+    }
+    if (!message || typeof message !== "object") return;
+    if (typeof message.method === "string") {
+      const request = message;
+      if (request.id === void 0 || request.id === null) {
+        this.notificationHandler?.(request);
+        return;
+      }
+      await this.answerServerRequest(request);
+      return;
+    }
+    if (message.id !== void 0 && message.id !== null) {
+      const pending = this.pending.get(message.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(message.id);
+        pending.resolve(message);
+      }
+    }
+  }
+  /** Server→client requests: elicitation goes to the handler, `ping` is answered, the rest refused. */
+  async answerServerRequest(request) {
+    const id = request.id;
+    let reply;
+    if (request.method === "elicitation/create") {
+      reply = { jsonrpc: "2.0", id, result: await this.elicit(request.params) };
+    } else if (request.method === "ping") {
+      reply = { jsonrpc: "2.0", id, result: {} };
+    } else {
+      reply = { jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${request.method}` } };
+    }
+    const result = await this.post(JSON.stringify(reply));
+    if (!result.ok) this.log(`HTTP ${result.status} answering ${request.method}: ${result.body}`);
+  }
+  async elicit(params) {
+    if (!this.elicitationHandler) return { action: "decline" };
+    try {
+      return await this.elicitationHandler(params);
+    } catch (error) {
+      this.log("Elicitation handler error:", error);
+      return { action: "cancel" };
+    }
+  }
+  closeStream(reason) {
+    const controller = this.stream;
+    this.stream = void 0;
+    controller?.abort();
+    this.rejectPending(reason);
+  }
+  rejectPending(reason) {
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.resolve({ jsonrpc: "2.0", id, error: { code: -32e3, message: reason } });
+    }
+    this.pending.clear();
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // POSTING
+  // ═══════════════════════════════════════════════════════════════════
+  /** POST a message and resolve with the response the stream carries for `id`. */
+  async postAndAwait(id, body) {
+    const answer = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        resolve({ jsonrpc: "2.0", id, error: { code: -32e3, message: `Request timeout after ${this.timeout}ms` } });
+      }, this.timeout);
+      this.pending.set(id, { resolve, timer });
+    });
+    const result = await this.post(body);
+    if (!result.ok) {
+      const pending = this.pending.get(id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(id);
+      }
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32e3, message: `HTTP ${result.status}: ${result.statusText}`, data: result.body }
+      };
+    }
+    return answer;
+  }
+  async post(body) {
+    const endpoint = this.messageEndpoint;
+    if (!endpoint) throw new Error("SSE transport has no message endpoint. Call connect() first.");
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    this.log(`POST ${endpoint}`, body);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(endpoint, { method: "POST", headers, body, signal: controller.signal });
+      const text = await response.text();
+      return { ok: response.ok, status: response.status, statusText: response.statusText, body: text };
+    } catch (error) {
+      if (isAbortError(error)) {
+        return { ok: false, status: 0, statusText: `timeout after ${this.timeout}ms`, body: "" };
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // HELPERS
+  // ═══════════════════════════════════════════════════════════════════
+  async requestAnonymousToken() {
+    const url = new URL(this.baseUrl);
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}/oauth/token`;
+    url.search = "";
+    const tokenUrl = url.toString();
+    try {
+      const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ grant_type: "anonymous", client_id: crypto.randomUUID(), resource: this.baseUrl })
+      });
+      if (!response.ok) {
+        this.log(`No anonymous token (HTTP ${response.status})`);
+        return;
+      }
+      const token = await response.json();
+      if (token.access_token) this.authToken = token.access_token;
+    } catch (error) {
+      this.log("Error requesting anonymous token:", error);
+    }
+  }
+  /** `<baseUrl><entryPath>/sse`, built from URL parts so query params on `baseUrl` survive. */
+  sseUrl() {
+    const url = new URL(this.baseUrl);
+    const entry = (this.entryPath ?? "").replace(/^\/+|\/+$/g, "");
+    const basePath = url.pathname.replace(/\/+$/, "");
+    url.pathname = entry ? `${basePath}/${entry}/sse` : `${basePath}/sse`;
+    return url.toString();
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream"
+    };
+    if (this.clientInfo) headers["User-Agent"] = `${this.clientInfo.name}/${this.clientInfo.version}`;
+    if (this.authToken) headers["Authorization"] = `Bearer ${this.authToken}`;
+    if (this.sessionId) headers["mcp-session-id"] = this.sessionId;
+    Object.assign(headers, this.authHeaders);
+    return headers;
+  }
+  ensureConnected() {
+    if (this.state !== "connected") {
+      throw new Error("Transport not connected. Call connect() first.");
+    }
+  }
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[SSE] ${message}`, data ?? "");
+    }
+  }
+};
+function splitSSEEvents(buffer) {
+  const endsWithCarriageReturn = buffer.endsWith("\r");
+  const normalized = (endsWithCarriageReturn ? buffer.slice(0, -1) : buffer).replace(/\r\n?/g, "\n");
+  const completeEvents = normalized.split("\n\n");
+  const remainder = completeEvents.pop() ?? "";
+  return { completeEvents, remainder: endsWithCarriageReturn ? `${remainder}\r` : remainder };
+}
+function parseSSEEvent(text) {
+  let type = "message";
+  const data = [];
+  for (const line of text.split("\n")) {
+    if (line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+    if (field === "event") type = value;
+    else if (field === "data") data.push(value);
+  }
+  return data.length > 0 ? { type, data: data.join("\n") } : void 0;
+}
+
+// libs/testing/src/transport/streamable-http.transport.ts
+var DEFAULT_TIMEOUT2 = 3e4;
 var NOTIFICATION_STREAM_REOPEN_DELAY_MS = 250;
 var StreamableHttpTransport = class {
   config;
@@ -483,7 +955,7 @@ var StreamableHttpTransport = class {
       baseUrl: config.baseUrl.replace(/\/$/, ""),
       // Remove trailing slash
       entryPath: config.entryPath,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT2,
       auth: config.auth ?? {},
       publicMode: config.publicMode ?? false,
       debug: config.debug ?? false,
@@ -568,7 +1040,7 @@ var StreamableHttpTransport = class {
           return mockResponse2;
         }
         case "error":
-          throw interceptResult.error;
+          throw markInterceptedError(interceptResult.error);
         case "continue":
           message = interceptResult.request;
           break;
@@ -629,7 +1101,7 @@ var StreamableHttpTransport = class {
       return jsonResponse;
     } catch (error) {
       clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
+      if (isAbortError(error)) {
         return {
           jsonrpc: "2.0",
           id: message.id ?? null,
@@ -668,7 +1140,7 @@ var StreamableHttpTransport = class {
       }
     } catch (error) {
       clearTimeout(timeoutId);
-      if (error instanceof Error && error.name !== "AbortError") {
+      if (!isAbortError(error)) {
         throw error;
       }
     }
@@ -709,7 +1181,7 @@ var StreamableHttpTransport = class {
         error: {
           code: -32700,
           message: "Parse error",
-          data: error instanceof Error ? error.message : "Unknown error"
+          data: errorMessage(error)
         }
       };
     }
@@ -823,7 +1295,7 @@ var StreamableHttpTransport = class {
     let buffer = "";
     try {
       for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
-        const { completeEvents, remainder } = splitSSEEvents(buffer + decoder.decode(chunk.value, { stream: true }));
+        const { completeEvents, remainder } = splitSSEEvents2(buffer + decoder.decode(chunk.value, { stream: true }));
         buffer = remainder;
         for (const eventText of completeEvents) {
           for (const event of this.parseSSEEvents(eventText, void 0).events) {
@@ -1079,7 +1551,7 @@ var StreamableHttpTransport = class {
     if (this.config.clientInfo) {
       headers["User-Agent"] = `${this.config.clientInfo.name}/${this.config.clientInfo.version}`;
     }
-    if (this.authToken && !this.publicMode) {
+    if (this.authToken) {
       headers["Authorization"] = `Bearer ${this.authToken}`;
     }
     if (this.sessionId) {
@@ -1157,7 +1629,7 @@ var StreamableHttpTransport = class {
     };
   }
 };
-function splitSSEEvents(buffer) {
+function splitSSEEvents2(buffer) {
   const endsWithCarriageReturn = buffer.endsWith("\r");
   const normalized = (endsWithCarriageReturn ? buffer.slice(0, -1) : buffer).replace(/\r\n?/g, "\n");
   const completeEvents = normalized.split("\n\n");
@@ -1414,7 +1886,7 @@ var McpTestClientBuilder = class {
 };
 
 // libs/testing/src/client/mcp-test-client.ts
-var DEFAULT_TIMEOUT2 = 3e4;
+var DEFAULT_TIMEOUT3 = 3e4;
 var DEFAULT_PROTOCOL_VERSION = "2025-06-18";
 var UNSUPPORTED_PROTOCOL_VERSIONS = ["2026-07-28"];
 var DEFAULT_CLIENT_INFO = {
@@ -1422,6 +1894,15 @@ var DEFAULT_CLIENT_INFO = {
   version: "0.4.0"
 };
 var MAX_LIST_PAGES = 1e3;
+function isAuthFailure(error) {
+  return typeof error?.message === "string" && /^HTTP (401|403)\b/.test(error.message);
+}
+function describeInitializeError(error) {
+  const message = error?.message ?? "Unknown error";
+  const data = error?.data;
+  const detail = typeof data === "string" ? data.trim() : "";
+  return detail ? `${message} - ${detail.slice(0, 500)}` : message;
+}
 function extractEntryPaths(data) {
   let payload = data;
   if (typeof payload === "string") {
@@ -1475,7 +1956,7 @@ var McpTestClient = class {
       transport: config.transport ?? "streamable-http",
       auth: config.auth ?? {},
       publicMode: config.publicMode ?? false,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT2,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT3,
       debug: config.debug ?? false,
       protocolVersion: config.protocolVersion ?? DEFAULT_PROTOCOL_VERSION,
       clientInfo: config.clientInfo ?? DEFAULT_CLIENT_INFO,
@@ -1508,19 +1989,22 @@ var McpTestClient = class {
   async connect() {
     this.log("debug", `Connecting to ${this.config.baseUrl}...`);
     this.triedDiscoveredEntryPath = false;
+    this.initResult = null;
     this.transport = this.createTransport();
     await this.transport.connect();
     const maxRetries = 3;
     const retryDelayMs = 500;
     let lastError;
     let reportedEntryPaths;
+    let attemptsMade = 0;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      attemptsMade = attempt;
       const initResponse = await this.initialize();
       if (initResponse.success && initResponse.data) {
         this.initResult = initResponse.data;
         break;
       }
-      lastError = initResponse.error?.message ?? "Unknown error";
+      lastError = describeInitializeError(initResponse.error);
       reportedEntryPaths = extractEntryPaths(initResponse.error?.data) ?? reportedEntryPaths;
       if (reportedEntryPaths?.length === 1 && !this.triedDiscoveredEntryPath) {
         this.triedDiscoveredEntryPath = true;
@@ -1532,6 +2016,7 @@ var McpTestClient = class {
         await this.transport.connect();
         continue;
       }
+      if (isAuthFailure(initResponse.error)) break;
       if (attempt < maxRetries) {
         this.log("debug", `MCP init attempt ${attempt} failed (${lastError}), retrying in ${retryDelayMs}ms...`);
         await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
@@ -1540,7 +2025,7 @@ var McpTestClient = class {
     if (!this.initResult) {
       const served = reportedEntryPaths?.length ? ` The server reports it serves MCP at ${reportedEntryPaths.join(", ")}; set \`entryPath\` in test.use() (or \`http.entryPath\` on the server) to match.` : "";
       throw new Error(
-        `Failed to initialize MCP connection to ${this.config.baseUrl}${this.mcpPathLabel()} after ${maxRetries} attempts: ${lastError}.${served}`
+        `Failed to initialize MCP connection to ${this.config.baseUrl}${this.mcpPathLabel()} after ${attemptsMade} attempt${attemptsMade === 1 ? "" : "s"}: ${lastError}.${served}`
       );
     }
     this._sessionId = this.transport.getSessionId();
@@ -1610,18 +2095,47 @@ var McpTestClient = class {
     return this._authState;
   }
   /**
-   * Authenticate with a token
+   * Authenticate with a token.
+   *
+   * When connected, this opens a NEW session with the token (the previous session was created
+   * for the previous identity) and rejects if the server refuses it — for example because the
+   * token is expired or badly signed. On rejection the client keeps its previous identity and
+   * session. The token is kept in the client config, so `reconnect()` keeps using it.
    */
   async authenticate(token) {
+    if (typeof token !== "string" || token.trim() === "") {
+      throw new Error("authenticate() requires a non-empty token");
+    }
+    const previousAuthState = this._authState;
+    const previousConfigAuth = this.config.auth;
+    this.config.auth = { ...previousConfigAuth, token };
     this._authState = {
       isAnonymous: false,
       token,
       scopes: this.parseScopesFromToken(token),
       user: this.parseUserFromToken(token)
     };
-    if (this.transport) {
-      this.transport.setAuthToken(token);
+    const previousTransport = this.transport;
+    if (!previousTransport) {
+      this.log("debug", "Authentication updated (not connected yet)");
+      return;
+    }
+    const previousInit = this.initResult;
+    const previousSessionId = this._sessionId;
+    const previousSessionInfo = this._sessionInfo;
+    try {
+      await this.connect();
+    } catch (err) {
+      await this.transport?.close().catch(() => void 0);
+      this.transport = previousTransport;
+      this.initResult = previousInit;
+      this._sessionId = previousSessionId;
+      this._sessionInfo = previousSessionInfo;
+      this.config.auth = previousConfigAuth;
+      this._authState = previousAuthState;
+      throw err;
     }
+    await previousTransport.close().catch(() => void 0);
     this.log("debug", "Authentication updated");
   }
   // ═══════════════════════════════════════════════════════════════════
@@ -2208,7 +2722,18 @@ var McpTestClient = class {
           notificationHandler: this.recordNotification
         });
       case "sse":
-        throw new Error("SSE transport not yet implemented");
+        return new SseTransport({
+          baseUrl,
+          entryPath: this.config.entryPath,
+          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,
+          notificationHandler: this.recordNotification
+        });
       default:
         throw new Error(`Unknown transport type: ${this.config.transport}`);
     }
@@ -2245,10 +2770,11 @@ var McpTestClient = class {
         requestId: id
       };
     } catch (err) {
+      if (isInterceptedError(err)) throw err;
       const durationMs = Date.now() - start;
       const error = {
         code: -32603,
-        message: err instanceof Error ? err.message : "Unknown error"
+        message: errorMessage(err)
       };
       return {
         success: false,
@@ -2396,12 +2922,12 @@ var McpTestClient = class {
       const payload = this.decodeJwtPayload(token);
       if (!payload) return [];
       const scope = payload["scope"];
-      const scopes = payload["scopes"];
+      const scopes2 = payload["scopes"];
       if (typeof scope === "string") {
         return scope.split(" ");
       }
-      if (Array.isArray(scopes)) {
-        return scopes;
+      if (Array.isArray(scopes2)) {
+        return scopes2;
       }
       return [];
     } catch {
@@ -2533,14 +3059,15 @@ var TestTokenFactory = class {
    */
   async createTestToken(options) {
     await this.ensureKeys();
-    const now = Math.floor(Date.now() / 1e3);
+    const nowMs = Date.now();
+    const iat = Math.floor(nowMs / 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,
+      iat,
+      exp: Math.ceil(nowMs / 1e3) + exp,
       scope: options.scopes?.join(" "),
       ...options.claims
     };
@@ -2565,10 +3092,10 @@ var TestTokenFactory = class {
   /**
    * Create a regular user token
    */
-  async createUserToken(sub = "user-001", scopes = ["read", "write"]) {
+  async createUserToken(sub = "user-001", scopes2 = ["read", "write"]) {
     return this.createTestToken({
       sub,
-      scopes,
+      scopes: scopes2,
       claims: {
         email: "user@test.local",
         name: "Test User",
@@ -2579,10 +3106,11 @@ var TestTokenFactory = class {
   /**
    * Create an anonymous user token
    */
-  async createAnonymousToken() {
+  async createAnonymousToken(expiresIn) {
     return this.createTestToken({
       sub: `anon:${Date.now()}`,
       scopes: ["anonymous"],
+      exp: expiresIn,
       claims: {
         name: "Anonymous",
         role: "anonymous"
@@ -2793,17 +3321,7 @@ function createTestUser(overrides) {
 
 // libs/testing/src/auth/mock-oauth-server.ts
 var import_http = require("http");
-var _randomBytes;
-var _sha256Base64url;
-var _base64urlEncode;
-async function loadCryptoUtils() {
-  if (!_randomBytes) {
-    const utils = await import("@frontmcp/utils");
-    _randomBytes = utils.randomBytes;
-    _sha256Base64url = utils.sha256Base64url;
-    _base64urlEncode = utils.base64urlEncode;
-  }
-}
+var import_utils = require("@frontmcp/utils");
 var MockOAuthServer = class {
   tokenFactory;
   options;
@@ -2818,8 +3336,8 @@ var MockOAuthServer = class {
   accessTokenTtlSeconds;
   /** Refresh token TTL in seconds */
   refreshTokenTtlSeconds;
-  constructor(tokenFactory3, options = {}) {
-    this.tokenFactory = tokenFactory3;
+  constructor(tokenFactory2, options = {}) {
+    this.tokenFactory = tokenFactory2;
     this.options = options;
     this.accessTokenTtlSeconds = options.accessTokenTtlSeconds ?? 3600;
     this.refreshTokenTtlSeconds = options.refreshTokenTtlSeconds ?? 30 * 24 * 3600;
@@ -3076,14 +3594,14 @@ ${error.stack}` : String(error);
         return;
       }
       const code = this.generateCode();
-      const scopes = scope.split(" ").filter(Boolean);
+      const scopes2 = scope.split(" ").filter(Boolean);
       this.authCodes.set(code, {
         code,
         clientId,
         redirectUri,
         codeChallenge,
         codeChallengeMethod,
-        scopes,
+        scopes: scopes2,
         user: testUser,
         state,
         expiresAt: Date.now() + 5 * 60 * 1e3,
@@ -3123,7 +3641,7 @@ ${error.stack}` : String(error);
     }
     const grantType = params.get("grant_type");
     if (grantType === "anonymous") {
-      const token = await this.tokenFactory.createAnonymousToken();
+      const token = await this.tokenFactory.createAnonymousToken(this.accessTokenTtlSeconds);
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(
         JSON.stringify({
@@ -3255,6 +3773,8 @@ ${error.stack}` : String(error);
     codeRecord.used = true;
     const accessToken = await this.tokenFactory.createTestToken({
       sub: codeRecord.user.sub,
+      scopes: codeRecord.scopes,
+      exp: this.accessTokenTtlSeconds,
       claims: {
         email: codeRecord.user.email,
         name: codeRecord.user.name,
@@ -3263,6 +3783,7 @@ ${error.stack}` : String(error);
     });
     const idToken = await this.tokenFactory.createTestToken({
       sub: codeRecord.user.sub,
+      exp: this.accessTokenTtlSeconds,
       claims: {
         email: codeRecord.user.email,
         name: codeRecord.user.name,
@@ -3340,6 +3861,8 @@ ${error.stack}` : String(error);
     }
     const accessToken = await this.tokenFactory.createTestToken({
       sub: tokenRecord.user.sub,
+      scopes: tokenRecord.scopes,
+      exp: this.accessTokenTtlSeconds,
       claims: {
         email: tokenRecord.user.email,
         name: tokenRecord.user.name,
@@ -3444,14 +3967,14 @@ ${error.stack}` : String(error);
       name
     };
     const code = this.generateCode();
-    const scopes = scope.split(" ").filter(Boolean);
+    const scopes2 = scope.split(" ").filter(Boolean);
     this.authCodes.set(code, {
       code,
       clientId,
       redirectUri,
       codeChallenge,
       codeChallengeMethod,
-      scopes,
+      scopes: scopes2,
       user: testUser,
       state,
       expiresAt: Date.now() + 5 * 60 * 1e3,
@@ -3557,8 +4080,7 @@ ${error.stack}` : String(error);
    * Generate a random authorization code
    */
   async generateCodeAsync() {
-    await loadCryptoUtils();
-    return _base64urlEncode(_randomBytes(32));
+    return (0, import_utils.base64urlEncode)((0, import_utils.randomBytes)(32));
   }
   /**
    * Generate a random authorization code (sync wrapper for compatibility)
@@ -3574,8 +4096,7 @@ ${error.stack}` : String(error);
    */
   async computeCodeChallengeAsync(verifier, method) {
     if (method === "S256") {
-      await loadCryptoUtils();
-      return _sha256Base64url(verifier);
+      return (0, import_utils.sha256Base64url)(verifier);
     }
     return verifier;
   }
@@ -4163,7 +4684,7 @@ var MockCimdServer = class {
 
 // libs/testing/src/server/test-server.ts
 var import_child_process = require("child_process");
-var import_utils = require("@frontmcp/utils");
+var import_utils2 = require("@frontmcp/utils");
 
 // libs/testing/src/errors/index.ts
 var TestClientError = class extends Error {
@@ -4269,6 +4790,8 @@ var E2E_PORT_RANGES = {
   "demo-e2e-distributed": { start: 50440, size: 20 },
   // Protocol revision E2E tests (50460-50479)
   "demo-e2e-protocol-20260728": { start: 50460, size: 20 },
+  // Testing library E2E tests (50480-50499)
+  "demo-e2e-testing": { start: 50480, size: 20 },
   // Mock servers and utilities (50900-50999)
   "mock-oauth": { start: 50900, size: 10 },
   "mock-api": { start: 50910, size: 10 },
@@ -4277,6 +4800,66 @@ var E2E_PORT_RANGES = {
   default: { start: 51e3, size: 100 }
 };
 var reservedPorts = /* @__PURE__ */ new Map();
+var lockedPorts = /* @__PURE__ */ new Set();
+var LOCK_MAX_AGE_MS = 10 * 60 * 1e3;
+function lockDir() {
+  try {
+    const os = require("node:os");
+    const path = require("node:path");
+    return path.join(os.tmpdir(), "frontmcp-testing-ports");
+  } catch {
+    return void 0;
+  }
+}
+function pidIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function acquirePortLock(port) {
+  if (lockedPorts.has(port)) return false;
+  let fs;
+  let file;
+  try {
+    fs = require("node:fs");
+    const dir = lockDir();
+    if (!dir) return true;
+    fs.mkdirSync(dir, { recursive: true });
+    file = require("node:path").join(dir, `${port}.lock`);
+  } catch {
+    return true;
+  }
+  const payload = JSON.stringify({ pid: process.pid, at: Date.now() });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      fs.writeFileSync(file, payload, { flag: "wx" });
+      lockedPorts.add(port);
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST") return true;
+      try {
+        const held = JSON.parse(fs.readFileSync(file, "utf8"));
+        const fresh = typeof held.at === "number" && Date.now() - held.at < LOCK_MAX_AGE_MS;
+        if (fresh && typeof held.pid === "number" && pidIsAlive(held.pid)) return false;
+        fs.unlinkSync(file);
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function releasePortLock(port) {
+  if (!lockedPorts.delete(port)) return;
+  try {
+    const fs = require("node:fs");
+    const dir = lockDir();
+    if (dir) fs.unlinkSync(require("node:path").join(dir, `${port}.lock`));
+  } catch {
+  }
+}
 var projectPortIndex = /* @__PURE__ */ new Map();
 function getPortRange(project) {
   const key = project;
@@ -4287,15 +4870,22 @@ function getPortRange(project) {
 }
 async function reservePort(project, preferredPort) {
   const range = getPortRange(project);
-  if (preferredPort !== void 0) {
+  const handle = (port) => ({
+    port,
+    // Frees the socket only, so the server about to be spawned can bind the port; the lock file stays
+    releaseSocket: async () => {
+      await releasePort(port);
+    },
+    release: async () => {
+      await releasePort(port);
+      releasePortLock(port);
+    }
+  });
+  const wantsSpecificPort = preferredPort !== void 0 && Number.isInteger(preferredPort) && preferredPort > 0;
+  if (wantsSpecificPort) {
     const reservation = await tryReservePort(preferredPort, project);
     if (reservation) {
-      return {
-        port: preferredPort,
-        release: async () => {
-          await releasePort(preferredPort);
-        }
-      };
+      return handle(preferredPort);
     }
     console.warn(`[PortRegistry] Preferred port ${preferredPort} not available for ${project}, allocating from range`);
   }
@@ -4304,30 +4894,19 @@ async function reservePort(project, preferredPort) {
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     const port = range.start + index % range.size;
     index = (index + 1) % range.size;
-    if (reservedPorts.has(port)) {
+    if (reservedPorts.has(port) || lockedPorts.has(port)) {
       continue;
     }
     const reservation = await tryReservePort(port, project);
     if (reservation) {
       projectPortIndex.set(project, index);
-      return {
-        port,
-        release: async () => {
-          await releasePort(port);
-        }
-      };
+      return handle(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);
-        }
-      };
+  for (let port = 51e3; port < 52e3; port++) {
+    if (reservedPorts.has(port) || lockedPorts.has(port)) continue;
+    if (await tryReservePort(port, project)) {
+      return handle(port);
     }
   }
   throw new Error(
@@ -4335,9 +4914,13 @@ async function reservePort(project, preferredPort) {
   );
 }
 async function tryReservePort(port, project) {
+  if (!acquirePortLock(port)) {
+    return false;
+  }
   return new Promise((resolve) => {
     const server = (0, import_net.createServer)();
     server.once("error", () => {
+      releasePortLock(port);
       resolve(false);
     });
     server.listen(port, () => {
@@ -4363,31 +4946,6 @@ async function releasePort(port) {
     });
   });
 }
-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 = (0, import_net.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";
@@ -4396,8 +4954,11 @@ var TestServer = class _TestServer {
   options;
   _info;
   logs = [];
+  /** Frees the port reservation (socket and cross-process lock); held until stop() */
   portRelease = null;
-  constructor(options, port, portRelease) {
+  /** Frees only the reservation socket, just before the server is spawned */
+  portReleaseSocket = null;
+  constructor(options, port, portRelease, portReleaseSocket) {
     this.options = {
       port,
       project: options.project,
@@ -4409,6 +4970,7 @@ var TestServer = class _TestServer {
       debug: options.debug ?? DEBUG_SERVER
     };
     this.portRelease = portRelease ?? null;
+    this.portReleaseSocket = portReleaseSocket ?? portRelease ?? null;
     this._info = {
       baseUrl: `http://localhost:${port}`,
       port
@@ -4421,8 +4983,8 @@ var TestServer = class _TestServer {
     const project = options.project ?? "default";
     const maxAttempts = 3;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      const { port, release } = await reservePort(project, options.port);
-      const server = new _TestServer(options, port, release);
+      const { port, release, releaseSocket } = await reservePort(project, options.port);
+      const server = new _TestServer(options, port, release, releaseSocket);
       try {
         await server.startProcess();
         return server;
@@ -4462,7 +5024,7 @@ var TestServer = class _TestServer {
     }
     const maxAttempts = 3;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      const { port, release } = await reservePort(project, options.port);
+      const { port, release, releaseSocket } = await reservePort(project, options.port);
       const serverOptions = {
         ...options,
         port,
@@ -4470,7 +5032,7 @@ var TestServer = class _TestServer {
         command: `npx nx serve ${project} --port ${port}`,
         cwd: options.cwd ?? process.cwd()
       };
-      const server = new _TestServer(serverOptions, port, release);
+      const server = new _TestServer(serverOptions, port, release, releaseSocket);
       try {
         await server.startProcess();
         return server;
@@ -4528,10 +5090,17 @@ var TestServer = class _TestServer {
    * Stop the test server
    */
   async stop() {
-    if (this.portRelease) {
-      await this.portRelease();
-      this.portRelease = null;
+    try {
+      await this.stopProcess();
+    } finally {
+      if (this.portRelease) {
+        await this.portRelease();
+        this.portRelease = null;
+      }
+      this.portReleaseSocket = null;
     }
+  }
+  async stopProcess() {
     if (this.process) {
       this.log("Stopping server...");
       if (this.process.exitCode !== null || this.process.signalCode !== null) {
@@ -4604,7 +5173,7 @@ var TestServer = class _TestServer {
    * Restart the server
    */
   async restart() {
-    await this.stop();
+    await this.stopProcess();
     await this.startProcess();
   }
   /**
@@ -4634,9 +5203,9 @@ var TestServer = class _TestServer {
       PORT: String(this.options.port)
     };
     const runtimeEnv = withWorkspaceProtocolFallback(env, this.options.cwd);
-    if (this.portRelease) {
-      await this.portRelease();
-      this.portRelease = null;
+    if (this.portReleaseSocket) {
+      await this.portReleaseSocket();
+      this.portReleaseSocket = null;
       await sleep2(300);
     }
     this.process = (0, import_child_process.spawn)(this.options.command, [], {
@@ -4646,9 +5215,8 @@ var TestServer = class _TestServer {
       detached: true,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    if (this.process.pid !== void 0) {
-      this._info.pid = this.process.pid;
-    }
+    this._info.pid = this.process.pid;
+    this._info.shellPid = this.process.pid;
     let processExited = false;
     let exitCode = null;
     let exitError = null;
@@ -4751,6 +5319,8 @@ ${allLogs}`);
         });
         if (response.ok || response.status === 404) {
           this.log(`Server is ready after ${healthCheckAttempts} health check attempts`);
+          const listeningPid = await findListeningPid(this.options.port);
+          if (listeningPid !== void 0) this._info.pid = listeningPid;
           return;
         }
         lastHealthCheckError = `HTTP ${response.status}: ${response.statusText}`;
@@ -4795,6 +5365,19 @@ TIP: Set DEBUG_SERVER=1 or DEBUG=1 environment variable for verbose output`
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function findListeningPid(port) {
+  if (process.platform === "win32") return Promise.resolve(void 0);
+  return new Promise((resolve) => {
+    (0, import_child_process.execFile)("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], { timeout: 2e3 }, (error, stdout) => {
+      if (error) {
+        resolve(void 0);
+        return;
+      }
+      const pid = parseInt(String(stdout).split("\n")[0] ?? "", 10);
+      resolve(Number.isInteger(pid) && pid > 0 ? pid : void 0);
+    });
+  });
+}
 function withWorkspaceProtocolFallback(env, cwd) {
   if (findInstalledProtocolPackageDir(cwd)) {
     return env;
@@ -4844,7 +5427,7 @@ function withProtocolNodePathAlias(env, cwd, workspacePackageDir) {
   const fs = require("node:fs");
   const os = require("node:os");
   const path = require("node:path");
-  const aliasRoot = path.join(os.tmpdir(), "frontmcp-test-node-path", (0, import_utils.sha256Hex)(cwd).slice(0, 12));
+  const aliasRoot = path.join(os.tmpdir(), "frontmcp-test-node-path", (0, import_utils2.sha256Hex)(cwd).slice(0, 12));
   const scopeDir = path.join(aliasRoot, "@frontmcp");
   const aliasPackageDir = path.join(scopeDir, "protocol");
   fs.mkdirSync(scopeDir, { recursive: true });
@@ -5066,94 +5649,173 @@ function hasMimeType(result, mimeType) {
   return result.hasMimeType(mimeType);
 }
 
-// libs/testing/src/fixtures/test-fixture.ts
-var import_globals = require("@jest/globals");
-
 // libs/testing/src/fixtures/gateway-token-binding.ts
-var import_utils2 = require("@frontmcp/utils");
+var import_utils3 = require("@frontmcp/utils");
 function gatewayTokenBinding(serverUrl, entryPath) {
-  const base = (0, import_utils2.trimTrailing)(serverUrl, "/");
-  const prefix = (0, import_utils2.trimSlashes)(entryPath ?? "");
+  const base = (0, import_utils3.trimTrailing)(serverUrl, "/");
+  const prefix = (0, import_utils3.trimSlashes)(entryPath ?? "");
   const mcpUrl = prefix ? `${base}/${prefix}` : base;
   return { issuer: mcpUrl, audience: mcpUrl };
 }
 
 // libs/testing/src/fixtures/test-fixture.ts
-var describe2 = import_globals.describe;
-var beforeAll2 = import_globals.beforeAll;
-var beforeEach2 = import_globals.beforeEach;
-var afterEach2 = import_globals.afterEach;
-var afterAll2 = import_globals.afterAll;
-var it2 = import_globals.it;
-var currentConfig = {};
-var serverInstance = null;
-var tokenFactory = null;
-var serverStartedByUs = false;
-var skipScopes = [{ skipped: false }];
-function currentSkipScope() {
-  return skipScopes[skipScopes.length - 1];
+var jestApi;
+function jestGlobals() {
+  if (jestApi) return jestApi;
+  try {
+    const api = require("@jest/globals");
+    jestApi = {
+      describe: api["describe"],
+      beforeAll: api["beforeAll"],
+      beforeEach: api["beforeEach"],
+      afterEach: api["afterEach"],
+      afterAll: api["afterAll"],
+      it: api["it"]
+    };
+    return jestApi;
+  } catch (error) {
+    throw new Error(
+      `@frontmcp/testing fixtures ("test", "test.use", ...) can only be used inside a Jest test file: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
 }
-async function initializeSharedResources() {
-  if (!serverInstance) {
-    if (currentConfig.baseUrl && !currentConfig.server) {
-      serverInstance = TestServer.connect(currentConfig.baseUrl);
-      serverStartedByUs = false;
-    } else if (currentConfig.server) {
-      const serverCommand = resolveServerCommand(currentConfig.server);
-      const isDebug = currentConfig.logLevel === "debug" || process.env["DEBUG"] === "1" || process.env["DEBUG_SERVER"] === "1";
+function newScope(parent) {
+  return {
+    skipped: parent?.skipped ?? false,
+    reason: parent?.reason,
+    config: {},
+    envs: [],
+    configured: false,
+    cleanupRegistered: false,
+    beforeEachHooks: [],
+    afterEachHooks: []
+  };
+}
+var scopes = [newScope()];
+function currentScope() {
+  return scopes[scopes.length - 1];
+}
+var serverEntries = /* @__PURE__ */ new Map();
+function resolveConfig(chain) {
+  const merged = {};
+  for (const scope of chain) {
+    Object.assign(merged, scope.config);
+    for (const env of scope.envs) merged.env = { ...merged.env, ...env };
+  }
+  return merged;
+}
+function ownerScopeOf(chain) {
+  for (let i = chain.length - 1; i > 0; i--) {
+    if (chain[i].configured) return chain[i];
+  }
+  return chain[0];
+}
+function serverKey(config) {
+  const env = Object.fromEntries(Object.entries(config.env ?? {}).sort(([a], [b]) => a.localeCompare(b)));
+  return JSON.stringify({
+    server: config.server,
+    baseUrl: config.baseUrl,
+    project: config.project,
+    port: config.port,
+    entryPath: config.entryPath,
+    startupTimeout: config.startupTimeout,
+    logLevel: config.logLevel,
+    auth: config.auth,
+    env
+  });
+}
+function serverEnv(config) {
+  const extra = {};
+  if (config.auth?.mode) extra["FRONTMCP_TEST_AUTH_MODE"] = config.auth.mode;
+  if (config.auth?.type) extra["FRONTMCP_TEST_AUTH_TYPE"] = config.auth.type;
+  if (Object.keys(extra).length === 0 && !config.env) return void 0;
+  return { ...extra, ...config.env };
+}
+async function startServerEntry(config, owner) {
+  let server;
+  let startedByUs = false;
+  if (config.baseUrl && !config.server) {
+    server = TestServer.connect(config.baseUrl);
+  } else if (config.server) {
+    const serverCommand = resolveServerCommand(config.server);
+    const isDebug = config.logLevel === "debug" || process.env["DEBUG"] === "1" || process.env["DEBUG_SERVER"] === "1";
+    if (isDebug) {
+      console.log(`[TestFixture] Starting server: ${serverCommand}`);
+    }
+    try {
+      server = await TestServer.start({
+        project: config.project,
+        port: config.port,
+        command: serverCommand,
+        env: serverEnv(config),
+        startupTimeout: config.startupTimeout ?? 3e4,
+        debug: isDebug
+      });
+      startedByUs = true;
       if (isDebug) {
-        console.log(`[TestFixture] Starting server: ${serverCommand}`);
+        console.log(`[TestFixture] Server started at ${server.info.baseUrl}`);
       }
-      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(`[TestFixture] 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.
+    } 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"}
+Server entry: ${config.server}
+Project: ${config.project ?? "default"}
 Command: ${serverCommand}
 
-Error: ${errMsg}`
-        );
-      }
-    } else {
-      throw new Error(
-        'test.use() requires either "server" (entry file path) or "baseUrl" (for external server) option'
+Error: ${errMsg}`,
+        { cause: error }
       );
     }
+  } else {
+    throw new Error('test.use() requires either "server" (entry file path) or "baseUrl" (for external server) option');
   }
-  if (!tokenFactory) {
-    const sharedSecret = currentConfig.env?.["JWT_SECRET"];
-    const binding = serverInstance ? gatewayTokenBinding(resolveClientBaseUrl(serverInstance), currentConfig.entryPath) : void 0;
-    tokenFactory = new TestTokenFactory(sharedSecret ? { hmacSecret: sharedSecret, ...binding } : {});
-  }
+  const sharedSecret = config.env?.["JWT_SECRET"];
+  const binding = sharedSecret ? gatewayTokenBinding(config.baseUrl ?? server.info.baseUrl, config.entryPath) : void 0;
+  const tokenFactory2 = new TestTokenFactory(sharedSecret ? { hmacSecret: sharedSecret, ...binding } : {});
+  return { server, startedByUs, tokenFactory: tokenFactory2, owner };
 }
-async function createTestFixtures() {
-  await initializeSharedResources();
-  if (!serverInstance) {
-    throw new Error("Server instance not initialized");
-  }
-  if (!tokenFactory) {
-    throw new Error("Token factory not initialized");
+function acquireServer(chain) {
+  const config = resolveConfig(chain);
+  const key = serverKey(config);
+  let entry = serverEntries.get(key);
+  if (!entry) {
+    entry = startServerEntry(config, ownerScopeOf(chain));
+    serverEntries.set(key, entry);
+    entry.catch(() => serverEntries.delete(key));
+  }
+  return entry;
+}
+async function stopServers(owner) {
+  for (const [key, pending] of Array.from(serverEntries)) {
+    let entry;
+    try {
+      entry = await pending;
+    } catch {
+      serverEntries.delete(key);
+      continue;
+    }
+    if (owner && entry.owner !== owner) continue;
+    serverEntries.delete(key);
+    if (entry.startedByUs) {
+      await entry.server.stop();
+    }
   }
+}
+var fixtureContexts = /* @__PURE__ */ new WeakMap();
+async function buildFixtures(chain) {
+  const config = resolveConfig(chain);
+  const entry = await acquireServer(chain);
+  const { server, tokenFactory: tokenFactory2 } = entry;
+  const publicMode = config.publicMode ?? config.auth?.mode === "public";
+  const clientConfig = { ...config, publicMode };
   const clientInstance = McpTestClient.create({
-    baseUrl: resolveClientBaseUrl(serverInstance),
-    entryPath: currentConfig.entryPath,
-    transport: currentConfig.transport ?? "streamable-http",
-    publicMode: currentConfig.publicMode
+    baseUrl: resolveClientBaseUrl(server, clientConfig),
+    entryPath: clientConfig.entryPath,
+    transport: clientConfig.transport ?? "streamable-http",
+    publicMode
   }).build();
   try {
     await clientInstance.connect();
@@ -5167,17 +5829,18 @@ async function createTestFixtures() {
       throw err;
     }
   }
-  const auth = createAuthFixture(tokenFactory);
-  const server = createServerFixture(serverInstance);
-  return {
+  const context = { extraClients: [] };
+  const fixtures = {
     mcp: clientInstance,
-    auth,
-    server
+    auth: createAuthFixture(tokenFactory2),
+    server: createServerFixture(server, clientConfig, clientInstance, context)
   };
+  fixtureContexts.set(fixtures, context);
+  return fixtures;
 }
 async function cleanupTestFixtures(fixtures, testFailed = false) {
-  if (testFailed && serverInstance) {
-    const logs = serverInstance.getLogs();
+  if (testFailed) {
+    const logs = fixtures.server.getLogs();
     if (logs.length > 0) {
       console.error("\n[TestFixture] === Server Logs (test failed) ===");
       const recentLogs = logs.slice(-50);
@@ -5188,20 +5851,18 @@ async function cleanupTestFixtures(fixtures, testFailed = false) {
       console.error("[TestFixture] === End Server Logs ===\n");
     }
   }
+  const extras = fixtureContexts.get(fixtures)?.extraClients ?? [];
+  for (const client of extras) {
+    if (client.isConnected()) {
+      await client.disconnect().catch(() => void 0);
+    }
+  }
   if (fixtures.mcp.isConnected()) {
     await fixtures.mcp.disconnect();
   }
 }
-async function cleanupSharedResources() {
-  if (serverInstance && serverStartedByUs) {
-    await serverInstance.stop();
-  }
-  serverInstance = null;
-  tokenFactory = null;
-  serverStartedByUs = false;
-}
-function resolveClientBaseUrl(server) {
-  return currentConfig.baseUrl ?? server.info.baseUrl;
+function resolveClientBaseUrl(server, config) {
+  return config.baseUrl ?? server.info.baseUrl;
 }
 function createAuthFixture(factory) {
   const users = {
@@ -5247,28 +5908,39 @@ function createAuthFixture(factory) {
     getAudience: () => factory.getAudience()
   };
 }
-function createServerFixture(server) {
+function createServerFixture(server, config, mcp, context) {
   return {
-    info: server.info,
+    // Live view: `pid` is filled in once the server is listening and follows restarts
+    get info() {
+      return server.info;
+    },
     createClient: async (opts) => {
-      return McpTestClient.create({
-        baseUrl: resolveClientBaseUrl(server),
-        entryPath: opts?.entryPath ?? currentConfig.entryPath,
+      const client = await McpTestClient.create({
+        baseUrl: resolveClientBaseUrl(server, config),
+        entryPath: opts?.entryPath ?? config.entryPath,
         transport: opts?.transport ?? "streamable-http",
         auth: opts?.token ? { token: opts.token } : void 0,
         clientInfo: opts?.clientInfo,
-        publicMode: currentConfig.publicMode
+        publicMode: config.publicMode
       }).buildAndConnect();
+      context.extraClients.push(client);
+      return client;
     },
     createClientBuilder: () => {
       const builder = new McpTestClientBuilder({
-        baseUrl: resolveClientBaseUrl(server),
-        entryPath: currentConfig.entryPath,
-        publicMode: currentConfig.publicMode
+        baseUrl: resolveClientBaseUrl(server, config),
+        entryPath: config.entryPath,
+        publicMode: config.publicMode
       });
       return builder;
     },
-    restart: () => server.restart(),
+    restart: async () => {
+      const reconnect = [mcp, ...context.extraClients].filter((client) => client.isConnected());
+      await server.restart();
+      for (const client of reconnect) {
+        await client.reconnect();
+      }
+    },
     getLogs: () => server.getLogs(),
     clearLogs: () => server.clearLogs()
   };
@@ -5279,38 +5951,71 @@ function resolveServerCommand(server) {
   }
   return `npx tsx ${server}`;
 }
-function runWithFixtures(fn) {
-  return async () => {
-    const fixtures = await createTestFixtures();
-    let testFailed = false;
+function runWithFixtures(fn, chain) {
+  return async (...extra) => {
+    const fixtures = await buildFixtures(chain);
+    let failure;
     try {
-      await fn(fixtures);
+      for (const scope of chain) {
+        for (const hook of scope.beforeEachHooks) await hook(fixtures);
+      }
+      await fn(fixtures, ...extra);
     } catch (error) {
-      testFailed = true;
-      throw error;
-    } finally {
-      await cleanupTestFixtures(fixtures, testFailed);
+      failure = { error };
+    }
+    try {
+      await runAfterEachHooks(chain, fixtures);
+    } catch (error) {
+      failure ??= { error };
     }
+    await cleanupTestFixtures(fixtures, failure !== void 0);
+    if (failure) throw failure.error;
   };
 }
+async function runAfterEachHooks(chain, fixtures) {
+  let firstError;
+  let failed = false;
+  for (let i = chain.length - 1; i >= 0; i--) {
+    for (const hook of chain[i].afterEachHooks) {
+      try {
+        await hook(fixtures);
+      } catch (error) {
+        if (!failed) firstError = error;
+        failed = true;
+      }
+    }
+  }
+  if (failed) throw firstError;
+}
+function skipTitle(name, scope) {
+  return scope.reason ? `${name} (skipped: ${scope.reason})` : name;
+}
 function testWithFixtures(name, fn) {
-  const scope = currentSkipScope();
+  const chain = scopes.slice();
+  const scope = currentScope();
   if (scope.skipped) {
-    it2.skip(scope.reason ? `${name} (skipped: ${scope.reason})` : name, runWithFixtures(fn));
+    jestGlobals().it.skip(skipTitle(name, scope), runWithFixtures(fn, chain));
     return;
   }
-  it2(name, runWithFixtures(fn));
+  jestGlobals().it(name, runWithFixtures(fn, chain));
 }
 function use(config) {
-  currentConfig = { ...currentConfig, ...config };
-  afterAll2(async () => {
-    await cleanupSharedResources();
-  });
+  const scope = currentScope();
+  const { env, ...rest } = config;
+  scope.config = { ...scope.config, ...rest };
+  if (env) scope.envs.push(env);
+  scope.configured = true;
+  if (!scope.cleanupRegistered) {
+    scope.cleanupRegistered = true;
+    jestGlobals().afterAll(async () => {
+      await stopServers(scope === scopes[0] ? void 0 : scope);
+    });
+  }
 }
 function skip(nameOrCondition, fnOrReason) {
   if (typeof nameOrCondition === "boolean") {
     if (nameOrCondition) {
-      const scope = currentSkipScope();
+      const scope = currentScope();
       scope.skipped = true;
       scope.reason = typeof fnOrReason === "string" ? fnOrReason : void 0;
     }
@@ -5321,57 +6026,114 @@ function skip(nameOrCondition, fnOrReason) {
       `test.skip expects either (name: string, fn) or (condition: boolean, reason?: string); received (${typeof nameOrCondition}, ${typeof fnOrReason}).`
     );
   }
-  it2.skip(nameOrCondition, runWithFixtures(fnOrReason));
+  jestGlobals().it.skip(nameOrCondition, runWithFixtures(fnOrReason, scopes.slice()));
 }
 function only(name, fn) {
-  const scope = currentSkipScope();
+  const scope = currentScope();
   if (scope.skipped) {
-    it2.skip(scope.reason ? `${name} (skipped: ${scope.reason})` : name, runWithFixtures(fn));
+    jestGlobals().it.skip(skipTitle(name, scope), runWithFixtures(fn, scopes.slice()));
     return;
   }
-  it2.only(name, runWithFixtures(fn));
+  jestGlobals().it.only(name, runWithFixtures(fn, scopes.slice()));
 }
 function todo(name) {
-  it2.todo(name);
+  jestGlobals().it.todo(name);
 }
-function withSkipScope(register) {
+function each(table, ...tagged) {
+  const chain = scopes.slice();
+  const register = jestGlobals().it.each(table, ...tagged);
   return (name, fn) => {
-    register(name, () => {
-      const parent = currentSkipScope();
-      skipScopes.push({ skipped: parent.skipped, reason: parent.reason });
-      try {
-        fn();
-      } finally {
-        skipScopes.pop();
-      }
-    });
+    const scope = currentScope();
+    if (scope.skipped) {
+      const skipRegister = jestGlobals().it.skip.each(table, ...tagged);
+      skipRegister(skipTitle(name, scope), runWithFixtures(fn, chain));
+      return;
+    }
+    register(name, runWithFixtures(fn, chain));
   };
 }
-function eachWithSkipScope(each) {
-  return ((...eachArgs) => {
-    const register = each(...eachArgs);
-    return withSkipScope(register);
-  });
+function withScope(fn) {
+  return (...args) => {
+    scopes.push(newScope(currentScope()));
+    try {
+      fn(...args);
+    } finally {
+      scopes.pop();
+    }
+  };
+}
+function scopedRegister(pick) {
+  return (name, fn, timeout) => {
+    pick()(name, withScope(fn), timeout);
+  };
+}
+function scopedEach(pick) {
+  return (...eachArgs) => (name, fn, timeout) => {
+    const register = pick()(...eachArgs);
+    register(name, withScope(fn), timeout);
+  };
+}
+var describeWithScope = Object.assign(
+  scopedRegister(() => jestGlobals().describe),
+  {
+    // `describe.skip` still evaluates its callback during collection, so it needs a scope too
+    only: Object.assign(
+      scopedRegister(() => jestGlobals().describe.only),
+      {
+        each: scopedEach(() => jestGlobals().describe.only.each)
+      }
+    ),
+    skip: Object.assign(
+      scopedRegister(() => jestGlobals().describe.skip),
+      {
+        each: scopedEach(() => jestGlobals().describe.skip.each)
+      }
+    ),
+    each: scopedEach(() => jestGlobals().describe.each)
+  }
+);
+function eachHook(kind) {
+  return (fn, timeout) => {
+    if (typeof fn === "function" && fn.length > 0) {
+      const scope = currentScope();
+      (kind === "beforeEach" ? scope.beforeEachHooks : scope.afterEachHooks).push(fn);
+      return;
+    }
+    jestGlobals()[kind](fn, timeout);
+  };
 }
-var describeWithSkipScope = Object.assign(withSkipScope(describe2), describe2, {
-  only: Object.assign(withSkipScope(describe2.only), { each: eachWithSkipScope(describe2.only.each) }),
-  skip: Object.assign(withSkipScope(describe2.skip), { each: eachWithSkipScope(describe2.skip.each) }),
-  each: eachWithSkipScope(describe2.each)
-});
 var test = testWithFixtures;
 test.use = use;
-test.describe = describeWithSkipScope;
-test.beforeAll = beforeAll2;
-test.beforeEach = beforeEach2;
-test.afterEach = afterEach2;
-test.afterAll = afterAll2;
+test.describe = describeWithScope;
+test.beforeAll = ((...args) => jestGlobals().beforeAll(...args));
+test.beforeEach = eachHook("beforeEach");
+test.afterEach = eachHook("afterEach");
+test.afterAll = ((...args) => jestGlobals().afterAll(...args));
 test.skip = skip;
 test.only = only;
 test.todo = todo;
+test.each = each;
 
 // libs/testing/src/expect.ts
-var import_globals2 = require("@jest/globals");
-var expect = import_globals2.expect;
+var resolvedExpect;
+function resolveJestExpect() {
+  if (resolvedExpect) return resolvedExpect;
+  try {
+    resolvedExpect = require("@jest/globals").expect;
+    return resolvedExpect;
+  } catch (error) {
+    throw new Error(
+      `expect() from @frontmcp/testing can only be used inside a Jest test file: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+var expect = new Proxy(function frontmcpExpect() {
+}, {
+  apply: (_target, thisArg, args) => Reflect.apply(resolveJestExpect(), thisArg, args),
+  get: (_target, prop) => Reflect.get(resolveJestExpect(), prop),
+  has: (_target, prop) => Reflect.has(resolveJestExpect(), prop)
+});
 
 // libs/testing/src/platform/platform-types.ts
 function getPlatformMetaNamespace(platform) {
@@ -6034,34 +6796,44 @@ var HttpInterceptorImpl = class {
       }
     };
   }
-  get(url, response) {
+  get(url, response, options) {
     return this.mock({
-      match: { url, method: "GET" },
-      response: normalizeResponse(response)
+      match: { url, method: "GET", ...options?.match },
+      response: normalizeResponse(response),
+      ...options?.times !== void 0 && { times: options.times },
+      ...options?.name !== void 0 && { name: options.name }
     });
   }
-  post(url, response) {
+  post(url, response, options) {
     return this.mock({
-      match: { url, method: "POST" },
-      response: normalizeResponse(response)
+      match: { url, method: "POST", ...options?.match },
+      response: normalizeResponse(response),
+      ...options?.times !== void 0 && { times: options.times },
+      ...options?.name !== void 0 && { name: options.name }
     });
   }
-  put(url, response) {
+  put(url, response, options) {
     return this.mock({
-      match: { url, method: "PUT" },
-      response: normalizeResponse(response)
+      match: { url, method: "PUT", ...options?.match },
+      response: normalizeResponse(response),
+      ...options?.times !== void 0 && { times: options.times },
+      ...options?.name !== void 0 && { name: options.name }
     });
   }
-  delete(url, response) {
+  delete(url, response, options) {
     return this.mock({
-      match: { url, method: "DELETE" },
-      response: normalizeResponse(response)
+      match: { url, method: "DELETE", ...options?.match },
+      response: normalizeResponse(response),
+      ...options?.times !== void 0 && { times: options.times },
+      ...options?.name !== void 0 && { name: options.name }
     });
   }
-  any(url, response) {
+  any(url, response, options) {
     return this.mock({
-      match: { url },
-      response: normalizeResponse(response)
+      match: { url, ...options?.match },
+      response: normalizeResponse(response),
+      ...options?.times !== void 0 && { times: options.times },
+      ...options?.name !== void 0 && { name: options.name }
     });
   }
   clear() {
@@ -6093,6 +6865,9 @@ ${descriptions.join("\n")}`);
     if (index !== -1) {
       activeInterceptors.splice(index, 1);
     }
+    if (activeInterceptors.length === 0) {
+      httpMock.disable();
+    }
   }
   // Internal methods
   isActive() {
@@ -6192,43 +6967,49 @@ ${descriptions.join("\n")}`);
   }
 };
 async function interceptedFetch(input, init) {
-  const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-  const method = (init?.method ?? "GET").toUpperCase();
+  const request = typeof Request !== "undefined" && input instanceof Request ? input : void 0;
+  const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : request?.url ?? String(input);
+  const method = (init?.method ?? request?.method ?? "GET").toUpperCase();
   const headers = {};
-  if (init?.headers) {
-    if (init.headers instanceof Headers) {
-      init.headers.forEach((value, key) => {
+  const collectHeaders = (source) => {
+    if (!source) return;
+    if (source instanceof Headers) {
+      source.forEach((value, key) => {
         headers[key.toLowerCase()] = value;
       });
-    } else if (Array.isArray(init.headers)) {
-      for (const [key, value] of init.headers) {
+    } else if (Array.isArray(source)) {
+      for (const [key, value] of source) {
         headers[key.toLowerCase()] = value;
       }
     } else {
-      for (const [key, value] of Object.entries(init.headers)) {
+      for (const [key, value] of Object.entries(source)) {
         headers[key.toLowerCase()] = value;
       }
     }
-  }
+  };
+  collectHeaders(init?.headers ?? request?.headers);
   let body;
   let rawBody;
-  if (init?.body) {
-    if (typeof init.body === "string") {
-      rawBody = init.body;
-      try {
-        body = JSON.parse(init.body);
-      } catch {
-        body = init.body;
-      }
-    } else if (init.body instanceof ArrayBuffer || init.body instanceof Uint8Array) {
-      rawBody = new TextDecoder().decode(init.body);
+  let bodySource = init?.body;
+  if ((bodySource === void 0 || bodySource === null) && request && request.body !== null) {
+    bodySource = await request.clone().text();
+  }
+  if (bodySource) {
+    if (typeof bodySource === "string") {
+      rawBody = bodySource;
+    } else if (bodySource instanceof ArrayBuffer || ArrayBuffer.isView(bodySource)) {
+      rawBody = new TextDecoder().decode(bodySource);
+    } else if (bodySource instanceof URLSearchParams) {
+      rawBody = bodySource.toString();
+    }
+    if (rawBody !== void 0) {
       try {
         body = JSON.parse(rawBody);
       } catch {
         body = rawBody;
       }
     } else {
-      body = init.body;
+      body = bodySource;
     }
   }
   const requestInfo = {
@@ -6258,8 +7039,20 @@ async function interceptedFetch(input, init) {
 Add a mock using httpMock.interceptor().${method.toLowerCase()}('${url}', { body: ... })`
   );
 }
+var RESPONSE_KEYS = /* @__PURE__ */ new Set(["status", "statusText", "headers", "body", "delay"]);
+function isResponseDescriptor(value) {
+  const keys = Object.keys(value);
+  if (keys.length === 0 || !keys.every((key) => RESPONSE_KEYS.has(key))) return false;
+  if ("status" in value) {
+    const status = value["status"];
+    if (typeof status !== "number" || !Number.isInteger(status) || status < 200 || status > 599) return false;
+  }
+  return true;
+}
 function normalizeResponse(response) {
-  if (!("status" in response) && !("body" in response) && !("headers" in response)) {
+  const isNetworkError = !Array.isArray(response) && response["_throwError"] === true;
+  if (isNetworkError) return response;
+  if (Array.isArray(response) || !isResponseDescriptor(response)) {
     return { body: response };
   }
   return response;
@@ -7593,47 +8386,48 @@ function clearGlobalMeasurements() {
 }
 
 // libs/testing/src/perf/perf-test.ts
-var currentConfig2 = {};
-var serverInstance2 = null;
-var tokenFactory2 = null;
-var serverStartedByUs2 = false;
-async function initializeSharedResources2() {
-  if (!tokenFactory2) {
-    tokenFactory2 = new TestTokenFactory();
-  }
-  if (!serverInstance2) {
-    if (currentConfig2.baseUrl) {
-      serverInstance2 = TestServer.connect(currentConfig2.baseUrl);
-      serverStartedByUs2 = false;
-    } else if (currentConfig2.server) {
-      const serverCommand = resolveServerCommand2(currentConfig2.server);
+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 = resolveServerCommand2(currentConfig.server);
       const isDebug = process.env["DEBUG"] === "1" || process.env["DEBUG_SERVER"] === "1";
       if (isDebug) {
         console.log(`[PerfTest] Starting server: ${serverCommand}`);
       }
       try {
-        serverInstance2 = await TestServer.start({
-          project: currentConfig2.project,
-          port: currentConfig2.port,
+        serverInstance = await TestServer.start({
+          project: currentConfig.project,
+          port: currentConfig.port,
           command: serverCommand,
-          env: currentConfig2.env,
-          startupTimeout: currentConfig2.startupTimeout ?? 3e4,
+          env: currentConfig.env,
+          startupTimeout: currentConfig.startupTimeout ?? 3e4,
           debug: isDebug
         });
-        serverStartedByUs2 = true;
+        serverStartedByUs = true;
         if (isDebug) {
-          console.log(`[PerfTest] Server started at ${serverInstance2.info.baseUrl}`);
+          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: ${currentConfig2.server}
-Project: ${currentConfig2.project ?? "default"}
+Server entry: ${currentConfig.server}
+Project: ${currentConfig.project ?? "default"}
 Command: ${serverCommand}
 
-Error: ${errMsg}`
+Error: ${errMsg}`,
+          { cause: error }
         );
       }
     } else {
@@ -7641,23 +8435,23 @@ Error: ${errMsg}`
     }
   }
 }
-async function createTestFixtures2(testName) {
-  await initializeSharedResources2();
-  if (!serverInstance2) {
+async function createTestFixtures(testName) {
+  await initializeSharedResources();
+  if (!serverInstance) {
     throw new Error("Server instance not initialized");
   }
-  if (!tokenFactory2) {
+  if (!tokenFactory) {
     throw new Error("Token factory not initialized");
   }
   const clientInstance = await McpTestClient.create({
-    baseUrl: serverInstance2.info.baseUrl,
-    transport: currentConfig2.transport ?? "streamable-http",
-    publicMode: currentConfig2.publicMode
+    baseUrl: serverInstance.info.baseUrl,
+    transport: currentConfig.transport ?? "streamable-http",
+    publicMode: currentConfig.publicMode
   }).buildAndConnect();
-  const auth = createAuthFixture2(tokenFactory2);
-  const server = createServerFixture2(serverInstance2);
-  const perfImpl = createPerfFixtures(testName, currentConfig2.project ?? "unknown");
-  if (currentConfig2.forceGcOnBaseline !== false) {
+  const auth = createAuthFixture2(tokenFactory);
+  const server = createServerFixture2(serverInstance);
+  const perfImpl = createPerfFixtures(testName, currentConfig.project ?? "unknown");
+  if (currentConfig.forceGcOnBaseline !== false) {
     await perfImpl.baseline();
   }
   return {
@@ -7673,8 +8467,8 @@ async function createTestFixtures2(testName) {
 async function cleanupTestFixtures2(fixtures, perfImpl, testFailed = false) {
   const measurement = perfImpl.buildMeasurement();
   addGlobalMeasurement(measurement);
-  if (testFailed && serverInstance2) {
-    const logs = serverInstance2.getLogs();
+  if (testFailed && serverInstance) {
+    const logs = serverInstance.getLogs();
     if (logs.length > 0) {
       console.error("\n[PerfTest] === Server Logs (test failed) ===");
       const recentLogs = logs.slice(-50);
@@ -7689,13 +8483,13 @@ async function cleanupTestFixtures2(fixtures, perfImpl, testFailed = false) {
     await fixtures.mcp.disconnect();
   }
 }
-async function cleanupSharedResources2() {
-  if (serverInstance2 && serverStartedByUs2) {
-    await serverInstance2.stop();
+async function cleanupSharedResources() {
+  if (serverInstance && serverStartedByUs) {
+    await serverInstance.stop();
   }
-  serverInstance2 = null;
-  tokenFactory2 = null;
-  serverStartedByUs2 = false;
+  serverInstance = null;
+  tokenFactory = null;
+  serverStartedByUs = false;
 }
 function createAuthFixture2(factory) {
   const users = {
@@ -7750,13 +8544,13 @@ function createServerFixture2(server) {
         transport: opts?.transport ?? "streamable-http",
         auth: opts?.token ? { token: opts.token } : void 0,
         clientInfo: opts?.clientInfo,
-        publicMode: currentConfig2.publicMode
+        publicMode: currentConfig.publicMode
       }).buildAndConnect();
     },
     createClientBuilder: () => {
       return new McpTestClientBuilder({
         baseUrl: server.info.baseUrl,
-        publicMode: currentConfig2.publicMode
+        publicMode: currentConfig.publicMode
       });
     },
     restart: () => server.restart(),
@@ -7772,7 +8566,7 @@ function resolveServerCommand2(server) {
 }
 function perfTestWithFixtures(name, fn) {
   it(name, async () => {
-    const { fixtures, perfImpl } = await createTestFixtures2(name);
+    const { fixtures, perfImpl } = await createTestFixtures(name);
     let testFailed = false;
     try {
       await fn(fixtures);
@@ -7785,14 +8579,14 @@ function perfTestWithFixtures(name, fn) {
   });
 }
 function use2(config) {
-  currentConfig2 = { ...currentConfig2, ...config };
+  currentConfig = { ...currentConfig, ...config };
   afterAll(async () => {
-    await cleanupSharedResources2();
+    await cleanupSharedResources();
   });
 }
 function skip2(name, fn) {
   it.skip(name, async () => {
-    const { fixtures, perfImpl } = await createTestFixtures2(name);
+    const { fixtures, perfImpl } = await createTestFixtures(name);
     let testFailed = false;
     try {
       await fn(fixtures);
@@ -7806,7 +8600,7 @@ function skip2(name, fn) {
 }
 function only2(name, fn) {
   it.only(name, async () => {
-    const { fixtures, perfImpl } = await createTestFixtures2(name);
+    const { fixtures, perfImpl } = await createTestFixtures(name);
     let testFailed = false;
     try {
       await fn(fixtures);
@@ -7823,16 +8617,19 @@ function todo2(name) {
 }
 var perfTest = perfTestWithFixtures;
 perfTest.use = use2;
-perfTest.describe = describe;
-perfTest.beforeAll = beforeAll;
-perfTest.beforeEach = beforeEach;
-perfTest.afterEach = afterEach;
-perfTest.afterAll = afterAll;
+for (const hook of ["describe", "beforeAll", "beforeEach", "afterEach", "afterAll"]) {
+  Object.defineProperty(perfTest, hook, {
+    get: () => globalThis[hook],
+    enumerable: true,
+    configurable: true
+  });
+}
 perfTest.skip = skip2;
 perfTest.only = only2;
 perfTest.todo = todo2;
 
 // libs/testing/src/perf/baseline-store.ts
+var import_utils4 = require("@frontmcp/utils");
 var BASELINE_START_MARKER = "<!-- PERF_BASELINE_START -->";
 var BASELINE_END_MARKER = "<!-- PERF_BASELINE_END -->";
 var DEFAULT_BASELINE_PATH = "perf-results/baseline.json";
@@ -7847,11 +8644,10 @@ var BaselineStore = class {
    */
   async load() {
     try {
-      const { readFile, fileExists } = await import("@frontmcp/utils");
-      if (!await fileExists(this.baselinePath)) {
+      if (!await (0, import_utils4.fileExists)(this.baselinePath)) {
         return null;
       }
-      const content = await readFile(this.baselinePath);
+      const content = await (0, import_utils4.readFile)(this.baselinePath);
       this.baseline = JSON.parse(content);
       return this.baseline;
     } catch {
@@ -7862,10 +8658,9 @@ var BaselineStore = class {
    * 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));
+    await (0, import_utils4.ensureDir)(dir);
+    await (0, import_utils4.writeFile)(this.baselinePath, JSON.stringify(baseline, null, 2));
     this.baseline = baseline;
   }
   /**
@@ -8118,6 +8913,7 @@ function getRegressionDetector(config) {
 }
 
 // libs/testing/src/perf/report-generator.ts
+var import_utils5 = require("@frontmcp/utils");
 var ReportGenerator = class {
   detector;
   constructor() {
@@ -8373,14 +9169,13 @@ var ReportGenerator = class {
   }
 };
 async function saveReports(measurements, outputDir, baseline, gitInfo) {
-  const { writeFile, ensureDir } = await import("@frontmcp/utils");
-  await ensureDir(outputDir);
+  await (0, import_utils5.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));
+  await (0, import_utils5.writeFile)(jsonPath, generator.generateJsonReport(report));
+  await (0, import_utils5.writeFile)(markdownPath, generator.generateMarkdownReport(report));
   return { jsonPath, markdownPath };
 }
 function createReportGenerator() {
@@ -8442,6 +9237,7 @@ function isTcpPortListening(port, host = "127.0.0.1", timeoutMs = 1500) {
   RegressionDetector,
   ReportGenerator,
   ServerStartError,
+  SseTransport,
   StreamableHttpTransport,
   TestClientError,
   TestServer,