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

package/dist/runtime/lib/router.test.js

@@ -1,6 +1,6 @@
 import React from "react";
 import { describe, expect, it } from "vitest";
-import { defineRoutes, layout, matchPath, prefix, render, route, } from "./router";
+import { defineRoutes, except, layout, matchPath, prefix, render, route, } from "./router";
 describe("matchPath", () => {
     // Test case 1: Static paths
     it("should match static paths", () => {
@@ -62,6 +62,7 @@ describe("defineRoutes - Request Handling Behavior", () => {
     const createMockDependencies = () => {
         const mockRequestInfo = {
             request: new Request("http://localhost:3000/"),
+            path: "/",
             params: {},
             ctx: {},
             rw: {
@@ -293,6 +294,109 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(executionOrder).toEqual(["prefixedMiddleware"]);
             expect(await response.text()).toBe("From prefixed middleware");
         });
+        it("should pass prefix parameters to route handlers", async () => {
+            let capturedParams = null;
+            const TaskDetailPage = (requestInfo) => {
+                capturedParams = requestInfo.params;
+                return React.createElement("div", {}, "Task Detail");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [route("/", TaskDetailPage)]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParams).toEqual({ containerId: "123" });
+        });
+        it("should pass prefix parameters to middlewares within a parameterized prefix", async () => {
+            const executionOrder = [];
+            let capturedParams = null;
+            const prefixedMiddleware = (requestInfo) => {
+                executionOrder.push("prefixedMiddleware");
+                capturedParams = requestInfo.params;
+            };
+            const PageComponent = () => {
+                executionOrder.push("PageComponent");
+                return React.createElement("div", {}, "Page");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [
+                    prefixedMiddleware,
+                    route("/", PageComponent),
+                ]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["prefixedMiddleware", "PageComponent"]);
+            // The wildcard captures the trailing slash as an empty string
+            expect(capturedParams).toEqual({ containerId: "123", $0: "" });
+        });
+        it("should pass prefix parameters to route handlers (array)", async () => {
+            let capturedParamsInMiddleware = null;
+            let capturedParamsInComponent = null;
+            const middleware = (requestInfo) => {
+                capturedParamsInMiddleware = requestInfo.params;
+            };
+            const Component = (requestInfo) => {
+                capturedParamsInComponent = requestInfo.params;
+                return React.createElement("div", {}, "Component");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [route("/", [middleware, Component])]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParamsInMiddleware).toEqual({ containerId: "123" });
+            expect(capturedParamsInComponent).toEqual({ containerId: "123" });
+        });
+        it("should match even if prefix has a trailing slash", async () => {
+            let capturedParams = null;
+            const TaskDetailPage = (requestInfo) => {
+                capturedParams = requestInfo.params;
+                return React.createElement("div", {}, "Task Detail");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId/", [route("/", TaskDetailPage)]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParams).toEqual({ containerId: "123" });
+        });
     });
     describe("RSC Action Handling", () => {
         it("should handle RSC actions before the first route definition", async () => {
@@ -884,4 +988,242 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(await response.text()).toBe("Rendered: Element");
         });
     });
+    describe("except - Error Handling", () => {
+        it("should catch errors from global middleware", async () => {
+            const errorMessage = "Middleware error";
+            const middleware = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                middleware,
+                errorHandler,
+                route("/test/", () => React.createElement("div")),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from route handlers (components)", async () => {
+            const errorMessage = "Component error";
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from route handlers (functions)", async () => {
+            const errorMessage = "Handler error";
+            const routeHandler = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", routeHandler),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from RSC actions", async () => {
+            const errorMessage = "RSC action error";
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", () => React.createElement("div")),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/?__rsc_action_id=test");
+            deps.mockRscActionHandler = async () => {
+                throw new Error(errorMessage);
+            };
+            const request = new Request("http://localhost:3000/test/?__rsc_action_id=test");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should use the most recent except handler before the error", async () => {
+            const errorMessage = "Route error";
+            const firstHandler = except((error) => {
+                return new Response("First handler", { status: 500 });
+            });
+            const secondHandler = except((error) => {
+                return new Response("Second handler", { status: 500 });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                firstHandler,
+                secondHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            // Should use the second handler (most recent before the route)
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe("Second handler");
+        });
+        it("should try next except handler if current one throws", async () => {
+            const errorMessage = "Route error";
+            const firstHandler = except(() => {
+                throw new Error("First handler error");
+            });
+            const secondHandler = except((error) => {
+                return new Response(`Caught by second: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                secondHandler, // Outer handler
+                firstHandler, // Inner handler (closer to route)
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            // Should catch the error from the first handler with the second handler
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe("Caught by second: First handler error");
+        });
+        it("should return JSX element from except handler", async () => {
+            const errorMessage = "Route error";
+            function ErrorComponent() {
+                return React.createElement("div", {}, "Error Page");
+            }
+            const errorHandler = except(() => {
+                return React.createElement(ErrorComponent);
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("Rendered: ErrorComponent");
+        });
+        it("should work with prefix and layout", async () => {
+            const errorMessage = "Route error";
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const Layout = ({ children }) => {
+                return React.createElement("div", {}, children);
+            };
+            const router = defineRoutes([
+                errorHandler,
+                layout(Layout, [prefix("/api", [route("/test/", PageComponent)])]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/api/test/");
+            const request = new Request("http://localhost:3000/api/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+    });
 });

package/dist/runtime/requestInfo/types.d.ts

@@ -3,6 +3,7 @@ export interface DefaultAppContext {
 }
 export interface RequestInfo<Params = any, AppContext = DefaultAppContext> {
     request: Request;
+    path: string;
     params: Params;
     ctx: AppContext;
     rw: RwContext;

package/dist/runtime/requestInfo/utils.js

@@ -9,6 +9,7 @@ export const constructWithDefaultRequestInfo = (overrides = {}) => {
     const { rw: rwOverrides, ...otherRequestInfoOverrides } = overrides;
     const defaultRequestInfo = {
         request: new Request("http://localhost/"),
+        path: "/",
         params: {},
         ctx: {},
         cf: {

package/dist/runtime/requestInfo/worker.js

@@ -17,7 +17,8 @@ export const requestInfo = Object.freeze(requestInfoBase);
 export function getRequestInfo() {
     const store = requestInfoStore.getStore();
     if (!store) {
-        throw new Error("Request context not found");
+        throw new Error("RedwoodSDK: Request context not found. getRequestInfo() can only be called within the request lifecycle (e.g., in a route handler, middleware, or server action).\n\n" +
+            "For detailed troubleshooting steps, see: https://docs.rwsdk.com/guides/troubleshooting#request-context-errors");
     }
     return store;
 }

package/dist/runtime/worker.js

@@ -11,11 +11,11 @@ import { defineRoutes } from "./lib/router";
 import { generateNonce } from "./lib/utils";
 export * from "./requestInfo/types";
 export const defineApp = (routes) => {
+    const router = defineRoutes(routes);
     return {
         __rwRoutes: routes,
         fetch: async (request, env, cf) => {
             globalThis.__webpack_require__ = ssrWebpackRequire;
-            const router = defineRoutes(routes);
             // context(justinvdm, 5 Feb 2025): Serve assets requests using the assets service binding
             // todo(justinvdm, 5 Feb 2025): Find a way to avoid this so asset requests are served directly
             // rather than first needing to go through the worker
@@ -63,6 +63,10 @@ export const defineApp = (routes) => {
             }
             try {
                 const url = new URL(request.url);
+                let path = url.pathname;
+                if (path !== "/" && !path.endsWith("/")) {
+                    path = path + "/";
+                }
                 const isRSCRequest = url.searchParams.has("__rsc") ||
                     request.headers.get("accept")?.includes("text/x-component");
                 const isAction = url.searchParams.has("__rsc_action_id");
@@ -83,6 +87,7 @@ export const defineApp = (routes) => {
                 };
                 const outerRequestInfo = {
                     request,
+                    path,
                     cf,
                     params: {},
                     ctx: {},

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

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

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

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _a, _SyncedStateServer_keyHandler, _SyncedStateServer_setStateHandler, _SyncedStateServer_getStateHandler, _SyncedStateServer_stateStore, _SyncedStateServer_subscriptions, _SyncedStateServer_subscriptionRefs, _CoordinatorApi_coordinator;
+var _SyncedStateServer_instances, _a, _SyncedStateServer_keyHandler, _SyncedStateServer_roomHandler, _SyncedStateServer_setStateHandler, _SyncedStateServer_getStateHandler, _SyncedStateServer_subscribeHandler, _SyncedStateServer_unsubscribeHandler, _SyncedStateServer_namespace, _SyncedStateServer_durableObjectName, _SyncedStateServer_stub, _SyncedStateServer_stateStore, _SyncedStateServer_subscriptions, _SyncedStateServer_subscriptionRefs, _SyncedStateServer_getStubForHandlers, _CoordinatorApi_coordinator, _CoordinatorApi_stub;
 import { RpcTarget, newWorkersRpcResponse } from "capnweb";
 import { DurableObject } from "cloudflare:workers";
 /**
@@ -18,6 +18,8 @@ import { DurableObject } from "cloudflare:workers";
 export class SyncedStateServer extends DurableObject {
     constructor() {
         super(...arguments);
+        _SyncedStateServer_instances.add(this);
+        _SyncedStateServer_stub.set(this, null);
         _SyncedStateServer_stateStore.set(this, new Map());
         _SyncedStateServer_subscriptions.set(this, new Map());
         _SyncedStateServer_subscriptionRefs.set(this, new Map());
@@ -28,23 +30,62 @@ export class SyncedStateServer extends DurableObject {
     static getKeyHandler() {
         return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_keyHandler);
     }
+    static registerRoomHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_roomHandler);
+    }
+    static getRoomHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_roomHandler);
+    }
+    static registerNamespace(namespace, durableObjectName) {
+        __classPrivateFieldSet(_a, _a, namespace, "f", _SyncedStateServer_namespace);
+        if (durableObjectName) {
+            __classPrivateFieldSet(_a, _a, durableObjectName, "f", _SyncedStateServer_durableObjectName);
+        }
+    }
+    static getNamespace() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_namespace);
+    }
+    static getDurableObjectName() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_durableObjectName);
+    }
+    setStub(stub) {
+        __classPrivateFieldSet(this, _SyncedStateServer_stub, stub, "f");
+    }
     static registerSetStateHandler(handler) {
         __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_setStateHandler);
     }
     static registerGetStateHandler(handler) {
         __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_getStateHandler);
     }
+    static registerSubscribeHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_subscribeHandler);
+    }
+    static registerUnsubscribeHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_unsubscribeHandler);
+    }
+    static getSubscribeHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_subscribeHandler);
+    }
+    static getUnsubscribeHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_unsubscribeHandler);
+    }
     getState(key) {
         const value = __classPrivateFieldGet(this, _SyncedStateServer_stateStore, "f").get(key);
         if (__classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler)) {
-            __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler).call(_a, key, value);
+            const stub = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getStubForHandlers).call(this);
+            if (stub) {
+                __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler).call(_a, key, value, stub);
+            }
         }
         return value;
     }
     setState(value, key) {
         __classPrivateFieldGet(this, _SyncedStateServer_stateStore, "f").set(key, value);
         if (__classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler)) {
-            __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler).call(_a, key, value);
+            const stub = __classPrivateFieldGet(this, _SyncedStateServer_instances, "m", _SyncedStateServer_getStubForHandlers).call(this);
+            if (stub) {
+                __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler).call(_a, key, value, stub);
+            }
         }
         const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key);
         if (!subscribers) {
@@ -78,7 +119,9 @@ export class SyncedStateServer extends DurableObject {
         if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").has(key)) {
             __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").set(key, new Map());
         }
-        const duplicate = client.dup();
+        const duplicate = typeof client.dup === "function"
+            ? client.dup()
+            : client;
         __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key).add(duplicate);
         __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key).set(client, duplicate);
     }
@@ -98,19 +141,44 @@ export class SyncedStateServer extends DurableObject {
         }
     }
     async fetch(request) {
-        const api = new CoordinatorApi(this);
+        // Create a placeholder stub - it will be set by the worker via _setStub
+        const api = new CoordinatorApi(this, __classPrivateFieldGet(this, _SyncedStateServer_stub, "f") || {});
         return newWorkersRpcResponse(request, api);
     }
 }
-_a = SyncedStateServer, _SyncedStateServer_stateStore = new WeakMap(), _SyncedStateServer_subscriptions = new WeakMap(), _SyncedStateServer_subscriptionRefs = new WeakMap();
+_a = SyncedStateServer, _SyncedStateServer_stub = new WeakMap(), _SyncedStateServer_stateStore = new WeakMap(), _SyncedStateServer_subscriptions = new WeakMap(), _SyncedStateServer_subscriptionRefs = new WeakMap(), _SyncedStateServer_instances = new WeakSet(), _SyncedStateServer_getStubForHandlers = function _SyncedStateServer_getStubForHandlers() {
+    // If we have a stub already, use it
+    if (__classPrivateFieldGet(this, _SyncedStateServer_stub, "f")) {
+        return __classPrivateFieldGet(this, _SyncedStateServer_stub, "f");
+    }
+    // Otherwise, try to get a stub from the registered namespace using our own ID
+    const namespace = __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_namespace);
+    if (namespace) {
+        return namespace.get(this.ctx.id);
+    }
+    return null;
+};
 _SyncedStateServer_keyHandler = { value: null };
+_SyncedStateServer_roomHandler = { value: null };
 _SyncedStateServer_setStateHandler = { value: null };
 _SyncedStateServer_getStateHandler = { value: null };
+_SyncedStateServer_subscribeHandler = { value: null };
+_SyncedStateServer_unsubscribeHandler = { value: null };
+_SyncedStateServer_namespace = { value: null };
+_SyncedStateServer_durableObjectName = { value: "syncedState" };
 class CoordinatorApi extends RpcTarget {
-    constructor(coordinator) {
+    constructor(coordinator, stub) {
         super();
         _CoordinatorApi_coordinator.set(this, void 0);
+        _CoordinatorApi_stub.set(this, void 0);
         __classPrivateFieldSet(this, _CoordinatorApi_coordinator, coordinator, "f");
+        __classPrivateFieldSet(this, _CoordinatorApi_stub, stub, "f");
+        coordinator.setStub(stub);
+    }
+    // Internal method to set the stub - called from worker
+    _setStub(stub) {
+        __classPrivateFieldSet(this, _CoordinatorApi_stub, stub, "f");
+        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").setStub(stub);
     }
     getState(key) {
         return __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").getState(key);
@@ -125,4 +193,4 @@ class CoordinatorApi extends RpcTarget {
         __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").unsubscribe(key, client);
     }
 }
-_CoordinatorApi_coordinator = new WeakMap();
+_CoordinatorApi_coordinator = new WeakMap(), _CoordinatorApi_stub = new WeakMap();