rwsdk 1.0.0-beta.42 → 1.0.0-beta.44

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

@@ -46,9 +46,12 @@ describe("SyncedStateServer", () => {
     });
     it("invokes registered onSet handler", () => {
         const coordinator = new SyncedStateServer({}, {});
+        const mockStub = {};
+        coordinator.setStub(mockStub);
         const calls = [];
-        SyncedStateServer.registerSetStateHandler((key, value) => {
+        SyncedStateServer.registerSetStateHandler((key, value, stub) => {
             calls.push({ key, value });
+            expect(stub).toBe(mockStub);
         });
         coordinator.setState(2, "counter");
         expect(calls).toEqual([{ key: "counter", value: 2 }]);
@@ -56,9 +59,12 @@ describe("SyncedStateServer", () => {
     });
     it("invokes registered onGet handler", () => {
         const coordinator = new SyncedStateServer({}, {});
+        const mockStub = {};
+        coordinator.setStub(mockStub);
         const calls = [];
-        SyncedStateServer.registerGetStateHandler((key, value) => {
+        SyncedStateServer.registerGetStateHandler((key, value, stub) => {
             calls.push({ key, value });
+            expect(stub).toBe(mockStub);
         });
         coordinator.setState(4, "counter");
         expect(coordinator.getState("counter")).toBe(4);
@@ -66,43 +72,44 @@ describe("SyncedStateServer", () => {
         SyncedStateServer.registerGetStateHandler(null);
     });
     describe("registerKeyHandler", () => {
+        const mockStub = {};
         afterEach(() => {
-            SyncedStateServer.registerKeyHandler(async (key) => key);
+            SyncedStateServer.registerKeyHandler(async (key, stub) => key);
         });
         it("stores and retrieves the registered handler", async () => {
-            const handler = async (key) => `transformed:${key}`;
+            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) => `user:123:${key}`;
+            const handler = async (key, stub) => `user:123:${key}`;
             SyncedStateServer.registerKeyHandler(handler);
-            const result = await handler("counter");
+            const result = await handler("counter", mockStub);
             expect(result).toBe("user:123:counter");
         });
         it("returns null when no handler is registered", () => {
-            SyncedStateServer.registerKeyHandler(async (key) => key);
+            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) => {
+            const handler = async (key, stub) => {
                 await new Promise((resolve) => setTimeout(resolve, 10));
                 return `async:${key}`;
             };
             SyncedStateServer.registerKeyHandler(handler);
-            const result = await handler("test");
+            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) => {
+            const handler = async (key, stub) => {
                 receivedKey = key;
                 return key;
             };
             SyncedStateServer.registerKeyHandler(handler);
-            await handler("myKey");
+            await handler("myKey", mockStub);
             expect(receivedKey).toBe("myKey");
         });
     });

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

@@ -18,52 +18,53 @@ describe("SyncedStateProxy", () => {
     beforeEach(() => {
         mockCoordinator = new SyncedStateServer({}, {});
     });
+    const mockStub = {};
     afterEach(() => {
-        SyncedStateServer.registerKeyHandler(async (key) => key);
+        SyncedStateServer.registerKeyHandler(async (key, stub) => key);
     });
     it("transforms keys before calling coordinator methods when handler is registered", async () => {
-        const handler = async (key) => `transformed:${key}`;
+        const handler = async (key, stub) => `transformed:${key}`;
         SyncedStateServer.registerKeyHandler(handler);
-        const transformedKey = await handler("counter");
+        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) => key);
+        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) => key;
+        const handler = async (key, stub) => key;
         SyncedStateServer.registerKeyHandler(handler);
-        const result = await handler("counter");
+        const result = await handler("counter", mockStub);
         expect(result).toBe("counter");
     });
     it("handler can scope keys per user", async () => {
-        const handler = async (key) => {
+        const handler = async (key, stub) => {
             const userId = "user123";
             return `user:${userId}:${key}`;
         };
         SyncedStateServer.registerKeyHandler(handler);
-        const result = await handler("settings");
+        const result = await handler("settings", mockStub);
         expect(result).toBe("user:user123:settings");
     });
     it("allows errors from handler to propagate", async () => {
-        const handler = async (_key) => {
+        const handler = async (_key, stub) => {
             throw new Error("Handler error");
         };
         SyncedStateServer.registerKeyHandler(handler);
-        await expect(handler("test")).rejects.toThrow("Handler error");
+        await expect(handler("test", mockStub)).rejects.toThrow("Handler error");
     });
     it("handles async operations in handler", async () => {
-        const handler = async (key) => {
+        const handler = async (key, stub) => {
             await new Promise((resolve) => setTimeout(resolve, 5));
             return `async:${key}`;
         };
         SyncedStateServer.registerKeyHandler(handler);
-        const result = await handler("data");
+        const result = await handler("data", mockStub);
         expect(result).toBe("async:data");
     });
 });

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

@@ -6,12 +6,14 @@ export type SyncedStateClient = {
 };
 /**
  * Returns a cached client for the provided endpoint, creating it when necessary.
+ * The client is wrapped to track subscriptions for cleanup on page reload.
  * @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.
+ * The client is wrapped to track subscriptions for cleanup on page reload.
  * @param options Optional endpoint override.
  * @returns Cached client instance or `null` when running without `window`.
  */
@@ -20,6 +22,7 @@ export declare const initSyncedStateClient: (options?: {
 }) => SyncedStateClient | null;
 /**
  * Injects a client instance for tests and updates the cached endpoint.
+ * Also clears the subscription registry for test isolation.
  * @param client Stub client instance or `null` to clear the cache.
  * @param endpoint Endpoint associated with the injected client.
  */

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

@@ -1,39 +1,103 @@
 import { newWebSocketRpcSession } from "capnweb";
 import { DEFAULT_SYNCED_STATE_PATH } from "./constants.mjs";
-let cachedClient = null;
-let cachedEndpoint = DEFAULT_SYNCED_STATE_PATH;
+// Map of endpoint URLs to their respective clients
+const clientCache = new Map();
+const activeSubscriptions = new Set();
+// Set up beforeunload handler to unsubscribe all active subscriptions
+if (typeof window !== "undefined") {
+    const handleBeforeUnload = () => {
+        if (activeSubscriptions.size === 0) {
+            return;
+        }
+        // Unsubscribe all active subscriptions
+        // Use a synchronous approach where possible, but don't block page unload
+        const subscriptions = Array.from(activeSubscriptions);
+        activeSubscriptions.clear();
+        // Fire-and-forget unsubscribe calls - we can't await during beforeunload
+        for (const { key, handler, client } of subscriptions) {
+            void client.unsubscribe(key, handler).catch(() => {
+                // Ignore errors during page unload - the connection will be closed anyway
+            });
+        }
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+}
 /**
  * Returns a cached client for the provided endpoint, creating it when necessary.
+ * The client is wrapped to track subscriptions for cleanup on page reload.
  * @param endpoint Endpoint to connect to.
  * @returns RPC client instance.
  */
-export const getSyncedStateClient = (endpoint = cachedEndpoint) => {
-    if (cachedClient && endpoint === cachedEndpoint) {
-        return cachedClient;
+export const getSyncedStateClient = (endpoint = DEFAULT_SYNCED_STATE_PATH) => {
+    // Return existing client if already cached for this endpoint
+    const existingClient = clientCache.get(endpoint);
+    if (existingClient) {
+        return existingClient;
     }
-    cachedEndpoint = endpoint;
-    cachedClient = newWebSocketRpcSession(cachedEndpoint);
-    return cachedClient;
+    const baseClient = newWebSocketRpcSession(endpoint);
+    // Wrap the client using a Proxy to track subscriptions
+    // The RPC client uses dynamic property access, so we can't use .bind()
+    const wrappedClient = new Proxy(baseClient, {
+        get(target, prop) {
+            if (prop === "subscribe") {
+                return async (key, handler) => {
+                    const subscription = {
+                        key,
+                        handler,
+                        client: wrappedClient,
+                    };
+                    activeSubscriptions.add(subscription);
+                    return target[prop](key, handler);
+                };
+            }
+            if (prop === "unsubscribe") {
+                return async (key, handler) => {
+                    // Find and remove the subscription
+                    for (const sub of activeSubscriptions) {
+                        if (sub.key === key &&
+                            sub.handler === handler &&
+                            sub.client === wrappedClient) {
+                            activeSubscriptions.delete(sub);
+                            break;
+                        }
+                    }
+                    return target[prop](key, handler);
+                };
+            }
+            // Pass through all other properties/methods
+            return target[prop];
+        },
+    });
+    // Cache the client for this endpoint
+    clientCache.set(endpoint, wrappedClient);
+    return wrappedClient;
 };
 /**
  * Initializes and caches an RPC client instance for the sync state endpoint.
+ * The client is wrapped to track subscriptions for cleanup on page reload.
  * @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;
+    const endpoint = options.endpoint ?? DEFAULT_SYNCED_STATE_PATH;
     if (typeof window === "undefined") {
         return null;
     }
-    cachedClient = newWebSocketRpcSession(cachedEndpoint);
-    return cachedClient;
+    // Use getSyncedStateClient which now handles caching via Map
+    return getSyncedStateClient(endpoint);
 };
 /**
  * Injects a client instance for tests and updates the cached endpoint.
+ * Also clears the subscription registry for test isolation.
  * @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;
+    if (client) {
+        clientCache.set(endpoint, client);
+    }
+    else {
+        clientCache.delete(endpoint);
+    }
+    activeSubscriptions.clear();
 };

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

@@ -8,6 +8,7 @@ type HookDeps = {
 type Setter<T> = (value: T | ((previous: T) => T)) => void;
 export type CreateSyncedStateHookOptions = {
     url?: string;
+    roomId?: string;
     hooks?: HookDeps;
 };
 /**
@@ -15,6 +16,6 @@ export type CreateSyncedStateHookOptions = {
  * @param options Optional overrides for endpoint and React primitives.
  * @returns Hook that syncs state through the sync state service.
  */
-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 declare const createSyncedStateHook: (options?: CreateSyncedStateHookOptions) => <T>(initialValue: T, key: string, roomId?: string | undefined) => [T, Setter<T>];
+export declare const useSyncedState: <T>(initialValue: T, key: string, roomId?: string | undefined) => [T, Setter<T>];
 export {};

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

@@ -13,13 +13,14 @@ const defaultDeps = {
  * @returns Hook that syncs state through the sync state service.
  */
 export const createSyncedStateHook = (options = {}) => {
-    const resolvedUrl = options.url ?? DEFAULT_SYNCED_STATE_PATH;
+    const basePath = options.url ?? DEFAULT_SYNCED_STATE_PATH;
     const deps = options.hooks ?? defaultDeps;
     const { useState, useEffect, useRef, useCallback } = deps;
-    return function useSyncedState(initialValue, key) {
+    return function useSyncedState(initialValue, key, roomId = options.roomId) {
         if (typeof window === "undefined" && !options.hooks) {
             return [initialValue, () => { }];
         }
+        const resolvedUrl = roomId ? `${basePath}/${roomId}` : basePath;
         const client = getSyncedStateClient(resolvedUrl);
         const [value, setValue] = useState(initialValue);
         const valueRef = useRef(value);
@@ -49,7 +50,12 @@ export const createSyncedStateHook = (options = {}) => {
             void client.subscribe(key, handleUpdate);
             return () => {
                 isActive = false;
-                void client.unsubscribe(key, handleUpdate);
+                // Call unsubscribe when component unmounts
+                // Page reloads are handled by the beforeunload event listener in client-core.ts
+                void client.unsubscribe(key, handleUpdate).catch((error) => {
+                    // Log but don't throw - cleanup should not prevent unmounting
+                    console.error("[useSyncedState] Error during unsubscribe:", error);
+                });
             };
         }, [client, key, setValue, valueRef]);
         return [value, setSyncValue];

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

@@ -1,3 +1,4 @@
+import type { RequestInfo } from "../runtime/requestInfo/types";
 import { SyncedStateServer } from "./SyncedStateServer.mjs";
 export { SyncedStateServer };
 export type SyncedStateRouteOptions = {
@@ -10,4 +11,4 @@ export type SyncedStateRouteOptions = {
  * @param options Optional overrides for base path and object name.
  * @returns Router entries for the sync state API.
  */
-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>>[];
+export declare const syncedStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncedStateServer>, options?: SyncedStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<`/${string}`, RequestInfo<any, import("../runtime/requestInfo/types").DefaultAppContext>>[];

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

@@ -9,40 +9,91 @@ 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 _SyncedStateProxy_stub, _SyncedStateProxy_keyHandler;
+var _SyncedStateProxy_instances, _SyncedStateProxy_stub, _SyncedStateProxy_keyHandler, _SyncedStateProxy_requestInfo, _SyncedStateProxy_transformKey, _SyncedStateProxy_callHandler;
 import { RpcTarget, newWorkersRpcResponse } from "capnweb";
 import { env } from "cloudflare:workers";
 import { route } from "../runtime/entries/router";
+import { runWithRequestInfo } from "../runtime/requestInfo/worker";
 import { SyncedStateServer, } from "./SyncedStateServer.mjs";
 import { DEFAULT_SYNCED_STATE_PATH } from "./constants.mjs";
 export { SyncedStateServer };
 const DEFAULT_SYNC_STATE_NAME = "syncedState";
 class SyncedStateProxy extends RpcTarget {
-    constructor(stub, keyHandler) {
+    constructor(stub, keyHandler, requestInfo) {
         super();
+        _SyncedStateProxy_instances.add(this);
         _SyncedStateProxy_stub.set(this, void 0);
         _SyncedStateProxy_keyHandler.set(this, void 0);
+        _SyncedStateProxy_requestInfo.set(this, void 0);
         __classPrivateFieldSet(this, _SyncedStateProxy_stub, stub, "f");
         __classPrivateFieldSet(this, _SyncedStateProxy_keyHandler, keyHandler, "f");
+        __classPrivateFieldSet(this, _SyncedStateProxy_requestInfo, requestInfo, "f");
+        // Set stub in DO instance so handlers can access it
+        if (stub && typeof stub._setStub === "function") {
+            void stub._setStub(stub);
+        }
     }
     async getState(key) {
-        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        const transformedKey = await __classPrivateFieldGet(this, _SyncedStateProxy_instances, "m", _SyncedStateProxy_transformKey).call(this, key);
         return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").getState(transformedKey);
     }
     async setState(value, key) {
-        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        const transformedKey = await __classPrivateFieldGet(this, _SyncedStateProxy_instances, "m", _SyncedStateProxy_transformKey).call(this, key);
         return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").setState(value, transformedKey);
     }
     async subscribe(key, 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);
+        const transformedKey = await __classPrivateFieldGet(this, _SyncedStateProxy_instances, "m", _SyncedStateProxy_transformKey).call(this, key);
+        const subscribeHandler = SyncedStateServer.getSubscribeHandler();
+        if (subscribeHandler) {
+            __classPrivateFieldGet(this, _SyncedStateProxy_instances, "m", _SyncedStateProxy_callHandler).call(this, subscribeHandler, transformedKey, __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f"));
+        }
+        // dup the client if it is a function; otherwise, pass it as is;
+        // this is because the client is a WebSocketRpcSession, and we need to pass a new instance of the client to the DO;
+        const clientToPass = typeof client.dup === "function" ? client.dup() : client;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").subscribe(transformedKey, clientToPass);
     }
     async unsubscribe(key, 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);
+        const transformedKey = await __classPrivateFieldGet(this, _SyncedStateProxy_instances, "m", _SyncedStateProxy_transformKey).call(this, key);
+        // Call unsubscribe handler before unsubscribe, similar to subscribe handler
+        // This ensures the handler is called even if the unsubscribe doesn't find a match
+        // or if the RPC call fails
+        const unsubscribeHandler = SyncedStateServer.getUnsubscribeHandler();
+        if (unsubscribeHandler) {
+            __classPrivateFieldGet(this, _SyncedStateProxy_instances, "m", _SyncedStateProxy_callHandler).call(this, unsubscribeHandler, transformedKey, __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f"));
+        }
+        try {
+            await __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").unsubscribe(transformedKey, client);
+        }
+        catch (error) {
+            // Ignore errors during unsubscribe - handler has already been called
+            // This prevents RPC stub disposal errors from propagating
+        }
     }
 }
-_SyncedStateProxy_stub = new WeakMap(), _SyncedStateProxy_keyHandler = new WeakMap();
+_SyncedStateProxy_stub = new WeakMap(), _SyncedStateProxy_keyHandler = new WeakMap(), _SyncedStateProxy_requestInfo = new WeakMap(), _SyncedStateProxy_instances = new WeakSet(), _SyncedStateProxy_transformKey = 
+/**
+ * Transforms a key using the keyHandler, preserving async context so requestInfo.ctx is available.
+ */
+async function _SyncedStateProxy_transformKey(key) {
+    if (!__classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f")) {
+        return key;
+    }
+    if (__classPrivateFieldGet(this, _SyncedStateProxy_requestInfo, "f")) {
+        // Preserve async context when calling keyHandler so requestInfo.ctx is available
+        return await runWithRequestInfo(__classPrivateFieldGet(this, _SyncedStateProxy_requestInfo, "f"), async () => await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f")(key, __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f")));
+    }
+    return await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key, __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f"));
+}, _SyncedStateProxy_callHandler = function _SyncedStateProxy_callHandler(handler, key, stub) {
+    if (__classPrivateFieldGet(this, _SyncedStateProxy_requestInfo, "f")) {
+        // Preserve async context when calling handler so requestInfo.ctx is available
+        runWithRequestInfo(__classPrivateFieldGet(this, _SyncedStateProxy_requestInfo, "f"), () => {
+            handler(key, stub);
+        });
+    }
+    else {
+        handler(key, stub);
+    }
+};
 /**
  * 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.
@@ -52,18 +103,33 @@ _SyncedStateProxy_stub = new WeakMap(), _SyncedStateProxy_keyHandler = new WeakM
 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 forwardRequest = async (request, requestInfo) => {
+        const namespace = getNamespace(env);
+        // Register the namespace and DO name so handlers can access it
+        SyncedStateServer.registerNamespace(namespace, durableObjectName);
         const keyHandler = SyncedStateServer.getKeyHandler();
+        const roomHandler = SyncedStateServer.getRoomHandler();
+        // Get the room ID from the URL parameter, or undefined if not present
+        const idParam = requestInfo.params?.id;
+        // Resolve the room name using the roomHandler if present, otherwise use the param or default
+        let resolvedRoomName;
+        if (roomHandler) {
+            resolvedRoomName = await runWithRequestInfo(requestInfo, async () => await roomHandler(idParam, requestInfo));
+        }
+        else {
+            resolvedRoomName = idParam ?? durableObjectName;
+        }
         if (!keyHandler) {
-            const namespace = getNamespace(env);
-            const id = namespace.idFromName(durableObjectName);
+            const id = namespace.idFromName(resolvedRoomName);
             return namespace.get(id).fetch(request);
         }
-        const namespace = getNamespace(env);
-        const id = namespace.idFromName(durableObjectName);
+        const id = namespace.idFromName(resolvedRoomName);
         const coordinator = namespace.get(id);
-        const proxy = new SyncedStateProxy(coordinator, keyHandler);
+        const proxy = new SyncedStateProxy(coordinator, keyHandler, requestInfo);
         return newWorkersRpcResponse(request, proxy);
     };
-    return [route(basePath, ({ request }) => forwardRequest(request))];
+    return [
+        route(basePath, (requestInfo) => forwardRequest(requestInfo.request, requestInfo)),
+        route(basePath + "/:id", (requestInfo) => forwardRequest(requestInfo.request, requestInfo)),
+    ];
 };

package/dist/vite/runDirectivesScan.mjs

@@ -298,7 +298,9 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
         });
     }
     catch (e) {
-        throw new Error(`RWSDK directive scan failed:\n${e.stack}`);
+        throw new Error(`RedwoodSDK: Directive scan failed. This often happens due to syntax errors in files using "use client" or "use server". Check your directive files for issues.\n\n` +
+            `For detailed troubleshooting steps, see: https://docs.rwsdk.com/guides/troubleshooting#directive-scan-errors\n\n` +
+            `${e.stack}`);
     }
     finally {
         deferredLog("✔ (rwsdk) Done scanning for 'use client' and 'use server' directives.");

package/dist/vite/transformClientComponents.test.mjs

@@ -288,6 +288,7 @@ function SidebarGroup() { return jsx("div", {}); }
 function SidebarGroupLabel() { return jsx("div", {}); }
 function SidebarGroupAction() { return jsx("div", {}); }
 function SidebarGroupContent() { return jsx("div", {}); }
+function SidebarGroupContent() { return jsx("div", {}); }
 function SidebarMenu() { return jsx("div", {}); }
 function SidebarMenuItem() { return jsx("div", {}); }
 function SidebarMenuButton() { return jsx("div", {}); }
@@ -326,6 +327,37 @@ const SidebarSeparator = registerClientReference(SSRModule, "/test/file.tsx", "S
 const SidebarTrigger = registerClientReference(SSRModule, "/test/file.tsx", "SidebarTrigger");
 const useSidebar = registerClientReference(SSRModule, "/test/file.tsx", "useSidebar");
 export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar };
+`);
+    });
+    it("does not transform inlined functions (Issue #471)", async () => {
+        const code = `"use client"
+
+export function Stars({ level }) {
+  const renderStars = (level) => {
+    return level;
+  }
+  return renderStars(level);
+}`;
+        expect((await transform(code)) ?? "").toEqual(`import { ssrLoadModule } from "rwsdk/__ssr_bridge";
+import { registerClientReference } from "rwsdk/worker";
+const SSRModule = await ssrLoadModule("/test/file.tsx");
+const Stars = registerClientReference(SSRModule, "/test/file.tsx", "Stars");
+export { Stars };
+`);
+    });
+    it("does not transform inlined functions in default export (Issue #471)", async () => {
+        const code = `"use client"
+
+export default function Stars({ level }) {
+  const renderStars = (level) => {
+    return level;
+  }
+  return renderStars(level);
+}`;
+        expect((await transform(code)) ?? "").toEqual(`import { ssrLoadModule } from "rwsdk/__ssr_bridge";
+import { registerClientReference } from "rwsdk/worker";
+const SSRModule = await ssrLoadModule("/test/file.tsx");
+export default registerClientReference(SSRModule, "/test/file.tsx", "default");
 `);
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.42",
+  "version": "1.0.0-beta.44",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -18,13 +18,16 @@
     "build:watch": "npm run build -- --watch",
     "release": "./scripts/release.sh",
     "test": "vitest --run",
+    "bench": "vitest bench --run",
+    "bench:baseline": "vitest bench --run --outputJson=benchmarks/router-bench-baseline.json",
+    "bench:compare": "vitest bench --run --compare=benchmarks/router-bench-baseline.json",
     "debug:sync": "tsx ./src/scripts/debug-sync.mts",
     "smoke-test": "tsx ./src/scripts/smoke-test.mts"
   },
   "exports": {
     "./vite": {
-      "default": "./dist/vite/index.mjs",
-      "types": "./dist/vite/index.d.mts"
+      "types": "./dist/vite/index.d.mts",
+      "default": "./dist/vite/index.mjs"
     },
     "./worker": {
       "react-server": "./dist/runtime/entries/worker.js",
@@ -179,6 +182,7 @@
     "puppeteer-core": "~24.22.0",
     "react-is": "~19.1.0",
     "rsc-html-stream": "~0.0.6",
+    "server-only": "^0.0.1",
     "tmp-promise": "~3.0.3",
     "ts-morph": "~27.0.0",
     "unique-names-generator": "~4.7.1",