rwsdk 1.1.0 → 1.2.1

package/dist/runtime/client/navigation.d.ts

@@ -1,7 +1,7 @@
 import { type NavigationCache, type NavigationCacheStorage } from "./navigationCache.js";
 export type { NavigationCache, NavigationCacheStorage };
 export interface ClientNavigationOptions {
-    onNavigate?: () => void;
+    onNavigate?: () => Promise<void> | void;
     scrollToTop?: boolean;
     scrollBehavior?: "auto" | "smooth" | "instant";
     cacheStorage?: NavigationCacheStorage;
@@ -9,6 +9,7 @@ export interface ClientNavigationOptions {
 export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
 export interface NavigateOptions {
     history?: "push" | "replace";
+    onNavigate?: () => Promise<void> | void;
     info?: {
         scrollToTop?: boolean;
         scrollBehavior?: "auto" | "smooth" | "instant";

package/dist/runtime/client/navigation.js

@@ -32,6 +32,10 @@ export function validateClickEvent(event, target) {
     return true;
 }
 let IS_CLIENT_NAVIGATION = false;
+// Scroll intent recorded at navigation time and applied post-commit in
+// onHydrated, so the new scroll position aligns with the new DOM rather
+// than flashing on top of the old one.
+let pendingScroll = null;
 export async function navigate(href, options = { history: "push" }) {
     if (!IS_CLIENT_NAVIGATION) {
         window.location.href = href;
@@ -45,17 +49,14 @@ export async function navigate(href, options = { history: "push" }) {
     else {
         window.history.replaceState({ path: href }, "", url);
     }
-    await globalThis.__rsc_callServer(null, null, "navigation");
     const scrollToTop = options.info?.scrollToTop ?? true;
-    const scrollBehavior = options.info?.scrollBehavior ?? "instant";
-    if (scrollToTop && history.scrollRestoration === "auto") {
-        window.scrollTo({
-            top: 0,
-            left: 0,
-            behavior: scrollBehavior,
-        });
-        saveScrollPosition(0, 0);
+    const scrollBehavior = (options.info?.scrollBehavior ??
+        "instant");
+    if (scrollToTop) {
+        pendingScroll = { x: 0, y: 0, behavior: scrollBehavior };
     }
+    await options.onNavigate?.();
+    await globalThis.__rsc_callServer(null, null, "navigation");
 }
 function saveScrollPosition(x, y) {
     window.history.replaceState({
@@ -64,6 +65,14 @@ function saveScrollPosition(x, y) {
         scrollY: y,
     }, "", window.location.href);
 }
+function applyPendingScroll() {
+    if (!pendingScroll)
+        return;
+    const { x, y, behavior } = pendingScroll;
+    pendingScroll = null;
+    window.scrollTo({ top: y, left: x, behavior });
+    saveScrollPosition(x, y);
+}
 /**
  * Initializes client-side navigation for Single Page App (SPA) behavior.
  *
@@ -107,7 +116,23 @@ function saveScrollPosition(x, y) {
  */
 export function initClientNavigation(opts = {}) {
     IS_CLIENT_NAVIGATION = true;
-    history.scrollRestoration = "auto";
+    // Take manual control of scroll restoration. With "auto", the browser
+    // restores scroll immediately on popstate — before the RSC payload has
+    // committed — which causes the old DOM to flash at the new scroll offset.
+    history.scrollRestoration = "manual";
+    // If we're booting onto an entry that already has a saved scroll (e.g.
+    // a reload after scrolling, or a back-forward cache restore), queue that
+    // position so the first commit lands us where the user left off.
+    const bootState = window.history.state;
+    if (bootState &&
+        (typeof bootState.scrollX === "number" ||
+            typeof bootState.scrollY === "number")) {
+        pendingScroll = {
+            x: bootState.scrollX ?? 0,
+            y: bootState.scrollY ?? 0,
+            behavior: "instant",
+        };
+    }
     document.addEventListener("click", async function handleClickEvent(event) {
         if (!validateClickEvent(event, event.target)) {
             return;
@@ -116,11 +141,31 @@ export function initClientNavigation(opts = {}) {
         const el = event.target;
         const a = el.closest("a");
         const href = a?.getAttribute("href");
-        await navigate(href);
+        await navigate(href, { history: "push", onNavigate: opts.onNavigate });
     }, true);
     window.addEventListener("popstate", async function handlePopState() {
+        const state = window.history.state ?? {};
+        pendingScroll = {
+            x: typeof state.scrollX === "number" ? state.scrollX : 0,
+            y: typeof state.scrollY === "number" ? state.scrollY : 0,
+            behavior: "instant",
+        };
+        await opts.onNavigate?.();
         await globalThis.__rsc_callServer(null, null, "navigation");
     });
+    // Persist the user's scroll position on the current history entry so
+    // that back/forward navigation can restore it accurately once the new
+    // RSC payload commits. Coalesced via rAF to avoid thrashing replaceState.
+    let scrollSaveScheduled = false;
+    window.addEventListener("scroll", () => {
+        if (scrollSaveScheduled)
+            return;
+        scrollSaveScheduled = true;
+        requestAnimationFrame(() => {
+            scrollSaveScheduled = false;
+            saveScrollPosition(window.scrollX, window.scrollY);
+        });
+    }, { passive: true });
     function handleResponse(response) {
         if (response.status >= 300 && response.status < 400) {
             const location = response.headers.get("Location");
@@ -142,6 +187,10 @@ export function initClientNavigation(opts = {}) {
         globalThis.__rsc_cacheStorage = opts.cacheStorage;
     }
     function onHydrated() {
+        // Apply any pending scroll intent now that React has committed the new
+        // DOM — this is what prevents the scroll flash on both link-click and
+        // popstate navigations.
+        applyPendingScroll();
         // After each RSC hydration/update, increment generation and evict old caches,
         // then warm the navigation cache based on any <link rel="x-prefetch"> tags
         // rendered for the current location.

package/dist/runtime/client/navigation.test.js

@@ -75,6 +75,113 @@ describe("clientNavigation", () => {
         })).toBe(true);
     });
 });
+// Regression tests for issue #1123: onNavigate callback was never called
+// Root cause: commit c543ef7 extracted navigate() but dropped onNavigate wiring
+describe("onNavigate callback (issue #1123 regression)", () => {
+    let capturedClickHandler = null;
+    let capturedPopstateHandler = null;
+    beforeEach(() => {
+        capturedClickHandler = null;
+        capturedPopstateHandler = null;
+        vi.clearAllMocks();
+        // Capture registered event listeners so we can invoke them manually
+        vi.stubGlobal("document", {
+            addEventListener: vi.fn((event, handler) => {
+                if (event === "click")
+                    capturedClickHandler = handler;
+            }),
+        });
+        vi.stubGlobal("window", {
+            location: { href: "http://localhost/" },
+            addEventListener: vi.fn((event, handler) => {
+                if (event === "popstate")
+                    capturedPopstateHandler = handler;
+            }),
+            history: {
+                scrollRestoration: "auto",
+                pushState: vi.fn(),
+                replaceState: vi.fn(),
+                state: {},
+            },
+            scrollTo: vi.fn(),
+        });
+        vi.stubGlobal("history", {
+            scrollRestoration: "auto",
+            pushState: vi.fn(),
+            replaceState: vi.fn(),
+            state: {},
+        });
+        vi.stubGlobal("URL", class {
+            constructor(path, base) {
+                this.href = base.replace(/\/$/, "") + path;
+            }
+        });
+        // Assign directly to globalThis without replacing it (avoids breaking Vitest internals)
+        globalThis.__rsc_callServer = vi.fn().mockResolvedValue(undefined);
+    });
+    it("onNavigate is called during link click navigation", async () => {
+        const onNavigate = vi.fn();
+        initClientNavigation({ onNavigate });
+        expect(capturedClickHandler).not.toBeNull();
+        const fakeAnchor = {
+            getAttribute: (attr) => (attr === "href" ? "/about" : null),
+            hasAttribute: () => false,
+            target: "",
+            closest: (sel) => (sel === "a" ? fakeAnchor : null),
+        };
+        const fakeTarget = {
+            closest: (sel) => (sel === "a" ? fakeAnchor : null),
+        };
+        const fakeClickEvent = {
+            button: 0,
+            ctrlKey: false,
+            metaKey: false,
+            shiftKey: false,
+            altKey: false,
+            target: fakeTarget,
+            preventDefault: vi.fn(),
+        };
+        await capturedClickHandler(fakeClickEvent);
+        expect(onNavigate).toHaveBeenCalled();
+    });
+    it("onNavigate is called during popstate navigation", async () => {
+        const onNavigate = vi.fn();
+        initClientNavigation({ onNavigate });
+        expect(capturedPopstateHandler).not.toBeNull();
+        await capturedPopstateHandler();
+        expect(onNavigate).toHaveBeenCalled();
+    });
+    it("onNavigate fires after pushState but before RSC fetch", async () => {
+        const callOrder = [];
+        const onNavigate = vi.fn(() => { callOrder.push("onNavigate"); });
+        globalThis.__rsc_callServer = vi.fn(() => {
+            callOrder.push("rscCallServer");
+            return Promise.resolve();
+        });
+        initClientNavigation({ onNavigate });
+        const fakeAnchor = {
+            getAttribute: (attr) => (attr === "href" ? "/about" : null),
+            hasAttribute: () => false,
+            target: "",
+            closest: (sel) => (sel === "a" ? fakeAnchor : null),
+        };
+        const fakeTarget = {
+            closest: (sel) => (sel === "a" ? fakeAnchor : null),
+        };
+        const fakeClickEvent = {
+            button: 0,
+            ctrlKey: false,
+            metaKey: false,
+            shiftKey: false,
+            altKey: false,
+            target: fakeTarget,
+            preventDefault: vi.fn(),
+        };
+        await capturedClickHandler(fakeClickEvent);
+        expect(callOrder).toEqual(["onNavigate", "rscCallServer"]);
+        expect(window.history.pushState).toHaveBeenCalled();
+    });
+});
 describe("initClientNavigation", () => {
     beforeEach(() => {
         window.location.href = "http://localhost/";
@@ -101,4 +208,9 @@ describe("initClientNavigation", () => {
         expect(result).toBe(false);
         expect(window.location.href).toBe("http://localhost/");
     });
+    it("sets history.scrollRestoration to manual so the browser does not restore scroll before the RSC payload commits", () => {
+        history.scrollRestoration = "auto";
+        initClientNavigation();
+        expect(history.scrollRestoration).toBe("manual");
+    });
 });

package/dist/runtime/entries/types/client.d.ts

@@ -1,6 +1,6 @@
 import "./shared";
 export interface ClientNavigationOptions {
-    onNavigate?: () => void;
+    onNavigate?: () => Promise<void> | void;
     scrollToTop?: boolean;
     scrollBehavior?: "auto" | "smooth" | "instant";
 }

package/dist/runtime/lib/router.d.ts

@@ -146,7 +146,7 @@ export declare const wrapHandlerToThrowResponses: <T extends RequestInfo = Reque
  *   route("/post/:id", ({ params }) => <BlogPost id={params.id} />),
  * ])
  */
-export declare function layout<T extends RequestInfo = RequestInfo, Routes extends readonly Route<T>[] = readonly Route<T>[]>(LayoutComponent: React.FC<LayoutProps<T>>, routes: Routes): Routes;
+export declare function layout<TLayout extends RequestInfo = RequestInfo, Routes extends readonly Route<any>[] = readonly Route<any>[]>(LayoutComponent: React.FC<LayoutProps<TLayout>>, routes: Routes): Routes;
 /**
  * Wraps routes with a Document component and configures rendering options.
  *

package/dist/runtime/lib/router.js

@@ -171,7 +171,10 @@ export function defineRoutes(routes) {
                 return renderPage(requestInfo, Element, onError);
             }
             async function handleMiddlewareResult(result) {
-                if (result instanceof Response) {
+                // NOTE: instanceof fails for cross-realm Responses (e.g. Response.json()
+                // in Cloudflare's vite dev mode constructs from a different realm's
+                // prototype). Fall back to constructor.name check.
+                if (result instanceof Response || result?.constructor?.name === 'Response') {
                     return result;
                 }
                 if (result && React.isValidElement(result)) {

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

@@ -1,6 +1,6 @@
 import React from "react";
 import { describe, expect, it } from "vitest";
-import { defineRoutes, except, layout, matchPath, prefix, render, route, } from "./router";
+import { defineRoutes, except, index, layout, matchPath, prefix, render, route, } from "./router";
 describe("matchPath", () => {
     // Test case 1: Static paths
     it("should match static paths", () => {
@@ -793,6 +793,48 @@ describe("defineRoutes - Request Handling Behavior", () => {
             });
             expect(await response.text()).toBe("Rendered with layouts");
         });
+        it("should accept child routes whose params are a superset of the layout's params", async () => {
+            let capturedLayoutProps = null;
+            let capturedRouteParams = null;
+            // Layout only needs { orgId }
+            const AppLayout = (props) => {
+                capturedLayoutProps = props;
+                return React.createElement("div", { className: "app-layout" }, props.children);
+            };
+            const OrgIndex = () => {
+                return React.createElement("div", {}, "Org Index");
+            };
+            // Schedule needs { orgId, date } — a superset
+            const Schedule = (requestInfo) => {
+                capturedRouteParams = requestInfo.params;
+                return React.createElement("div", {}, `${requestInfo.params.orgId} / ${requestInfo.params.date}`);
+            };
+            const routes = prefix("/:orgId", [
+                layout(AppLayout, [
+                    index(OrgIndex),
+                    prefix("/schedule", [
+                        route("/:date", Schedule),
+                    ]),
+                ]),
+            ]);
+            const router = defineRoutes([...routes]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/acme/schedule/2025-01-15/");
+            const request = new Request("http://localhost:3000/acme/schedule/2025-01-15/");
+            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(200);
+            expect(deps.mockRequestInfo.params).toEqual({
+                orgId: "acme",
+                date: "2025-01-15",
+            });
+        });
     });
     describe("Parameter Extraction", () => {
         it("should extract path parameters and make them available in request info", async () => {
@@ -1055,6 +1097,157 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(await response.text()).toBe("GET Response");
         });
     });
+    describe("Cross-realm Response.json() handling", () => {
+        // In Cloudflare's vite dev mode, Response.json() constructs from a
+        // different realm's prototype, so `instanceof Response` fails.
+        // handleMiddlewareResult must recognize these as valid Responses.
+        //
+        // We simulate this by calling Response.json() and then stripping the
+        // prototype, which is exactly what a cross-realm boundary does: the
+        // object is a real Response but its [[Prototype]] comes from a different
+        // global, so `instanceof` against the local `Response` returns false.
+        function crossRealmResponseJson(data, init) {
+            // In workerd/vite dev mode, Response.json() constructs from a different
+            // realm's Response. The resulting object has constructor.name === "Response"
+            // but fails instanceof against the local Response global.
+            //
+            // We can't just swap the prototype in Node because V8's brand checks on
+            // Response internal slots would throw. Instead, wrap a real Response.json()
+            // result in a Proxy that fakes a foreign prototype chain — matching exactly
+            // what workerd produces: instanceof false, constructor.name "Response",
+            // all properties/methods functional.
+            const real = Response.json(data, init);
+            const foreignProto = { constructor: { name: "Response" } };
+            const proxy = new Proxy(real, {
+                get(target, prop, _receiver) {
+                    if (prop === "constructor")
+                        return foreignProto.constructor;
+                    const val = Reflect.get(target, prop, target);
+                    if (typeof val === "function")
+                        return val.bind(target);
+                    return val;
+                },
+                getPrototypeOf() {
+                    return foreignProto;
+                },
+            });
+            // Sanity: must match the real workerd behavior
+            if (proxy instanceof Response) {
+                throw new Error("Test setup broken: cross-realm response should not pass instanceof");
+            }
+            // TS narrows proxy to `never` after the instanceof check above (it
+            // assumes non-Response means no constructor), but the whole point is
+            // that this object IS a Response from a foreign realm.
+            if (proxy.constructor?.name !== "Response") {
+                throw new Error("Test setup broken: constructor.name should be 'Response'");
+            }
+            return proxy;
+        }
+        it("should return cross-realm Response.json() from a POST route handler", async () => {
+            const router = defineRoutes([
+                route("/api/users/", {
+                    post: () => crossRealmResponseJson({ created: true }, { status: 201 }),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            const request = new Request("http://localhost:3000/api/users/", {
+                method: "POST",
+            });
+            deps.mockRequestInfo.request = request;
+            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(201);
+            expect(await response.json()).toEqual({ created: true });
+        });
+        it("should short-circuit global middleware returning cross-realm Response.json()", async () => {
+            const executionOrder = [];
+            const authMiddleware = () => {
+                executionOrder.push("authMiddleware");
+                return crossRealmResponseJson({ error: "forbidden" }, { status: 403 });
+            };
+            const PageComponent = () => {
+                executionOrder.push("PageComponent");
+                return React.createElement("div", {}, "Page");
+            };
+            const router = defineRoutes([
+                authMiddleware,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            const request = new Request("http://localhost:3000/test/");
+            deps.mockRequestInfo.request = request;
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["authMiddleware"]);
+            expect(response.status).toBe(403);
+            expect(await response.json()).toEqual({ error: "forbidden" });
+        });
+        it("should short-circuit route-specific middleware returning cross-realm Response.json()", async () => {
+            const executionOrder = [];
+            const checkRole = () => {
+                executionOrder.push("checkRole");
+                return crossRealmResponseJson({ error: "unauthorized" }, { status: 401 });
+            };
+            const PageComponent = () => {
+                executionOrder.push("PageComponent");
+                return React.createElement("div", {}, "Page");
+            };
+            const router = defineRoutes([
+                route("/admin/", [checkRole, PageComponent]),
+            ]);
+            const deps = createMockDependencies();
+            const request = new Request("http://localhost:3000/admin/");
+            deps.mockRequestInfo.request = request;
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["checkRole"]);
+            expect(response.status).toBe(401);
+            expect(await response.json()).toEqual({ error: "unauthorized" });
+        });
+        it("should handle cross-realm Response.json() from an except handler", async () => {
+            const errorHandler = except(() => {
+                return crossRealmResponseJson({ error: "internal" }, { status: 500 });
+            });
+            const PageComponent = () => {
+                throw new Error("boom");
+            };
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            const request = new Request("http://localhost:3000/test/");
+            deps.mockRequestInfo.request = request;
+            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.json()).toEqual({ error: "internal" });
+        });
+    });
     describe("Edge Cases", () => {
         it("should handle middleware-only apps with RSC actions", async () => {
             const executionOrder = [];

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

@@ -1,4 +1,4 @@
-import { RpcStub } from "capnweb";
+import type { RpcStub } from "capnweb";
 import { DurableObject } from "cloudflare:workers";
 import type { RequestInfo } from "../runtime/requestInfo/types";
 export type SyncedStateValue = unknown;

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

@@ -9,9 +9,46 @@ 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 _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";
+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;
 import { DurableObject } from "cloudflare:workers";
+import { loadCapnweb } from "./capnweb-loader.mjs";
+let CoordinatorApiClass = null;
+async function getCoordinatorApi() {
+    var _CoordinatorApi_coordinator, _CoordinatorApi_stub, _b;
+    const { RpcTarget, newWorkersRpcResponse } = await loadCapnweb();
+    if (!CoordinatorApiClass) {
+        CoordinatorApiClass = (_b = class CoordinatorApi extends RpcTarget {
+                constructor(coordinator, stub) {
+                    super();
+                    _CoordinatorApi_coordinator.set(this, void 0);
+                    _CoordinatorApi_stub.set(this, void 0);
+                    __classPrivateFieldSet(this, _CoordinatorApi_coordinator, coordinator, "f");
+                    __classPrivateFieldSet(this, _CoordinatorApi_stub, stub, "f");
+                    coordinator.setStub(stub);
+                }
+                _setStub(stub) {
+                    __classPrivateFieldSet(this, _CoordinatorApi_stub, stub, "f");
+                    __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").setStub(stub);
+                }
+                getState(key) {
+                    return __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").getState(key);
+                }
+                setState(value, key) {
+                    __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").setState(value, key);
+                }
+                subscribe(key, client) {
+                    __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").subscribe(key, client);
+                }
+                unsubscribe(key, client) {
+                    __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").unsubscribe(key, client);
+                }
+            },
+            _CoordinatorApi_coordinator = new WeakMap(),
+            _CoordinatorApi_stub = new WeakMap(),
+            _b);
+    }
+    return { CoordinatorApi: CoordinatorApiClass, newWorkersRpcResponse };
+}
 /**
  * Durable Object that keeps shared state for multiple clients and notifies subscribers.
  */
@@ -141,6 +178,7 @@ export class SyncedStateServer extends DurableObject {
         }
     }
     async fetch(request) {
+        const { CoordinatorApi, newWorkersRpcResponse } = await getCoordinatorApi();
         // 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);
@@ -166,31 +204,3 @@ _SyncedStateServer_subscribeHandler = { value: null };
 _SyncedStateServer_unsubscribeHandler = { value: null };
 _SyncedStateServer_namespace = { value: null };
 _SyncedStateServer_durableObjectName = { value: "syncedState" };
-class CoordinatorApi extends RpcTarget {
-    constructor(coordinator, stub) {
-        super();
-        _CoordinatorApi_coordinator.set(this, void 0);
-        _CoordinatorApi_stub.set(this, void 0);
-        __classPrivateFieldSet(this, _CoordinatorApi_coordinator, coordinator, "f");
-        __classPrivateFieldSet(this, _CoordinatorApi_stub, stub, "f");
-        coordinator.setStub(stub);
-    }
-    // Internal method to set the stub - called from worker
-    _setStub(stub) {
-        __classPrivateFieldSet(this, _CoordinatorApi_stub, stub, "f");
-        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").setStub(stub);
-    }
-    getState(key) {
-        return __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").getState(key);
-    }
-    setState(value, key) {
-        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").setState(value, key);
-    }
-    subscribe(key, client) {
-        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").subscribe(key, client);
-    }
-    unsubscribe(key, client) {
-        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").unsubscribe(key, client);
-    }
-}
-_CoordinatorApi_coordinator = new WeakMap(), _CoordinatorApi_stub = new WeakMap();

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

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