rwsdk 1.0.0-beta.30-test.20251120210809 → 1.0.0-beta.30-test.20251120213828

package/dist/lib/e2e/testHarness.mjs

@@ -413,7 +413,12 @@ function createSDKTestRunner() {
                         console.warn("Failed to connect to existing browser instance. " +
                             "This might happen if you are running a single test file. " +
                             "Launching a new browser instance instead.");
-                        browser = await launchBrowser();
+                        // Check for RWSDK_HEADLESS environment variable (default to true if not set)
+                        // Set RWSDK_HEADLESS=0 or RWSDK_HEADLESS=false to run in headed mode
+                        const headless = process.env.RWSDK_HEADLESS === undefined ||
+                            process.env.RWSDK_HEADLESS === "1" ||
+                            process.env.RWSDK_HEADLESS === "true";
+                        browser = await launchBrowser(undefined, headless);
                     }
                 }, SETUP_WAIT_TIMEOUT);
                 afterAll(async () => {

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

@@ -0,0 +1,21 @@
+import { RpcStub } from "capnweb";
+import { DurableObject } from "cloudflare:workers";
+export type SyncedStateValue = unknown;
+type OnSetHandler = (key: string, value: SyncedStateValue) => void;
+type OnGetHandler = (key: string, value: SyncedStateValue | undefined) => void;
+/**
+ * Durable Object that keeps shared state for multiple clients and notifies subscribers.
+ */
+export declare class SyncedStateServer extends DurableObject {
+    #private;
+    static registerKeyHandler(handler: (key: string) => Promise<string>): void;
+    static getKeyHandler(): ((key: string) => Promise<string>) | null;
+    static registerSetStateHandler(handler: OnSetHandler | null): void;
+    static registerGetStateHandler(handler: OnGetHandler | null): void;
+    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/{SyncStateServer.mjs → SyncedStateServer.mjs}

@@ -9,51 +9,51 @@ 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 _a, _SyncStateServer_keyHandler, _SyncStateServer_setStateHandler, _SyncStateServer_getStateHandler, _SyncStateServer_stateStore, _SyncStateServer_subscriptions, _SyncStateServer_subscriptionRefs, _CoordinatorApi_coordinator;
-import { RpcTarget } from "capnweb";
+var _a, _SyncedStateServer_keyHandler, _SyncedStateServer_setStateHandler, _SyncedStateServer_getStateHandler, _SyncedStateServer_stateStore, _SyncedStateServer_subscriptions, _SyncedStateServer_subscriptionRefs, _CoordinatorApi_coordinator;
+import { RpcTarget, newWorkersRpcResponse } from "capnweb";
 import { DurableObject } from "cloudflare:workers";
 /**
  * Durable Object that keeps shared state for multiple clients and notifies subscribers.
  */
-export class SyncStateServer extends DurableObject {
+export class SyncedStateServer extends DurableObject {
     constructor() {
         super(...arguments);
-        _SyncStateServer_stateStore.set(this, new Map());
-        _SyncStateServer_subscriptions.set(this, new Map());
-        _SyncStateServer_subscriptionRefs.set(this, new Map());
+        _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", _SyncStateServer_keyHandler);
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_keyHandler);
     }
     static getKeyHandler() {
-        return __classPrivateFieldGet(_a, _a, "f", _SyncStateServer_keyHandler);
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_keyHandler);
     }
     static registerSetStateHandler(handler) {
-        __classPrivateFieldSet(_a, _a, handler, "f", _SyncStateServer_setStateHandler);
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_setStateHandler);
     }
     static registerGetStateHandler(handler) {
-        __classPrivateFieldSet(_a, _a, handler, "f", _SyncStateServer_getStateHandler);
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_getStateHandler);
     }
     getState(key) {
-        const value = __classPrivateFieldGet(this, _SyncStateServer_stateStore, "f").get(key);
-        if (__classPrivateFieldGet(_a, _a, "f", _SyncStateServer_getStateHandler)) {
-            __classPrivateFieldGet(_a, _a, "f", _SyncStateServer_getStateHandler).call(_a, key, value);
+        const value = __classPrivateFieldGet(this, _SyncedStateServer_stateStore, "f").get(key);
+        if (__classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler)) {
+            __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler).call(_a, key, value);
         }
         return value;
     }
     setState(value, key) {
-        __classPrivateFieldGet(this, _SyncStateServer_stateStore, "f").set(key, value);
-        if (__classPrivateFieldGet(_a, _a, "f", _SyncStateServer_setStateHandler)) {
-            __classPrivateFieldGet(_a, _a, "f", _SyncStateServer_setStateHandler).call(_a, key, value);
+        __classPrivateFieldGet(this, _SyncedStateServer_stateStore, "f").set(key, value);
+        if (__classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler)) {
+            __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler).call(_a, key, value);
         }
-        const subscribers = __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").get(key);
+        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, _SyncStateServer_subscriptionRefs, "f").get(key);
+                const refs = __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key);
                 if (refs) {
                     for (const [original, duplicate] of refs) {
                         if (duplicate === subscriber) {
@@ -62,46 +62,50 @@ export class SyncStateServer extends DurableObject {
                         }
                     }
                     if (refs.size === 0) {
-                        __classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").delete(key);
+                        __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").delete(key);
                     }
                 }
             });
         }
         if (subscribers.size === 0) {
-            __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").delete(key);
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").delete(key);
         }
     }
     subscribe(key, client) {
-        if (!__classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").has(key)) {
-            __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").set(key, new Set());
+        if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").has(key)) {
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").set(key, new Set());
         }
-        if (!__classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").has(key)) {
-            __classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").set(key, new Map());
+        if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").has(key)) {
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").set(key, new Map());
         }
         const duplicate = client.dup();
-        __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").get(key).add(duplicate);
-        __classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").get(key).set(client, duplicate);
+        __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, _SyncStateServer_subscriptionRefs, "f").get(key);
+        const duplicates = __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key);
         const duplicate = duplicates?.get(client);
-        const subscribers = __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").get(key);
+        const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key);
         if (duplicate && subscribers) {
             subscribers.delete(duplicate);
             duplicates.delete(client);
             if (subscribers.size === 0) {
-                __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").delete(key);
+                __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").delete(key);
             }
             if (duplicates.size === 0) {
-                __classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").delete(key);
+                __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").delete(key);
             }
         }
     }
+    async fetch(request) {
+        const api = new CoordinatorApi(this);
+        return newWorkersRpcResponse(request, api);
+    }
 }
-_a = SyncStateServer, _SyncStateServer_stateStore = new WeakMap(), _SyncStateServer_subscriptions = new WeakMap(), _SyncStateServer_subscriptionRefs = new WeakMap();
-_SyncStateServer_keyHandler = { value: null };
-_SyncStateServer_setStateHandler = { value: null };
-_SyncStateServer_getStateHandler = { value: null };
+_a = SyncedStateServer, _SyncedStateServer_stateStore = new WeakMap(), _SyncedStateServer_subscriptions = new WeakMap(), _SyncedStateServer_subscriptionRefs = new WeakMap();
+_SyncedStateServer_keyHandler = { value: null };
+_SyncedStateServer_setStateHandler = { value: null };
+_SyncedStateServer_getStateHandler = { value: null };
 class CoordinatorApi extends RpcTarget {
     constructor(coordinator) {
         super();

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

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

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

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { setSyncStateClientForTesting } from "../client";
-import { createSyncStateHook, } from "../useSyncedState";
+import { setSyncedStateClientForTesting, } from "../client";
+import { createSyncedStateHook, } from "../useSyncedState";
 const createStateHarness = () => {
     let currentState;
     const cleanups = [];
@@ -39,7 +39,7 @@ const createStateHarness = () => {
         runCleanups: () => cleanups.forEach((fn) => fn()),
     };
 };
-describe("createSyncStateHook", () => {
+describe("createSyncedStateHook", () => {
     const subscribeHandlers = new Map();
     const client = {
         async getState() {
@@ -65,15 +65,15 @@ describe("createSyncStateHook", () => {
     };
     beforeEach(() => {
         resetClient();
-        setSyncStateClientForTesting(client);
+        setSyncedStateClientForTesting(client);
         subscribeHandlers.clear();
     });
     afterEach(() => {
-        setSyncStateClientForTesting(null);
+        setSyncedStateClientForTesting(null);
     });
     it("loads remote state and updates local value", async () => {
         const harness = createStateHarness();
-        const useSyncedState = createSyncStateHook({ hooks: harness.deps });
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
         const [value] = useSyncedState(0, "counter");
         expect(value).toBe(0);
         await Promise.resolve();
@@ -85,7 +85,7 @@ describe("createSyncStateHook", () => {
         client.setState = async (value, key) => {
             setCalls.push({ key, value });
         };
-        const useSyncedState = createSyncStateHook({ hooks: harness.deps });
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
         const [, setSyncValue] = useSyncedState(0, "counter");
         setSyncValue(9);
         expect(harness.getState()).toBe(9);
@@ -93,7 +93,7 @@ describe("createSyncStateHook", () => {
     });
     it("applies remote updates from the subscription handler", async () => {
         const harness = createStateHarness();
-        const useSyncedState = createSyncStateHook({ hooks: harness.deps });
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
         useSyncedState(0, "counter");
         await Promise.resolve();
         const handler = subscribeHandlers.get("counter");
@@ -107,7 +107,7 @@ describe("createSyncStateHook", () => {
             unsubscribed.push({ key });
             subscribeHandlers.delete(key);
         };
-        const useSyncedState = createSyncStateHook({ hooks: harness.deps });
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
         useSyncedState(0, "counter");
         harness.runCleanups();
         expect(unsubscribed).toEqual([{ key: "counter" }]);

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

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { setSyncStateClientForTesting, } from "../client";
-import { createSyncStateHook, } from "../useSyncedState";
+import { setSyncedStateClientForTesting, } from "../client";
+import { createSyncedStateHook, } from "../useSyncedState";
 const createStateHarness = () => {
     let currentState;
     const cleanups = [];
@@ -39,7 +39,7 @@ const createStateHarness = () => {
         runCleanups: () => cleanups.forEach((fn) => fn()),
     };
 };
-describe("createSyncStateHook", () => {
+describe("createSyncedStateHook", () => {
     const subscribeHandlers = new Map();
     const client = {
         async getState() {
@@ -65,15 +65,15 @@ describe("createSyncStateHook", () => {
     };
     beforeEach(() => {
         resetClient();
-        setSyncStateClientForTesting(client);
+        setSyncedStateClientForTesting(client);
         subscribeHandlers.clear();
     });
     afterEach(() => {
-        setSyncStateClientForTesting(null);
+        setSyncedStateClientForTesting(null);
     });
     it("loads remote state and updates local value", async () => {
         const harness = createStateHarness();
-        const useSyncedState = createSyncStateHook({ hooks: harness.deps });
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
         const [value] = useSyncedState(0, "counter");
         expect(value).toBe(0);
         await Promise.resolve();
@@ -85,7 +85,7 @@ describe("createSyncStateHook", () => {
         client.setState = async (value, key) => {
             setCalls.push({ key, value });
         };
-        const useSyncedState = createSyncStateHook({ hooks: harness.deps });
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
         const [, setSyncValue] = useSyncedState(0, "counter");
         setSyncValue(9);
         expect(harness.getState()).toBe(9);
@@ -93,7 +93,7 @@ describe("createSyncStateHook", () => {
     });
     it("applies remote updates from the subscription handler", async () => {
         const harness = createStateHarness();
-        const useSyncedState = createSyncStateHook({ hooks: harness.deps });
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
         useSyncedState(0, "counter");
         await Promise.resolve();
         const handler = subscribeHandlers.get("counter");
@@ -107,7 +107,7 @@ describe("createSyncStateHook", () => {
             unsubscribed.push({ key });
             subscribeHandlers.delete(key);
         };
-        const useSyncedState = createSyncStateHook({ hooks: harness.deps });
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
         useSyncedState(0, "counter");
         harness.runCleanups();
         expect(unsubscribed).toEqual([{ key: "counter" }]);

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

@@ -12,18 +12,18 @@ vi.mock("capnweb", () => ({
 vi.mock("../runtime/entries/router", () => ({
     route: vi.fn((path, handler) => ({ path, handler })),
 }));
-import { SyncStateServer } from "../SyncStateServer.mjs";
-describe("SyncStateProxy", () => {
+import { SyncedStateServer } from "../SyncedStateServer.mjs";
+describe("SyncedStateProxy", () => {
     let mockCoordinator;
     beforeEach(() => {
-        mockCoordinator = new SyncStateServer({}, {});
+        mockCoordinator = new SyncedStateServer({}, {});
     });
     afterEach(() => {
-        SyncStateServer.registerKeyHandler(async (key) => key);
+        SyncedStateServer.registerKeyHandler(async (key) => key);
     });
     it("transforms keys before calling coordinator methods when handler is registered", async () => {
         const handler = async (key) => `transformed:${key}`;
-        SyncStateServer.registerKeyHandler(handler);
+        SyncedStateServer.registerKeyHandler(handler);
         const transformedKey = await handler("counter");
         expect(transformedKey).toBe("transformed:counter");
         mockCoordinator.setState(5, transformedKey);
@@ -31,13 +31,13 @@ describe("SyncStateProxy", () => {
         expect(value).toBe(5);
     });
     it("does not transform keys when no handler is registered", () => {
-        SyncStateServer.registerKeyHandler(async (key) => key);
-        const handler = SyncStateServer.getKeyHandler();
+        SyncedStateServer.registerKeyHandler(async (key) => key);
+        const handler = SyncedStateServer.getKeyHandler();
         expect(handler).not.toBeNull();
     });
     it("passes through original key when handler returns it unchanged", async () => {
         const handler = async (key) => key;
-        SyncStateServer.registerKeyHandler(handler);
+        SyncedStateServer.registerKeyHandler(handler);
         const result = await handler("counter");
         expect(result).toBe("counter");
     });
@@ -46,7 +46,7 @@ describe("SyncStateProxy", () => {
             const userId = "user123";
             return `user:${userId}:${key}`;
         };
-        SyncStateServer.registerKeyHandler(handler);
+        SyncedStateServer.registerKeyHandler(handler);
         const result = await handler("settings");
         expect(result).toBe("user:user123:settings");
     });
@@ -54,7 +54,7 @@ describe("SyncStateProxy", () => {
         const handler = async (_key) => {
             throw new Error("Handler error");
         };
-        SyncStateServer.registerKeyHandler(handler);
+        SyncedStateServer.registerKeyHandler(handler);
         await expect(handler("test")).rejects.toThrow("Handler error");
     });
     it("handles async operations in handler", async () => {
@@ -62,7 +62,7 @@ describe("SyncStateProxy", () => {
             await new Promise((resolve) => setTimeout(resolve, 5));
             return `async:${key}`;
         };
-        SyncStateServer.registerKeyHandler(handler);
+        SyncedStateServer.registerKeyHandler(handler);
         const result = await handler("data");
         expect(result).toBe("async:data");
     });

package/dist/use-synced-state/client-core.d.ts

@@ -0,0 +1,26 @@
+export type SyncedStateClient = {
+    getState(key: string): Promise<unknown>;
+    setState(value: unknown, key: string): Promise<void>;
+    subscribe(key: string, handler: (value: unknown) => void): Promise<void>;
+    unsubscribe(key: string, handler: (value: unknown) => void): Promise<void>;
+};
+/**
+ * Returns a cached client for the provided endpoint, creating it when necessary.
+ * @param endpoint Endpoint to connect to.
+ * @returns RPC client instance.
+ */
+export declare const getSyncedStateClient: (endpoint?: string) => SyncedStateClient;
+/**
+ * Initializes and caches an RPC client instance for the sync state endpoint.
+ * @param options Optional endpoint override.
+ * @returns Cached client instance or `null` when running without `window`.
+ */
+export declare const initSyncedStateClient: (options?: {
+    endpoint?: string;
+}) => SyncedStateClient | null;
+/**
+ * Injects a client instance for tests and updates the cached endpoint.
+ * @param client Stub client instance or `null` to clear the cache.
+ * @param endpoint Endpoint associated with the injected client.
+ */
+export declare const setSyncedStateClientForTesting: (client: SyncedStateClient | null, endpoint?: string) => void;

package/dist/use-synced-state/client-core.js

@@ -0,0 +1,39 @@
+import { newWebSocketRpcSession } from "capnweb";
+import { DEFAULT_SYNCED_STATE_PATH } from "./constants.mjs";
+let cachedClient = null;
+let cachedEndpoint = DEFAULT_SYNCED_STATE_PATH;
+/**
+ * Returns a cached client for the provided endpoint, creating it when necessary.
+ * @param endpoint Endpoint to connect to.
+ * @returns RPC client instance.
+ */
+export const getSyncedStateClient = (endpoint = cachedEndpoint) => {
+    if (cachedClient && endpoint === cachedEndpoint) {
+        return cachedClient;
+    }
+    cachedEndpoint = endpoint;
+    cachedClient = newWebSocketRpcSession(cachedEndpoint);
+    return cachedClient;
+};
+/**
+ * Initializes and caches an RPC client instance for the sync state endpoint.
+ * @param options Optional endpoint override.
+ * @returns Cached client instance or `null` when running without `window`.
+ */
+export const initSyncedStateClient = (options = {}) => {
+    cachedEndpoint = options.endpoint ?? DEFAULT_SYNCED_STATE_PATH;
+    if (typeof window === "undefined") {
+        return null;
+    }
+    cachedClient = newWebSocketRpcSession(cachedEndpoint);
+    return cachedClient;
+};
+/**
+ * Injects a client instance for tests and updates the cached endpoint.
+ * @param client Stub client instance or `null` to clear the cache.
+ * @param endpoint Endpoint associated with the injected client.
+ */
+export const setSyncedStateClientForTesting = (client, endpoint = DEFAULT_SYNCED_STATE_PATH) => {
+    cachedClient = client;
+    cachedEndpoint = endpoint;
+};

package/dist/use-synced-state/client.d.ts

@@ -1,28 +1,3 @@
-export type SyncStateClient = {
-    getState(key: string): Promise<unknown>;
-    setState(value: unknown, key: string): Promise<void>;
-    subscribe(key: string, handler: (value: unknown) => void): Promise<void>;
-    unsubscribe(key: string, handler: (value: unknown) => void): Promise<void>;
-};
-type InitOptions = {
-    endpoint?: string;
-};
-/**
- * Initializes and caches an RPC client instance for the sync state endpoint.
- * @param options Optional endpoint override.
- * @returns Cached client instance or `null` when running without `window`.
- */
-export declare const initSyncStateClient: (options?: InitOptions) => SyncStateClient | null;
-/**
- * Returns a cached client for the provided endpoint, creating it when necessary.
- * @param endpoint Endpoint to connect to.
- * @returns RPC client instance.
- */
-export declare const getSyncStateClient: (endpoint?: string) => SyncStateClient;
-/**
- * Injects a client instance for tests and updates the cached endpoint.
- * @param client Stub client instance or `null` to clear the cache.
- * @param endpoint Endpoint associated with the injected client.
- */
-export declare const setSyncStateClientForTesting: (client: SyncStateClient | null, endpoint?: string) => void;
-export {};
+export { getSyncedStateClient, initSyncedStateClient, setSyncedStateClientForTesting, } from "./client-core.js";
+export type { SyncedStateClient } from "./client-core.js";
+export { useSyncedState } from "./useSyncedState.js";

package/dist/use-synced-state/client.js

@@ -1,39 +1,4 @@
-import { newWebSocketRpcSession } from "capnweb";
-import { DEFAULT_SYNC_STATE_PATH } from "./constants.mjs";
-let cachedClient = null;
-let cachedEndpoint = DEFAULT_SYNC_STATE_PATH;
-/**
- * Initializes and caches an RPC client instance for the sync state endpoint.
- * @param options Optional endpoint override.
- * @returns Cached client instance or `null` when running without `window`.
- */
-export const initSyncStateClient = (options = {}) => {
-    cachedEndpoint = options.endpoint ?? DEFAULT_SYNC_STATE_PATH;
-    if (typeof window === "undefined") {
-        return null;
-    }
-    cachedClient = newWebSocketRpcSession(cachedEndpoint);
-    return cachedClient;
-};
-/**
- * Returns a cached client for the provided endpoint, creating it when necessary.
- * @param endpoint Endpoint to connect to.
- * @returns RPC client instance.
- */
-export const getSyncStateClient = (endpoint = cachedEndpoint) => {
-    if (cachedClient && endpoint === cachedEndpoint) {
-        return cachedClient;
-    }
-    cachedEndpoint = endpoint;
-    cachedClient = newWebSocketRpcSession(cachedEndpoint);
-    return cachedClient;
-};
-/**
- * Injects a client instance for tests and updates the cached endpoint.
- * @param client Stub client instance or `null` to clear the cache.
- * @param endpoint Endpoint associated with the injected client.
- */
-export const setSyncStateClientForTesting = (client, endpoint = DEFAULT_SYNC_STATE_PATH) => {
-    cachedClient = client;
-    cachedEndpoint = endpoint;
-};
+// Re-export everything from client-core to maintain the public API
+export { getSyncedStateClient, initSyncedStateClient, setSyncedStateClientForTesting, } from "./client-core.js";
+// Re-export useSyncedState (no circular dependency since useSyncedState imports from client-core, not client)
+export { useSyncedState } from "./useSyncedState.js";

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

@@ -1 +1 @@
-export declare const DEFAULT_SYNC_STATE_PATH = "/__sync-state";
+export declare const DEFAULT_SYNCED_STATE_PATH = "/__synced-state";

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

@@ -1 +1 @@
-export const DEFAULT_SYNC_STATE_PATH = "/__sync-state";
+export const DEFAULT_SYNCED_STATE_PATH = "/__synced-state";

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

@@ -1,4 +1,4 @@
-import { React } from "../runtime/client/client";
+import React from "react";
 type HookDeps = {
     useState: typeof React.useState;
     useEffect: typeof React.useEffect;
@@ -6,7 +6,7 @@ type HookDeps = {
     useCallback: typeof React.useCallback;
 };
 type Setter<T> = (value: T | ((previous: T) => T)) => void;
-export type CreateSyncStateHookOptions = {
+export type CreateSyncedStateHookOptions = {
     url?: string;
     hooks?: HookDeps;
 };
@@ -15,6 +15,6 @@ export type CreateSyncStateHookOptions = {
  * @param options Optional overrides for endpoint and React primitives.
  * @returns Hook that syncs state through the sync state service.
  */
-export declare const createSyncStateHook: (options?: CreateSyncStateHookOptions) => <T>(initialValue: T, key: string) => [T, Setter<T>];
+export declare const createSyncedStateHook: (options?: CreateSyncedStateHookOptions) => <T>(initialValue: T, key: string) => [T, Setter<T>];
 export declare const useSyncedState: <T>(initialValue: T, key: string) => [T, Setter<T>];
 export {};

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

@@ -1,6 +1,6 @@
-import { React } from "../runtime/client/client";
-import { getSyncStateClient } from "./client";
-import { DEFAULT_SYNC_STATE_PATH } from "./constants.mjs";
+import React from "react";
+import { getSyncedStateClient } from "./client-core.js";
+import { DEFAULT_SYNCED_STATE_PATH } from "./constants.mjs";
 const defaultDeps = {
     useState: React.useState,
     useEffect: React.useEffect,
@@ -12,15 +12,15 @@ const defaultDeps = {
  * @param options Optional overrides for endpoint and React primitives.
  * @returns Hook that syncs state through the sync state service.
  */
-export const createSyncStateHook = (options = {}) => {
-    const resolvedUrl = options.url ?? DEFAULT_SYNC_STATE_PATH;
+export const createSyncedStateHook = (options = {}) => {
+    const resolvedUrl = options.url ?? DEFAULT_SYNCED_STATE_PATH;
     const deps = options.hooks ?? defaultDeps;
     const { useState, useEffect, useRef, useCallback } = deps;
     return function useSyncedState(initialValue, key) {
         if (typeof window === "undefined" && !options.hooks) {
             return [initialValue, () => { }];
         }
-        const client = getSyncStateClient(resolvedUrl);
+        const client = getSyncedStateClient(resolvedUrl);
         const [value, setValue] = useState(initialValue);
         const valueRef = useRef(value);
         valueRef.current = value;
@@ -55,4 +55,4 @@ export const createSyncStateHook = (options = {}) => {
         return [value, setSyncValue];
     };
 };
-export const useSyncedState = createSyncStateHook();
+export const useSyncedState = createSyncedStateHook();

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

@@ -1,14 +1,13 @@
-import { SyncStateServer } from "./SyncStateServer.mjs";
-export { SyncStateServer } from "./SyncStateServer.mjs";
-export type SyncStateRouteOptions = {
+import { SyncedStateServer } from "./SyncedStateServer.mjs";
+export { SyncedStateServer };
+export type SyncedStateRouteOptions = {
     basePath?: string;
-    resetPath?: string;
     durableObjectName?: string;
 };
 /**
  * Registers routes that forward sync state requests to the configured Durable Object namespace.
  * @param getNamespace Function that returns the Durable Object namespace from the Worker env.
- * @param options Optional overrides for base path, reset path, and object name.
- * @returns Router entries for the sync state API and reset endpoint.
+ * @param options Optional overrides for base path and object name.
+ * @returns Router entries for the sync state API.
  */
-export declare const syncStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncStateServer>, options?: SyncStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<`/${string}`, import("../runtime/worker.js").RequestInfo<any, import("../runtime/worker.js").DefaultAppContext>>[];
+export declare const syncedStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncedStateServer>, options?: SyncedStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<`/${string}`, import("../runtime/worker.js").RequestInfo<any, import("../runtime/worker.js").DefaultAppContext>>[];

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

@@ -9,52 +9,51 @@ 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 _SyncStateProxy_stub, _SyncStateProxy_keyHandler;
+var _SyncedStateProxy_stub, _SyncedStateProxy_keyHandler;
 import { RpcTarget, newWorkersRpcResponse } from "capnweb";
 import { env } from "cloudflare:workers";
 import { route } from "../runtime/entries/router";
-import { SyncStateServer } from "./SyncStateServer.mjs";
-import { DEFAULT_SYNC_STATE_PATH } from "./constants.mjs";
-export { SyncStateServer } from "./SyncStateServer.mjs";
+import { SyncedStateServer, } from "./SyncedStateServer.mjs";
+import { DEFAULT_SYNCED_STATE_PATH } from "./constants.mjs";
+export { SyncedStateServer };
 const DEFAULT_SYNC_STATE_NAME = "syncedState";
-class SyncStateProxy extends RpcTarget {
+class SyncedStateProxy extends RpcTarget {
     constructor(stub, keyHandler) {
         super();
-        _SyncStateProxy_stub.set(this, void 0);
-        _SyncStateProxy_keyHandler.set(this, void 0);
-        __classPrivateFieldSet(this, _SyncStateProxy_stub, stub, "f");
-        __classPrivateFieldSet(this, _SyncStateProxy_keyHandler, keyHandler, "f");
+        _SyncedStateProxy_stub.set(this, void 0);
+        _SyncedStateProxy_keyHandler.set(this, void 0);
+        __classPrivateFieldSet(this, _SyncedStateProxy_stub, stub, "f");
+        __classPrivateFieldSet(this, _SyncedStateProxy_keyHandler, keyHandler, "f");
     }
     async getState(key) {
-        const transformedKey = __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f").call(this, key) : key;
-        return __classPrivateFieldGet(this, _SyncStateProxy_stub, "f").getState(transformedKey);
+        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").getState(transformedKey);
     }
     async setState(value, key) {
-        const transformedKey = __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f").call(this, key) : key;
-        return __classPrivateFieldGet(this, _SyncStateProxy_stub, "f").setState(value, transformedKey);
+        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").setState(value, transformedKey);
     }
     async subscribe(key, client) {
-        const transformedKey = __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f").call(this, key) : key;
-        return __classPrivateFieldGet(this, _SyncStateProxy_stub, "f").subscribe(transformedKey, client);
+        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").subscribe(transformedKey, client);
     }
     async unsubscribe(key, client) {
-        const transformedKey = __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f").call(this, key) : key;
-        return __classPrivateFieldGet(this, _SyncStateProxy_stub, "f").unsubscribe(transformedKey, client);
+        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").unsubscribe(transformedKey, client);
     }
 }
-_SyncStateProxy_stub = new WeakMap(), _SyncStateProxy_keyHandler = new WeakMap();
+_SyncedStateProxy_stub = new WeakMap(), _SyncedStateProxy_keyHandler = new WeakMap();
 /**
  * Registers routes that forward sync state requests to the configured Durable Object namespace.
  * @param getNamespace Function that returns the Durable Object namespace from the Worker env.
- * @param options Optional overrides for base path, reset path, and object name.
- * @returns Router entries for the sync state API and reset endpoint.
+ * @param options Optional overrides for base path and object name.
+ * @returns Router entries for the sync state API.
  */
-export const syncStateRoutes = (getNamespace, options = {}) => {
-    const basePath = options.basePath ?? DEFAULT_SYNC_STATE_PATH;
-    const resetPath = options.resetPath ?? `${basePath}/reset`;
+export const syncedStateRoutes = (getNamespace, options = {}) => {
+    const basePath = options.basePath ?? DEFAULT_SYNCED_STATE_PATH;
     const durableObjectName = options.durableObjectName ?? DEFAULT_SYNC_STATE_NAME;
     const forwardRequest = async (request) => {
-        const keyHandler = SyncStateServer.getKeyHandler();
+        const keyHandler = SyncedStateServer.getKeyHandler();
         if (!keyHandler) {
             const namespace = getNamespace(env);
             const id = namespace.idFromName(durableObjectName);
@@ -63,11 +62,8 @@ export const syncStateRoutes = (getNamespace, options = {}) => {
         const namespace = getNamespace(env);
         const id = namespace.idFromName(durableObjectName);
         const coordinator = namespace.get(id);
-        const proxy = new SyncStateProxy(coordinator, keyHandler);
+        const proxy = new SyncedStateProxy(coordinator, keyHandler);
         return newWorkersRpcResponse(request, proxy);
     };
-    return [
-        route(basePath, ({ request }) => forwardRequest(request)),
-        route(resetPath, ({ request }) => forwardRequest(request)),
-    ];
+    return [route(basePath, ({ request }) => forwardRequest(request))];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.30-test.20251120210809",
+  "version": "1.0.0-beta.30-test.20251120213828",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -110,8 +110,8 @@
       "default": "./dist/use-synced-state/client.js"
     },
     "./use-synced-state/worker": {
-      "types": "./dist/use-synced-state/worker.d.ts",
-      "default": "./dist/use-synced-state/worker.js"
+      "types": "./dist/use-synced-state/worker.d.mts",
+      "workerd": "./dist/use-synced-state/worker.mjs"
     }
   },
   "keywords": [
@@ -157,7 +157,6 @@
     "@types/react-dom": "~19.1.2",
     "@types/react-is": "~19.0.0",
     "@vitejs/plugin-react": "~5.0.0",
-    "capnweb": "~0.2.0",
     "chokidar": "~4.0.0",
     "debug": "~4.4.0",
     "decompress": "~4.2.1",
@@ -187,6 +186,7 @@
   },
   "peerDependencies": {
     "@cloudflare/vite-plugin": "^1.13.10",
+    "capnweb": "~0.2.0",
     "react": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
     "react-dom": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
     "react-server-dom-webpack": ">=19.2.0-0 <19.3.0 || >=19.3.0-0 <20.0.0",
@@ -196,6 +196,7 @@
   "packageManager": "pnpm@10.0.0+sha512.b8fef5494bd3fe4cbd4edabd0745df2ee5be3e4b0b8b08fa643aa3e4c6702ccc0f00d68fa8a8c9858a735a0032485a44990ed2810526c875e416f001b17df12b",
   "devDependencies": {
     "@cloudflare/vite-plugin": "1.13.3",
+    "capnweb": "~0.2.0",
     "@types/debug": "~4.1.12",
     "@types/js-beautify": "~1.14.3",
     "@types/lodash": "~4.17.16",

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

@@ -1,20 +0,0 @@
-import { RpcStub } from "capnweb";
-import { DurableObject } from "cloudflare:workers";
-export type SyncStateValue = unknown;
-type OnSetHandler = (key: string, value: SyncStateValue) => void;
-type OnGetHandler = (key: string, value: SyncStateValue | undefined) => void;
-/**
- * Durable Object that keeps shared state for multiple clients and notifies subscribers.
- */
-export declare class SyncStateServer extends DurableObject {
-    #private;
-    static registerKeyHandler(handler: (key: string) => Promise<string>): void;
-    static getKeyHandler(): ((key: string) => Promise<string>) | null;
-    static registerSetStateHandler(handler: OnSetHandler | null): void;
-    static registerGetStateHandler(handler: OnGetHandler | null): void;
-    getState(key: string): SyncStateValue;
-    setState(value: SyncStateValue, key: string): void;
-    subscribe(key: string, client: RpcStub<(value: SyncStateValue) => void>): void;
-    unsubscribe(key: string, client: RpcStub<(value: SyncStateValue) => void>): void;
-}
-export {};

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

@@ -1,20 +0,0 @@
-import { React } from "../runtime/client/client";
-type HookDeps = {
-    useState: typeof React.useState;
-    useEffect: typeof React.useEffect;
-    useRef: typeof React.useRef;
-    useCallback: typeof React.useCallback;
-};
-type Setter<T> = (value: T | ((previous: T) => T)) => void;
-export type CreateSyncStateHookOptions = {
-    url?: string;
-    hooks?: HookDeps;
-};
-/**
- * Builds a `useSyncedState` hook configured with optional endpoint and hook overrides.
- * @param options Optional overrides for endpoint and React primitives.
- * @returns Hook that syncs state through the sync state service.
- */
-export declare const createSyncStateHook: (options?: CreateSyncStateHookOptions) => <T>(initialValue: T, key: string) => [T, Setter<T>];
-export declare const useSyncedState: <T>(initialValue: T, key: string) => [T, Setter<T>];
-export {};

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

@@ -1,58 +0,0 @@
-import { React } from "../runtime/client/client";
-import { getSyncStateClient } from "./client";
-import { DEFAULT_SYNC_STATE_PATH } from "./constants.mjs";
-const defaultDeps = {
-    useState: React.useState,
-    useEffect: React.useEffect,
-    useRef: React.useRef,
-    useCallback: React.useCallback,
-};
-/**
- * Builds a `useSyncedState` hook configured with optional endpoint and hook overrides.
- * @param options Optional overrides for endpoint and React primitives.
- * @returns Hook that syncs state through the sync state service.
- */
-export const createSyncStateHook = (options = {}) => {
-    const resolvedUrl = options.url ?? DEFAULT_SYNC_STATE_PATH;
-    const deps = options.hooks ?? defaultDeps;
-    const { useState, useEffect, useRef, useCallback } = deps;
-    return function useSyncedState(initialValue, key) {
-        if (typeof window === "undefined" && !options.hooks) {
-            return [initialValue, () => { }];
-        }
-        const client = getSyncStateClient(resolvedUrl);
-        const [value, setValue] = useState(initialValue);
-        const valueRef = useRef(value);
-        valueRef.current = value;
-        const setSyncValue = useCallback((nextValue) => {
-            const resolved = typeof nextValue === "function"
-                ? nextValue(valueRef.current)
-                : nextValue;
-            setValue(resolved);
-            valueRef.current = resolved;
-            void client.setState(resolved, key);
-        }, [client, key, setValue, valueRef]);
-        useEffect(() => {
-            let isActive = true;
-            const handleUpdate = (next) => {
-                if (isActive) {
-                    setValue(next);
-                    valueRef.current = next;
-                }
-            };
-            void client.getState(key).then((existing) => {
-                if (existing !== undefined && isActive) {
-                    setValue(existing);
-                    valueRef.current = existing;
-                }
-            });
-            void client.subscribe(key, handleUpdate);
-            return () => {
-                isActive = false;
-                void client.unsubscribe(key, handleUpdate);
-            };
-        }, [client, key, setValue, valueRef]);
-        return [value, setSyncValue];
-    };
-};
-export const useSyncedState = createSyncStateHook();