Improve readability of READMEs

README.md

···
 - **Static File Serving**: Serve static files with proper MIME types and security checks
 - **Goroutine-Safe**: Thread-safe session management with proper synchronization
 
-## Status
-
-Production-ready Go implementation of the Cap'n Web RPC protocol. This is a complete rewrite of the original C++ implementation in Go.
-
 ## Dependencies
 
 - Go 1.21+
···
 3. **Server Push**
    ```bash
    cd examples/serverpush
+   go run main.go
+   ```
+
+   In a second tab:
+   ```bash
+   cd static
+   npm install
+   npm run dev
+   ```
+   Open: http://localhost:3000
+
+4. **Bluesky**
+   ```bash
+   cd examples/bluesky
    go run main.go
    ```
 

examples/batch-pipelining/README.md

···
+# Batch Pipelining Example
+
+This example demonstrates the power of Cap'n Web RPC's batch pipelining feature by showing how multiple dependent RPC calls can be executed in a single HTTP request.
+
+## What This Demo Shows
+
+- **Batch Pipelining**: Multiple dependent RPC calls in a single HTTP request
+- **Pipeline References**: Using the result of one call as input to subsequent calls
+- **Performance Comparison**: Side-by-side comparison of pipelined vs sequential execution
+- **Network Latency Simulation**: Configurable simulated RTT to demonstrate real-world benefits
+- **Reactive UI**: Built with Svelte 5 for smooth, reactive user experience
+
+## Running the Example
+
+1. **Start the Go Server**:
+   ```bash
+   go run main.go
+   ```
+
+2. In a new terminal, start the Svelte development server:
+   ```bash
+   cd static
+   npm install
+   npm run dev
+   ```
+
+3. Open your browser to `http://localhost:3000`
+
+## The Problem
+
+Traditional RPC requires multiple round trips for dependent operations:
+
+```javascript
+// Sequential: 3 separate HTTP requests (3 round trips)
+const user = await api.authenticate('cookie-123');     // Round trip 1
+const profile = await api.getUserProfile(user.id);     // Round trip 2  
+const notifications = await api.getNotifications(user.id); // Round trip 3
+```
+
+With typical network latency (120ms RTT), this takes ~360ms just for network overhead!
+
+## The Solution: Pipeline References
+
+Cap'n Web RPC's pipelining allows dependent calls to be batched:
+
+```javascript
+// Pipelined: All 3 calls in 1 HTTP request (1 round trip)
+const api = newHttpBatchRpcSession(RPC_URL);
+const user = api.authenticate('cookie-123');
+const profile = api.getUserProfile(user.id);           // References user.id before it resolves!
+const notifications = api.getNotifications(user.id);   // References user.id before it resolves!
+
+const [u, p, n] = await Promise.all([user, profile, notifications]);
+```
+
+All three calls are sent together in a single HTTP request. The server resolves them in dependency order and returns all results at once!
+
+## How It Works
+
+### Backend (Go)
+
+The Go server implements three RPC methods:
+
+1. **`authenticate(sessionToken)`** - Returns a User object with ID and name
+2. **`getUserProfile(userID)`** - Returns profile data for a user
+3. **`getNotifications(userID)`** - Returns an array of notifications for a user
+
+Sample data:
+- Session tokens: `cookie-123`, `cookie-456`
+- Users: `u_1` (Ada Lovelace), `u_2` (Alan Turing)
+
+### Frontend (Svelte)
+
+**Pipelined Execution** (1 HTTP request):
+```javascript
+const api = newHttpBatchRpcSession(RPC_URL);
+const user = api.authenticate('cookie-123');
+const profile = api.getUserProfile(user.id);
+const notifications = api.getNotifications(user.id);
+
+const [u, p, n] = await Promise.all([user, profile, notifications]);
+```
+
+**Sequential Execution** (3 HTTP requests):
+```javascript
+const api1 = newHttpBatchRpcSession(RPC_URL);
+const u = await api1.authenticate('cookie-123');
+
+const api2 = newHttpBatchRpcSession(RPC_URL);
+const p = await api2.getUserProfile(u.id);
+
+const api3 = newHttpBatchRpcSession(RPC_URL);
+const n = await api3.getNotifications(u.id);
+```
+
+## Performance Benefits
+
+With default simulated latency (120ms RTT ± 40ms jitter):
+
+- **Pipelined**: ~1 round trip = ~120-160ms
+- **Sequential**: ~3 round trips = ~360-480ms
+
+**Pipelined execution is typically 60-70% faster!**
+
+The benefits increase with:
+- Higher network latency
+- More dependent operations
+- Geographic distance between client and server
+
+## Testing with curl
+
+Test the backend directly:
+
+```bash
+# Authenticate
+curl -X POST http://localhost:8000/rpc \
+  -d '["push",["pipeline",1,["authenticate"],["cookie-123"]]]'
+
+curl -X POST http://localhost:8000/rpc \
+  -d '["pull",1]'
+
+# Get profile (using user ID u_1)
+curl -X POST http://localhost:8000/rpc \
+  -d '["push",["pipeline",2,["getUserProfile"],["u_1"]]]'
+
+curl -X POST http://localhost:8000/rpc \
+  -d '["pull",2]'
+
+# Get notifications
+curl -X POST http://localhost:8000/rpc \
+  -d '["push",["pipeline",3,["getNotifications"],["u_1"]]]'
+
+curl -X POST http://localhost:8000/rpc \
+  -d '["pull",3]'
+```

examples/bluesky/README.md

···
 
 ## Running the Example
 
-### Start the Go Backend
-
-```bash
-cd examples/bluesky
-go mod tidy
-go run main.go
-```
-
-The server will start on `http://localhost:8000`
-
-### Start the Frontend
-
-In a new terminal:
+1. **Start the Server**:
+   ```bash
+   go run main.go
+   ```
 
-```bash
-cd examples/bluesky/static
-npm install
-npm run dev
-```
+2. In a new terminal, start the Svelte development server:
+   ```bash
+   cd static
+   npm install
+   npm run dev
+   ```
 
-The Svelte dev server will start on `http://localhost:3000`
+3. Open your browser to `http://localhost:3000`
 
 ## How It Works
 
···
 
 - `bsky.app` - Official Bluesky account
 - `jay.bsky.team` - Jay Graber (Bluesky CEO)
-- `pfrazee.com` - Paul Frazee (Bluesky engineer)
+- `pfrazee.com` - Paul Frazee (Bluesky CTO)
 
 ## Testing with curl
 
···
 
 ```
 Browser (Svelte)
-    ↓ Cap'n Web RPC (batched)
+    ↓ Cap'n Web RPC
 Go Server (localhost:8000)
     ↓ HTTPS
 AT Protocol API (public.api.bsky.app)

examples/helloworld/README.md

···
+# Hello World - Cap'n Web RPC Svelte Demo
+
+This is a Svelte version of the Hello World demo that shows WebSocket RPC communication between a Svelte frontend and a Go server using the Cap'n Web protocol.
+
+## Features
+
+- **Svelte Frontend**: Modern reactive UI built with Svelte
+- **WebSocket RPC**: Real-time bidirectional communication
+- **Hot Module Replacement**: Fast development with Vite
+- **TypeScript Support**: Ready for TypeScript if needed
+
+## Setup and Running
+
+### Prerequisites
+
+- Node.js (v16 or higher)
+– Golang v1.21 or higher
+
+### Running the Example
+
+1. **Start the Server**:
+   ```bash
+   go run main.go
+   ```
+
+2. In a new terminal, start the Svelte development server:
+    ```bash
+    cd static
+    npm install
+    npm run dev
+    ```
+
+3. Open your browser to `http://localhost:3000`

examples/helloworld/static/README.md

···
-# Hello World - Cap'n Web RPC Svelte Demo
-
-This is a Svelte version of the Hello World demo that shows WebSocket RPC communication between a Svelte frontend and a Go server using the Cap'n Web protocol.
-
-## Features
-
-- **Svelte Frontend**: Modern reactive UI built with Svelte
-- **WebSocket RPC**: Real-time bidirectional communication
-- **Hot Module Replacement**: Fast development with Vite
-- **TypeScript Support**: Ready for TypeScript if needed
-
-## Setup and Running
-
-### Prerequisites
-
-- Node.js (v16 or higher)
-- Go server running (see the Go example in `../../helloworld/`)
-
-### Installation
-
-1. Install dependencies:
-```bash
-npm install
-```
-
-### Development
-
-1. Start the Go server (from the `../../helloworld/` directory):
-```bash
-cd ../../helloworld/
-go run main.go
-```
-
-2. In a new terminal, start the Svelte development server:
-```bash
-npm run dev
-```
-
-3. Open your browser to `http://localhost:3000`
-
-### Production Build
-
-To build for production:
-
-```bash
-npm run build
-```
-
-The built files will be in the `dist/` directory.
-
-To preview the production build:
-
-```bash
-npm run preview
-```
-
-## What's Different from the Original
-
-- **Reactive State**: Uses Svelte's reactive variables instead of DOM manipulation
-- **Component-based**: All UI logic is contained in a single Svelte component
-- **Better UX**: Loading states, disabled buttons during requests, and smoother interactions
-- **Modern Build**: Uses Vite for fast builds and hot module replacement
-- **Cleaner Code**: More maintainable and readable code structure
-
-## File Structure
-
-```
-├── src/
-│   ├── App.svelte          # Main Svelte component
-│   └── main.js             # Entry point
-├── dist/                   # Built files (after npm run build)
-├── index.html              # HTML template
-├── package.json            # Dependencies and scripts
-├── vite.config.js          # Vite configuration
-└── svelte.config.js        # Svelte configuration
-```
-
-## API Usage
-
-The demo connects to the Go server's WebSocket endpoint at `ws://127.0.0.1:8000/api` and calls the `hello` method with a name parameter.
-
-Example RPC call:
-```javascript
-const result = await api.hello("World");
-// Returns: "Hello, World!"
-```

examples/serverpush/README.md

···
 
 ## What This Demo Shows
 
-- 💻 **System Metrics Monitoring**: CPU, memory, and network I/O metrics updated in real-time  
-- 🔄 **Subscription-based Data Feeds**: Client subscribes to specific data streams
-- 📊 **Dynamic Data Visualization**: Real-time charts and progress bars
-- ⚡ **Polling-based Server Push**: Efficient polling mechanism simulating server push
+- **System Metrics Monitoring**: CPU, memory, and network I/O metrics updated in real-time  
+- **Subscription-based Data Feeds**: Client subscribes to specific data streams
+- **Dynamic Data Visualization**: Real-time charts and progress bars
+- **Polling-based Server Push**: Efficient polling mechanism simulating server push
 
 ## Architecture
 
···
 
 1. **Start the Server**:
    ```bash
-   cd examples/serverpush
    go run main.go
-   # or build and run:
-   go build && ./serverpush
    ```
 
-2. **Open the Demo**:
+2. In a new terminal, start the Svelte development server:
+   ```bash
+   cd static
+   npm install
+   npm run dev
    ```
-   http://localhost:8000/static/serverpush/
-   ```
+
+3. Open your browser to `http://localhost:3000`
 
-3. **Test the API** (optional):
+4. **Test the API** (optional):
    ```bash
    # Subscribe to system metrics
    echo '["push",["pipeline",1,["subscribeSystemMetrics"],[]]]
    ["pull",1]' | curl -X POST http://localhost:8000/api -H "Content-Type: text/plain" --data-binary @-
    ```
-
-## Available RPC Methods
-
-### `subscribeSystemMetrics()`
-- **Returns**: `{subscriptionId, message, status, pollInterval}`
-- **Description**: Subscribe to real-time system metrics
-
-### `pollMetricsUpdates(subscriptionId)`
-- **Parameters**: `subscriptionId` (string)
-- **Returns**: `{subscriptionId, updates, hasMore, timestamp}`
-- **Description**: Poll for buffered system metrics updates
-
-### `unsubscribe(subscriptionId)`
-- **Parameters**: `subscriptionId` (string)
-- **Returns**: `{subscriptionId, message, status}`
-- **Description**: Unsubscribe from a data stream
-
-## Data Formats
-
-### System Metrics Update
-```json
-{
-  "cpuUsage": 45.2,
-  "memoryUsage": 62.8,
-  "networkIO": 23.4,
-  "timestamp": 1640995200
-}
-```
-
-## Features Demonstrated
-
-- **WebSocket RPC Connection**: Persistent connection for low-latency communication
-- **Subscription Management**: Server tracks client subscriptions with unique IDs
-- **Data Buffering**: Efficient buffering prevents data loss during polling gaps
-- **Real-time Visualization**: Dynamic charts, tables, and progress indicators
-- **Error Handling**: Graceful handling of connection issues and invalid subscriptions
-- **Resource Management**: Automatic cleanup of subscriptions and polling intervals
-
-## Technical Implementation
-
-- **Backend**: Go with Echo framework and Gorilla WebSocket
-- **Frontend**: Vanilla JavaScript with modern ES6 modules
-- **RPC Protocol**: Cap'n Web RPC over WebSocket
-- **Data Generation**: Background goroutines with realistic price/metrics simulation
-- **Concurrency**: Thread-safe subscription management with sync.RWMutex
-
 This example serves as a foundation for implementing real-time data streaming in applications that need to push updates to clients while working within the constraints of request-response protocols.