crx-rpc 2.0.0 → 2.1.0

package/README.md

@@ -1,657 +1,152 @@
-# Chrome Extension RPC (crx-rpc)
+# crx-rpc
 
-A lightweight, type-safe RPC framework for Chrome Extensions supporting communication between web pages, content scripts, and background scripts. Built with TypeScript for maximum type safety and developer experience.
+A type-safe RPC implementation for Chrome Extensions, supporting communication between Content Scripts, Background, Popup/Sidepanel, and Web Pages.
 
 ## Features
 
-- 🔒 **Type Safety**: Full TypeScript type support with automatic proxy type generation
-- 🚀 **Easy to Use**: Auto-generated client proxies based on interfaces
-- 🔄 **Bidirectional Communication**: Supports web page ↔ content script ↔ background script
-- 📦 **Zero Configuration**: No manual method binding required
-- 🎯 **Observable Support**: Built-in support for reactive data streams with RemoteSubject
-- 🛡️ **Error Handling**: Preserves stack traces and error types across boundaries
-- 🧹 **Resource Management**: Built-in disposable pattern for clean resource cleanup
-
-## Installation
-
-```bash
-npm install crx-rpc
-# or
-pnpm add crx-rpc
-# or
-yarn add crx-rpc
-```
+- **Type-safe**: Built with TypeScript.
+- **Flexible**: Supports various communication paths within a Chrome Extension.
+- **Observable**: Supports RxJS-like observables for real-time updates.
 
-## Quick Start
+## Communication Architecture
 
-### 1. Define Service Interface
+The library facilitates communication between different parts of a Chrome Extension.
 
-```typescript
-// services/math.ts
-import { createIdentifier } from 'crx-rpc';
+### Service Providers
 
-interface IMathService {
-    add(a: number, b: number): Promise<number>;
-    subtract(a: number, b: number): Promise<number>;
-    multiply(a: number, b: number): Promise<number>;
-    divide(a: number, b: number): Promise<number>;
-}
+Services can be hosted in two locations:
 
-// Create service identifier
-export const IMathService = createIdentifier<IMathService>('MathService');
-```
+1.  **Background**: Hosted using `BackgroundRPCHost`. Handles requests from Content Scripts and Web Pages.
+2.  **Content Script**: Hosted using `ContentRPCHost`. Handles requests from Background and Popup/Sidepanel.
 
-### 2. Implement Service (Background Script)
+### Callers
 
-```typescript
-// background.ts
-import { BackgroundRPC } from 'crx-rpc';
-import { IMathService } from './services/math';
+Callers can be:
 
-class MathService implements IMathService {
-    async add(a: number, b: number): Promise<number> {
-        return a + b;
-    }
-
-    async subtract(a: number, b: number): Promise<number> {
-        return a - b;
-    }
-
-    async multiply(a: number, b: number): Promise<number> {
-        return a * b;
-    }
-
-    async divide(a: number, b: number): Promise<number> {
-        if (b === 0) throw new Error('Division by zero');
-        return a / b;
-    }
-}
-
-// Register service with optional logging
-const rpc = new BackgroundRPC(true); // Enable logging
-// const rpc = new BackgroundRPC(); // Disable logging (default)
-rpc.register(IMathService, new MathService());
-```
-
-### 3. Initialize Content Script
+1.  **Runtime**: Content Scripts, Popup, Sidepanel.
+2.  **Web**: Injected scripts in the web page.
 
-Content scripts can work in two modes:
+### Supported Flows
 
-#### Option A: As a Bridge (for web page communication)
-
-```typescript
-// content.ts
-import { ContentRPC } from 'crx-rpc';
-
-// Initialize RPC bridge for web page ↔ background communication
-const contentRpc = new ContentRPC();
-
-// Remember to dispose when cleanup is needed
-// contentRpc.dispose();
-```
-
-#### Option B: As a Direct Client
-
-```typescript
-// content.ts
-import { ContentRPCClient } from 'crx-rpc';
-import { IMathService } from './services/math';
-
-// Use content script as a direct RPC client
-const client = new ContentRPCClient();
-const mathService = client.createWebRPCService(IMathService);
-
-// Direct calls to background services
-const result = await mathService.add(5, 3);
-console.log('Result from content script:', result);
-
-// Remember to dispose when cleanup is needed
-// client.dispose();
-```
-
-#### Option C: Both Bridge and Client
-
-```typescript
-// content.ts
-import { ContentRPC, ContentRPCClient } from 'crx-rpc';
-import { IMathService } from './services/math';
+| Caller | Target | Client | Host | Note |
+| :--- | :--- | :--- | :--- | :--- |
+| **Content Script** | **Background** | `RuntimeRPCClient` | `BackgroundRPCHost` | Standard Runtime -> Background communication. |
+| **Web Page** | **Background** | `WebRPCClient` | `BackgroundRPCHost` | Relayed via Content Script (`Web2BackgroundProxy`). |
+| **Background** | **Content Script** | `TabRPCClient` | `ContentRPCHost` | Targets a specific tab. |
+| **Popup/Sidepanel** | **Content Script** | `TabRPCClient` | `ContentRPCHost` | Targets a specific tab. |
 
-// Initialize bridge for web pages
-const bridge = new ContentRPC();
+> **Note**: Direct communication from Popup/Sidepanel to Background using `RuntimeRPCClient` is currently not supported by `BackgroundRPCHost` as it requires a sender tab ID.
 
-// Also use as direct client
-const client = new ContentRPCClient();
-const mathService = client.createWebRPCService(IMathService);
+## Usage
 
-// Content script can make its own RPC calls
-const result = await mathService.multiply(2, 3);
-console.log('Content script calculation:', result);
-```
+### 1. Define API
 
-### 4. Use Client (Web Page)
+Define your service interface and create an identifier.
 
 ```typescript
-// web-page.ts
-import { WebRPCClient } from 'crx-rpc';
-import { IMathService } from './services/math';
-
-async function calculate() {
-    // Create RPC client
-    const client = new WebRPCClient();
-
-    // Create type-safe service proxy
-    const mathService = client.createWebRPCService(IMathService);
-
-    // Type-safe method calls
-    const sum = await mathService.add(1, 2); // TypeScript knows this returns Promise<number>
-    const difference = await mathService.subtract(10, 5);
-    const product = await mathService.multiply(3, 4);
-    const quotient = await mathService.divide(15, 3);
-
-    console.log('Results:', { sum, difference, product, quotient });
+import { createIdentifier } from 'crx-rpc';
 
-    // Remember to dispose when cleanup is needed
-    // client.dispose();
+export interface IMathService {
+  add(a: number, b: number): Promise<number>;
 }
-```
 
-## Architecture
-
-### Complete Communication Topology
-
-```mermaid
-graph TB
-    subgraph WebPage["Web Page Context"]
-        WC[WebRPCClient]
-        WO[WebObservable]
-    end
-    
-    subgraph ContentScript["Content Script Context"]
-        CR[ContentRPC<br/>Bridge Mode]
-        CC[ContentRPCClient<br/>Direct Mode]
-        CO[ContentObservable]
-    end
-    
-    subgraph Background["Background Script Context"]
-        BR[BackgroundRPC]
-        MS[MathService]
-        US[UserService]
-        RS[RemoteSubject]
-        RSM[RemoteSubjectManager]
-    end
-    
-    subgraph ExtPage["Extension Page Context<br/>(Popup/Options/Sidepanel)"]
-        EC[ExtPageRPCClient]
-        EO[ExtPageObservable]
-    end
-    
-    subgraph TabContext["Tab-specific Access"]
-        TC[TabRPCClient]
-    end
-    
-    %% RPC Calls
-    WC -->|"CustomEvent<br/>.add(1,2)"| CR
-    CR -->|"chrome.runtime<br/>Forward"| BR
-    CC -->|"chrome.runtime<br/>.multiply(2,3)"| BR
-    EC -->|"chrome.runtime<br/>.divide(10,2)"| BR
-    TC -->|"chrome.tabs<br/>Access Content Service"| CC
-    
-    BR -->|Response| CR
-    CR -->|CustomEvent| WC
-    BR -->|Response| CC
-    BR -->|Response| EC
-    
-    BR -.->|Manages| MS
-    BR -.->|Manages| US
-    
-    %% Observable Streams
-    WO -.->|Subscribe| CR
-    CR -.->|Forward| RSM
-    CO -.->|Subscribe| RSM
-    EO -.->|Subscribe| RSM
-    RSM -.->|Broadcast| RS
-    RS -.->|Updates| CR
-    CR -.->|Updates| WO
-    RS -.->|Updates| CO
-    RS -.->|Updates| EO
-    
-    style WC fill:#e1f5ff
-    style CC fill:#e1f5ff
-    style EC fill:#e1f5ff
-    style TC fill:#e1f5ff
-    style BR fill:#fff4e6
-    style MS fill:#f0f0f0
-    style US fill:#f0f0f0
-    style RS fill:#ffe6f0
-    style RSM fill:#ffe6f0
-    style CR fill:#e8f5e9
+export const IMathService = createIdentifier<IMathService>('math-service', 'background');
 ```
 
-### Communication Paths
-
-| Path | Method | Description |
-|------|--------|-------------|
-| **Web Page → Background** | CustomEvent + chrome.runtime | Through ContentRPC bridge |
-| **Content Script → Background** | chrome.runtime | Direct communication |
-| **Extension Page → Background** | chrome.runtime | Direct communication |
-| **Extension Page → Content Script** | chrome.tabs + TabRPCClient | Tab-specific access |
-| **Background → All Contexts** | RemoteSubject broadcast | Real-time data streaming |
-
-### Key Components
-
-- **WebRPCClient**: Client for web pages using window events
-- **ContentRPC**: Bridge that forwards messages between web and background
-- **ContentRPCClient**: Direct RPC client for content scripts (bypasses bridge)
-- **BackgroundRPC**: Service registry and handler in the background script
-- **RPCClient**: Base client with service proxy generation
+### 2. Implement & Host Service
 
-## Logging Support
-
-The framework includes built-in logging support for debugging and monitoring RPC calls.
-
-### Enable Logging
-
-```typescript
-// Enable logging in BackgroundRPC
-const rpc = new BackgroundRPC(true); // Enable logging
-// const rpc = new BackgroundRPC(); // Disable logging (default)
-
-// Example output:
-// [RPC] Call: MathService.add { id: "123", args: [5, 3], senderId: 456, timestamp: "2025-09-01T10:00:00.000Z" }
-// [RPC] Success: MathService.add { id: "123", result: 8, timestamp: "2025-09-01T10:00:00.001Z" }
-
-// For errors:
-// [RPC] Error: MathService.divide { id: "124", error: "Division by zero", timestamp: "2025-09-01T10:00:01.000Z" }
-```
-
-### Log Output
-
-When logging is enabled, the following information is logged:
-
-- **Function Calls**: Service name, method name, arguments, sender ID, and timestamp
-- **Success Responses**: Service name, method name, result, and timestamp  
-- **Error Responses**: Service name, method name, error message, and timestamp
-- **Unknown Services/Methods**: Warnings for invalid service or method calls
-
-### Use Cases
-
-- **Development**: Debug RPC communication during development
-- **Production Monitoring**: Track RPC usage patterns and performance
-- **Troubleshooting**: Identify failed calls and error patterns
-- **Security Auditing**: Monitor RPC access patterns
-
-## Observable Support
-
-The framework includes built-in support for reactive data streams using `RemoteSubject` and `Observable` patterns with a centralized message management system.
-
-### Remote Subject Manager & Remote Subject (Background Script)
-
-The `RemoteSubjectManager` acts as a centralized message hub that handles all subscription management and message routing, while `RemoteSubject` focuses purely on state management.
+#### In Background
 
 ```typescript
 // background.ts
-import { BackgroundRPC, RemoteSubjectManager, createIdentifier } from 'crx-rpc';
-
-interface ICounterObservable {
-    value: number;
-}
-
-const ICounterObservable = createIdentifier<ICounterObservable>('Counter');
-
-const rpc = new BackgroundRPC();
-
-// Create a centralized subject manager
-const subjectManager = new RemoteSubjectManager();
-
-// Create a remote subject through the manager
-const counterSubject = subjectManager.createSubject(
-    ICounterObservable, 
-    'main', 
-    { value: 0 }
-);
-
-// Update value and broadcast to all subscribers
-setInterval(() => {
-    const newValue = { value: Math.floor(Math.random() * 100) };
-    counterSubject.next(newValue);
-}, 1000);
-
-// The manager handles:
-// - Message routing and subscription management
-// - Queuing subscriptions that arrive before subjects are created
-// - Automatic cleanup when tabs are closed
-// - Broadcasting to multiple subscribers
-
-// Cleanup
-// subjectManager.dispose(); // This will dispose all subjects
-```
-
-### Key Features of RemoteSubjectManager
-
-- **Centralized Message Hub**: All observable-related messages are handled by the manager
-- **Queue Management**: Subscriptions received before subject creation are queued and processed later
-- **Resource Management**: Automatic cleanup of subscriptions when tabs are closed
-- **Type Safety**: Full TypeScript support with proper typing throughout
-
-### Architecture
-
-```
-┌─────────────────┐    ┌──────────────────────────────────────┐    ┌─────────────────┐
-│   Web Page      │    │         Background Script            │    │ Content Script  │
-├─────────────────┤    ├──────────────────────────────────────┤    ├─────────────────┤
-│ WebObservable   │    │       RemoteSubjectManager           │    │ContentObservable│
-│                 │    │  ┌─────────────────────────────────┐ │    │                 │
-│ subscribe() ────┼───▶│  │ Message Routing & Queue Mgmt    │ │◄───┤ subscribe()     │
-│                 │◄───│  │                                 │ │    │                 │
-└─────────────────┘    │  └─────────────────────────────────┘ │    └─────────────────┘
-                       │                │                     │
-                       │  ┌─────────────▼─────────────────┐   │
-                       │  │        RemoteSubject          │   │
-                       │  │  (Pure State Management)      │   │
-                       │  │                               │   │
-                       │  │ next() ─────────────────────▶ │   │
-                       │  │ complete() ─────────────────▶ │   │
-                       │  └───────────────────────────────┘   │
-                       └──────────────────────────────────────┘
-```
+import { BackgroundRPCHost } from 'crx-rpc';
+import { IMathService } from './api';
 
-### Subscribing from Web Page
-
-```typescript
-// web-page.ts
-import { WebObservable, createIdentifier } from 'crx-rpc';
-
-interface ICounterObservable {
-    value: number;
+class MathService implements IMathService {
+  async add(a: number, b: number) {
+    return a + b;
+  }
 }
 
-const ICounterObservable = createIdentifier<ICounterObservable>('Counter');
-
-// Subscribe to remote observable
-const observable = new WebObservable(
-    ICounterObservable,
-    'main',
-    (value) => {
-        console.log('Counter updated:', value.value);
-    }
-);
-
-// Cleanup when done
-// observable.dispose();
+const host = new BackgroundRPCHost();
+host.register(IMathService, new MathService());
 ```
 
-### Subscribing from Content Script
+#### In Content Script
 
 ```typescript
 // content.ts
-import { ContentObservable, createIdentifier } from 'crx-rpc';
-
-interface ICounterObservable {
-    value: number;
-}
-
-const ICounterObservable = createIdentifier<ICounterObservable>('Counter');
-
-// Content script can directly subscribe to observables
-const observable = new ContentObservable(
-    ICounterObservable,
-    'main',
-    (value) => {
-        console.log('Counter from content script:', value.value);
-        // Content script can react to real-time updates
-        updateUI(value.value);
-    }
-);
-
-// Cleanup when done
-// observable.dispose();
-```
-
-### Subscribing from Extension Page
+import { ContentRPCHost, createIdentifier } from 'crx-rpc';
 
-```typescript
-// popup.ts / options.ts
-import { ExtPageObservable, createIdentifier } from 'crx-rpc';
-
-interface ICounterObservable {
-    value: number;
+export interface IPageService {
+    doSomething(): void;
 }
+export const IPageService = createIdentifier<IPageService>('page-service', 'content');
 
-const ICounterObservable = createIdentifier<ICounterObservable>('Counter');
-
-// Extension page can subscribe to background observables
-const observable = new ExtPageObservable(
-    ICounterObservable,
-    'main',
-    (value) => {
-        console.log('Counter from extension page:', value.value);
-        document.getElementById('counter').textContent = value.value.toString();
-    }
-);
-
-// Cleanup when done
-window.addEventListener('unload', () => {
-    observable.dispose();
-});
+const host = new ContentRPCHost();
+host.register(IPageService, new PageService());
 ```
 
-### Observable Communication Patterns
+### 3. Call Service
 
-The Observable system supports multiple communication patterns with centralized management:
+#### From Content Script (to Background)
 
 ```typescript
-// Pattern 1: Background → Web Page (via Content Script bridge)
-// Background: RemoteSubjectManager creates and manages RemoteSubject
-// Background: RemoteSubject.next() → Manager routes to subscribers
-// Web Page: WebObservable.subscribe()
-
-// Pattern 2: Background → Content Script (direct)
-// Background: RemoteSubject.next() → Manager routes directly
-// Content Script: ContentObservable.subscribe()
-
-// Pattern 3: Background → Both Web Page and Content Script
-// Background: RemoteSubject.next() → Manager broadcasts to all subscribers
-// Web Page: WebObservable.subscribe()
-// Content Script: ContentObservable.subscribe()
-
-// Pattern 4: Subscription before Subject Creation (Queue Management)
-// Subscriber: WebObservable.subscribe() → Manager queues subscription
-// Background: Later creates RemoteSubject → Manager processes queued subscriptions
-// Result: No missed initial values, proper subscription ordering
-```
+import { RuntimeRPCClient } from 'crx-rpc';
+import { IMathService } from './api';
 
-## Advanced Usage
+const client = new RuntimeRPCClient();
+const mathService = client.createRPCService(IMathService);
 
-### Resource Management with Disposables
+await mathService.add(1, 2);
+```
 
-All RPC components extend the `Disposable` class for proper cleanup:
+#### From Web Page (to Background)
 
 ```typescript
-import { WebRPCClient, ContentRPC, BackgroundRPC } from 'crx-rpc';
+import { WebRPCClient } from 'crx-rpc';
+import { IMathService } from './api';
 
 const client = new WebRPCClient();
-const contentRpc = new ContentRPC();
-const backgroundRpc = new BackgroundRPC();
-
-// Proper cleanup
-function cleanup() {
-    client.dispose();
-    contentRpc.dispose();
-    backgroundRpc.dispose();
-}
+const mathService = client.createRPCService(IMathService);
 
-// Check if already disposed
-if (!client.isDisposed()) {
-    const service = client.createWebRPCService(IMathService);
-    // Use service...
-}
+await mathService.add(1, 2);
 ```
 
-### Extension Page Accessing Content Script Services
-
-Extension pages can access content script services using `TabRPCClient` by specifying the target tab ID:
+*Note: Requires `Web2BackgroundProxy` to be active in the content script.*
 
 ```typescript
-// popup.ts
-import { TabRPCClient } from 'crx-rpc';
-import { IContentService } from './services';
-
-// Get current active tab
-const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
-
-if (tab.id) {
-    // Create RPC client for specific tab
-    const tabClient = new TabRPCClient(tab.id);
-    
-    // Access content script services in that tab
-    const contentService = tabClient.createWebRPCService(IContentService);
-    
-    // Call content script methods
-    const result = await contentService.getDOMInfo();
-    console.log('DOM info from content script:', result);
-    
-    // Cleanup when done
-    window.addEventListener('unload', () => {
-        tabClient.dispose();
-    });
-}
+// content.ts
+import { Web2BackgroundProxy } from 'crx-rpc';
+const proxy = new Web2BackgroundProxy();
 ```
 
-#### Use Cases for Extension Page → Content Script Communication:
-
-1. **DOM Inspection**: Popup queries content script for page information
-2. **User Actions**: Options page triggers content script actions on specific tabs
-3. **Multi-tab Management**: Sidepanel coordinates actions across multiple tabs
-4. **Live Preview**: Extension page gets real-time updates from content script
-
-#### Complete Example: Popup with Tab-specific Services
+#### From Background/Popup (to Content)
 
 ```typescript
-// content.ts - Register services in content script
-import { ContentRPCHost } from 'crx-rpc';
-import { IPageService } from './services';
-
-class PageService implements IPageService {
-    async getTitle(): Promise<string> {
-        return document.title;
-    }
-    
-    async getSelection(): Promise<string> {
-        return window.getSelection()?.toString() || '';
-    }
-    
-    async highlightText(text: string): Promise<void> {
-        // Highlight logic...
-    }
-}
-
-const contentHost = new ContentRPCHost();
-contentHost.register(IPageService, new PageService());
-
-// popup.ts - Access content script from popup
-import { TabRPCClient, ExtPageRPCClient } from 'crx-rpc';
-import { IPageService, IMathService } from './services';
-
-// Access background services
-const bgClient = new ExtPageRPCClient();
-const mathService = bgClient.createWebRPCService(IMathService);
-
-// Access content script services in active tab
-const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
-if (tab.id) {
-    const tabClient = new TabRPCClient(tab.id);
-    const pageService = tabClient.createWebRPCService(IPageService);
-    
-    // Get page info from content script
-    const title = await pageService.getTitle();
-    const selection = await pageService.getSelection();
-    
-    // Process with background service
-    const result = await mathService.calculate(selection.length);
-    
-    // Update popup UI
-    document.getElementById('title').textContent = title;
-    document.getElementById('result').textContent = result.toString();
-}
-```
-
-## Usage Scenarios
-
-### Scenario 1: Web Page Only
-- Web pages need to communicate with background services
-- Use: `WebRPCClient` + `ContentRPC` bridge
-
-### Scenario 2: Content Script Only  
-- Content scripts need direct access to background services
-- Use: `ContentRPCClient` directly (no bridge needed)
+import { TabRPCClient } from 'crx-rpc';
+import { IPageService } from './api';
 
-### Scenario 3: Both Web Page and Content Script
-- Both contexts need RPC access
-- Use: `ContentRPC` bridge + `ContentRPCClient` for direct access
+const tabId = 123; // Target Tab ID
+const client = new TabRPCClient(tabId);
+const pageService = client.createRPCService(IPageService);
 
-### Scenario 4: Real-time Data Streaming
-- Background needs to push updates to multiple contexts
-- Use: `RemoteSubject` + `WebObservable`/`ContentObservable`
+await pageService.doSomething();
+```
 
 ## API Reference
 
-### Core Classes
-
-- **`BackgroundRPC`**: Service registry and message handler for background scripts
-- **`ContentRPC`**: Message bridge between web pages and background scripts
-- **`WebRPCClient`**: RPC client for web pages
-- **`ContentRPCClient`**: Direct RPC client for content scripts
-- **`RemoteSubjectManager`**: Centralized observable message management system
-
-### Observable Classes
-
-- **`RemoteSubjectManager`**: Centralized message hub that manages subscriptions and message routing for all observables
-- **`RemoteSubject<T>`**: Pure state management observable that works with the manager to broadcast updates
-- **`WebObservable<T>`**: Observable subscriber for web pages
-- **`ContentObservable<T>`**: Observable subscriber for content scripts
-
-### Utility Functions
-
-- **`createIdentifier<T>(key: string)`**: Creates a type-safe service identifier
-
-### Interfaces
-
-- **`Identifier<T>`**: Type-safe service identifier interface
-- **`RpcRequest`**: RPC request message structure
-- **`RpcResponse`**: RPC response message structure
-- **`IMessageAdapter`**: Message transport abstraction interface
-- **`IDisposable`**: Resource management interface
-
-## Best Practices
-
-1. **Service Interface Design**
-   - Use clear method names and proper TypeScript types
-   - Return Promise types for async operation support
-   - Define detailed parameter and return value types
-   - Keep interfaces focused and cohesive
-
-2. **Resource Management**
-   - Always call `dispose()` on RPC instances when cleanup is needed
-   - Check `isDisposed()` before using disposed instances
-   - Use proper cleanup in component unmount/destroy lifecycle
+### Hosts
 
-3. **Error Handling**
-   - Implement proper error handling in service methods
-   - Throw meaningful errors with descriptive messages
-   - Handle RPC errors appropriately on the client side
+-   `BackgroundRPCHost`: Handles RPC requests in the background script.
+-   `ContentRPCHost`: Handles RPC requests in the content script.
 
-4. **Performance Optimization**
-   - Avoid frequent small data transfers
-   - Consider batching operations when possible
-   - Use Observable pattern for real-time data updates with `RemoteSubjectManager` for efficient message routing
-   - Implement caching strategies where appropriate
-   - The manager automatically handles subscription queuing to prevent race conditions
+### Clients
 
-5. **Security Considerations**
-   - Validate input parameters in service implementations
-   - Don't expose sensitive operations through RPC
-   - Consider rate limiting for resource-intensive operations
+-   `RuntimeRPCClient`: Used in Content Scripts to call Background services.
+-   `WebRPCClient`: Used in Web Pages to call Background services (via relay).
+-   `TabRPCClient`: Used in Background/Popup to call Content Script services for a specific tab.
 
-## License
+### Proxies
 
-MIT
+-   `Web2BackgroundProxy`: Relays messages from Web Page to Background. Must be instantiated in the Content Script.