rwsdk 1.5.0 → 1.5.2

package/dist/use-synced-state/hibernation/connection/messages.js

@@ -1,4 +1,5 @@
 import { packMessage, unpackServerMessage, } from "../protocol.mjs";
+import { startPendingRequestTimer } from "./timer.js";
 export function makeMessageId(connection) {
     return `${connection.nextId++}`;
 }
@@ -7,6 +8,7 @@ export async function sendMessage(connection, message) {
     if (isOpen) {
         return new Promise((resolve, reject) => {
             pending.set(message.id, { resolve, reject });
+            startPendingRequestTimer(connection);
             ws.send(packMessage(message));
         });
     }
@@ -14,6 +16,7 @@ export async function sendMessage(connection, message) {
         const onOpen = () => {
             cleanup();
             connection.pending.set(message.id, { resolve, reject });
+            startPendingRequestTimer(connection);
             connection.ws.send(packMessage(message));
         };
         const onClose = () => {
@@ -44,6 +47,7 @@ export function handleServerMessage(connection, message) {
                 pending.reject(new Error(message.message));
             }
         }
+        startPendingRequestTimer(connection);
         return;
     }
     const pending = connection.pending.get(message.id);
@@ -51,6 +55,7 @@ export function handleServerMessage(connection, message) {
         return;
     connection.pending.delete(message.id);
     pending.resolve(message.kind === "getState" ? message.value : undefined);
+    startPendingRequestTimer(connection);
 }
 export function unpackMessage(data) {
     if (typeof data !== "string")

package/dist/use-synced-state/hibernation/connection/timer.d.ts

@@ -1,5 +1,5 @@
 import { type Connection } from "./types.js";
-export declare const DEAD_CONNECTION_TIMEOUT_MS = 90000;
-export declare function cleanupConnectionTimers(connection: Connection): void;
+export declare const PENDING_REQUEST_TIMEOUT_MS = 30000;
+export declare function startPendingRequestTimer(connection: Connection): void;
+export declare function stopPendingRequestTimer(connection: Connection): void;
 export declare function rejectPending(connection: Connection, reason: string): void;
-export declare function resetDeadConnectionTimer(connection: Connection, endpoint: string): void;

package/dist/use-synced-state/hibernation/connection/timer.js

@@ -1,10 +1,27 @@
-import { manager } from "../state/clientManager.js";
-import { reconnect } from "../reconnect/reconnect.js";
-export const DEAD_CONNECTION_TIMEOUT_MS = 90_000;
-export function cleanupConnectionTimers(connection) {
-    if (connection.deadConnectionTimer) {
-        clearTimeout(connection.deadConnectionTimer);
-        connection.deadConnectionTimer = null;
+// context(justinvdm, 29 Jun 2026): This timeout applies only to requests that
+// are waiting for a server response, not to idle connections. Hibernation
+// relies on idle sockets being allowed to sleep, so we must not close a socket
+// just because no traffic has arrived.
+export const PENDING_REQUEST_TIMEOUT_MS = 30_000;
+export function startPendingRequestTimer(connection) {
+    stopPendingRequestTimer(connection);
+    if (connection.pending.size === 0) {
+        return;
+    }
+    connection.pendingRequestTimer = setTimeout(() => {
+        // We intentionally do not close the socket here. In Cloudflare's
+        // environment a half-open WebSocket is unlikely; the server should
+        // already have sent an error frame for any throw (see server.mts).
+        // Closing would trigger a visible reconnect that looks like the old
+        // idle-timeout symptom. We only reject the pending promises so the
+        // caller is not left hanging forever.
+        rejectPending(connection, "useSyncedState request timed out");
+    }, PENDING_REQUEST_TIMEOUT_MS);
+}
+export function stopPendingRequestTimer(connection) {
+    if (connection.pendingRequestTimer) {
+        clearTimeout(connection.pendingRequestTimer);
+        connection.pendingRequestTimer = null;
     }
 }
 export function rejectPending(connection, reason) {
@@ -12,22 +29,5 @@ export function rejectPending(connection, reason) {
         pending.reject(new Error(reason));
     }
     connection.pending.clear();
-}
-export function resetDeadConnectionTimer(connection, endpoint) {
-    if (connection.deadConnectionTimer) {
-        clearTimeout(connection.deadConnectionTimer);
-    }
-    connection.deadConnectionTimer = setTimeout(() => {
-        try {
-            connection.ws.close();
-        }
-        catch { }
-        connection.isOpen = false;
-        rejectPending(connection, "WebSocket timed out");
-        cleanupConnectionTimers(connection);
-        if (manager.getConnection(endpoint) === connection) {
-            manager.deleteConnection(endpoint);
-            reconnect(endpoint);
-        }
-    }, DEAD_CONNECTION_TIMEOUT_MS);
+    stopPendingRequestTimer(connection);
 }

package/dist/use-synced-state/hibernation/connection/types.d.ts

@@ -17,6 +17,6 @@ export type Connection = {
     pending: Map<string, PendingRequest>;
     isOpen: boolean;
     messageHandlers: Map<string, Set<(value: unknown) => void>>;
-    deadConnectionTimer: ReturnType<typeof setTimeout> | null;
+    pendingRequestTimer: ReturnType<typeof setTimeout> | null;
     webSocketFactory: WebSocketFactory;
 };

package/dist/use-synced-state/hibernation/identity.d.mts

@@ -1,4 +1,7 @@
 export type SyncedStateIdentity = unknown;
+export declare class SyncedStateIdentityError extends Error {
+    constructor(message: string);
+}
 export declare function setIdentityInUrl(identity: SyncedStateIdentity, url: URL): URL;
 export declare function getIdentityFromUrl(url: URL): SyncedStateIdentity;
 export declare function removeIdentityFromUrl(url: URL): URL;

package/dist/use-synced-state/hibernation/identity.mjs

@@ -1,10 +1,29 @@
 const IDENTITY_QUERY_PARAM = "__ssi";
-// context(justinvdm, 19 Jun 2026): Serialize the captured identity into a URL
+const MAX_IDENTITY_SIZE_BYTES = 4096;
+export class SyncedStateIdentityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SyncedStateIdentityError";
+    }
+}
+// context(justinvdm, 29 Jun 2026): Serialize the captured identity into a URL
 // query parameter so the worker can pass it to the DO during the WebSocket
 // upgrade. The identity is extracted from requestInfo in the worker and is not
 // user-controlled, so passing it in the internal worker->DO request is safe.
+// We validate serializability and size here so a bad extractor fails the
+// handshake with a clear error instead of an opaque internal failure.
 export function setIdentityInUrl(identity, url) {
-    url.searchParams.set(IDENTITY_QUERY_PARAM, JSON.stringify(identity));
+    let serialized;
+    try {
+        serialized = JSON.stringify(identity);
+    }
+    catch (error) {
+        throw new SyncedStateIdentityError(`useSyncedState identity must be JSON-serializable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (serialized.length > MAX_IDENTITY_SIZE_BYTES) {
+        throw new SyncedStateIdentityError(`useSyncedState identity exceeds maximum size of ${MAX_IDENTITY_SIZE_BYTES} bytes`);
+    }
+    url.searchParams.set(IDENTITY_QUERY_PARAM, serialized);
     return url;
 }
 export function getIdentityFromUrl(url) {

package/dist/use-synced-state/hibernation/server.d.mts

@@ -55,7 +55,7 @@ export declare class SyncedStateServer extends DurableObject {
     setStub(stub: DurableObjectStub<SyncedStateServer>): void;
     fetch(request: Request): Promise<Response>;
     webSocketMessage(ws: WebSocket, data: string | ArrayBuffer): Promise<void>;
-    webSocketClose(ws: WebSocket): Promise<void>;
+    webSocketClose(_ws: WebSocket): Promise<void>;
     getState(key: string): Promise<SyncedStateValue | undefined>;
     setState(value: SyncedStateValue, key: string): Promise<void>;
 }

package/dist/use-synced-state/hibernation/server.mjs

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _SyncedStateServer_instances, _a, _SyncedStateServer_keyHandler, _SyncedStateServer_roomHandler, _SyncedStateServer_setStateHandler, _SyncedStateServer_getStateHandler, _SyncedStateServer_subscribeHandler, _SyncedStateServer_unsubscribeHandler, _SyncedStateServer_identityExtractor, _SyncedStateServer_namespace, _SyncedStateServer_durableObjectName, _SyncedStateServer_stub, _SyncedStateServer_stateStore, _SyncedStateServer_stateStoreLoaded, _SyncedStateServer_loadStateStore, _SyncedStateServer_stateStorageKey, _SyncedStateServer_getState, _SyncedStateServer_setState, _SyncedStateServer_subscriptions, _SyncedStateServer_subscribe, _SyncedStateServer_unsubscribe, _SyncedStateServer_broadcastUpdate, _SyncedStateServer_getAttachment, _SyncedStateServer_getIdentity, _SyncedStateServer_getSubscriptionsFromAttachment, _SyncedStateServer_setSubscriptionsInAttachment, _SyncedStateServer_ensureSubscriptionsLoaded, _SyncedStateServer_resolveStorageKey, _SyncedStateServer_getStubForHandlers, _SyncedStateServer_send, _SyncedStateServer_sendError;
+var _SyncedStateServer_instances, _a, _SyncedStateServer_keyHandler, _SyncedStateServer_roomHandler, _SyncedStateServer_setStateHandler, _SyncedStateServer_getStateHandler, _SyncedStateServer_subscribeHandler, _SyncedStateServer_unsubscribeHandler, _SyncedStateServer_identityExtractor, _SyncedStateServer_namespace, _SyncedStateServer_durableObjectName, _SyncedStateServer_stub, _SyncedStateServer_handleClientMessage, _SyncedStateServer_stateStore, _SyncedStateServer_stateStoreLoaded, _SyncedStateServer_loadStateStore, _SyncedStateServer_stateStorageKey, _SyncedStateServer_getState, _SyncedStateServer_setState, _SyncedStateServer_subscribe, _SyncedStateServer_unsubscribe, _SyncedStateServer_broadcastUpdate, _SyncedStateServer_getAttachment, _SyncedStateServer_getIdentity, _SyncedStateServer_getSubscriptionsFromAttachment, _SyncedStateServer_setSubscriptionsInAttachment, _SyncedStateServer_resolveStorageKey, _SyncedStateServer_getStubForHandlers, _SyncedStateServer_send, _SyncedStateServer_sendError;
 import { DurableObject } from "cloudflare:workers";
 import { getIdentityFromUrl, } from "./identity.mjs";
 import { unpackClientMessage, packMessage, } from "./protocol.mjs";
@@ -87,13 +87,6 @@ export class SyncedStateServer extends DurableObject {
         // the DO, so every write is persisted and the cache is warmed on first read.
         _SyncedStateServer_stateStore.set(this, new Map());
         _SyncedStateServer_stateStoreLoaded.set(this, false);
-        // ---------------------------------------------------------------------------
-        // Subscriptions
-        // ---------------------------------------------------------------------------
-        // Map from storage key to the subscribers for that key. We store the
-        // user-facing key per subscriber so broadcasts can send each socket the key
-        // it originally subscribed to.
-        _SyncedStateServer_subscriptions.set(this, new Map());
         this.state = state;
         this.env = env;
         this.storage = state.storage;
@@ -128,73 +121,20 @@ export class SyncedStateServer extends DurableObject {
             __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_sendError).call(this, ws, error instanceof Error ? error.message : "Invalid protocol message");
             return;
         }
-        // After DO eviction the in-memory subscription map is empty. Rehydrate it
-        // from the socket attachment before handling any message that depends on
-        // knowing this socket's subscriptions (especially broadcasts on setState).
-        __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_ensureSubscriptionsLoaded).call(this, ws);
-        const identity = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getIdentity).call(this, ws);
-        const storageKey = await __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_resolveStorageKey).call(this, message.key, identity);
-        switch (message.kind) {
-            case "getState": {
-                const value = await __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getState).call(this, storageKey, identity);
-                __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_send).call(this, ws, {
-                    kind: "getState",
-                    key: message.key,
-                    value,
-                    id: message.id,
-                });
-                break;
-            }
-            case "setState": {
-                await __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_setState).call(this, storageKey, message.value, identity);
-                __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_send).call(this, ws, {
-                    kind: "setState",
-                    key: message.key,
-                    id: message.id,
-                });
-                break;
-            }
-            case "subscribe": {
-                __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_subscribe).call(this, ws, storageKey, message.key);
-                __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_send).call(this, ws, {
-                    kind: "subscribe",
-                    key: message.key,
-                    id: message.id,
-                });
-                break;
-            }
-            case "unsubscribe": {
-                __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_unsubscribe).call(this, ws, storageKey, message.key);
-                __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_send).call(this, ws, {
-                    kind: "unsubscribe",
-                    key: message.key,
-                    id: message.id,
-                });
-                break;
-            }
-            default: {
-                __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_sendError).call(this, ws, "Unknown message kind", message.id);
-            }
-        }
-    }
-    async webSocketClose(ws) {
-        // context(justinvdm, 18 Jun 2026): Remove this socket from all in-memory
-        // subscription sets. The attachment is dropped by the runtime, so no
-        // persistent cleanup is required.
-        for (const subscribers of __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").values()) {
-            for (const entry of subscribers) {
-                if (entry.ws === ws) {
-                    subscribers.delete(entry);
-                    break;
-                }
-            }
+        // Once a request id is parsed, the client is waiting for a matching
+        // response. Every dispatch path must resolve or reject that request id.
+        try {
+            await __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_handleClientMessage).call(this, ws, message);
         }
-        for (const [key, subscribers] of __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f")) {
-            if (subscribers.size === 0) {
-                __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").delete(key);
-            }
+        catch (error) {
+            __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_sendError).call(this, ws, error instanceof Error ? error.message : String(error), message.id);
         }
     }
+    async webSocketClose(_ws) {
+        // context(justinvdm, 29 Jun 2026): Subscriptions are persisted on the
+        // WebSocket attachment. When the runtime removes the socket, the
+        // attachment disappears with it, so no persistent cleanup is required.
+    }
     // Public RPC surface exposed to handler callbacks and other Workers RPC callers.
     async getState(key) {
         return __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getState).call(this, key, undefined);
@@ -203,7 +143,52 @@ export class SyncedStateServer extends DurableObject {
         await __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_setState).call(this, key, value, undefined);
     }
 }
-_a = SyncedStateServer, _SyncedStateServer_stub = new WeakMap(), _SyncedStateServer_stateStore = new WeakMap(), _SyncedStateServer_stateStoreLoaded = new WeakMap(), _SyncedStateServer_subscriptions = new WeakMap(), _SyncedStateServer_instances = new WeakSet(), _SyncedStateServer_loadStateStore = async function _SyncedStateServer_loadStateStore() {
+_a = SyncedStateServer, _SyncedStateServer_stub = new WeakMap(), _SyncedStateServer_stateStore = new WeakMap(), _SyncedStateServer_stateStoreLoaded = new WeakMap(), _SyncedStateServer_instances = new WeakSet(), _SyncedStateServer_handleClientMessage = async function _SyncedStateServer_handleClientMessage(ws, message) {
+    const identity = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getIdentity).call(this, ws);
+    const storageKey = await __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_resolveStorageKey).call(this, message.key, identity);
+    switch (message.kind) {
+        case "getState": {
+            const value = await __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getState).call(this, storageKey, identity);
+            __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_send).call(this, ws, {
+                kind: "getState",
+                key: message.key,
+                value,
+                id: message.id,
+            });
+            break;
+        }
+        case "setState": {
+            await __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_setState).call(this, storageKey, message.value, identity);
+            __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_send).call(this, ws, {
+                kind: "setState",
+                key: message.key,
+                id: message.id,
+            });
+            break;
+        }
+        case "subscribe": {
+            __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_subscribe).call(this, ws, storageKey, message.key);
+            __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_send).call(this, ws, {
+                kind: "subscribe",
+                key: message.key,
+                id: message.id,
+            });
+            break;
+        }
+        case "unsubscribe": {
+            __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_unsubscribe).call(this, ws, storageKey, message.key);
+            __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_send).call(this, ws, {
+                kind: "unsubscribe",
+                key: message.key,
+                id: message.id,
+            });
+            break;
+        }
+        default: {
+            __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_sendError).call(this, ws, "Unknown message kind", message.id);
+        }
+    }
+}, _SyncedStateServer_loadStateStore = async function _SyncedStateServer_loadStateStore() {
     if (__classPrivateFieldGet(this, _SyncedStateServer_stateStoreLoaded, "f")) {
         return;
     }
@@ -239,20 +224,14 @@ _a = SyncedStateServer, _SyncedStateServer_stub = new WeakMap(), _SyncedStateSer
     }
     __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_broadcastUpdate).call(this, key, value);
 }, _SyncedStateServer_subscribe = function _SyncedStateServer_subscribe(ws, storageKey, userKey) {
-    if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").has(storageKey)) {
-        __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").set(storageKey, new Set());
-    }
-    const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(storageKey);
     // Defensive deduplication: a stateful client may send subscribe more than
-    // once for the same key (e.g. across reconnects), and DO eviction can
-    // rehydrate the same subscription from the attachment. Keep only one entry
-    // per (socket, userKey) pair.
-    for (const entry of subscribers) {
-        if (entry.ws === ws && entry.userKey === userKey) {
-            return;
-        }
+    // once for the same key (e.g. across reconnects). Keep only one entry per
+    // (socket, userKey) pair in the attachment.
+    const subs = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getSubscriptionsFromAttachment).call(this, ws);
+    if (!subs.some((s) => s.userKey === userKey && s.storageKey === storageKey)) {
+        subs.push({ userKey, storageKey });
+        __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_setSubscriptionsInAttachment).call(this, ws, subs);
     }
-    subscribers.add({ ws, userKey });
     const identity = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getIdentity).call(this, ws);
     const subscribeHandler = __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_subscribeHandler);
     if (subscribeHandler) {
@@ -261,26 +240,9 @@ _a = SyncedStateServer, _SyncedStateServer_stub = new WeakMap(), _SyncedStateSer
             subscribeHandler(storageKey, identity, stub);
         }
     }
-    // Persist the subscription in the socket attachment so it survives
-    // DO eviction.
-    const subs = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getSubscriptionsFromAttachment).call(this, ws);
-    if (!subs.some((s) => s.userKey === userKey && s.storageKey === storageKey)) {
-        subs.push({ userKey, storageKey });
-        __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_setSubscriptionsInAttachment).call(this, ws, subs);
-    }
 }, _SyncedStateServer_unsubscribe = function _SyncedStateServer_unsubscribe(ws, storageKey, userKey) {
-    const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(storageKey);
-    if (subscribers) {
-        for (const entry of subscribers) {
-            if (entry.ws === ws && entry.userKey === userKey) {
-                subscribers.delete(entry);
-                break;
-            }
-        }
-        if (subscribers.size === 0) {
-            __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").delete(storageKey);
-        }
-    }
+    const subs = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getSubscriptionsFromAttachment).call(this, ws).filter((s) => !(s.userKey === userKey && s.storageKey === storageKey));
+    __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_setSubscriptionsInAttachment).call(this, ws, subs);
     const identity = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getIdentity).call(this, ws);
     const unsubscribeHandler = __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_unsubscribeHandler);
     if (unsubscribeHandler) {
@@ -289,24 +251,27 @@ _a = SyncedStateServer, _SyncedStateServer_stub = new WeakMap(), _SyncedStateSer
             unsubscribeHandler(storageKey, identity, stub);
         }
     }
-    const subs = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getSubscriptionsFromAttachment).call(this, ws).filter((s) => !(s.userKey === userKey && s.storageKey === storageKey));
-    __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_setSubscriptionsInAttachment).call(this, ws, subs);
-}, _SyncedStateServer_broadcastUpdate = function _SyncedStateServer_broadcastUpdate(key, value) {
-    const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key);
-    if (!subscribers || subscribers.size === 0) {
-        return;
-    }
-    for (const { ws, userKey } of subscribers) {
-        const message = {
-            kind: "update",
-            key: userKey,
-            value,
-        };
-        try {
-            ws.send(packMessage(message));
-        }
-        catch {
-            // Socket is already closed; it will be cleaned up via webSocketClose.
+}, _SyncedStateServer_broadcastUpdate = function _SyncedStateServer_broadcastUpdate(storageKey, value) {
+    // Cloudflare's live socket list is the source of truth for currently
+    // connected sockets. Each socket's attachment holds the user-facing keys it
+    // subscribed to, so we send each socket its original key even after the DO
+    // has hibernated.
+    for (const ws of this.ctx.getWebSockets()) {
+        const subs = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getSubscriptionsFromAttachment).call(this, ws);
+        for (const sub of subs) {
+            if (sub.storageKey !== storageKey)
+                continue;
+            const message = {
+                kind: "update",
+                key: sub.userKey,
+                value,
+            };
+            try {
+                ws.send(packMessage(message));
+            }
+            catch {
+                // Socket is already closed; it will be cleaned up via webSocketClose.
+            }
         }
     }
 }, _SyncedStateServer_getAttachment = function _SyncedStateServer_getAttachment(ws) {
@@ -326,24 +291,6 @@ _a = SyncedStateServer, _SyncedStateServer_stub = new WeakMap(), _SyncedStateSer
     const attachment = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getAttachment).call(this, ws);
     attachment.subscriptions = subscriptions;
     ws.serializeAttachment(attachment);
-}, _SyncedStateServer_ensureSubscriptionsLoaded = function _SyncedStateServer_ensureSubscriptionsLoaded(ws) {
-    const subs = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getSubscriptionsFromAttachment).call(this, ws);
-    for (const { userKey, storageKey } of subs) {
-        if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").has(storageKey)) {
-            __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").set(storageKey, new Set());
-        }
-        const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(storageKey);
-        let exists = false;
-        for (const entry of subscribers) {
-            if (entry.ws === ws && entry.userKey === userKey) {
-                exists = true;
-                break;
-            }
-        }
-        if (!exists) {
-            subscribers.add({ ws, userKey });
-        }
-    }
 }, _SyncedStateServer_resolveStorageKey = 
 // ---------------------------------------------------------------------------
 // Handlers

package/dist/use-synced-state/hibernation/state/clientFactory.js

@@ -30,12 +30,22 @@ export function createSyncedStateClient(endpoint, webSocketFactory) {
             }
             handlers.add(handler);
             if (connection.isOpen) {
-                connection.ws.send(JSON.stringify({
-                    v: 1,
-                    kind: "subscribe",
-                    key,
-                    id: makeMessageId(connection),
-                }));
+                try {
+                    await sendMessage(connection, {
+                        kind: "subscribe",
+                        key,
+                        id: makeMessageId(connection),
+                    });
+                }
+                catch (error) {
+                    // Roll back local subscription state so we don't pretend to be
+                    // subscribed when the server rejected or never processed it.
+                    handlers.delete(handler);
+                    if (handlers.size === 0)
+                        connection.messageHandlers.delete(key);
+                    manager.removeSubscription(key, handler, client);
+                    throw error;
+                }
             }
         },
         async unsubscribe(key, handler) {
@@ -49,13 +59,18 @@ export function createSyncedStateClient(endpoint, webSocketFactory) {
                 if (handlers.size === 0)
                     connection.messageHandlers.delete(key);
             }
-            if (connection.isOpen) {
-                connection.ws.send(JSON.stringify({
-                    v: 1,
-                    kind: "unsubscribe",
-                    key,
-                    id: makeMessageId(connection),
-                }));
+            try {
+                if (connection.isOpen) {
+                    await sendMessage(connection, {
+                        kind: "unsubscribe",
+                        key,
+                        id: makeMessageId(connection),
+                    });
+                }
+            }
+            catch {
+                // Unsubscribe is often called during cleanup. Swallow errors from a
+                // closing socket; the server attachment will be dropped anyway.
             }
         },
     };

package/dist/use-synced-state/hibernation/state/clientManager.js

@@ -53,7 +53,9 @@ export class SyncedStateClientManager {
     normalizeEndpoint(endpoint) {
         if (endpoint.startsWith("/") && typeof window !== "undefined") {
             const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-            return `${protocol}//${window.location.host}${endpoint}`;
+            // Strip a trailing DNS root dot so the WebSocket URL matches routing.
+            const host = window.location.host.replace(/\.$/, "");
+            return `${protocol}//${host}${endpoint}`;
         }
         return endpoint;
     }
@@ -125,9 +127,9 @@ export class SyncedStateClientManager {
         const normalized = this.normalizeEndpoint(endpoint);
         const connection = this.getConnection(normalized);
         if (connection) {
-            if (connection.deadConnectionTimer) {
-                clearTimeout(connection.deadConnectionTimer);
-                connection.deadConnectionTimer = null;
+            if (connection.pendingRequestTimer) {
+                clearTimeout(connection.pendingRequestTimer);
+                connection.pendingRequestTimer = null;
             }
             try {
                 connection.ws.close();

package/dist/use-synced-state/hibernation/worker.mjs

@@ -23,21 +23,39 @@ export const syncedStateRoutes = (getNamespace, options = {}) => {
         const roomHandler = SyncedStateServer.getRoomHandler();
         const idParam = requestInfo.params?.id;
         let resolvedRoomName;
-        if (roomHandler) {
-            resolvedRoomName = await runWithRequestInfo(requestInfo, async () => await roomHandler(idParam, requestInfo));
+        try {
+            if (roomHandler) {
+                resolvedRoomName = await runWithRequestInfo(requestInfo, async () => await roomHandler(idParam, requestInfo));
+            }
+            else {
+                resolvedRoomName = idParam ?? durableObjectName;
+            }
         }
-        else {
-            resolvedRoomName = idParam ?? durableObjectName;
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Room resolution failed";
+            return new Response(message, { status: 500 });
         }
         const id = namespace.idFromName(resolvedRoomName);
         const stub = namespace.get(id);
         let identity = undefined;
-        if (identityExtractor) {
-            identity = await runWithRequestInfo(requestInfo, async () => await identityExtractor(requestInfo));
+        try {
+            if (identityExtractor) {
+                identity = await runWithRequestInfo(requestInfo, async () => await identityExtractor(requestInfo));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Identity extraction failed";
+            return new Response(message, { status: 500 });
         }
         const doUrl = new URL(request.url);
         doUrl.searchParams.set("clientId", crypto.randomUUID());
-        setIdentityInUrl(identity, doUrl);
+        try {
+            setIdentityInUrl(identity, doUrl);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Invalid identity";
+            return new Response(message, { status: 500 });
+        }
         const doRequest = new Request(doUrl.toString(), {
             headers: request.headers,
         });