@mcp-b/transports 4.0.0 → 5.0.0

package/dist/index.d.ts

@@ -1,353 +1,65 @@
-import { JSONRPCMessage, Transport, TransportSendOptions } from "@mcp-b/webmcp-ts-sdk";
+/// <reference types="chrome" />
+import { JSONRPCMessage, Transport, TransportSendOptions } from "@modelcontextprotocol/server";
 
-//#region src/browser-types.d.ts
+//#region src/post-message.d.ts
 /**
- * Unique identifier for an event in the event store
+ * Channel discriminators. Both ends of a pair must agree or the envelope check in
+ * `isMcpMessage` silently drops every message — no error, just a hang.
  */
-type EventId = string;
-/**
- * Unique identifier for a stream of events
- */
-type StreamId = string;
-/**
- * Options for connecting to an MCP server
- */
-interface MCPConnectOptions {
-  /**
-   * The event ID to resume from if reconnecting
-   */
-  resumeFrom?: EventId;
-}
-/**
- * Information about the MCP server
- */
-interface MCPServerInfo {
-  /**
-   * Unique identifier for this server instance
-   */
-  instanceId: string;
-  /**
-   * Whether the server maintains session state
-   */
-  stateful: boolean;
-  /**
-   * Whether the server has event storage enabled
-   */
-  hasEventStore: boolean;
-}
-/**
- * Event storage interface for accessing stored events
- */
-interface MCPEventStore {
-  /**
-   * Get stored events, optionally filtered by client and/or after a specific event
-   * @param clientId - Optional client ID to filter events
-   * @param afterEventId - Optional event ID to get events after
-   * @param limit - Maximum number of events to return (default: 100)
-   */
-  getEvents(clientId?: string, afterEventId?: EventId, limit?: number): StoredEvent[];
-  /**
-   * Get the ID of the last event, optionally for a specific client
-   * @param clientId - Optional client ID to filter by
-   */
-  getLastEventId(clientId?: string): EventId | null;
-  /**
-   * Clear stored events, optionally for a specific client
-   * @param clientId - Optional client ID to clear events for
-   */
-  clearEvents(clientId?: string): void;
-}
-/**
- * The MCP interface exposed on window for browser environments
- */
-interface MCPBrowserInterface {
-  /**
-   * Connect a client to the MCP server
-   * @param clientId - Unique identifier for the client
-   * @param options - Optional connection options
-   * @returns MessagePort for communication or null if connection fails
-   */
-  connect(clientId: string, options?: MCPConnectOptions): MessagePort | null;
-  /**
-   * Disconnect a client from the MCP server
-   * @param clientId - The client ID to disconnect
-   */
-  disconnect(clientId: string): void;
-  /**
-   * Terminate a client's session and clean up all associated resources
-   * @param clientId - The client ID to terminate
-   */
-  terminateSession?(clientId: string): void;
-  /**
-   * Check if the MCP server is available and running
-   */
-  isServerAvailable(): boolean;
-  /**
-   * Get information about the MCP server
-   */
-  getServerInfo(): MCPServerInfo;
-  /**
-   * Event storage access (only available in stateful mode with event store)
-   */
-  events?: MCPEventStore;
-}
-/**
- * Extended Window interface with MCP support
- */
-interface MCPWindow extends Window {
-  mcp?: MCPBrowserInterface;
-}
-/**
- * Message types for internal MCP communication
- */
-interface MCPServerInfoMessage {
-  type: 'mcp-server-info';
-  serverInstanceId: string;
-  serverSessionId?: string;
-  hasEventStore: boolean;
-  streamId: StreamId;
-}
-interface MCPEventMessage {
-  type: 'mcp-event';
-  eventId: EventId;
-  message: JSONRPCMessage;
-}
-interface MCPReplayEventMessage {
-  type: 'mcp-replay-event';
-  eventId: EventId;
-  message: JSONRPCMessage;
-}
-/**
- * Stored event with metadata for event sourcing
- */
-interface StoredEvent {
-  eventId: EventId;
-  streamId: StreamId;
-  message: JSONRPCMessage;
-  timestamp: number;
-  clientId: string;
-}
-declare enum NativeMessageType {
-  START = "start",
-  STARTED = "started",
-  STOP = "stop",
-  STOPPED = "stopped",
-  PING = "ping",
-  PONG = "pong",
-  ERROR = "error",
-  LIST_TOOLS = "list_tools",
-  CALL_TOOL = "call_tool",
-  TOOL_LIST_UPDATED = "tool_list_updated",
-  TOOL_LIST_UPDATED_ACK = "tool_list_updated_ack",
-  PROCESS_DATA = "process_data",
-  SERVER_STARTED = "server_started",
-  SERVER_STOPPED = "server_stopped",
-  ERROR_FROM_NATIVE_HOST = "error_from_native_host",
-  CONNECT_NATIVE = "connectNative",
-  PING_NATIVE = "ping_native",
-  DISCONNECT_NATIVE = "disconnect_native"
-}
-/**
- * Chrome Extension Constants
- * Centralized configuration values and magic constants
- */
-declare const NATIVE_HOST: {
-  readonly NAME: "com.chromemcp.nativehost";
-  readonly DEFAULT_PORT: 12306;
-};
-declare const ERROR_MESSAGES: {
-  readonly NATIVE_CONNECTION_FAILED: "Failed to connect to native host";
-  readonly NATIVE_DISCONNECTED: "Native connection disconnected";
-  readonly SERVER_STATUS_LOAD_FAILED: "Failed to load server status";
-  readonly TOOL_EXECUTION_FAILED: "Tool execution failed";
-  readonly SERVER_STATUS_SAVE_FAILED: "Failed to save server status";
-};
-declare const SUCCESS_MESSAGES: {
-  readonly TOOL_EXECUTED: "Tool executed successfully";
-  readonly CONNECTION_ESTABLISHED: "Connection established";
-  readonly SERVER_STARTED: "Server started successfully";
-  readonly SERVER_STOPPED: "Server stopped successfully";
-};
-declare const STORAGE_KEYS: {
-  readonly SERVER_STATUS: "serverStatus";
-};
-declare const BACKGROUND_MESSAGE_TYPES: {
-  readonly GET_SERVER_STATUS: "get_server_status";
-  readonly REFRESH_SERVER_STATUS: "refresh_server_status";
-  readonly SERVER_STATUS_CHANGED: "server_status_changed";
-};
-declare const HOST_NAME: "com.chromemcp.nativehost";
-/**
- * Server status management interface
- */
-interface ServerStatus {
-  isRunning: boolean;
-  port?: number;
-  lastUpdated: number;
-}
+declare const DEFAULT_TAB_CHANNEL_ID = "mcp-default";
+declare const DEFAULT_IFRAME_CHANNEL_ID = "mcp-iframe";
 //#endregion
 //#region src/ExtensionClientTransport.d.ts
-/**
- * Configuration options for ExtensionClientTransport
- */
 interface ExtensionClientTransportOptions {
-  /**
-   * The extension ID to connect to (optional for same-extension connections)
-   */
+  /** Extension ID to connect to. Omit for the current extension. */
   extensionId?: string;
-  /**
-   * Port name for the connection
-   * Default: 'mcp'
-   */
+  /** Port name (default: `mcp`). */
   portName?: string;
-  /**
-   * Enable automatic reconnection on disconnect
-   * Default: true
-   */
-  autoReconnect?: boolean;
-  /**
-   * Maximum number of reconnection attempts
-   * Default: 10
-   */
-  maxReconnectAttempts?: number;
-  /**
-   * Initial reconnection delay in milliseconds
-   * Default: 1000
-   */
-  reconnectDelay?: number;
-  /**
-   * Maximum reconnection delay in milliseconds
-   * Default: 30000
-   */
-  maxReconnectDelay?: number;
-  /**
-   * Reconnection backoff multiplier
-   * Default: 1.5
-   */
-  reconnectBackoffMultiplier?: number;
 }
-/**
- * Client transport for Chrome extensions using Port-based messaging.
- * This transport can be used in content scripts, popup scripts, or sidepanel scripts
- * to connect to a server running in the background service worker.
- *
- * Features automatic reconnection to handle background service worker lifecycle.
- */
+/** Client transport for Chrome extension Port messaging. */
 declare class ExtensionClientTransport implements Transport {
   private _port;
-  private _extensionId;
-  private _portName;
+  private readonly _extensionId;
+  private readonly _portName;
   private _messageHandler;
   private _disconnectHandler;
-  private _isReconnecting;
-  private _reconnectAttempts;
-  private _reconnectTimer;
-  private _currentReconnectDelay;
-  private _isStarted;
-  private _isClosed;
-  private _autoReconnect;
-  private _maxReconnectAttempts;
-  private _reconnectDelay;
-  private _maxReconnectDelay;
-  private _reconnectBackoffMultiplier;
+  private _started;
+  private _closed;
   onclose?: () => void;
   onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
+  onmessage?: Transport['onmessage'];
   constructor(options?: ExtensionClientTransportOptions);
-  /**
-   * Starts the transport by connecting to the extension port
-   */
   start(): Promise<void>;
-  /**
-   * Connects to the extension port
-   */
-  private _connect;
-  /**
-   * Sends a message to the server
-   */
   send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
-  /**
-   * Closes the transport
-   */
   close(): Promise<void>;
-  /**
-   * Cleans up event listeners and references
-   */
+  private _finishClose;
   private _cleanup;
-  /**
-   * Schedules a reconnection attempt
-   */
-  private _scheduleReconnect;
-  /**
-   * Attempts to reconnect to the extension
-   */
-  private _attemptReconnect;
 }
 //#endregion
 //#region src/ExtensionServerTransport.d.ts
-/**
- * Configuration options for ExtensionServerTransport
- */
-type ExtensionServerTransportOptions = {
-  /**
-   * Enable keep-alive mechanism to prevent service worker shutdown
-   * Default: true
-   */
+interface ExtensionServerTransportOptions {
+  /** Send keep-alive messages (default: true). */
   keepAlive?: boolean;
-  /**
-   * Keep-alive interval in milliseconds
-   * Default: 25000 (25 seconds, less than Chrome's 30-second timeout)
-   */
+  /** Keep-alive interval in milliseconds (default: 25,000). */
   keepAliveInterval?: number;
-};
-/**
- * Server transport for Chrome extensions using Port-based messaging.
- * This transport handles a single client connection through Chrome's port messaging API.
- * It should be used in the extension's background service worker.
- *
- * Features:
- * - Keep-alive mechanism to prevent service worker shutdown
- * - Graceful connection state management
- */
+}
+/** Server transport for one Chrome extension Port connection. */
 declare class ExtensionServerTransport implements Transport {
   private _port;
   private _started;
+  private _closed;
   private _messageHandler;
   private _disconnectHandler;
   private _keepAliveTimer;
-  private _options;
-  private _connectionInfo;
+  private readonly _keepAliveInterval;
+  private readonly _connectionInfo;
   onclose?: () => void;
   onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
+  onmessage?: Transport['onmessage'];
   constructor(port: chrome.runtime.Port, options?: ExtensionServerTransportOptions);
-  /**
-   * Starts the transport and begins handling messages
-   */
   start(): Promise<void>;
-  /**
-   * Sends a message to the client
-   */
   send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
-  /**
-   * Closes the transport
-   */
   close(): Promise<void>;
-  /**
-   * Cleans up event listeners and references
-   */
-  private _cleanup;
-  /**
-   * Starts the keep-alive mechanism
-   */
-  private _startKeepAlive;
-  /**
-   * Stops the keep-alive mechanism
-   */
-  private _stopKeepAlive;
-  /**
-   * Gets connection information
-   */
   getConnectionInfo(): {
     uptime: number;
     isConnected: boolean;
@@ -355,584 +67,129 @@ declare class ExtensionServerTransport implements Transport {
     lastMessageAt: number;
     messageCount: number;
   };
+  private _finishClose;
+  private _cleanup;
 }
 //#endregion
 //#region src/IframeChildTransport.d.ts
 interface IframeChildTransportOptions {
-  /** Whitelist of parent origins allowed to connect (for security) */
-  allowedOrigins: string[];
-  /** Optional channel name (default: 'mcp-iframe') */
+  /** Parent origins allowed to connect. Pass `['*']` only to disable validation deliberately. */
+  allowedOrigins: readonly string[];
+  /** Channel name (default: `mcp-iframe`). */
   channelId?: string;
-  /** Retry interval for broadcasting ready signal in milliseconds (default: 250) */
-  serverReadyRetryMs?: number;
 }
-/**
- * IframeChildTransport - Server transport for iframe
- *
- * Use this transport when an iframe wants to expose an MCP server to its parent page.
- * Supports cross-origin communication.
- *
- * @example
- * ```typescript
- * const transport = new IframeChildTransport({
- *   allowedOrigins: ['https://parent-app.com'],
- * });
- *
- * const server = new Server({ name: 'IframeApp', version: '1.0.0' });
- * await server.connect(transport);
- * ```
- */
+/** Server transport for an MCP server running inside an iframe. */
 declare class IframeChildTransport implements Transport {
   private _started;
-  private _allowedOrigins;
-  private _channelId;
-  private _messageHandler?;
+  private _closed;
+  private readonly _allowedOrigins;
+  private readonly _channelId;
+  private _messageHandler;
   private _clientOrigin?;
-  private _serverReadyTimeout;
-  private readonly _serverReadyRetryMs;
+  /**
+   * Fires when the connected parent's origin is first established, and again if a
+   * different parent takes over the channel. Lets a server scope per-tool exposure
+   * to the embedder it is actually talking to.
+   */
+  onclientorigin?: (origin: string) => void;
   onclose?: () => void;
   onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
+  onmessage?: Transport['onmessage'];
   constructor(options: IframeChildTransportOptions);
+  /** Origin of the connected parent, or `undefined` before its first message arrives. */
+  get clientOrigin(): string | undefined;
   start(): Promise<void>;
-  private broadcastServerReady;
-  private scheduleServerReadyRetry;
-  private clearServerReadyRetry;
-  send(message: JSONRPCMessage): Promise<void>;
+  send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
   close(): Promise<void>;
+  private _broadcastServerReady;
 }
 //#endregion
 //#region src/IframeParentTransport.d.ts
 interface IframeParentTransportOptions {
-  /** Reference to the iframe element */
   iframe: HTMLIFrameElement;
-  /** Expected origin of the iframe (for security) */
-  targetOrigin?: string;
-  /** Optional channel name (default: 'mcp-iframe') */
+  /** Expected iframe origin. Pass `'*'` only to disable origin validation deliberately. */
+  targetOrigin: string;
+  /** Channel name (default: `mcp-iframe`). */
   channelId?: string;
-  /** Retry interval for ready handshake in milliseconds (default: 250) */
+  /** Retry interval while `iframe.contentWindow` is unavailable (default: 250ms). */
   checkReadyRetryMs?: number;
 }
-/**
- * IframeParentTransport - Client transport for parent page
- *
- * Use this transport when the parent page wants to connect to an MCP server
- * running inside an iframe. Supports cross-origin communication.
- *
- * @example
- * ```typescript
- * const iframe = document.querySelector('iframe');
- * const transport = new IframeParentTransport({
- *   iframe,
- *   targetOrigin: 'https://iframe-app.com',
- * });
- *
- * const client = new Client({ name: 'Parent', version: '1.0.0' });
- * await client.connect(transport);
- * ```
- */
+/** Client transport for an MCP server running inside an iframe. */
 declare class IframeParentTransport implements Transport {
   private _started;
-  private _iframe;
-  private _targetOrigin;
-  private _channelId;
-  private _messageHandler?;
-  private _checkReadyTimeout;
+  private _closed;
+  private readonly _iframe;
+  private readonly _targetOrigin;
+  private readonly _channelId;
   private readonly _checkReadyRetryMs;
-  readonly serverReadyPromise: Promise<void>;
+  private _messageHandler;
+  private _checkReadyTimeout;
   private _serverReadyResolve;
   private _serverReadyReject;
+  private _serverReadySettled;
+  readonly serverReadyPromise: Promise<void>;
   onclose?: () => void;
   onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
+  onmessage?: Transport['onmessage'];
   constructor(options: IframeParentTransportOptions);
   start(): Promise<void>;
-  private sendCheckReady;
-  private scheduleCheckReadyRetry;
-  private clearCheckReadyRetry;
-  send(message: JSONRPCMessage): Promise<void>;
+  send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
   close(): Promise<void>;
+  private _sendCheckReady;
+  private _clearCheckReadyRetry;
+  private _resolveServerReady;
 }
 //#endregion
 //#region src/TabClientTransport.d.ts
-/**
- * Configuration options for TabClientTransport.
- *
- * @see {@link TabClientTransport}
- */
 interface TabClientTransportOptions {
-  /**
-   * Expected origin of the server window for security validation.
-   *
-   * **Security**: This origin is checked against `event.origin` for all incoming
-   * messages to prevent cross-origin attacks. Only messages from this origin will
-   * be processed.
-   *
-   * @example 'https://example.com'
-   * @example 'http://localhost:3000'
-   */
-  targetOrigin?: string;
-  /**
-   * Channel identifier for message routing.
-   *
-   * Multiple transports can coexist on the same page by using different channel IDs.
-   * This allows for isolated communication channels between different MCP clients
-   * and servers.
-   *
-   * @default 'mcp-default'
-   */
+  /** Expected server origin. Pass `'*'` only to disable origin validation deliberately. */
+  targetOrigin: string;
+  /** Channel name (default: `mcp-default`). */
   channelId?: string;
-  /**
-   * Request timeout in milliseconds.
-   *
-   * If a request doesn't receive a response within this time, a timeout error
-   * is synthesized and delivered to the client. This prevents infinite hangs
-   * when the server becomes unresponsive due to:
-   * - Page navigation
-   * - JavaScript errors
-   * - Network issues
-   * - Server crashes
-   *
-   * **Design rationale**: 10 seconds is appropriate for most tool operations.
-   * For operations that may take longer (e.g., complex computations, slow network
-   * requests), increase this value via the configuration option.
-   *
-   * @default 10000 (10 seconds)
-   * @see {@link _handleRequestTimeout} for timeout implementation
-   */
-  requestTimeout?: number;
 }
-/**
- * Client-side transport for same-window MCP communication via postMessage.
- *
- * This transport connects an MCP client to a TabServerTransport running in the same
- * window. Communication occurs via the browser's `window.postMessage()` API, which
- * provides:
- * - Same-window message passing (no network overhead)
- * - Origin validation for security
- * - Asynchronous message delivery
- *
- * **Architecture**:
- * ```
- * ┌─────────────────┐                    ┌──────────────────┐
- * │  MCP Client     │  postMessage()     │  MCP Server      │
- * │  (This side)    │ ←─────────────────→│  (TabServerTransport)
- * └─────────────────┘                    └──────────────────┘
- * ```
- *
- * **Key features**:
- * - Request timeout to prevent infinite hangs (default 10s)
- * - Server ready detection via handshake
- * - Origin validation for security
- * - Channel-based message routing
- *
- * **Use cases**:
- * - MCP client running in content script connecting to page context
- * - MCP client in extension popup connecting to background page
- * - Testing and development scenarios
- *
- * @example Basic usage
- * ```typescript
- * const transport = new TabClientTransport({
- *   targetOrigin: 'https://example.com',
- *   channelId: 'my-mcp-channel',
- *   requestTimeout: 10000, // Optional (default)
- * });
- *
- * // Wait for server to be ready
- * await transport.start();
- * await transport.serverReadyPromise;
- *
- * // Now safe to send messages
- * await transport.send({
- *   jsonrpc: '2.0',
- *   id: 1,
- *   method: 'tools/call',
- *   params: { name: 'my_tool', arguments: {} }
- * });
- * ```
- *
- * @example With custom timeout
- * ```typescript
- * const transport = new TabClientTransport({
- *   targetOrigin: '*',
- *   requestTimeout: 60000, // 60 seconds for slow operations
- * });
- * ```
- *
- * @see {@link TabServerTransport} for the server-side implementation
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage} for postMessage API
- */
+/** Client transport for an MCP server running in the same window. */
 declare class TabClientTransport implements Transport {
-  /** Transport state flag */
   private _started;
-  /** Expected origin for message validation */
+  private _closed;
   private readonly _targetOrigin;
-  /** Channel ID for message routing */
   private readonly _channelId;
-  /** Request timeout in milliseconds */
-  private readonly _requestTimeout;
-  /** Message event listener */
-  private _messageHandler?;
-  /**
-   * Promise that resolves when the server is ready to receive messages.
-   *
-   * **Usage**: Always `await` this promise after calling `start()` and before
-   * sending messages. Sending messages before the server is ready may result
-   * in lost messages.
-   *
-   * @example
-   * ```typescript
-   * await transport.start();
-   * await transport.serverReadyPromise;
-   * // Now safe to send messages
-   * ```
-   */
-  readonly serverReadyPromise: Promise<void>;
-  /** Internal resolver for serverReadyPromise */
-  private readonly _serverReadyResolve;
-  /** Internal rejector for serverReadyPromise */
-  private readonly _serverReadyReject;
-  /** Tracks if serverReadyPromise has been settled */
+  private _messageHandler;
+  private _serverReadyResolve;
+  private _serverReadyReject;
   private _serverReadySettled;
-  /**
-   * Active request tracking for timeout management.
-   *
-   * **Key**: Request ID (from JSON-RPC message)
-   * **Value**: Timeout ID and original request
-   *
-   * When a response is received, the entry is removed and timeout cleared.
-   * If timeout expires first, an error response is synthesized.
-   */
-  private readonly _activeRequests;
-  /** Callback invoked when transport closes */
+  /** Resolves when the server signals readiness. `send()` awaits it automatically. */
+  readonly serverReadyPromise: Promise<void>;
   onclose?: () => void;
-  /** Callback invoked on errors */
   onerror?: (error: Error) => void;
-  /** Callback invoked when message received */
-  onmessage?: (message: JSONRPCMessage) => void;
-  /**
-   * Creates a new TabClientTransport instance.
-   *
-   * **Note**: The transport is not started automatically. Call `start()` to begin
-   * listening for messages.
-   *
-   * @param options - Configuration options
-   * @throws {Error} If targetOrigin is not specified
-   */
+  onmessage?: Transport['onmessage'];
   constructor(options: TabClientTransportOptions);
-  /**
-   * Starts the transport by registering message listeners.
-   *
-   * **Lifecycle**:
-   * 1. Register `window.addEventListener('message', ...)` handler
-   * 2. Send server ready check (in case server started first)
-   * 3. Wait for server ready signal via `serverReadyPromise`
-   *
-   * **Note**: Always `await transport.serverReadyPromise` after calling this method
-   * and before sending messages.
-   *
-   * @throws {Error} If transport is already started
-   */
   start(): Promise<void>;
-  /**
-   * Sends a JSON-RPC message to the server.
-   *
-   * **Request timeout**: If this is a request (has `method` and `id`), a timeout
-   * is started. If the server doesn't respond within `requestTimeout` milliseconds,
-   * an error response is synthesized.
-   *
-   * **Await server ready**: This method automatically awaits `serverReadyPromise`
-   * before sending, ensuring messages aren't lost.
-   *
-   * @param message - JSON-RPC message to send
-   * @throws {Error} If transport is not started
-   */
-  send(message: JSONRPCMessage): Promise<void>;
-  /**
-   * Closes the transport and cleans up resources.
-   *
-   * **Cleanup performed**:
-   * - Removes message event listener
-   * - Clears all active request timeouts
-   * - Rejects server ready promise if still pending
-   * - Invokes `onclose` callback
-   *
-   * **Note**: After calling this method, the transport cannot be reused.
-   * Create a new instance if needed.
-   */
+  send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
   close(): Promise<void>;
-  /**
-   * Sends a server ready check message.
-   *
-   * This prompts the server to respond with 'mcp-server-ready' signal,
-   * resolving the `serverReadyPromise`. Useful when the server may have
-   * started before the client.
-   *
-   * @private
-   */
-  private _sendCheckReady;
-  /**
-   * Starts timeout tracking for a request.
-   *
-   * **Behavior**: After `requestTimeout` milliseconds, if no response is received,
-   * `_handleRequestTimeout` is called to synthesize an error response.
-   *
-   * **Note**: Only requests (messages with `method` and `id`) are tracked.
-   * Notifications (no `id`) and responses are not tracked.
-   *
-   * @param message - JSON-RPC request message
-   * @private
-   */
-  private _startRequestTimeout;
-  /**
-   * Clears timeout tracking for a response.
-   *
-   * Called when a response (with `result` or `error`) is received.
-   * Clears the timeout and removes the tracking entry.
-   *
-   * @param message - JSON-RPC response message
-   * @private
-   */
-  private _clearRequestTimeout;
-  /**
-   * Handles request timeout by synthesizing an error response.
-   *
-   * **Error response format** (JSON-RPC 2.0):
-   * ```json
-   * {
-   *   "jsonrpc": "2.0",
-   *   "id": "<request-id>",
-   *   "error": {
-   *     "code": -32000,
-   *     "message": "Request timeout - server may have navigated or become unresponsive",
-   *     "data": {
-   *       "timeoutMs": 10000,
-   *       "originalMethod": "tools/call"
-   *     }
-   *   }
-   * }
-   * ```
-   *
-   * **Error code**: `-32000` (Server error) per JSON-RPC 2.0 specification.
-   *
-   * @param requestId - ID of the timed-out request
-   * @private
-   */
-  private _handleRequestTimeout;
+  private _resolveServerReady;
 }
 //#endregion
 //#region src/TabServerTransport.d.ts
 interface TabServerTransportOptions {
-  /** Whitelist of origins allowed to connect (for security) */
-  allowedOrigins: string[];
-  /** Optional channel name (default: 'mcp-default') */
+  /** Origins allowed to connect. Pass `['*']` only to disable origin validation deliberately. */
+  allowedOrigins: readonly string[];
+  /** Channel name (default: `mcp-default`). */
   channelId?: string;
 }
 declare class TabServerTransport implements Transport {
   private _started;
-  private _allowedOrigins;
-  private _channelId;
-  private _messageHandler?;
-  private _beforeUnloadHandler?;
-  private _cleanupInterval?;
-  private _pendingRequests;
-  private readonly SELF_TARGET_ORIGIN;
-  private readonly REQUEST_TIMEOUT_MS;
-  onclose?: () => void;
-  onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
-  constructor(options: TabServerTransportOptions);
-  start(): Promise<void>;
-  send(message: JSONRPCMessage): Promise<void>;
-  /**
-   * Handle page navigation by sending interrupted responses for all pending requests.
-   * Called during beforeunload event.
-   * @private
-   */
-  private _handleBeforeUnload;
-  /**
-   * Clean up stale requests that have been pending for too long.
-   * Called periodically to prevent memory leaks.
-   * @private
-   */
-  private _cleanupStaleRequests;
-  close(): Promise<void>;
-}
-//#endregion
-//#region src/UserScriptClientTransport.d.ts
-/**
- * Configuration options for UserScriptClientTransport
- */
-interface UserScriptClientTransportOptions {
-  /**
-   * The extension ID to connect to (optional for same-extension connections)
-   */
-  extensionId?: string;
-  /**
-   * Port name for the connection
-   * Default: 'mcp'
-   */
-  portName?: string;
-  /**
-   * Enable automatic reconnection on disconnect
-   * Default: true
-   */
-  autoReconnect?: boolean;
-  /**
-   * Maximum number of reconnection attempts
-   * Default: 10
-   */
-  maxReconnectAttempts?: number;
-  /**
-   * Initial reconnection delay in milliseconds
-   * Default: 1000
-   */
-  reconnectDelay?: number;
-  /**
-   * Maximum reconnection delay in milliseconds
-   * Default: 30000
-   */
-  maxReconnectDelay?: number;
-  /**
-   * Reconnection backoff multiplier
-   * Default: 1.5
-   */
-  reconnectBackoffMultiplier?: number;
-}
-/**
- * Client transport for Chrome MV3 User Scripts using Port-based messaging.
- * This transport can be used inside a User Script context to connect to the
- * extension's background service worker. On the extension side, connections
- * are received via chrome.runtime.onUserScriptConnect.
- *
- * Features automatic reconnection to handle background service worker lifecycle.
- */
-declare class UserScriptClientTransport implements Transport {
-  private _port;
-  private _extensionId;
-  private _portName;
-  private _messageHandler;
-  private _disconnectHandler;
-  private _isReconnecting;
-  private _reconnectAttempts;
-  private _reconnectTimer;
-  private _currentReconnectDelay;
-  private _isStarted;
-  private _isClosed;
-  private _autoReconnect;
-  private _maxReconnectAttempts;
-  private _reconnectDelay;
-  private _maxReconnectDelay;
-  private _reconnectBackoffMultiplier;
-  onclose?: () => void;
-  onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
-  constructor(options?: UserScriptClientTransportOptions);
-  /**
-   * Starts the transport by connecting to the extension port
-   */
-  start(): Promise<void>;
-  /**
-   * Connects to the extension port
-   */
-  private _connect;
-  /**
-   * Sends a message to the server
-   */
-  send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
-  /**
-   * Closes the transport
-   */
-  close(): Promise<void>;
-  /**
-   * Cleans up event listeners and references
-   */
-  private _cleanup;
-  /**
-   * Schedules a reconnection attempt
-   */
-  private _scheduleReconnect;
-  /**
-   * Attempts to reconnect to the extension
-   */
-  private _attemptReconnect;
-}
-//#endregion
-//#region src/UserScriptServerTransport.d.ts
-/**
- * Configuration options for UserScriptServerTransport
- */
-type UserScriptServerTransportOptions = {
-  /**
-   * Enable keep-alive mechanism to prevent service worker shutdown
-   * Default: true
-   */
-  keepAlive?: boolean;
-  /**
-   * Keep-alive interval in milliseconds
-   * Default: 25000 (25 seconds, less than Chrome's 30-second timeout)
-   */
-  keepAliveInterval?: number;
-};
-/**
- * Server transport for Chrome MV3 User Scripts using Port-based messaging.
- * This transport handles a single client connection through Chrome's port
- * messaging API. It should be used in the extension's background service
- * worker. Connections are initiated from User Scripts via chrome.runtime.connect
- * and received here via chrome.runtime.onUserScriptConnect.
- *
- * Features:
- * - Keep-alive mechanism to prevent service worker shutdown
- * - Graceful connection state management
- */
-declare class UserScriptServerTransport implements Transport {
-  private _port;
-  private _started;
+  private _closed;
+  private readonly _allowedOrigins;
+  private readonly _channelId;
   private _messageHandler;
-  private _disconnectHandler;
-  private _keepAliveTimer;
-  private _options;
-  private _connectionInfo;
   onclose?: () => void;
   onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage) => void;
-  constructor(port: chrome.runtime.Port, options?: UserScriptServerTransportOptions);
-  /**
-   * Starts the transport and begins handling messages
-   */
+  onmessage?: Transport['onmessage'];
+  constructor(options: TabServerTransportOptions);
   start(): Promise<void>;
-  /**
-   * Sends a message to the client
-   */
   send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
-  /**
-   * Closes the transport
-   */
   close(): Promise<void>;
-  /**
-   * Cleans up event listeners and references
-   */
-  private _cleanup;
-  /**
-   * Starts the keep-alive mechanism
-   */
-  private _startKeepAlive;
-  /**
-   * Stops the keep-alive mechanism
-   */
-  private _stopKeepAlive;
-  /**
-   * Gets connection information
-   */
-  getConnectionInfo(): {
-    uptime: number;
-    isConnected: boolean;
-    connectedAt: number;
-    lastMessageAt: number;
-    messageCount: number;
-  };
 }
 //#endregion
-export { BACKGROUND_MESSAGE_TYPES, ERROR_MESSAGES, EventId, ExtensionClientTransport, ExtensionClientTransportOptions, ExtensionServerTransport, ExtensionServerTransportOptions, HOST_NAME, IframeChildTransport, IframeChildTransportOptions, IframeParentTransport, IframeParentTransportOptions, MCPBrowserInterface, MCPConnectOptions, MCPEventMessage, MCPEventStore, MCPReplayEventMessage, MCPServerInfo, MCPServerInfoMessage, MCPWindow, NATIVE_HOST, NativeMessageType, STORAGE_KEYS, SUCCESS_MESSAGES, ServerStatus, StoredEvent, StreamId, TabClientTransport, TabClientTransportOptions, TabServerTransport, TabServerTransportOptions, UserScriptClientTransport, UserScriptClientTransportOptions, UserScriptServerTransport, UserScriptServerTransportOptions };
+export { DEFAULT_IFRAME_CHANNEL_ID, DEFAULT_TAB_CHANNEL_ID, ExtensionClientTransport, ExtensionClientTransportOptions, ExtensionServerTransport, ExtensionServerTransportOptions, IframeChildTransport, IframeChildTransportOptions, IframeParentTransport, IframeParentTransportOptions, TabClientTransport, TabClientTransportOptions, TabServerTransport, TabServerTransportOptions };
 //# sourceMappingURL=index.d.ts.map