rwsdk 1.0.0-beta.5 → 1.0.0-beta.50

package/dist/use-synced-state/SyncedStateServer.d.mts

@@ -0,0 +1,36 @@
+import { RpcStub } from "capnweb";
+import { DurableObject } from "cloudflare:workers";
+import type { RequestInfo } from "../runtime/requestInfo/types";
+export type SyncedStateValue = unknown;
+type OnSetHandler = (key: string, value: SyncedStateValue, stub: DurableObjectStub<SyncedStateServer>) => void;
+type OnGetHandler = (key: string, value: SyncedStateValue | undefined, stub: DurableObjectStub<SyncedStateServer>) => void;
+type OnKeyHandler = (key: string, stub: DurableObjectStub<SyncedStateServer>) => Promise<string>;
+type OnRoomHandler = (roomId: string | undefined, requestInfo: RequestInfo | null) => Promise<string>;
+type OnSubscribeHandler = (key: string, stub: DurableObjectStub<SyncedStateServer>) => void;
+type OnUnsubscribeHandler = (key: string, stub: DurableObjectStub<SyncedStateServer>) => void;
+/**
+ * Durable Object that keeps shared state for multiple clients and notifies subscribers.
+ */
+export declare class SyncedStateServer extends DurableObject {
+    #private;
+    static registerKeyHandler(handler: OnKeyHandler | null): void;
+    static getKeyHandler(): OnKeyHandler | null;
+    static registerRoomHandler(handler: OnRoomHandler | null): void;
+    static getRoomHandler(): OnRoomHandler | null;
+    static registerNamespace(namespace: DurableObjectNamespace<SyncedStateServer>, durableObjectName?: string): void;
+    static getNamespace(): DurableObjectNamespace<SyncedStateServer> | null;
+    static getDurableObjectName(): string;
+    setStub(stub: DurableObjectStub<SyncedStateServer>): void;
+    static registerSetStateHandler(handler: OnSetHandler | null): void;
+    static registerGetStateHandler(handler: OnGetHandler | null): void;
+    static registerSubscribeHandler(handler: OnSubscribeHandler | null): void;
+    static registerUnsubscribeHandler(handler: OnUnsubscribeHandler | null): void;
+    static getSubscribeHandler(): OnSubscribeHandler | null;
+    static getUnsubscribeHandler(): OnUnsubscribeHandler | null;
+    getState(key: string): SyncedStateValue;
+    setState(value: SyncedStateValue, key: string): void;
+    subscribe(key: string, client: RpcStub<(value: SyncedStateValue) => void>): void;
+    unsubscribe(key: string, client: RpcStub<(value: SyncedStateValue) => void>): void;
+    fetch(request: Request): Promise<Response>;
+}
+export {};

package/dist/use-synced-state/SyncedStateServer.mjs

@@ -0,0 +1,196 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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_namespace, _SyncedStateServer_durableObjectName, _SyncedStateServer_stub, _SyncedStateServer_stateStore, _SyncedStateServer_subscriptions, _SyncedStateServer_subscriptionRefs, _SyncedStateServer_getStubForHandlers, _CoordinatorApi_coordinator, _CoordinatorApi_stub;
+import { RpcTarget, newWorkersRpcResponse } from "capnweb";
+import { DurableObject } from "cloudflare:workers";
+/**
+ * Durable Object that keeps shared state for multiple clients and notifies subscribers.
+ */
+export class SyncedStateServer extends DurableObject {
+    constructor() {
+        super(...arguments);
+        _SyncedStateServer_instances.add(this);
+        _SyncedStateServer_stub.set(this, null);
+        _SyncedStateServer_stateStore.set(this, new Map());
+        _SyncedStateServer_subscriptions.set(this, new Map());
+        _SyncedStateServer_subscriptionRefs.set(this, new Map());
+    }
+    static registerKeyHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_keyHandler);
+    }
+    static getKeyHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_keyHandler);
+    }
+    static registerRoomHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_roomHandler);
+    }
+    static getRoomHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_roomHandler);
+    }
+    static registerNamespace(namespace, durableObjectName) {
+        __classPrivateFieldSet(_a, _a, namespace, "f", _SyncedStateServer_namespace);
+        if (durableObjectName) {
+            __classPrivateFieldSet(_a, _a, durableObjectName, "f", _SyncedStateServer_durableObjectName);
+        }
+    }
+    static getNamespace() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_namespace);
+    }
+    static getDurableObjectName() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_durableObjectName);
+    }
+    setStub(stub) {
+        __classPrivateFieldSet(this, _SyncedStateServer_stub, stub, "f");
+    }
+    static registerSetStateHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_setStateHandler);
+    }
+    static registerGetStateHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_getStateHandler);
+    }
+    static registerSubscribeHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_subscribeHandler);
+    }
+    static registerUnsubscribeHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_unsubscribeHandler);
+    }
+    static getSubscribeHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_subscribeHandler);
+    }
+    static getUnsubscribeHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_unsubscribeHandler);
+    }
+    getState(key) {
+        const value = __classPrivateFieldGet(this, _SyncedStateServer_stateStore, "f").get(key);
+        if (__classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler)) {
+            const stub = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getStubForHandlers).call(this);
+            if (stub) {
+                __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler).call(_a, key, value, stub);
+            }
+        }
+        return value;
+    }
+    setState(value, key) {
+        __classPrivateFieldGet(this, _SyncedStateServer_stateStore, "f").set(key, value);
+        if (__classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler)) {
+            const stub = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getStubForHandlers).call(this);
+            if (stub) {
+                __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler).call(_a, key, value, stub);
+            }
+        }
+        const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key);
+        if (!subscribers) {
+            return;
+        }
+        for (const subscriber of subscribers) {
+            subscriber(value).catch(() => {
+                subscribers.delete(subscriber);
+                const refs = __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key);
+                if (refs) {
+                    for (const [original, duplicate] of refs) {
+                        if (duplicate === subscriber) {
+                            refs.delete(original);
+                            break;
+                        }
+                    }
+                    if (refs.size === 0) {
+                        __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").delete(key);
+                    }
+                }
+            });
+        }
+        if (subscribers.size === 0) {
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").delete(key);
+        }
+    }
+    subscribe(key, client) {
+        if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").has(key)) {
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").set(key, new Set());
+        }
+        if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").has(key)) {
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").set(key, new Map());
+        }
+        const duplicate = typeof client.dup === "function"
+            ? client.dup()
+            : client;
+        __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key).add(duplicate);
+        __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key).set(client, duplicate);
+    }
+    unsubscribe(key, client) {
+        const duplicates = __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key);
+        const duplicate = duplicates?.get(client);
+        const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key);
+        if (duplicate && subscribers) {
+            subscribers.delete(duplicate);
+            duplicates.delete(client);
+            if (subscribers.size === 0) {
+                __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").delete(key);
+            }
+            if (duplicates.size === 0) {
+                __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").delete(key);
+            }
+        }
+    }
+    async fetch(request) {
+        // Create a placeholder stub - it will be set by the worker via _setStub
+        const api = new CoordinatorApi(this, __classPrivateFieldGet(this, _SyncedStateServer_stub, "f") || {});
+        return newWorkersRpcResponse(request, api);
+    }
+}
+_a = SyncedStateServer, _SyncedStateServer_stub = new WeakMap(), _SyncedStateServer_stateStore = new WeakMap(), _SyncedStateServer_subscriptions = new WeakMap(), _SyncedStateServer_subscriptionRefs = new WeakMap(), _SyncedStateServer_instances = new WeakSet(), _SyncedStateServer_getStubForHandlers = function _SyncedStateServer_getStubForHandlers() {
+    // If we have a stub already, use it
+    if (__classPrivateFieldGet(this, _SyncedStateServer_stub, "f")) {
+        return __classPrivateFieldGet(this, _SyncedStateServer_stub, "f");
+    }
+    // Otherwise, try to get a stub from the registered namespace using our own ID
+    const namespace = __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_namespace);
+    if (namespace) {
+        return namespace.get(this.ctx.id);
+    }
+    return null;
+};
+_SyncedStateServer_keyHandler = { value: null };
+_SyncedStateServer_roomHandler = { value: null };
+_SyncedStateServer_setStateHandler = { value: null };
+_SyncedStateServer_getStateHandler = { value: null };
+_SyncedStateServer_subscribeHandler = { value: null };
+_SyncedStateServer_unsubscribeHandler = { value: null };
+_SyncedStateServer_namespace = { value: null };
+_SyncedStateServer_durableObjectName = { value: "syncedState" };
+class CoordinatorApi extends RpcTarget {
+    constructor(coordinator, stub) {
+        super();
+        _CoordinatorApi_coordinator.set(this, void 0);
+        _CoordinatorApi_stub.set(this, void 0);
+        __classPrivateFieldSet(this, _CoordinatorApi_coordinator, coordinator, "f");
+        __classPrivateFieldSet(this, _CoordinatorApi_stub, stub, "f");
+        coordinator.setStub(stub);
+    }
+    // Internal method to set the stub - called from worker
+    _setStub(stub) {
+        __classPrivateFieldSet(this, _CoordinatorApi_stub, stub, "f");
+        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").setStub(stub);
+    }
+    getState(key) {
+        return __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").getState(key);
+    }
+    setState(value, key) {
+        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").setState(value, key);
+    }
+    subscribe(key, client) {
+        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").subscribe(key, client);
+    }
+    unsubscribe(key, client) {
+        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").unsubscribe(key, client);
+    }
+}
+_CoordinatorApi_coordinator = new WeakMap(), _CoordinatorApi_stub = new WeakMap();

package/dist/use-synced-state/__tests__/SyncStateServer.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/use-synced-state/__tests__/SyncStateServer.test.mjs

@@ -0,0 +1,116 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+vi.mock("cloudflare:workers", () => {
+    class DurableObject {
+    }
+    return { DurableObject };
+});
+import { SyncedStateServer } from "../SyncedStateServer.mjs";
+const createStub = (onInvoke) => {
+    const fn = Object.assign(async (value) => {
+        await onInvoke(value);
+    }, {
+        dup: () => fn,
+    });
+    return fn;
+};
+describe("SyncedStateServer", () => {
+    it("notifies subscribers when state changes", async () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const received = [];
+        const stub = createStub((value) => {
+            received.push(value);
+        });
+        coordinator.subscribe("counter", stub);
+        coordinator.setState(5, "counter");
+        expect(coordinator.getState("counter")).toBe(5);
+        expect(received).toEqual([5]);
+    });
+    it("removes subscriptions on unsubscribe", () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const stub = createStub(() => { });
+        coordinator.subscribe("counter", stub);
+        coordinator.unsubscribe("counter", stub);
+        coordinator.setState(1, "counter");
+        expect(coordinator.getState("counter")).toBe(1);
+    });
+    it("drops failing subscribers", async () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const stub = createStub(async () => {
+            throw new Error("fail");
+        });
+        coordinator.subscribe("counter", stub);
+        coordinator.setState(3, "counter");
+        await Promise.resolve();
+        coordinator.setState(4, "counter");
+        expect(coordinator.getState("counter")).toBe(4);
+    });
+    it("invokes registered onSet handler", () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const mockStub = {};
+        coordinator.setStub(mockStub);
+        const calls = [];
+        SyncedStateServer.registerSetStateHandler((key, value, stub) => {
+            calls.push({ key, value });
+            expect(stub).toBe(mockStub);
+        });
+        coordinator.setState(2, "counter");
+        expect(calls).toEqual([{ key: "counter", value: 2 }]);
+        SyncedStateServer.registerSetStateHandler(null);
+    });
+    it("invokes registered onGet handler", () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const mockStub = {};
+        coordinator.setStub(mockStub);
+        const calls = [];
+        SyncedStateServer.registerGetStateHandler((key, value, stub) => {
+            calls.push({ key, value });
+            expect(stub).toBe(mockStub);
+        });
+        coordinator.setState(4, "counter");
+        expect(coordinator.getState("counter")).toBe(4);
+        expect(calls).toEqual([{ key: "counter", value: 4 }]);
+        SyncedStateServer.registerGetStateHandler(null);
+    });
+    describe("registerKeyHandler", () => {
+        const mockStub = {};
+        afterEach(() => {
+            SyncedStateServer.registerKeyHandler(async (key, stub) => key);
+        });
+        it("stores and retrieves the registered handler", async () => {
+            const handler = async (key, stub) => `transformed:${key}`;
+            SyncedStateServer.registerKeyHandler(handler);
+            const retrievedHandler = SyncedStateServer.getKeyHandler();
+            expect(retrievedHandler).toBe(handler);
+        });
+        it("transforms keys using the registered handler", async () => {
+            const handler = async (key, stub) => `user:123:${key}`;
+            SyncedStateServer.registerKeyHandler(handler);
+            const result = await handler("counter", mockStub);
+            expect(result).toBe("user:123:counter");
+        });
+        it("returns null when no handler is registered", () => {
+            SyncedStateServer.registerKeyHandler(async (key, stub) => key);
+            const handler = SyncedStateServer.getKeyHandler();
+            expect(handler).not.toBeNull();
+        });
+        it("allows handler to be async", async () => {
+            const handler = async (key, stub) => {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                return `async:${key}`;
+            };
+            SyncedStateServer.registerKeyHandler(handler);
+            const result = await handler("test", mockStub);
+            expect(result).toBe("async:test");
+        });
+        it("handler receives the correct key parameter", async () => {
+            let receivedKey = "";
+            const handler = async (key, stub) => {
+                receivedKey = key;
+                return key;
+            };
+            SyncedStateServer.registerKeyHandler(handler);
+            await handler("myKey", mockStub);
+            expect(receivedKey).toBe("myKey");
+        });
+    });
+});

package/dist/use-synced-state/__tests__/useSyncState.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/use-synced-state/__tests__/useSyncState.test.js

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { setSyncedStateClientForTesting, } from "../client";
+import { createSyncedStateHook, } from "../useSyncedState";
+const createStateHarness = () => {
+    let currentState;
+    const cleanups = [];
+    const useStateImpl = ((initialValue) => {
+        const resolved = typeof initialValue === "function"
+            ? initialValue()
+            : initialValue;
+        currentState = resolved;
+        const setState = (next) => {
+            currentState =
+                typeof next === "function"
+                    ? next(currentState)
+                    : next;
+        };
+        return [currentState, setState];
+    });
+    const useEffectImpl = (callback) => {
+        const cleanup = callback();
+        if (typeof cleanup === "function") {
+            cleanups.push(cleanup);
+        }
+    };
+    const useRefImpl = ((value) => ({
+        current: value,
+    }));
+    const useCallbackImpl = (fn) => fn;
+    const deps = {
+        useState: useStateImpl,
+        useEffect: useEffectImpl,
+        useRef: useRefImpl,
+        useCallback: useCallbackImpl,
+    };
+    return {
+        deps,
+        getState: () => currentState,
+        runCleanups: () => cleanups.forEach((fn) => fn()),
+    };
+};
+describe("createSyncedStateHook", () => {
+    const subscribeHandlers = new Map();
+    const client = {
+        async getState() {
+            return 5;
+        },
+        async setState(_value, _key) { },
+        async subscribe(key, handler) {
+            subscribeHandlers.set(key, handler);
+        },
+        async unsubscribe(key) {
+            subscribeHandlers.delete(key);
+        },
+    };
+    const resetClient = () => {
+        client.getState = async () => 5;
+        client.setState = async (_value, _key) => { };
+        client.subscribe = async (key, handler) => {
+            subscribeHandlers.set(key, handler);
+        };
+        client.unsubscribe = async (key) => {
+            subscribeHandlers.delete(key);
+        };
+    };
+    beforeEach(() => {
+        resetClient();
+        setSyncedStateClientForTesting(client);
+        subscribeHandlers.clear();
+    });
+    afterEach(() => {
+        setSyncedStateClientForTesting(null);
+    });
+    it("loads remote state and updates local value", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        const [value] = useSyncedState(0, "counter");
+        expect(value).toBe(0);
+        await Promise.resolve();
+        expect(harness.getState()).toBe(5);
+    });
+    it("sends updates through the client and applies optimistic value", async () => {
+        const harness = createStateHarness();
+        const setCalls = [];
+        client.setState = async (value, key) => {
+            setCalls.push({ key, value });
+        };
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        const [, setSyncValue] = useSyncedState(0, "counter");
+        setSyncValue(9);
+        expect(harness.getState()).toBe(9);
+        expect(setCalls).toEqual([{ key: "counter", value: 9 }]);
+    });
+    it("applies remote updates from the subscription handler", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        useSyncedState(0, "counter");
+        await Promise.resolve();
+        const handler = subscribeHandlers.get("counter");
+        handler?.(7);
+        expect(harness.getState()).toBe(7);
+    });
+    it("unsubscribes during cleanup", () => {
+        const harness = createStateHarness();
+        const unsubscribed = [];
+        client.unsubscribe = async (key) => {
+            unsubscribed.push({ key });
+            subscribeHandlers.delete(key);
+        };
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        useSyncedState(0, "counter");
+        harness.runCleanups();
+        expect(unsubscribed).toEqual([{ key: "counter" }]);
+    });
+});

package/dist/use-synced-state/__tests__/useSyncedState.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/use-synced-state/__tests__/useSyncedState.test.js

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { setSyncedStateClientForTesting, } from "../client";
+import { createSyncedStateHook, } from "../useSyncedState";
+const createStateHarness = () => {
+    let currentState;
+    const cleanups = [];
+    const useStateImpl = ((initialValue) => {
+        const resolved = typeof initialValue === "function"
+            ? initialValue()
+            : initialValue;
+        currentState = resolved;
+        const setState = (next) => {
+            currentState =
+                typeof next === "function"
+                    ? next(currentState)
+                    : next;
+        };
+        return [currentState, setState];
+    });
+    const useEffectImpl = (callback) => {
+        const cleanup = callback();
+        if (typeof cleanup === "function") {
+            cleanups.push(cleanup);
+        }
+    };
+    const useRefImpl = ((value) => ({
+        current: value,
+    }));
+    const useCallbackImpl = (fn) => fn;
+    const deps = {
+        useState: useStateImpl,
+        useEffect: useEffectImpl,
+        useRef: useRefImpl,
+        useCallback: useCallbackImpl,
+    };
+    return {
+        deps,
+        getState: () => currentState,
+        runCleanups: () => cleanups.forEach((fn) => fn()),
+    };
+};
+describe("createSyncedStateHook", () => {
+    const subscribeHandlers = new Map();
+    const client = {
+        async getState() {
+            return 5;
+        },
+        async setState(_value, _key) { },
+        async subscribe(key, handler) {
+            subscribeHandlers.set(key, handler);
+        },
+        async unsubscribe(key) {
+            subscribeHandlers.delete(key);
+        },
+    };
+    const resetClient = () => {
+        client.getState = async () => 5;
+        client.setState = async (_value, _key) => { };
+        client.subscribe = async (key, handler) => {
+            subscribeHandlers.set(key, handler);
+        };
+        client.unsubscribe = async (key) => {
+            subscribeHandlers.delete(key);
+        };
+    };
+    beforeEach(() => {
+        resetClient();
+        setSyncedStateClientForTesting(client);
+        subscribeHandlers.clear();
+    });
+    afterEach(() => {
+        setSyncedStateClientForTesting(null);
+    });
+    it("loads remote state and updates local value", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        const [value] = useSyncedState(0, "counter");
+        expect(value).toBe(0);
+        await Promise.resolve();
+        expect(harness.getState()).toBe(5);
+    });
+    it("sends updates through the client and applies optimistic value", async () => {
+        const harness = createStateHarness();
+        const setCalls = [];
+        client.setState = async (value, key) => {
+            setCalls.push({ key, value });
+        };
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        const [, setSyncValue] = useSyncedState(0, "counter");
+        setSyncValue(9);
+        expect(harness.getState()).toBe(9);
+        expect(setCalls).toEqual([{ key: "counter", value: 9 }]);
+    });
+    it("applies remote updates from the subscription handler", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        useSyncedState(0, "counter");
+        await Promise.resolve();
+        const handler = subscribeHandlers.get("counter");
+        handler?.(7);
+        expect(harness.getState()).toBe(7);
+    });
+    it("unsubscribes during cleanup", () => {
+        const harness = createStateHarness();
+        const unsubscribed = [];
+        client.unsubscribe = async (key) => {
+            unsubscribed.push({ key });
+            subscribeHandlers.delete(key);
+        };
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        useSyncedState(0, "counter");
+        harness.runCleanups();
+        expect(unsubscribed).toEqual([{ key: "counter" }]);
+    });
+});

package/dist/use-synced-state/__tests__/worker.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/use-synced-state/__tests__/worker.test.mjs

@@ -0,0 +1,70 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("cloudflare:workers", () => {
+    class DurableObject {
+    }
+    return { DurableObject, env: {} };
+});
+vi.mock("capnweb", () => ({
+    RpcTarget: class RpcTarget {
+    },
+    newWorkersRpcResponse: vi.fn(),
+}));
+vi.mock("../runtime/entries/router", () => ({
+    route: vi.fn((path, handler) => ({ path, handler })),
+}));
+import { SyncedStateServer } from "../SyncedStateServer.mjs";
+describe("SyncedStateProxy", () => {
+    let mockCoordinator;
+    beforeEach(() => {
+        mockCoordinator = new SyncedStateServer({}, {});
+    });
+    const mockStub = {};
+    afterEach(() => {
+        SyncedStateServer.registerKeyHandler(async (key, stub) => key);
+    });
+    it("transforms keys before calling coordinator methods when handler is registered", async () => {
+        const handler = async (key, stub) => `transformed:${key}`;
+        SyncedStateServer.registerKeyHandler(handler);
+        const transformedKey = await handler("counter", mockStub);
+        expect(transformedKey).toBe("transformed:counter");
+        mockCoordinator.setState(5, transformedKey);
+        const value = mockCoordinator.getState(transformedKey);
+        expect(value).toBe(5);
+    });
+    it("does not transform keys when no handler is registered", () => {
+        SyncedStateServer.registerKeyHandler(async (key, stub) => key);
+        const handler = SyncedStateServer.getKeyHandler();
+        expect(handler).not.toBeNull();
+    });
+    it("passes through original key when handler returns it unchanged", async () => {
+        const handler = async (key, stub) => key;
+        SyncedStateServer.registerKeyHandler(handler);
+        const result = await handler("counter", mockStub);
+        expect(result).toBe("counter");
+    });
+    it("handler can scope keys per user", async () => {
+        const handler = async (key, stub) => {
+            const userId = "user123";
+            return `user:${userId}:${key}`;
+        };
+        SyncedStateServer.registerKeyHandler(handler);
+        const result = await handler("settings", mockStub);
+        expect(result).toBe("user:user123:settings");
+    });
+    it("allows errors from handler to propagate", async () => {
+        const handler = async (_key, stub) => {
+            throw new Error("Handler error");
+        };
+        SyncedStateServer.registerKeyHandler(handler);
+        await expect(handler("test", mockStub)).rejects.toThrow("Handler error");
+    });
+    it("handles async operations in handler", async () => {
+        const handler = async (key, stub) => {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            return `async:${key}`;
+        };
+        SyncedStateServer.registerKeyHandler(handler);
+        const result = await handler("data", mockStub);
+        expect(result).toBe("async:data");
+    });
+});