@frontmcp/testing 1.8.5 → 1.8.7

package/index.js

@@ -460,6 +460,32 @@ var interceptors = {
   }
 };
 
+// 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/streamable-http.transport.ts
 var DEFAULT_TIMEOUT = 3e4;
 var NOTIFICATION_STREAM_REOPEN_DELAY_MS = 250;
@@ -568,7 +594,7 @@ var StreamableHttpTransport = class {
           return mockResponse2;
         }
         case "error":
-          throw interceptResult.error;
+          throw markInterceptedError(interceptResult.error);
         case "continue":
           message = interceptResult.request;
           break;
@@ -629,7 +655,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 +694,7 @@ var StreamableHttpTransport = class {
       }
     } catch (error) {
       clearTimeout(timeoutId);
-      if (error instanceof Error && error.name !== "AbortError") {
+      if (!isAbortError(error)) {
         throw error;
       }
     }
@@ -709,7 +735,7 @@ var StreamableHttpTransport = class {
         error: {
           code: -32700,
           message: "Parse error",
-          data: error instanceof Error ? error.message : "Unknown error"
+          data: errorMessage(error)
         }
       };
     }
@@ -1079,7 +1105,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) {
@@ -1421,6 +1447,16 @@ var DEFAULT_CLIENT_INFO = {
   name: "@frontmcp/testing",
   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") {
@@ -1507,19 +1543,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;
@@ -1531,6 +1570,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));
@@ -1539,7 +1579,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();
@@ -1609,18 +1649,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");
   }
   // ═══════════════════════════════════════════════════════════════════
@@ -1654,13 +1723,12 @@ var McpTestClient = class {
     /**
      * 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;
-    },
+    list: async () => this.listAllPages(
+      "tools/list",
+      "tools",
+      (cursor) => this.listTools(cursor),
+      (page) => page.tools
+    ),
     /**
      * Call a tool by name with arguments
      */
@@ -1676,23 +1744,21 @@ var McpTestClient = class {
     /**
      * 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: async () => this.listAllPages(
+      "resources/list",
+      "resources",
+      (cursor) => this.listResources(cursor),
+      (page) => page.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;
-    },
+    listTemplates: async () => this.listAllPages(
+      "resources/templates/list",
+      "resource templates",
+      (cursor) => this.listResourceTemplates(cursor),
+      (page) => page.resourceTemplates
+    ),
     /**
      * Read a resource by URI
      */
@@ -1720,13 +1786,12 @@ var McpTestClient = class {
     /**
      * 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;
-    },
+    list: async () => this.listAllPages(
+      "prompts/list",
+      "prompts",
+      (cursor) => this.listPrompts(cursor),
+      (page) => page.prompts
+    ),
     /**
      * Get a prompt with arguments
      */
@@ -2110,8 +2175,33 @@ var McpTestClient = class {
       clientInfo: this.config.clientInfo
     });
   }
-  async listTools() {
-    return this.request("tools/list", {});
+  async listTools(cursor) {
+    return this.request("tools/list", cursor ? { cursor } : {});
+  }
+  /**
+   * Follow `nextCursor` until the server stops returning one, concatenating the
+   * pages. A server that hands back a cursor it already returned, or never stops
+   * paging, fails the call rather than looping.
+   */
+  async listAllPages(method, label, fetchPage, itemsOf) {
+    const items = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor;
+    for (let page = 0; page < MAX_LIST_PAGES; page++) {
+      const response = await fetchPage(cursor);
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list ${label}: ${response.error?.message}`);
+      }
+      items.push(...itemsOf(response.data) ?? []);
+      const next = response.data.nextCursor;
+      if (!next) return items;
+      if (seenCursors.has(next)) {
+        throw new Error(`Failed to list ${label}: ${method} returned the cursor "${next}" twice`);
+      }
+      seenCursors.add(next);
+      cursor = next;
+    }
+    throw new Error(`Failed to list ${label}: ${method} did not finish within ${MAX_LIST_PAGES} pages`);
   }
   async callTool(name, args, progressToken) {
     return this.request("tools/call", {
@@ -2136,17 +2226,17 @@ var McpTestClient = class {
       timestamp
     });
   };
-  async listResources() {
-    return this.request("resources/list", {});
+  async listResources(cursor) {
+    return this.request("resources/list", cursor ? { cursor } : {});
   }
-  async listResourceTemplates() {
-    return this.request("resources/templates/list", {});
+  async listResourceTemplates(cursor) {
+    return this.request("resources/templates/list", cursor ? { cursor } : {});
   }
   async readResource(uri) {
     return this.request("resources/read", { uri });
   }
-  async listPrompts() {
-    return this.request("prompts/list", {});
+  async listPrompts(cursor) {
+    return this.request("prompts/list", cursor ? { cursor } : {});
   }
   async getPrompt(name, args) {
     return this.request("prompts/get", {
@@ -2223,10 +2313,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,
@@ -2374,12 +2465,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 {
@@ -2511,14 +2602,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
     };
@@ -2543,10 +2635,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",
@@ -2557,10 +2649,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"
@@ -2771,17 +2864,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;
@@ -2796,8 +2879,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;
@@ -3054,14 +3137,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,
@@ -3101,7 +3184,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({
@@ -3233,6 +3316,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,
@@ -3241,6 +3326,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,
@@ -3318,6 +3404,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,
@@ -3422,14 +3510,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,
@@ -3535,8 +3623,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)
@@ -3552,8 +3639,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;
   }
@@ -4141,7 +4227,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 {
@@ -4247,6 +4333,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 },
@@ -4255,6 +4343,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;
@@ -4265,15 +4413,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`);
   }
@@ -4282,30 +4437,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(
@@ -4313,9 +4457,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, () => {
@@ -4341,31 +4489,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";
@@ -4374,8 +4497,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,
@@ -4387,6 +4513,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
@@ -4399,8 +4526,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;
@@ -4440,7 +4567,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,
@@ -4448,7 +4575,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;
@@ -4506,10 +4633,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) {
@@ -4582,7 +4716,7 @@ var TestServer = class _TestServer {
    * Restart the server
    */
   async restart() {
-    await this.stop();
+    await this.stopProcess();
     await this.startProcess();
   }
   /**
@@ -4612,9 +4746,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, [], {
@@ -4624,9 +4758,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;
@@ -4729,6 +4862,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}`;
@@ -4773,6 +4908,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;
@@ -4822,7 +4970,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 });
@@ -5044,94 +5192,162 @@ 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";
+var scopes = [{ skipped: false, config: {}, configured: false, cleanupRegistered: false }];
+function currentScope() {
+  return scopes[scopes.length - 1];
+}
+var serverEntries = /* @__PURE__ */ new Map();
+function resolveConfig(chain) {
+  const merged = {};
+  for (const scope of chain) {
+    const { env, ...rest } = scope.config;
+    Object.assign(merged, rest);
+    if (env) 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();
@@ -5145,17 +5361,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);
@@ -5166,20 +5383,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 = {
@@ -5225,28 +5440,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()
   };
@@ -5257,12 +5483,12 @@ function resolveServerCommand(server) {
   }
   return `npx tsx ${server}`;
 }
-function runWithFixtures(fn) {
-  return async () => {
-    const fixtures = await createTestFixtures();
+function runWithFixtures(fn, chain) {
+  return async (...extra) => {
+    const fixtures = await buildFixtures(chain);
     let testFailed = false;
     try {
-      await fn(fixtures);
+      await fn(fixtures, ...extra);
     } catch (error) {
       testFailed = true;
       throw error;
@@ -5271,24 +5497,37 @@ function runWithFixtures(fn) {
     }
   };
 }
+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();
+  scope.config = {
+    ...scope.config,
+    ...config,
+    env: config.env ? { ...scope.config.env, ...config.env } : scope.config.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;
     }
@@ -5299,57 +5538,111 @@ 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 withScope(fn) {
+  return (...args) => {
+    const parent = currentScope();
+    scopes.push({
+      skipped: parent.skipped,
+      reason: parent.reason,
+      config: {},
+      configured: false,
+      cleanupRegistered: false
     });
+    try {
+      fn(...args);
+    } finally {
+      scopes.pop();
+    }
   };
 }
-function eachWithSkipScope(each) {
-  return ((...eachArgs) => {
-    const register = each(...eachArgs);
-    return withSkipScope(register);
-  });
+function scopedRegister(pick) {
+  return (name, fn, timeout) => {
+    pick()(name, withScope(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)
-});
+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)
+  }
+);
 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 = ((...args) => jestGlobals().beforeEach(...args));
+test.afterEach = ((...args) => jestGlobals().afterEach(...args));
+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) {
@@ -6012,34 +6305,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() {
@@ -6071,6 +6374,9 @@ ${descriptions.join("\n")}`);
     if (index !== -1) {
       activeInterceptors.splice(index, 1);
     }
+    if (activeInterceptors.length === 0) {
+      httpMock.disable();
+    }
   }
   // Internal methods
   isActive() {
@@ -6170,43 +6476,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 = {
@@ -6236,8 +6548,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;
@@ -7571,47 +7895,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 {
@@ -7619,23 +7944,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 {
@@ -7651,8 +7976,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);
@@ -7667,13 +7992,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 = {
@@ -7728,13 +8053,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(),
@@ -7750,7 +8075,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);
@@ -7763,14 +8088,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);
@@ -7784,7 +8109,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);
@@ -7801,16 +8126,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";
@@ -7825,11 +8153,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 {
@@ -7840,10 +8167,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;
   }
   /**
@@ -8096,6 +8422,7 @@ function getRegressionDetector(config) {
 }
 
 // libs/testing/src/perf/report-generator.ts
+var import_utils5 = require("@frontmcp/utils");
 var ReportGenerator = class {
   detector;
   constructor() {
@@ -8351,14 +8678,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() {