Accept and manage WebSockets in a Durable Object with the Hibernation API so idle connections stop accruing duration billing

Documented steps

1. In the Durable Object's fetch handler, create `const webSocketPair = new WebSocketPair(); const [client, server] = Object.values(webSocketPair);` then call `this.ctx.acceptWebSocket(server)` — NOT `server.accept()`. Only acceptWebSocket allows the object to hibernate.
2. Return the client end: `return new Response(null, { status: 101, webSocket: client });`.
3. Optionally tag the socket at accept time: `ctx.acceptWebSocket(server, tags)` where tags is an Array<string> — max 10 tags, 256 characters each — for later filtered lookup.
4. Replace `addEventListener("message"|"close"|"error", ...)` with handler METHODS on the class, which the runtime invokes automatically including after waking from hibernation: `async webSocketMessage(ws, message) {}`, `async webSocketClose(ws, code, reason, wasClean) {}`, `async webSocketError(ws, error) {}`.
5. Enumerate live sockets with `this.ctx.getWebSockets()` or `this.ctx.getWebSockets(tag)` for broadcast or connection counts, e.g. `ws.send(`connections: ${this.ctx.getWebSockets().length}`)`.
6. Read a socket's tags with `this.ctx.getTags(ws)`.
7. Persist small per-connection metadata across hibernation with `ws.serializeAttachment(value)` (structured-clone compatible, max 16,384 bytes serialized) and read it back with `ws.deserializeAttachment()` (null if unset). It is not auto-synced — re-call serializeAttachment whenever the value changes.
8. Keep keepalive traffic from waking the object: `this.ctx.setWebSocketAutoResponse(new WebSocketRequestResponsePair(request, response))`, where both strings are capped at 2,048 characters. Matching frames get the canned reply without invoking webSocketMessage or waking a hibernating object.
9. Inspect auto-response activity with `this.ctx.getWebSocketAutoResponseTimestamp(ws)` (Date | null) and read the configured pair with `this.ctx.getWebSocketAutoResponse()`.
10. Bound handler runtime with `this.ctx.setHibernatableWebSocketEventTimeout(ms)` (max 604,800,000 ms) and read it via `getHibernatableWebSocketEventTimeout()`.
11. Close server-side inside webSocketClose (e.g. `ws.close(code, reason)`), and batch outbound sends — the docs recommend 10 to 100 logical messages per WebSocket frame to cut overhead.
12. Understand the economics: billable duration (GB-s) does not accrue during hibernation while clients stay connected via acceptWebSocket. The standard addEventListener approach keeps the object resident and billable for the socket's entire lifetime, even fully idle.
13. Official documentation (verify before relying on limits, which change): https://developers.cloudflare.com/durable-objects/best-practices/websockets/ | https://developers.cloudflare.com/durable-objects/api/websockets/ | https://developers.cloudflare.com/durable-objects/api/state/