rwsdk 1.0.0-beta.30-test.20251119220440 → 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/runtime/entries/no-react-server-ssr-bridge.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("rwsdk: SSR bridge was resolved with 'react-server' condition. This is a bug - the SSR bridge should be intercepted by the esbuild plugin before reaching package.json exports. Please report this issue.");

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";