Add examples (#10)

## Summary
- Adds `worker-basic` example: HTTP batch + WebSocket transport toggle
with interactive playground
- Adds `worker-bidirectional` example: server-to-client RPC with Durable
Object audit log broadcast
- Returns `RpcSession` from WebSocket helpers instead of a proxy, giving
callers access to `session.onClose()` for connection lifecycle
management
- Adds `onClose(handler)` and `Symbol.dispose` to `RpcSession`

## API changes

`newWorkersWebSocketRpcSession` now returns `{ response, session }`
instead of `{ response, remote }`:

```ts
const { response, session } = newWorkersWebSocketRpcSession<ClientApi, typeof service>(
  request,
  service,
);

session.remote.onEvent(event);           // call methods on the client
session.onClose(() => cleanup());        // clean up when connection drops
```

`newWebSocketRpcSession` now returns an `RpcSession` instead of a proxy:

```ts
const session = newWebSocketRpcSession<ServerApi>(wsUrl);
await session.remote.add(1, 2);          // was: await proxy.add(1, 2)
session.close();
```

## Test plan
- [x] All 163 existing tests pass
- [x] New tests for `onClose` (transport close, session close,
already-closed, multiple handlers)
- [x] New test for `Symbol.dispose` on `RpcSession`
- [ ] Manual: run `worker-bidirectional` example, open two tabs, verify
audit events broadcast, close a tab and verify subscription cleanup via
`onClose`

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: jmorrell

.gitignore

@@ -2,3 +2,5 @@ repos
 node_modules
 dist
 .claude
+.wrangler
+.DS_Store

AGENTS.md

@@ -29,7 +29,7 @@ Last verified: 2026-02-16
 - `src/core.ts` - Shared types, error classes, and transport-agnostic JSON-RPC 2.0 engine (wire format types, type guards, request/response builders, RpcProtocolError, RPC processor)
 - `src/http-batch.ts` - HTTP batch transport: newHttpBatchRpcResponse (server) + newHttpBatchRpcSession (client with auto-batching)
 - `src/session.ts` - Bidirectional RPC over message transports (defines session-specific types: RpcTransport, RpcSessionOptions, RpcSession)
-- `src/websocket.ts` - WebSocket transport: newWorkersWebSocketRpcResponse (server, fire-and-forget) + newWorkersWebSocketRpcSession (server, bidirectional with typed remote proxy) + newWebSocketRpcSession (client with Disposable proxy)
+- `src/websocket.ts` - WebSocket transport: newWorkersWebSocketRpcResponse (server, fire-and-forget) + newWorkersWebSocketRpcSession (server, returns {response, session} for bidirectional RPC) + newWebSocketRpcSession (client, returns RpcSession)
 - `src/__tests__/` - Test files
 - `src/__tests__/fixtures/worker.ts` - Test worker entry point for Workers runtime tests
 - `src/__tests__/fixtures/wrangler.toml` - Minimal Workers config for test worker

examples/worker-basic/README.md

@@ -0,0 +1,49 @@
+# worker-basic
+
+Interactive playground for `@jmorrell/jsonrpc` on Cloudflare Workers.
+
+Defines a handful of toy RPC methods on the server and serves a static page
+where you can invoke them individually or in bulk. A toggle switches between
+**HTTP batch** and **WebSocket** transports — the server code is identical
+because `newWorkersRpcResponse` routes both automatically.
+
+## Running
+
+```bash
+# from repo root — the example links to the local library build
+npm run build
+
+# install and build the example
+cd examples/worker-basic
+npm install
+cd web && npm install && npm run build && cd ..
+
+# start the dev server
+npm run dev
+```
+
+Open http://localhost:8787.
+
+## Structure
+
+```
+src/worker.ts          Cloudflare Worker — defines the service and routes /api
+web/src/app.ts         Client — uses newHttpBatchRpcSession or newWebSocketRpcSession
+web/src/style.css      Styles
+web/index.html         Vite entry point
+web/vite.config.ts     Aliases @jmorrell/jsonrpc to the local dist build
+```
+
+## What it demonstrates
+
+- **Defining a service** — plain object with typed methods, passed to
+  `newWorkersRpcResponse`.
+- **HTTP auto-batching** — calls made in the same tick are combined into a
+  single POST containing a JSON-RPC batch array.
+- **WebSocket transport** — persistent connection, each call is an individual
+  JSON-RPC message (no batching needed).
+- **Type-safe client** — `newHttpBatchRpcSession<Api>` and
+  `newWebSocketRpcSession<Api>` return a typed proxy where method calls map
+  directly to RPC requests.
+- **Raw protocol visibility** — every call shows the JSON-RPC request and
+  response side by side.