request-iframe 0.0.2 → 0.0.4

package/library/__tests__/requestIframe.test.ts

@@ -1,7 +1,8 @@
 import { requestIframeClient, clearRequestIframeClientCache } from '../api/client';
 import { requestIframeServer, clearRequestIframeServerCache } from '../api/server';
 import { RequestConfig, Response, ErrorResponse, PostMessageData } from '../types';
-import { HttpHeader, Messages } from '../constants';
+import { HttpHeader, MessageRole, Messages } from '../constants';
+import { IframeWritableStream } from '../stream';
 
 /**
  * Create test iframe
@@ -22,6 +23,18 @@ function cleanupIframe(iframe: HTMLIFrameElement): void {
   }
 }
 
+/**
+ * Convert Blob to text (for assertions)
+ */
+function blobToText(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result ?? ''));
+    reader.onerror = reject;
+    reader.readAsText(blob);
+  });
+}
+
 describe('requestIframeClient and requestIframeServer', () => {
   beforeEach(() => {
     // Clear all caches
@@ -64,7 +77,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'ack',
                   requestId: msg.requestId,
-                  path: msg.path
+                  path: msg.path,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -79,7 +93,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                     requestId: msg.requestId,
                     data: { result: 'success' },
                     status: 200,
-                    statusText: 'OK'
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -108,6 +123,251 @@ describe('requestIframeClient and requestIframeServer', () => {
       cleanupIframe(iframe);
     });
 
+    it('should return response.data when returnData is true in options', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      const data = await client.send('test', { param: 'value' }, { ackTimeout: 1000, returnData: true });
+      // Should return data directly, not Response object
+      expect(data).toEqual({ result: 'success' });
+      expect((data as any).status).toBeUndefined();
+      expect((data as any).requestId).toBeUndefined();
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should return full Response when returnData is false', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      const response = await client.send('test', { param: 'value' }, { ackTimeout: 1000, returnData: false });
+      // Should return full Response object
+      expect(response).toHaveProperty('data');
+      expect(response).toHaveProperty('status');
+      expect(response).toHaveProperty('statusText');
+      expect(response).toHaveProperty('requestId');
+      expect(response.data).toEqual({ result: 'success' });
+      expect(response.status).toBe(200);
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should use default returnData from RequestIframeClientOptions', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      // Create client with returnData: true in options
+      const client = requestIframeClient(iframe, { returnData: true });
+      const server = requestIframeServer();
+
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      // Should return data directly without specifying returnData in send options
+      const data = await client.send('test', { param: 'value' }, { ackTimeout: 1000 });
+      expect(data).toEqual({ result: 'success' });
+      expect((data as any).status).toBeUndefined();
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should allow overriding default returnData in send options', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      // Create client with returnData: true in options
+      const client = requestIframeClient(iframe, { returnData: true });
+      const server = requestIframeServer();
+
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      // Override with returnData: false in send options
+      const response = await client.send('test', { param: 'value' }, { ackTimeout: 1000, returnData: false });
+      // Should return full Response object despite default being true
+      expect(response).toHaveProperty('data');
+      expect(response).toHaveProperty('status');
+      expect(response.data).toEqual({ result: 'success' });
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
     it('should throw error when iframe.contentWindow is unavailable', () => {
       const iframe = document.createElement('iframe');
       iframe.src = 'https://example.com/test.html';
@@ -157,7 +417,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'pong',
                   requestId: msg.requestId,
-                  secretKey: msg.secretKey
+                  secretKey: msg.secretKey,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -199,7 +460,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'ack',
                   requestId: msg.requestId,
-                  path: msg.path
+                  path: msg.path,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -215,7 +477,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                     requestId: msg.requestId,
                     data: { success: true },
                     status: 200,
-                    statusText: 'OK'
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -262,7 +525,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'ack',
                   requestId: msg.requestId,
-                  path: msg.path
+                  path: msg.path,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -278,7 +542,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                     requestId: msg.requestId,
                     data: { success: true },
                     status: 200,
-                    statusText: 'OK'
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -328,7 +593,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'ack',
                   requestId: msg.requestId,
-                  path: msg.path
+                  path: msg.path,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -347,7 +613,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                       code: 'METHOD_NOT_FOUND'
                     },
                     status: 404,
-                    statusText: 'Not Found'
+                    statusText: 'Not Found',
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -389,7 +656,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'ack',
                   requestId: msg.requestId,
-                  path: msg.path
+                  path: msg.path,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -403,7 +671,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                     __requestIframe__: 1,
                     type: 'async',
                     requestId: msg.requestId,
-                    path: msg.path
+                    path: msg.path,
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -420,7 +689,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                     requestId: msg.requestId,
                     data: { result: 'async success' },
                     status: 200,
-                    statusText: 'OK'
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -513,30 +783,338 @@ describe('requestIframeClient and requestIframeServer', () => {
     });
   });
 
-  describe('Middleware', () => {
-    it('should support global middleware', async () => {
+  describe('secretKey message isolation', () => {
+    it('should successfully communicate when client and server use the same secretKey', async () => {
       const origin = 'https://example.com';
       const iframe = createTestIframe(origin);
 
       const mockContentWindow = {
-        postMessage: jest.fn()
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            // Verify secretKey is in message
+            expect(msg.secretKey).toBe('test-key');
+            // Verify path is NOT prefixed with secretKey
+            expect(msg.path).toBe('test');
+            
+            // Send ACK first
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  secretKey: 'test-key',
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            // Then send response
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    secretKey: 'test-key',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
       };
       Object.defineProperty(iframe, 'contentWindow', {
         value: mockContentWindow,
         writable: true
       });
 
-      const client = requestIframeClient(iframe);
-      const server = requestIframeServer();
+      const client = requestIframeClient(iframe, { secretKey: 'test-key' });
+      const server = requestIframeServer({ secretKey: 'test-key' });
 
-      // Add middleware (auth validation)
-      const middleware = jest.fn((req, res, next) => {
-        if (req.headers['authorization'] === 'Bearer token123') {
-          next();
-        } else {
-          res.status(401).send({ error: 'Unauthorized' });
-        }
-      });
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      const response = await client.send('test', { param: 'value' }, { ackTimeout: 1000 });
+      expect(response.data).toEqual({ result: 'success' });
+      expect(response.status).toBe(200);
+      expect(mockContentWindow.postMessage).toHaveBeenCalled();
+      
+      // Verify the sent message has secretKey
+      const sentMessage = (mockContentWindow.postMessage as jest.Mock).mock.calls[0][0];
+      expect(sentMessage.secretKey).toBe('test-key');
+      expect(sentMessage.path).toBe('test'); // Path should NOT be prefixed
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should NOT communicate when client and server use different secretKeys', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, { secretKey: 'client-key' });
+      const server = requestIframeServer({ secretKey: 'server-key' });
+
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      // Request should timeout because server won't respond (different secretKey)
+      await expect(
+        client.send('test', { param: 'value' }, { ackTimeout: 100 })
+      ).rejects.toMatchObject({
+        code: 'ACK_TIMEOUT'
+      });
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should NOT communicate when client has secretKey but server does not', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, { secretKey: 'client-key' });
+      const server = requestIframeServer(); // No secretKey
+
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      // Request should timeout because server won't respond (different secretKey)
+      await expect(
+        client.send('test', { param: 'value' }, { ackTimeout: 100 })
+      ).rejects.toMatchObject({
+        code: 'ACK_TIMEOUT'
+      });
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should NOT communicate when client has no secretKey but server has secretKey', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe); // No secretKey
+      const server = requestIframeServer({ secretKey: 'server-key' });
+
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      // Request should timeout because server won't respond (different secretKey)
+      await expect(
+        client.send('test', { param: 'value' }, { ackTimeout: 100 })
+      ).rejects.toMatchObject({
+        code: 'ACK_TIMEOUT'
+      });
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should successfully communicate when both client and server have no secretKey', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            // Verify secretKey is NOT in message
+            expect(msg.secretKey).toBeUndefined();
+            // Verify path is NOT prefixed
+            expect(msg.path).toBe('test');
+            
+            // Send ACK first
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            // Then send response
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe); // No secretKey
+      const server = requestIframeServer(); // No secretKey
+
+      server.on('test', (req, res) => {
+        res.send({ result: 'success' });
+      });
+
+      const response = await client.send('test', { param: 'value' }, { ackTimeout: 1000 });
+      expect(response.data).toEqual({ result: 'success' });
+      expect(response.status).toBe(200);
+      expect(mockContentWindow.postMessage).toHaveBeenCalled();
+      
+      // Verify the sent message has no secretKey
+      const sentMessage = (mockContentWindow.postMessage as jest.Mock).mock.calls[0][0];
+      expect(sentMessage.secretKey).toBeUndefined();
+      expect(sentMessage.path).toBe('test'); // Path should NOT be prefixed
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should handle path correctly with secretKey (path should not be prefixed)', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            // Verify path is NOT prefixed with secretKey
+            expect(msg.path).toBe('api/users');
+            expect(msg.secretKey).toBe('my-app');
+            
+            // Send ACK first
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  secretKey: 'my-app',
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            // Then send response
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { users: [] },
+                    status: 200,
+                    statusText: 'OK',
+                    secretKey: 'my-app',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, { secretKey: 'my-app' });
+      const server = requestIframeServer({ secretKey: 'my-app' });
+
+      // Server registers handler with original path (not prefixed)
+      server.on('api/users', (req, res) => {
+        res.send({ users: [] });
+      });
+
+      // Client sends request with original path (not prefixed)
+      const response = await client.send('api/users', undefined, { ackTimeout: 1000 });
+      expect(response.data).toEqual({ users: [] });
+      
+      // Verify path in sent message is NOT prefixed
+      const sentMessage = (mockContentWindow.postMessage as jest.Mock).mock.calls[0][0];
+      expect(sentMessage.path).toBe('api/users');
+      expect(sentMessage.secretKey).toBe('my-app');
+      
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+  });
+
+  describe('Middleware', () => {
+    it('should support global middleware', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      // Add middleware (auth validation)
+      const middleware = jest.fn((req, res, next) => {
+        if (req.headers['authorization'] === 'Bearer token123') {
+          next();
+        } else {
+          res.status(401).send({ error: 'Unauthorized' });
+        }
+      });
 
       server.use(middleware);
 
@@ -689,7 +1267,7 @@ describe('requestIframeClient and requestIframeServer', () => {
   });
 
   describe('sendFile', () => {
-    it('should support sending file (base64 encoded)', async () => {
+    it('should support sending file (stream)', async () => {
       const origin = 'https://example.com';
       const iframe = createTestIframe(origin);
 
@@ -705,11 +1283,16 @@ describe('requestIframeClient and requestIframeServer', () => {
       const server = requestIframeServer();
 
       server.on('getFile', async (req, res) => {
-        const fileContent = 'Hello World';
-        await res.sendFile(fileContent, {
-          mimeType: 'text/plain',
-          fileName: 'test.txt'
-        });
+        try {
+          const fileContent = 'Hello World';
+          await res.sendFile(fileContent, {
+            mimeType: 'text/plain',
+            fileName: 'test.txt'
+          });
+        } catch (error) {
+          console.error('Error in sendFile:', error);
+          throw error;
+        }
       });
 
       // Simulate request from iframe
@@ -727,22 +1310,43 @@ describe('requestIframeClient and requestIframeServer', () => {
           source: mockContentWindow as any
         })
       );
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      // Wait for async handler to complete
+      await new Promise((resolve) => setTimeout(resolve, 1000));
 
-      // Verify sendFile was called
+      // Verify sendFile was called - now it uses stream
       expect(mockContentWindow.postMessage).toHaveBeenCalled();
-      const fileCall = mockContentWindow.postMessage.mock.calls.find(
-        (call: any[]) => call[0]?.type === 'response' && call[0]?.fileData
-      );
-      expect(fileCall).toBeDefined();
-      expect(fileCall[0].fileData.mimeType).toBe('text/plain');
-      expect(fileCall[0].fileData.fileName).toBe('test.txt');
       
-      // Decode base64 to verify content
-      if (fileCall[0].fileData.content) {
-        const decoded = atob(fileCall[0].fileData.content);
-        expect(decoded).toBe('Hello World');
+      // Debug: Check all message types sent
+      const allCalls = mockContentWindow.postMessage.mock.calls;
+      const messageTypes = allCalls.map(call => call[0]?.type).filter(Boolean);
+      if (messageTypes.length === 0) {
+        throw new Error('No messages were sent to mockContentWindow.postMessage');
+      }
+      
+      const streamStartCall = allCalls.find(
+        (call: any[]) => call[0]?.type === 'stream_start'
+      );
+      if (!streamStartCall) {
+        throw new Error(`stream_start not found. Message types sent: ${messageTypes.join(', ')}`);
       }
+      expect(streamStartCall).toBeDefined();
+      const streamBody = streamStartCall![0].body;
+      expect(streamBody.type).toBe('file');
+      expect(streamBody.autoResolve).toBe(true);
+      expect(streamBody.metadata?.mimeType).toBe('text/plain');
+      expect(streamBody.metadata?.filename).toBe('test.txt');
+
+      // Verify stream_data was sent
+      const streamDataCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'stream_data'
+      );
+      expect(streamDataCall).toBeDefined();
+      
+      // Verify stream_end was sent
+      const streamEndCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'stream_end'
+      );
+      expect(streamEndCall).toBeDefined();
 
       server.destroy();
       cleanupIframe(iframe);
@@ -784,13 +1388,17 @@ describe('requestIframeClient and requestIframeServer', () => {
           source: mockContentWindow as any
         })
       );
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve) => setTimeout(resolve, 200));
 
-      const fileCall = mockContentWindow.postMessage.mock.calls.find(
-        (call: any[]) => call[0]?.type === 'response' && call[0]?.fileData
+      // Verify stream_start was sent
+      const streamStartCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'stream_start'
       );
-      expect(fileCall).toBeDefined();
-      expect(fileCall![0].fileData.mimeType).toBe('text/plain');
+      expect(streamStartCall).toBeDefined();
+      const streamBody = streamStartCall![0].body;
+      expect(streamBody.type).toBe('file');
+      expect(streamBody.autoResolve).toBe(true);
+      expect(streamBody.metadata?.mimeType).toBe('text/plain');
 
       server.destroy();
       cleanupIframe(iframe);
@@ -829,13 +1437,17 @@ describe('requestIframeClient and requestIframeServer', () => {
           source: mockContentWindow as any
         })
       );
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve) => setTimeout(resolve, 200));
 
-      const fileCall = mockContentWindow.postMessage.mock.calls.find(
-        (call: any[]) => call[0]?.type === 'response' && call[0]?.fileData
+      // Verify stream_start was sent
+      const streamStartCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'stream_start'
       );
-      expect(fileCall).toBeDefined();
-      expect(fileCall[0].fileData.fileName).toBe('test.txt');
+      expect(streamStartCall).toBeDefined();
+      const streamBody = streamStartCall![0].body;
+      expect(streamBody.type).toBe('file');
+      expect(streamBody.autoResolve).toBe(true);
+      expect(streamBody.metadata?.filename).toBe('test.txt');
 
       server.destroy();
       cleanupIframe(iframe);
@@ -845,52 +1457,14 @@ describe('requestIframeClient and requestIframeServer', () => {
       const origin = 'https://example.com';
       const iframe = createTestIframe(origin);
 
-      let responseMessage: any = null;
       const mockContentWindow = {
-        postMessage: jest.fn((msg: PostMessageData) => {
-          if (msg.type === 'request') {
-            window.dispatchEvent(
-              new MessageEvent('message', {
-                data: {
-                  __requestIframe__: 1,
-                  type: 'ack',
-                  requestId: msg.requestId,
-                  path: msg.path
-                },
-                origin
-              })
-            );
-            setTimeout(() => {
-              const response: PostMessageData = {
-                __requestIframe__: 1,
-                timestamp: Date.now(),
-                type: 'response',
-                requestId: msg.requestId,
-                fileData: {
-                  content: btoa('test'),
-                  mimeType: 'text/plain',
-                  fileName: 'test.txt'
-                },
-                status: 200,
-                requireAck: true
-              };
-              responseMessage = response;
-              window.dispatchEvent(
-                new MessageEvent('message', {
-                  data: response,
-                  origin
-                })
-              );
-            }, 10);
-          }
-        })
+        postMessage: jest.fn()
       };
       Object.defineProperty(iframe, 'contentWindow', {
         value: mockContentWindow,
         writable: true
       });
 
-      const client = requestIframeClient(iframe);
       const server = requestIframeServer();
 
       server.on('getFileAck', async (req, res) => {
@@ -916,16 +1490,298 @@ describe('requestIframeClient and requestIframeServer', () => {
       );
       await new Promise((resolve) => setTimeout(resolve, 150));
 
-      // Client should send received message when requireAck is true
-      const receivedCall = mockContentWindow.postMessage.mock.calls.find(
-        (call: any[]) => call[0]?.type === 'received'
+      // Verify stream_start was sent with requireAck
+      const streamStartCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'stream_start'
       );
-      // Note: received message is sent by client, not server
-      // So we check that the response was sent with requireAck
-      if (responseMessage && 'requireAck' in responseMessage) {
-        expect(responseMessage.requireAck).toBe(true);
-      }
+      expect(streamStartCall).toBeDefined();
+      const streamBody = streamStartCall![0].body;
+      expect(streamBody.type).toBe('file');
+      expect(streamBody.autoResolve).toBe(true);
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should auto-resolve file stream to fileData on client side', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            // Send ACK first
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            // Then send stream_start
+            setTimeout(() => {
+              const streamId = 'stream-test';
+              const fileContent = btoa('Hello World');
+              
+              // Send stream_start
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    timestamp: Date.now(),
+                    type: 'stream_start',
+                    requestId: msg.requestId,
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {
+                      'Content-Type': 'text/plain',
+                      'Content-Disposition': 'attachment; filename="test.txt"'
+                    },
+                    body: {
+                      streamId,
+                      type: 'file',
+                      chunked: false,
+                      autoResolve: true,
+                      metadata: {
+                        filename: 'test.txt',
+                        mimeType: 'text/plain'
+                      }
+                    },
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+              
+              // Send stream_data
+              setTimeout(() => {
+                window.dispatchEvent(
+                  new MessageEvent('message', {
+                    data: {
+                      __requestIframe__: 1,
+                      timestamp: Date.now(),
+                      type: 'stream_data',
+                      requestId: msg.requestId,
+                      body: {
+                        streamId,
+                        data: fileContent,
+                        done: true
+                      },
+                      role: MessageRole.SERVER
+                    },
+                    origin
+                  })
+                );
+                
+                // Send stream_end
+                setTimeout(() => {
+                  window.dispatchEvent(
+                    new MessageEvent('message', {
+                      data: {
+                        __requestIframe__: 1,
+                        timestamp: Date.now(),
+                        type: 'stream_end',
+                        requestId: msg.requestId,
+                        body: {
+                          streamId
+                        },
+                        role: MessageRole.SERVER
+                      },
+                      origin
+                    })
+                  );
+                }, 100);
+              }, 100);
+            }, 100);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+
+      const response = await client.send('getFile', undefined, { 
+        ackTimeout: 1000,
+        timeout: 10000
+      }) as any;
+      
+      // Verify that data is a File object (auto-resolved from stream)
+      expect(response.data).toBeInstanceOf(File);
+      const file = response.data as File;
+      expect(file.name).toBe('test.txt');
+      expect(file.type).toBe('text/plain');
+      
+      // Verify file content using FileReader or arrayBuffer
+      const fileContent = await new Promise<string>((resolve) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+          resolve(reader.result as string);
+        };
+        reader.readAsText(file);
+      });
+      expect(fileContent).toBe('Hello World');
+      
+      // Verify that stream is not present (because it was auto-resolved)
+      expect(response.stream).toBeUndefined();
+
+      cleanupIframe(iframe);
+    }, 20000);
+  });
+
+  describe('Path parameters', () => {
+    it('should extract path parameters from route pattern', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow: any = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('/api/users/:id', (req, res) => {
+        expect(req.params.id).toBe('123');
+        expect(req.path).toBe('/api/users/123');
+        res.send({ userId: req.params.id });
+      });
+
+      const resp = await client.send<any>('/api/users/123');
+      expect((resp as any).data.userId).toBe('123');
+
+      client.destroy();
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should extract multiple path parameters', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow: any = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('/api/users/:userId/posts/:postId', (req, res) => {
+        expect(req.params.userId).toBe('456');
+        expect(req.params.postId).toBe('789');
+        res.send({ userId: req.params.userId, postId: req.params.postId });
+      });
+
+      const resp = await client.send<any>('/api/users/456/posts/789');
+      expect((resp as any).data.userId).toBe('456');
+      expect((resp as any).data.postId).toBe('789');
+
+      client.destroy();
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should return empty params for exact path match', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow: any = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('/api/users', (req, res) => {
+        expect(req.params).toEqual({});
+        expect(req.path).toBe('/api/users');
+        res.send({ success: true });
+      });
+
+      const resp = await client.send<any>('/api/users');
+      expect((resp as any).data.success).toBe(true);
+
+      client.destroy();
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should work with stream requests', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow: any = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('/api/upload/:fileId', async (req, res) => {
+        expect(req.params.fileId).toBe('file-123');
+        expect(req.stream).toBeDefined();
+        const chunks: any[] = [];
+        for await (const chunk of req.stream as any) {
+          chunks.push(chunk);
+        }
+        res.send({ fileId: req.params.fileId, chunks });
+      });
+
+      const stream = new IframeWritableStream({
+        iterator: async function* () {
+          yield 'chunk1';
+          yield 'chunk2';
+        }
+      });
 
+      const resp = await client.sendStream<any>('/api/upload/file-123', stream);
+      expect((resp as any).data.fileId).toBe('file-123');
+      expect((resp as any).data.chunks).toEqual(['chunk1', 'chunk2']);
+
+      client.destroy();
       server.destroy();
       cleanupIframe(iframe);
     });
@@ -1219,11 +2075,19 @@ describe('requestIframeClient and requestIframeServer', () => {
       );
       await new Promise((resolve) => setTimeout(resolve, 50));
 
+      // Wait for response to be sent
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
       // Simulate client receiving response
       const responseCall = mockContentWindow.postMessage.mock.calls.find(
         (call: any[]) => call[0]?.type === 'response'
       );
-      if (responseCall) {
+      expect(responseCall).toBeDefined();
+      if (responseCall && responseCall[0]) {
+        // Verify response contains Set-Cookie header
+        expect(responseCall[0].headers).toBeDefined();
+        expect(responseCall[0].headers[HttpHeader.SET_COOKIE]).toBeDefined();
+        
         window.dispatchEvent(
           new MessageEvent('message', {
             data: responseCall[0],
@@ -1232,6 +2096,9 @@ describe('requestIframeClient and requestIframeServer', () => {
           })
         );
       }
+      
+      // Wait for response to be processed
+      await responsePromise;
       await new Promise((resolve) => setTimeout(resolve, 50));
 
       // Verify client automatically saved server-set cookies
@@ -1258,7 +2125,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'ack',
                   requestId: msg.requestId,
-                  path: msg.path
+                  path: msg.path,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -1271,7 +2139,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                 requestId: msg.requestId,
                 data: { result: 'success' },
                 status: 200,
-                requireAck: true
+                requireAck: true,
+                role: MessageRole.SERVER
               };
               responseMessage = response;
               window.dispatchEvent(
@@ -1334,7 +2203,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'ack',
                   requestId: msg.requestId,
-                  path: msg.path
+                  path: msg.path,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -1348,7 +2218,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                     requestId: msg.requestId,
                     data: { json: true },
                     status: 200,
-                    requireAck: true
+                    requireAck: true,
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -1409,7 +2280,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                   __requestIframe__: 1,
                   type: 'ack',
                   requestId: msg.requestId,
-                  path: msg.path
+                  path: msg.path,
+                  role: MessageRole.SERVER
                 },
                 origin
               })
@@ -1423,7 +2295,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                     requestId: msg.requestId,
                     data: { error: 'Not Found' },
                     status: 404,
-                    statusText: 'Not Found'
+                    statusText: 'Not Found',
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -1977,105 +2850,257 @@ describe('requestIframeClient and requestIframeServer', () => {
     });
   });
 
-  describe('Stream response', () => {
-    it('should support sendStream', async () => {
+  describe('client send various body types', () => {
+    it('should send plain object and server receives JSON + Content-Type', async () => {
       const origin = 'https://example.com';
       const iframe = createTestIframe(origin);
 
-      const mockContentWindow = {
+      const mockContentWindow: any = {
         postMessage: jest.fn((msg: PostMessageData) => {
-          if (msg.type === 'request') {
-            window.dispatchEvent(
-              new MessageEvent('message', {
-                data: {
-                  __requestIframe__: 1,
-                  type: 'ack',
-                  requestId: msg.requestId,
-                  path: msg.path
-                },
-                origin
-              })
-            );
-            setTimeout(() => {
-              window.dispatchEvent(
-                new MessageEvent('message', {
-                  data: {
-                    __requestIframe__: 1,
-                    type: 'stream_start',
-                    requestId: msg.requestId,
-                    body: {
-                      streamId: 'stream-123',
-                      type: 'data',
-                      chunked: true
-                    }
-                  },
-                  origin
-                })
-              );
-            }, 10);
-          }
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
         })
       };
-      Object.defineProperty(iframe, 'contentWindow', {
-        value: mockContentWindow,
-        writable: true
-      });
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
 
       const client = requestIframeClient(iframe);
       const server = requestIframeServer();
 
-      server.on('getStream', async (req, res) => {
-        const { IframeWritableStream } = await import('../stream');
-        const stream = new IframeWritableStream({
-          iterator: async function* () {
-            yield 'chunk1';
-            yield 'chunk2';
-          }
-        });
-        await res.sendStream(stream);
+      server.on('echoObject', (req, res) => {
+        expect(req.headers[HttpHeader.CONTENT_TYPE]).toBe('application/json');
+        res.send({ ok: true, received: req.body });
       });
 
-      const requestId = 'req-stream';
-      window.dispatchEvent(
-        new MessageEvent('message', {
-          data: {
-            __requestIframe__: 1,
-            type: 'request',
-            requestId: requestId,
-            path: 'getStream',
-            body: {}
-          },
-          origin,
-          source: mockContentWindow as any
+      const resp = await client.send<any>('echoObject', { a: 1 });
+      expect((resp as any).data.ok).toBe(true);
+      expect((resp as any).data.received).toEqual({ a: 1 });
+
+      client.destroy();
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should send string and server receives text/plain Content-Type', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow: any = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
         })
-      );
-      await new Promise((resolve) => setTimeout(resolve, 150));
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
 
-      const streamStartCall = mockContentWindow.postMessage.mock.calls.find(
-        (call: any[]) => call[0]?.type === 'stream_start'
-      );
-      expect(streamStartCall).toBeDefined();
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
 
+      server.on('echoText', (req, res) => {
+        expect(req.headers[HttpHeader.CONTENT_TYPE]).toContain('text/plain');
+        res.send({ received: req.body, type: typeof req.body });
+      });
+
+      const resp = await client.send<any>('echoText', 'hello');
+      expect((resp as any).data.received).toBe('hello');
+      expect((resp as any).data.type).toBe('string');
+
+      client.destroy();
       server.destroy();
       cleanupIframe(iframe);
     });
 
-    it('should handle stream response from server', async () => {
+    it('should send URLSearchParams and server receives correct Content-Type', async () => {
       const origin = 'https://example.com';
       const iframe = createTestIframe(origin);
 
-      const mockContentWindow = {
+      const mockContentWindow: any = {
         postMessage: jest.fn((msg: PostMessageData) => {
-          if (msg.type === 'request') {
-            window.dispatchEvent(
-              new MessageEvent('message', {
-                data: {
-                  __requestIframe__: 1,
-                  type: 'ack',
-                  requestId: msg.requestId,
-                  path: msg.path
-                },
-                origin
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('echoParams', (req, res) => {
+        expect(req.headers[HttpHeader.CONTENT_TYPE]).toBe('application/x-www-form-urlencoded');
+        // URLSearchParams should be structured-cloneable in modern browsers
+        const value = req.body?.toString?.() ?? String(req.body);
+        res.send({ received: value });
+      });
+
+      const params = new URLSearchParams({ a: '1', b: '2' });
+      const resp = await client.send<any>('echoParams', params as any);
+      expect((resp as any).data.received).toContain('a=1');
+      expect((resp as any).data.received).toContain('b=2');
+
+      client.destroy();
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should auto-dispatch File/Blob body to client.sendFile and server receives file via stream (autoResolve)', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow: any = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('uploadFile', async (req, res) => {
+        expect(req.body).toBeDefined();
+        const blob = req.body as Blob;
+        const text = await blobToText(blob);
+        res.send({ ok: true, text });
+      });
+
+      const blob = new Blob(['Hello Upload'], { type: 'text/plain' });
+      const resp = await client.send<any>('uploadFile', blob);
+      expect((resp as any).data.ok).toBe(true);
+      expect((resp as any).data.text).toBe('Hello Upload');
+
+      client.destroy();
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should send stream from client to server and server receives req.stream', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow: any = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('uploadStream', async (req, res) => {
+        expect(req.stream).toBeDefined();
+        const chunks: any[] = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        for await (const chunk of req.stream as any) {
+          chunks.push(chunk);
+        }
+        res.send({ chunks });
+      });
+
+      const stream = new IframeWritableStream({
+        iterator: async function* () {
+          yield 'c1';
+          yield 'c2';
+          yield 'c3';
+        }
+      });
+
+      const resp = await client.sendStream<any>('uploadStream', stream);
+      expect((resp as any).data.chunks).toEqual(['c1', 'c2', 'c3']);
+
+      client.destroy();
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should support client.sendFile with autoResolve (server receives File/Blob in req.body)', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow: any = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              data: msg,
+              origin,
+              source: mockContentWindow as any
+            })
+          );
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', { value: mockContentWindow, writable: true });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('uploadFileStream', async (req, res) => {
+        // autoResolve: server should get File/Blob directly
+        expect(req.body).toBeDefined();
+        expect(req.stream).toBeUndefined();
+        const blob = req.body as Blob;
+        const text = await blobToText(blob);
+        res.send({ ok: true, text });
+      });
+
+      const blob = new Blob(['Hello Upload Stream'], { type: 'text/plain' });
+      const resp = await client.sendFile<any>('uploadFileStream', blob, {
+        autoResolve: true,
+        mimeType: 'text/plain',
+        fileName: 'upload.txt'
+      });
+      expect((resp as any).data.ok).toBe(true);
+      expect((resp as any).data.text).toBe('Hello Upload Stream');
+
+      client.destroy();
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+  });
+
+  describe('Stream response', () => {
+    it('should support sendStream', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
               })
             );
             setTimeout(() => {
@@ -2089,7 +3114,8 @@ describe('requestIframeClient and requestIframeServer', () => {
                       streamId: 'stream-123',
                       type: 'data',
                       chunked: true
-                    }
+                    },
+                    role: MessageRole.SERVER
                   },
                   origin
                 })
@@ -2142,6 +3168,90 @@ describe('requestIframeClient and requestIframeServer', () => {
       cleanupIframe(iframe);
     });
 
+    it('should handle stream response from server', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'stream_start',
+                    requestId: msg.requestId,
+                    body: {
+                      streamId: 'stream-123',
+                      type: 'data',
+                      chunked: true
+                    },
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const server = requestIframeServer();
+
+      server.on('getStream', async (req, res) => {
+        const { IframeWritableStream } = await import('../stream');
+        const stream = new IframeWritableStream({
+          iterator: async function* () {
+            yield 'chunk1';
+            yield 'chunk2';
+          }
+        });
+        await res.sendStream(stream);
+      });
+
+      const requestId = 'req-stream';
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            type: 'request',
+            requestId: requestId,
+            path: 'getStream',
+            body: {}
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const streamStartCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'stream_start'
+      );
+      expect(streamStartCall).toBeDefined();
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
     it('should handle server open/close methods', () => {
       const origin = 'https://example.com';
       const iframe = createTestIframe(origin);
@@ -2403,4 +3513,1872 @@ describe('requestIframeClient and requestIframeServer', () => {
       cleanupIframe(iframe);
     });
   });
+
+  describe('Client additional features', () => {
+    it('should support postMessage method for stream handler', () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const message = { type: 'test', data: 'value' };
+      
+      // Access postMessage through stream handler interface
+      (client as any).postMessage(message);
+      
+      // Verify message was sent via dispatcher
+      expect(mockContentWindow.postMessage).toHaveBeenCalled();
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle function-type headers', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, {
+        headers: {
+          'X-Dynamic': (config: RequestConfig) => `value-${config.path}`
+        }
+      });
+
+      await client.send('test', {});
+      
+      const requestCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'request'
+      );
+      expect(requestCall).toBeDefined();
+      if (requestCall && requestCall[0]) {
+        expect(requestCall[0].headers?.['X-Dynamic']).toBe('value-test');
+      }
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle isConnect timeout', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, { ackTimeout: 50 });
+      
+      // Server doesn't respond, should timeout
+      const connected = await client.isConnect();
+      expect(connected).toBe(false);
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle isConnect rejection', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'ping') {
+            // Simulate error by not sending pong
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'error',
+                    requestId: msg.requestId,
+                    error: { message: 'Connection failed' },
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      
+      const connected = await client.isConnect();
+      expect(connected).toBe(false);
+
+      cleanupIframe(iframe);
+    });
+
+    it('should remember targetServerId from ACK and use it in subsequent requests', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const serverId = 'server-123';
+      
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER,
+                  creatorId: serverId
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER,
+                    creatorId: serverId
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      
+      // First request - should remember serverId
+      await client.send('test1', {});
+      
+      // Second request - should use remembered serverId
+      await client.send('test2', {});
+      
+      const requestCalls = mockContentWindow.postMessage.mock.calls.filter(
+        (call: any[]) => call[0]?.type === 'request'
+      );
+      
+      // First request may not have targetId (if serverId not remembered yet)
+      // Second request should have targetId
+      expect(requestCalls.length).toBeGreaterThanOrEqual(2);
+      const secondRequest = requestCalls[requestCalls.length - 1];
+      if (secondRequest) {
+        expect(secondRequest[0].targetId).toBe(serverId);
+      }
+
+      cleanupIframe(iframe);
+    });
+
+    it('should not override existing targetServerId', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const existingServerId = 'existing-server';
+      const newServerId = 'new-server';
+      
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER,
+                  creatorId: newServerId
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER,
+                    creatorId: newServerId
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      
+      // Set existing targetServerId
+      (client as any)._targetServerId = existingServerId;
+      
+      // Send request with explicit targetId
+      await client.send('test', {}, { targetId: existingServerId });
+      
+      const requestCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'request'
+      );
+      expect(requestCall).toBeDefined();
+      if (requestCall) {
+        expect(requestCall[0].targetId).toBe(existingServerId);
+      }
+      
+      // targetServerId should not be overridden
+      expect((client as any)._targetServerId).toBe(existingServerId);
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle setCookie with expires option', () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const expires = new Date(Date.now() + 3600000); // 1 hour from now
+      
+      client.setCookie('token', 'value', { expires });
+      
+      expect(client.getCookie('token')).toBe('value');
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle setCookie with maxAge option', () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      
+      client.setCookie('token', 'value', { maxAge: 3600 });
+      
+      expect(client.getCookie('token')).toBe('value');
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle getServer method', () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const server = (client as any).getServer();
+      
+      expect(server).toBeDefined();
+      expect(server.isOpen).toBe(true);
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle non-autoResolve file stream', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              const streamId = 'stream-test';
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    timestamp: Date.now(),
+                    type: 'stream_start',
+                    requestId: msg.requestId,
+                    status: 200,
+                    statusText: 'OK',
+                    body: {
+                      streamId,
+                      type: 'file',
+                      chunked: false,
+                      autoResolve: false, // Not auto-resolve
+                      metadata: {
+                        filename: 'test.txt',
+                        mimeType: 'text/plain'
+                      }
+                    },
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+              setTimeout(() => {
+                window.dispatchEvent(
+                  new MessageEvent('message', {
+                    data: {
+                      __requestIframe__: 1,
+                      timestamp: Date.now(),
+                      type: 'stream_data',
+                      requestId: msg.requestId,
+                      body: {
+                        streamId,
+                        data: btoa('Hello World'),
+                        done: true
+                      },
+                      role: MessageRole.SERVER
+                    },
+                    origin
+                  })
+                );
+                setTimeout(() => {
+                  window.dispatchEvent(
+                    new MessageEvent('message', {
+                      data: {
+                        __requestIframe__: 1,
+                        timestamp: Date.now(),
+                        type: 'stream_end',
+                        requestId: msg.requestId,
+                        body: { streamId },
+                        role: MessageRole.SERVER
+                      },
+                      origin
+                    })
+                  );
+                }, 10);
+              }, 10);
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const response = await client.send('getFile', {}, { 
+        ackTimeout: 1000,
+        timeout: 10000
+      }) as any;
+
+      expect(response.stream).toBeDefined();
+      expect(response.data).not.toBeInstanceOf(File); // Not auto-resolved, data is not a File
+
+      cleanupIframe(iframe);
+    }, 20000);
+
+    it('should handle regular data stream (non-file)', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              const streamId = 'stream-test';
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    timestamp: Date.now(),
+                    type: 'stream_start',
+                    requestId: msg.requestId,
+                    status: 200,
+                    statusText: 'OK',
+                    body: {
+                      streamId,
+                      type: 'data',
+                      chunked: true
+                    },
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+              setTimeout(() => {
+                window.dispatchEvent(
+                  new MessageEvent('message', {
+                    data: {
+                      __requestIframe__: 1,
+                      timestamp: Date.now(),
+                      type: 'stream_data',
+                      requestId: msg.requestId,
+                      body: {
+                        streamId,
+                        data: btoa('chunk1'),
+                        done: false
+                      },
+                      role: MessageRole.SERVER
+                    },
+                    origin
+                  })
+                );
+                setTimeout(() => {
+                  window.dispatchEvent(
+                    new MessageEvent('message', {
+                      data: {
+                        __requestIframe__: 1,
+                        timestamp: Date.now(),
+                        type: 'stream_data',
+                        requestId: msg.requestId,
+                        body: {
+                          streamId,
+                          data: btoa('chunk2'),
+                          done: true
+                        },
+                        role: MessageRole.SERVER
+                      },
+                      origin
+                    })
+                  );
+                  setTimeout(() => {
+                    window.dispatchEvent(
+                      new MessageEvent('message', {
+                        data: {
+                          __requestIframe__: 1,
+                          timestamp: Date.now(),
+                          type: 'stream_end',
+                          requestId: msg.requestId,
+                          body: { streamId },
+                          role: MessageRole.SERVER
+                        },
+                        origin
+                      })
+                    );
+                  }, 10);
+                }, 10);
+              }, 10);
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const response = await client.send('getStream', {}, { 
+        ackTimeout: 1000,
+        timeout: 10000
+      }) as any;
+
+      expect(response.stream).toBeDefined();
+      expect(response.stream.type).toBe('data');
+
+      cleanupIframe(iframe);
+    }, 20000);
+
+    it('should handle dispatchStreamMessage for stream messages', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const streamId = 'test-stream';
+      const handler = jest.fn();
+      
+      // Register stream handler
+      (client as any).registerStreamHandler(streamId, handler);
+      
+      // Dispatch stream message
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            type: 'stream_data',
+            requestId: 'req123',
+            body: {
+              streamId,
+              data: 'test',
+              type: 'data'
+            },
+            role: MessageRole.SERVER
+          },
+          origin
+        })
+      );
+      
+      await new Promise(resolve => setTimeout(resolve, 50));
+      
+      expect(handler).toHaveBeenCalled();
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle error in response interceptor rejected callback', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'error',
+                    requestId: msg.requestId,
+                    error: { message: 'Test error', code: 'TEST_ERROR' },
+                    status: 500,
+                    statusText: 'Internal Server Error',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      
+      // Add error interceptor that rejects
+      client.interceptors.response.use(
+        (response) => response,
+        (error) => {
+          // Reject to test the catch path
+          return Promise.reject(error);
+        }
+      );
+
+      try {
+        await client.send('test', {});
+        fail('Should have thrown error');
+      } catch (error: any) {
+        expect(error.message).toBe('Test error');
+      }
+
+      cleanupIframe(iframe);
+    });
+  });
+
+  describe('Server additional features', () => {
+    it('should handle protocol version error', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer();
+      
+      // Send message with incompatible version
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 0, // Incompatible version
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(mockContentWindow.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'error',
+          requestId: 'req123'
+        }),
+        origin
+      );
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should handle handler returning undefined result', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer();
+      
+      server.on('test', (req, res) => {
+        // Handler doesn't return anything (undefined)
+        // This should trigger NO_RESPONSE_SENT error
+      });
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT,
+            targetId: server.id
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const errorCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'error' && call[0]?.requestId === 'req123'
+      );
+      expect(errorCall).toBeDefined();
+      if (errorCall && errorCall[0]) {
+        expect(errorCall[0]).toMatchObject({
+          type: 'error',
+          requestId: 'req123',
+          error: expect.objectContaining({
+            code: 'NO_RESPONSE'
+          })
+        });
+      }
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should skip processing when message already handled by another server', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server1 = requestIframeServer();
+      const server2 = requestIframeServer();
+      
+      const handler1 = jest.fn((req, res) => res.send({ server: 1 }));
+      const handler2 = jest.fn((req, res) => res.send({ server: 2 }));
+      
+      server1.on('test', handler1);
+      server2.on('test', handler2);
+
+      // Create a context that indicates message was already handled
+      const messageData = {
+        __requestIframe__: 1,
+        timestamp: Date.now(),
+        type: 'request' as const,
+        requestId: 'req123',
+        path: 'test',
+        role: MessageRole.CLIENT,
+        targetId: server1.id
+      };
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: messageData,
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Only server1 should handle it (because of targetId)
+      expect(handler1).toHaveBeenCalled();
+      expect(handler2).not.toHaveBeenCalled();
+
+      server1.destroy();
+      server2.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should handle ack timeout in registerPendingAck', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer({ ackTimeout: 50 });
+      
+      server.on('test', (req, res) => {
+        // Send response with requireAck, but client never sends 'received'
+        res.send({ result: 'success' }, { requireAck: true });
+      });
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT,
+            targetId: server.id
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      // Wait for ack timeout
+      await new Promise(resolve => setTimeout(resolve, 150));
+
+      // Server should have sent response
+      expect(mockContentWindow.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'response',
+          requestId: 'req123'
+        }),
+        origin
+      );
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should handle middleware that sends response early', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer();
+      
+      const middleware = jest.fn((req, res, next) => {
+        res.send({ middleware: true });
+        // Don't call next() - response already sent
+      });
+      
+      const handler = jest.fn((req, res) => {
+        res.send({ handler: true });
+      });
+      
+      server.use(middleware);
+      server.on('test', handler);
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT,
+            targetId: server.id
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Middleware should be called
+      expect(middleware).toHaveBeenCalled();
+      // Handler should NOT be called because response was already sent
+      expect(handler).not.toHaveBeenCalled();
+      
+      // Response should be from middleware
+      expect(mockContentWindow.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'response',
+          requestId: 'req123',
+          data: { middleware: true }
+        }),
+        origin
+      );
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should handle map return cleanup function', () => {
+      const server = requestIframeServer();
+      
+      const handler1 = jest.fn((req, res) => res.send({}));
+      const handler2 = jest.fn((req, res) => res.send({}));
+      
+      const cleanup = server.map({
+        'path1': handler1,
+        'path2': handler2
+      });
+      
+      // Cleanup should unregister all handlers
+      cleanup();
+      
+      // Verify handlers are unregistered
+      expect(server).toBeDefined();
+      
+      server.destroy();
+    });
+  });
+
+  describe('Cache utilities', () => {
+    it('should test server cache functions', () => {
+      const { getCachedServer, cacheServer, removeCachedServer, clearServerCache } = require('../utils/cache');
+      const { requestIframeServer } = require('../api/server');
+      
+      // Test getCachedServer with no id
+      expect(getCachedServer('key1')).toBeNull();
+      expect(getCachedServer(undefined, undefined)).toBeNull();
+      
+      // Test cacheServer with no id
+      const server1 = requestIframeServer({ id: 'server1', secretKey: 'key1' });
+      cacheServer(server1, 'key1', 'server1');
+      
+      // Test getCachedServer with id
+      const cached = getCachedServer('key1', 'server1');
+      expect(cached).toBe(server1);
+      
+      // Test removeCachedServer with no id
+      removeCachedServer('key1'); // Should not throw
+      removeCachedServer(undefined, undefined); // Should not throw
+      
+      // Test removeCachedServer with id
+      removeCachedServer('key1', 'server1');
+      expect(getCachedServer('key1', 'server1')).toBeNull();
+      
+      // Test clearServerCache
+      const server2 = requestIframeServer({ id: 'server2', secretKey: 'key2' });
+      cacheServer(server2, 'key2', 'server2');
+      clearServerCache();
+      expect(getCachedServer('key2', 'server2')).toBeNull();
+      
+      server1.destroy();
+      server2.destroy();
+    });
+
+    it('should test clearMessageChannelCache', () => {
+      const { clearMessageChannelCache, getOrCreateMessageChannel } = require('../utils/cache');
+      
+      // Create a channel
+      const channel1 = getOrCreateMessageChannel('test-key');
+      expect(channel1).toBeDefined();
+      
+      // Clear cache
+      clearMessageChannelCache();
+      
+      // Create another channel - should be new instance
+      const channel2 = getOrCreateMessageChannel('test-key');
+      expect(channel2).toBeDefined();
+      
+      channel1.release();
+      channel2.release();
+    });
+  });
+
+  describe('Additional edge cases', () => {
+    it('should handle headers in request options', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, {
+        headers: {
+          'X-Initial': 'initial-value'
+        }
+      });
+
+      // Send request with additional headers
+      await client.send('test', {}, {
+        headers: {
+          'X-Request': 'request-value',
+          'X-Dynamic': (config: RequestConfig) => `dynamic-${config.path}`
+        }
+      });
+
+      const requestCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'request'
+      );
+      expect(requestCall).toBeDefined();
+      if (requestCall && requestCall[0]) {
+        expect(requestCall[0].headers?.['X-Initial']).toBe('initial-value');
+        expect(requestCall[0].headers?.['X-Request']).toBe('request-value');
+        expect(requestCall[0].headers?.['X-Dynamic']).toBe('dynamic-test');
+      }
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle isConnect with error response', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'ping') {
+            // Send error instead of pong
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'error',
+                    requestId: msg.requestId,
+                    error: { message: 'Connection error' },
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, { ackTimeout: 1000 });
+      
+      const connected = await client.isConnect();
+      expect(connected).toBe(false);
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle response interceptor without rejected callback', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'error',
+                    requestId: msg.requestId,
+                    error: { message: 'Test error', code: 'TEST_ERROR' },
+                    status: 500,
+                    statusText: 'Internal Server Error',
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      
+      // Add response interceptor without rejected callback
+      client.interceptors.response.use(
+        (response) => response
+        // No rejected callback - should test the Promise.reject path
+      );
+
+      try {
+        await client.send('test', {});
+        fail('Should have thrown error');
+      } catch (error: any) {
+        expect(error.message).toBe('Test error');
+      }
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle request timeout', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            // Send ACK but never send response
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            // Don't send response - should timeout
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, { timeout: 50 });
+
+      try {
+        await client.send('test', {});
+        fail('Should have timed out');
+      } catch (error: any) {
+        expect(error.message).toContain('timeout');
+      }
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle async timeout', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              // Send ASYNC but never send response
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'async',
+                    requestId: msg.requestId,
+                    path: msg.path,
+                    role: MessageRole.SERVER
+                  },
+                  origin
+                })
+              );
+            }, 10);
+            // Don't send response - should timeout
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, { asyncTimeout: 50 });
+
+      try {
+        await client.send('test', {});
+        fail('Should have timed out');
+      } catch (error: any) {
+        expect(error.message).toContain('timeout');
+      }
+
+      cleanupIframe(iframe);
+    });
+
+    it('should not override existing targetServerId when receiving ACK', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const existingServerId = 'existing-server';
+      const newServerId = 'new-server';
+      
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER,
+                  creatorId: newServerId
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER,
+                    creatorId: newServerId
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      
+      // Set existing targetServerId
+      (client as any)._targetServerId = existingServerId;
+      
+      await client.send('test', {});
+      
+      // targetServerId should not be overridden
+      expect((client as any)._targetServerId).toBe(existingServerId);
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle response with requireAck', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'response',
+                    requestId: msg.requestId,
+                    data: { result: 'success' },
+                    status: 200,
+                    statusText: 'OK',
+                    role: MessageRole.SERVER,
+                    requireAck: true
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          } else if (msg.type === 'received') {
+            // Acknowledge receipt
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const response = await client.send('test', {});
+
+      expect(response.data).toEqual({ result: 'success' });
+      
+      // Verify RECEIVED message was sent
+      const receivedCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'received'
+      );
+      expect(receivedCall).toBeDefined();
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle handler returning a value', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer();
+      
+      // Handler returns a value (not undefined)
+      server.on('test', (req, res) => {
+        return { result: 'from-return' };
+      });
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT,
+            targetId: server.id
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should send response with returned value
+      expect(mockContentWindow.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'response',
+          requestId: 'req123',
+          data: { result: 'from-return' }
+        }),
+        origin
+      );
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should handle ack timeout in registerPendingAck reject callback', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer({ ackTimeout: 50 });
+      
+      server.on('test', (req, res) => {
+        // Send response with requireAck, but client never sends 'received'
+        res.send({ result: 'success' }, { requireAck: true });
+      });
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT,
+            targetId: server.id
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      // Wait for ack timeout (reject callback should be called)
+      await new Promise(resolve => setTimeout(resolve, 150));
+
+      // Server should have sent response
+      expect(mockContentWindow.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'response',
+          requestId: 'req123'
+        }),
+        origin
+      );
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should skip middleware when response already sent', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer();
+      
+      const middleware1 = jest.fn((req, res, next) => {
+        res.send({ middleware1: true });
+        // Response sent, don't call next
+      });
+      
+      const middleware2 = jest.fn((req, res, next) => {
+        next();
+      });
+      
+      const handler = jest.fn((req, res) => {
+        res.send({ handler: true });
+      });
+      
+      server.use(middleware1);
+      server.use(middleware2);
+      server.on('test', handler);
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT,
+            targetId: server.id
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Middleware1 should be called
+      expect(middleware1).toHaveBeenCalled();
+      // Middleware2 should NOT be called because response was already sent in middleware1
+      expect(middleware2).not.toHaveBeenCalled();
+      // Handler should NOT be called because response was already sent
+      expect(handler).not.toHaveBeenCalled();
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should handle isConnect reject callback', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe, { ackTimeout: 50 });
+      
+      // Simulate error in pending request registration
+      // This will trigger the reject callback
+      const connected = await client.isConnect();
+      expect(connected).toBe(false);
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle stream messages via dispatchStreamMessage', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      const streamId = 'test-stream';
+      const handler = jest.fn();
+      
+      // Register stream handler
+      (client as any).registerStreamHandler(streamId, handler);
+      
+      // Dispatch stream_data message
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            type: 'stream_data',
+            requestId: 'req123',
+            body: {
+              streamId,
+              data: 'test',
+              type: 'data'
+            },
+            role: MessageRole.SERVER
+          },
+          origin
+        })
+      );
+      
+      await new Promise(resolve => setTimeout(resolve, 50));
+      
+      expect(handler).toHaveBeenCalled();
+      
+      // Dispatch stream_end message
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            type: 'stream_end',
+            requestId: 'req123',
+            body: {
+              streamId
+            },
+            role: MessageRole.SERVER
+          },
+          origin
+        })
+      );
+      
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle error with requireAck', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn((msg: PostMessageData) => {
+          if (msg.type === 'request') {
+            window.dispatchEvent(
+              new MessageEvent('message', {
+                data: {
+                  __requestIframe__: 1,
+                  type: 'ack',
+                  requestId: msg.requestId,
+                  path: msg.path,
+                  role: MessageRole.SERVER
+                },
+                origin
+              })
+            );
+            setTimeout(() => {
+              window.dispatchEvent(
+                new MessageEvent('message', {
+                  data: {
+                    __requestIframe__: 1,
+                    type: 'error',
+                    requestId: msg.requestId,
+                    error: { message: 'Test error', code: 'TEST_ERROR' },
+                    status: 500,
+                    statusText: 'Internal Server Error',
+                    role: MessageRole.SERVER,
+                    requireAck: true
+                  },
+                  origin
+                })
+              );
+            }, 10);
+          }
+        })
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+
+      try {
+        await client.send('test', {});
+        fail('Should have thrown error');
+      } catch (error: any) {
+        expect(error.message).toBe('Test error');
+      }
+      
+      // Verify RECEIVED message was sent
+      const receivedCall = mockContentWindow.postMessage.mock.calls.find(
+        (call: any[]) => call[0]?.type === 'received'
+      );
+      expect(receivedCall).toBeDefined();
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle error in pending request registration', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const client = requestIframeClient(iframe);
+      
+      // Simulate error during request registration
+      // This will trigger the error callback in _registerPendingRequest
+      try {
+        // Force an error by making the server unavailable
+        await client.send('test', {}, { timeout: 50 });
+        fail('Should have thrown error');
+      } catch (error: any) {
+        expect(error).toBeDefined();
+      }
+
+      cleanupIframe(iframe);
+    });
+
+    it('should handle message already handled by another server', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server1 = requestIframeServer();
+      const server2 = requestIframeServer();
+      
+      const handler1 = jest.fn((req, res) => res.send({ server: 1 }));
+      const handler2 = jest.fn((req, res) => res.send({ server: 2 }));
+      
+      server1.on('test', handler1);
+      server2.on('test', handler2);
+
+      // Create message context that indicates it was already handled
+      // This simulates the case where context.handledBy is set
+      const messageData = {
+        __requestIframe__: 1,
+        timestamp: Date.now(),
+        type: 'request' as const,
+        requestId: 'req123',
+        path: 'test',
+        role: MessageRole.CLIENT,
+        targetId: server1.id
+      };
+
+      // First server processes it
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: messageData,
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Only server1 should handle it (because of targetId)
+      expect(handler1).toHaveBeenCalled();
+      expect(handler2).not.toHaveBeenCalled();
+
+      server1.destroy();
+      server2.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should handle ack timeout reject callback', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer({ ackTimeout: 50 });
+      
+      server.on('test', (req, res) => {
+        // Send response with requireAck, but client never sends 'received'
+        // This will trigger ack timeout and the reject callback
+        res.send({ result: 'success' }, { requireAck: true });
+      });
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT,
+            targetId: server.id
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      // Wait for ack timeout (reject callback should be called)
+      await new Promise(resolve => setTimeout(resolve, 150));
+
+      // Server should have sent response
+      expect(mockContentWindow.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'response',
+          requestId: 'req123'
+        }),
+        origin
+      );
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+
+    it('should skip next middleware when response already sent', async () => {
+      const origin = 'https://example.com';
+      const iframe = createTestIframe(origin);
+      const mockContentWindow = {
+        postMessage: jest.fn()
+      };
+      Object.defineProperty(iframe, 'contentWindow', {
+        value: mockContentWindow,
+        writable: true
+      });
+
+      const server = requestIframeServer();
+      
+      const middleware1 = jest.fn((req, res, next) => {
+        res.send({ middleware1: true });
+        // Response sent, but still call next to test the res._sent check
+        next();
+      });
+      
+      const middleware2 = jest.fn((req, res, next) => {
+        // This should not execute because res._sent is true
+        next();
+      });
+      
+      const handler = jest.fn((req, res) => {
+        res.send({ handler: true });
+      });
+      
+      server.use(middleware1);
+      server.use(middleware2);
+      server.on('test', handler);
+
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            __requestIframe__: 1,
+            timestamp: Date.now(),
+            type: 'request',
+            requestId: 'req123',
+            path: 'test',
+            role: MessageRole.CLIENT,
+            targetId: server.id
+          },
+          origin,
+          source: mockContentWindow as any
+        })
+      );
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Middleware1 should be called
+      expect(middleware1).toHaveBeenCalled();
+      // Middleware2's next() should check res._sent and return early, so handler should not be called
+      // Note: middleware2 itself may or may not be called depending on implementation
+      // Handler should NOT be called because response was already sent
+      expect(handler).not.toHaveBeenCalled();
+
+      server.destroy();
+      cleanupIframe(iframe);
+    });
+  });
 });