Durable ObjectがハイバネーションするとWebSocketは残り、クラスのフィールドは消える

import { DurableObject } from "cloudflare:workers";

export class Room extends DurableObject {
  constructor(ctx, env) {
    super(ctx, env);
    this.bornAt = Date.now();                       // in memory only
    this.nickInMemory = null;                       // in memory only
    this.messagesSeenInMemory = 0;                  // in memory only
    this.constructions = (ctx.storage.kv.get("constructions") ?? 0) + 1;   // in storage: survives
    ctx.storage.kv.put("constructions", this.constructions);
    console.log(`[room ${ctx.id.name}] constructor ran (#${this.constructions})`);
    // answer the application-level "ping" without running our code
    ctx.setWebSocketAutoResponse(new WebSocketRequestResponsePair("ping", "pong"));
  }

  async fetch(request) {
    const [client, server] = Object.values(new WebSocketPair());
    if (new URL(request.url).searchParams.has("std")) {                      // the standard API instead: server.accept()
      server.accept();
      server.addEventListener("message", () => server.send(JSON.stringify({ objectAgeMs: Date.now() - this.bornAt, constructions: this.constructions })));
      return new Response(null, { status: 101, webSocket: client });
    }
    this.ctx.acceptWebSocket(server);                                        // the hibernation API
    server.serializeAttachment({ joinedAt: Date.now(), nick: "anon" });      // per-connection state that survives
    if (new URL(request.url).searchParams.has("timer")) setInterval(() => {}, 1000);   // a pending timer
    return new Response(null, { status: 101, webSocket: client });
  }

  async webSocketMessage(ws, message) {
    this.messagesSeenInMemory++;
    const att = ws.deserializeAttachment();
    if (message === "mutate") att.nick = "changed-but-not-saved";            // no serializeAttachment() call
    if (message === "save")   { att.nick = "changed-and-saved"; ws.serializeAttachment(att); }
    if (message === "inmem")  this.nickInMemory = "kept-in-a-field";
    if (message === "big") {
      try { ws.serializeAttachment({ blob: "x".repeat(20000) }); ws.send("big: accepted"); }
      catch (e) { ws.send(`big: ${e.name}: ${e.message}`); }
      return;
    }
    ws.send(JSON.stringify({
      messagesSeenInMemory: this.messagesSeenInMemory,      // resets after hibernation
      objectAgeMs: Date.now() - this.bornAt,                // resets after hibernation
      nickInMemory: this.nickInMemory,                      // resets after hibernation
      constructions: this.constructions,                    // from storage: counts re-creations
      nick: ws.deserializeAttachment().nick,                // survives, if it was saved
      joinedAt: att.joinedAt,                               // survives
      sockets: this.ctx.getWebSockets().length,             // the connections themselves survive
    }));
  }

  async webSocketClose(ws, code) { console.log(`[room ${this.ctx.id.name}] close ${code}`); }
}

export default {
  async fetch(request, env) {
    const name = new URL(request.url).searchParams.get("room") ?? "lab";
    return env.ROOM.getByName(name).fetch(request);
  },
};

{
  "name": "hib-lab",
  "main": "src/index.js",
  "compatibility_date": "2026-04-07",
  "durable_objects": { "bindings": [{ "name": "ROOM", "class_name": "Room" }] },
  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["Room"] }]
}

// usage: node client.mjs <idle-seconds> "<query>"   e.g.  node client.mjs 15 "?room=a"
import fs from "node:fs";
import WebSocket from "ws";
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const idle = Number(process.argv[2] ?? 15), query = process.argv[3] ?? "?room=lab";
const room = new URLSearchParams(query).get("room");
const constructors = () => (fs.readFileSync("wrangler.log", "utf8").match(new RegExp(`\\[room ${room}\\] constructor`, "g")) || []).length;

const ws = new WebSocket(`ws://localhost:8787/${query}`);
const inbox = [];
ws.on("message", (m) => inbox.push(m.toString()));
await new Promise((r) => ws.on("open", r));
const ask = async (text) => { inbox.length = 0; ws.send(text); for (let i = 0; i < 50 && !inbox.length; i++) await sleep(100); return inbox[0]; };
const t0 = Date.now(); const at = () => `[${((Date.now() - t0) / 1000).toFixed(1).padStart(4)}s]`;

for (const m of ["hi", "mutate", "hi", "save", "inmem", "big", "ping"]) console.log(at(), m.padEnd(7), "->", await ask(m));
console.log(at(), `idle for ${idle} s; the socket stays open`);
await sleep(idle * 1000);
console.log(at(), "readyState", ws.readyState, "(1 = OPEN); constructor runs so far:", constructors());
console.log(at(), "ping    ->", await ask("ping"), "| constructor runs now:", constructors());
console.log(at(), "hi      ->", await ask("hi"), "| constructor runs now:", constructors());
console.log(at(), "big     ->", await ask("big"));
ws.close();

mkdir do && cd do && npm init -y
npm i wrangler ws            # wrangler 4.147.0、Node 22.23.3 で使用
# src/index.js と wrangler.jsonc を上のとおり保存し、client.mjs は package.json の隣に置く
npx wrangler dev --local --port 8787 > wrangler.log 2>&1 &
node client.mjs 15 "?room=a"

[ 0.0s] hi      -> messagesSeenInMemory 1, objectAgeMs 9,   nickInMemory null,              constructions 1, nick "anon",              sockets 1
[ 0.1s] mutate  -> messagesSeenInMemory 2, ...
[ 0.2s] hi      -> messagesSeenInMemory 3, ...                                               nick "anon"       (mutateは保存されていない)
[ 0.3s] save    -> messagesSeenInMemory 4, ...                                               nick "changed-and-saved"
[ 0.4s] inmem   -> messagesSeenInMemory 5, objectAgeMs 412, nickInMemory "kept-in-a-field", constructions 1, nick "changed-and-saved", sockets 1
[ 0.5s] big     -> big: Error: A WebSocket 'attachment' cannot be larger than 16384 bytes.'attachment' was 20015 bytes.
[ 0.6s] ping    -> pong
[ 0.7s] idle for 15 s; the socket stays open
[15.7s] readyState 1 (1 = OPEN); constructor runs so far: 1
[15.7s] ping    -> pong | constructor runs now: 1
[15.8s] hi      -> messagesSeenInMemory 1, objectAgeMs 4,   nickInMemory null,              constructions 2, nick "changed-and-saved", sockets 1 | constructor runs now: 2

import fs from "node:fs";
import WebSocket from "ws";
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const room = process.argv[2] ?? "d";   // use a room name you have not used before
const count = () => (fs.readFileSync("wrangler.log", "utf8").match(new RegExp(`\\[room ${room}\\] constructor`, "g")) || []).length;
const ws = new WebSocket(`ws://localhost:8787/?room=${room}`);
await new Promise((r) => ws.on("open", r));
await sleep(15000);                                   // longer than the 10 s idle rule
console.log("constructor runs after 15 s idle:", count());
let pongs = 0; ws.on("pong", () => pongs++);
for (let i = 0; i < 3; i++) { ws.ping(); await sleep(300); }
console.log("protocol pong frames received:", pongs, "| constructor runs now:", count());
ws.send("hi"); await sleep(500);
console.log("after one real message, constructor runs:", count());
ws.close();

constructor runs after 15 s idle: 1
protocol pong frames received: 3 | constructor runs now: 1
after one real message, constructor runs: 2