rwsdk 1.2.8 → 1.2.10

package/dist/runtime/lib/router.js

@@ -185,11 +185,28 @@ export function defineRoutes(routes) {
             function isExceptHandler(route) {
                 return route.type === "except";
             }
+            function isPathInExceptScope(pathPattern, requestPath) {
+                const normalized = pathPattern.endsWith("/")
+                    ? pathPattern
+                    : pathPattern + "/";
+                const hasParams = normalized.includes(":") || normalized.includes("*");
+                if (hasParams) {
+                    const wildcardPattern = normalized.slice(0, -1) + "/*";
+                    return (matchPath(wildcardPattern, requestPath) !== null ||
+                        matchPath(normalized.slice(0, -1), requestPath) !== null);
+                }
+                return (requestPath === normalized || requestPath.startsWith(normalized));
+            }
             async function executeExceptHandlers(error, startIndex) {
                 // Search backwards from startIndex to find the most recent except handler
                 for (let i = startIndex; i >= 0; i--) {
                     const route = compiledRoutes[i];
                     if (isExceptHandler(route)) {
+                        const pattern = route.handler.pathPattern;
+                        if (pattern &&
+                            !isPathInExceptScope(pattern, getRequestInfo().path)) {
+                            continue;
+                        }
                         try {
                             const result = await route.handler.handler(error, getRequestInfo());
                             const handled = await handleMiddlewareResult(result);
@@ -554,8 +571,16 @@ export function prefix(prefixPath, routes) {
             r !== null &&
             "__rwExcept" in r &&
             r.__rwExcept === true) {
-            // Pass through ExceptHandler as-is
-            return r;
+            const existing = r.pathPattern;
+            const combined = existing
+                ? joinPaths(normalizedPrefix, existing)
+                : normalizedPrefix;
+            const scoped = {
+                __rwExcept: true,
+                handler: r.handler,
+                pathPattern: combined,
+            };
+            return scoped;
         }
         if (Array.isArray(r)) {
             // Recursively process nested route arrays

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

@@ -1535,5 +1535,101 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(response.status).toBe(500);
             expect(await response.text()).toBe(`Caught: ${errorMessage}`);
         });
+        describe("prefix scoping", () => {
+            const makePrefixApp = () => {
+                const globalHandler = except(() => new Response("[GLOBAL]", {
+                    status: 500,
+                }));
+                const adminHandler = except(() => new Response("[ADMIN]", {
+                    status: 500,
+                }));
+                const router = defineRoutes([
+                    globalHandler,
+                    ...prefix("/admin", [
+                        adminHandler,
+                        route("/dashboard/", () => {
+                            throw new Error("admin dashboard error");
+                        }),
+                    ]),
+                    route("/", () => {
+                        throw new Error("home route error");
+                    }),
+                ]);
+                return router;
+            };
+            const handle = async (router, path) => {
+                const deps = createMockDependencies();
+                deps.mockRequestInfo.request = new Request(`http://localhost:3000${path}`);
+                return router.handle({
+                    request: new Request(`http://localhost:3000${path}`),
+                    renderPage: deps.mockRenderPage,
+                    getRequestInfo: deps.getRequestInfo,
+                    onError: deps.onError,
+                    runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                    rscActionHandler: deps.mockRscActionHandler,
+                });
+            };
+            it("an except inside prefix should NOT catch errors from routes outside the prefix", async () => {
+                const router = makePrefixApp();
+                const response = await handle(router, "/");
+                expect(await response.text()).toBe("[GLOBAL]");
+            });
+            it("an except inside prefix should catch errors from routes inside the prefix", async () => {
+                const router = makePrefixApp();
+                const response = await handle(router, "/admin/dashboard/");
+                expect(await response.text()).toBe("[ADMIN]");
+            });
+            it("an except inside prefix that returns void should bubble to the global handler", async () => {
+                const router = defineRoutes([
+                    except(() => new Response("[GLOBAL]", { status: 500 })),
+                    ...prefix("/admin", [
+                        except(() => undefined),
+                        route("/dashboard/", () => {
+                            throw new Error("boom");
+                        }),
+                    ]),
+                ]);
+                const response = await handle(router, "/admin/dashboard/");
+                expect(await response.text()).toBe("[GLOBAL]");
+            });
+            it("nested prefixes compose the scope path", async () => {
+                const router = defineRoutes([
+                    except(() => new Response("[GLOBAL]", { status: 500 })),
+                    ...prefix("/a", [
+                        ...prefix("/b", [
+                            except(() => new Response("[A/B]", { status: 500 })),
+                            route("/c/", () => {
+                                throw new Error("a/b/c error");
+                            }),
+                        ]),
+                    ]),
+                    route("/d/", () => {
+                        throw new Error("d error");
+                    }),
+                ]);
+                const inside = await handle(router, "/a/b/c/");
+                expect(await inside.text()).toBe("[A/B]");
+                const outside = await handle(router, "/d/");
+                expect(await outside.text()).toBe("[GLOBAL]");
+            });
+            it("parameterized prefixes scope the except handler", async () => {
+                const router = defineRoutes([
+                    except(() => new Response("[GLOBAL]", { status: 500 })),
+                    ...prefix("/users/:id", [
+                        except(() => new Response("[USER]", { status: 500 })),
+                        route("/profile/", () => {
+                            throw new Error("profile error");
+                        }),
+                    ]),
+                    route("/about/", () => {
+                        throw new Error("about error");
+                    }),
+                ]);
+                const inside = await handle(router, "/users/42/profile/");
+                expect(await inside.text()).toBe("[USER]");
+                const outside = await handle(router, "/about/");
+                expect(await outside.text()).toBe("[GLOBAL]");
+            });
+        });
     });
 });

package/dist/scripts/worker-run.mjs

@@ -5,6 +5,7 @@ import path from "path";
 import { pathToFileURL } from "url";
 import * as vite from "vite";
 import { createLogger } from "vite";
+import { checkServerUp } from "../lib/e2e/browser.mjs";
 const debug = dbg("rwsdk:worker-run");
 const main = async () => {
     process.env.RWSDK_WORKER_RUN = "1";
@@ -47,14 +48,47 @@ const main = async () => {
         });
         await server.listen();
         const fileUrl = pathToFileURL(scriptPath).href;
-        const url = `http://localhost:${port}/__worker-run?script=${encodeURIComponent(fileUrl)}`;
-        debug("Fetching %s", url);
-        const response = await fetch(url, {
-            headers: {
-                "x-rwsdk-worker-run-token": token,
-            },
-        });
-        debug("Response from worker: %s", response);
+        const readyUrl = await checkServerUp(`http://localhost:${port}`, "/__debug", 30, false);
+        const readyOrigin = new URL(readyUrl).origin;
+        const readyOriginUrl = new URL(readyOrigin);
+        const candidateBaseUrls = Array.from(new Set([
+            readyOrigin,
+            `${readyOriginUrl.protocol}//127.0.0.1:${readyOriginUrl.port}`,
+            `${readyOriginUrl.protocol}//[::1]:${readyOriginUrl.port}`,
+        ]));
+        let response;
+        let lastFetchError;
+        for (const candidateBaseUrl of candidateBaseUrls) {
+            const url = `${candidateBaseUrl}/__worker-run?script=${encodeURIComponent(fileUrl)}`;
+            const fetchAttempts = 5;
+            debug("Fetching %s", url);
+            for (let attempt = 0; attempt < fetchAttempts; attempt++) {
+                try {
+                    response = await fetch(url, {
+                        headers: {
+                            "x-rwsdk-worker-run-token": token,
+                        },
+                    });
+                    debug("Response from worker: %s", response);
+                    break;
+                }
+                catch (error) {
+                    lastFetchError = error;
+                    debug("Fetch failed for %s on attempt %d/%d: %O", url, attempt + 1, fetchAttempts, error);
+                    if (attempt < fetchAttempts - 1) {
+                        await new Promise((resolve) => {
+                            setTimeout(() => resolve(), 2000);
+                        });
+                    }
+                }
+            }
+            if (response) {
+                break;
+            }
+        }
+        if (!response) {
+            throw lastFetchError ?? new Error("worker-run fetch failed");
+        }
         if (!response.ok) {
             const errorText = await response.text();
             console.error(`Error: worker-run script failed with status ${response.status}.`);

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

@@ -6,12 +6,15 @@ vi.mock("cloudflare:workers", () => {
 });
 import { SyncedStateServer } from "../SyncedStateServer.mjs";
 const createStub = (onInvoke) => {
-    const fn = Object.assign(async (value) => {
-        await onInvoke(value);
-    }, {
-        dup: () => fn,
-    });
-    return fn;
+    const makeStub = () => {
+        const fn = Object.assign(async (value) => {
+            await onInvoke(value);
+        }, {
+            dup: () => makeStub(),
+        });
+        return fn;
+    };
+    return makeStub();
 };
 describe("SyncedStateServer", () => {
     it("notifies subscribers when state changes", async () => {
@@ -27,11 +30,15 @@ describe("SyncedStateServer", () => {
     });
     it("removes subscriptions on unsubscribe", () => {
         const coordinator = new SyncedStateServer({}, {});
-        const stub = createStub(() => { });
+        const received = [];
+        const stub = createStub((value) => {
+            received.push(value);
+        });
         coordinator.subscribe("counter", stub);
         coordinator.unsubscribe("counter", stub);
         coordinator.setState(1, "counter");
         expect(coordinator.getState("counter")).toBe(1);
+        expect(received).toEqual([]);
     });
     it("drops failing subscribers", async () => {
         const coordinator = new SyncedStateServer({}, {});

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

@@ -9,10 +9,14 @@ vi.mock("capnweb", () => ({
     },
     newWorkersRpcResponse: vi.fn(),
 }));
-vi.mock("../runtime/entries/router", () => ({
+vi.mock("../../runtime/entries/router", () => ({
     route: vi.fn((path, handler) => ({ path, handler })),
 }));
-import { SyncedStateServer } from "../SyncedStateServer.mjs";
+vi.mock("../../runtime/requestInfo/worker", () => ({
+    runWithRequestInfo: (_requestInfo, fn) => fn(),
+}));
+import { newWorkersRpcResponse } from "capnweb";
+import { syncedStateRoutes, SyncedStateServer } from "../worker.mjs";
 describe("SyncedStateProxy", () => {
     let mockCoordinator;
     beforeEach(() => {
@@ -20,6 +24,7 @@ describe("SyncedStateProxy", () => {
     });
     const mockStub = {};
     afterEach(() => {
+        vi.mocked(newWorkersRpcResponse).mockReset();
         SyncedStateServer.registerKeyHandler(async (key, stub) => key);
     });
     it("transforms keys before calling coordinator methods when handler is registered", async () => {
@@ -58,6 +63,40 @@ describe("SyncedStateProxy", () => {
         SyncedStateServer.registerKeyHandler(handler);
         await expect(handler("test", mockStub)).rejects.toThrow("Handler error");
     });
+    it("uses the subscribed duplicated RPC client when unsubscribing (#1207)", async () => {
+        const coordinator = {
+            _setStub: vi.fn(),
+            subscribe: vi.fn().mockResolvedValue(undefined),
+            unsubscribe: vi.fn().mockResolvedValue(undefined),
+        };
+        const namespace = {
+            idFromName: vi.fn(() => "synced-state-id"),
+            get: vi.fn(() => coordinator),
+        };
+        let proxy;
+        vi.mocked(newWorkersRpcResponse).mockImplementation(async (_request, api) => {
+            proxy = api;
+            return new Response(null, { status: 204 });
+        });
+        SyncedStateServer.registerKeyHandler(async (key) => key);
+        const [baseRoute] = syncedStateRoutes(() => namespace);
+        await baseRoute.handler({
+            request: new Request("https://example.com/__synced-state"),
+            params: {},
+        });
+        const duplicatedClient = Object.assign(vi.fn(), {
+            dup: vi.fn(() => duplicatedClient),
+        });
+        const originalClient = Object.assign(vi.fn(), {
+            dup: vi.fn(() => duplicatedClient),
+        });
+        await proxy.subscribe("notifications", originalClient);
+        await proxy.unsubscribe("notifications", originalClient);
+        const subscribeClient = coordinator.subscribe.mock.calls[0][1];
+        const unsubscribeClient = coordinator.unsubscribe.mock.calls[0][1];
+        expect(subscribeClient).not.toBe(originalClient);
+        expect(unsubscribeClient).toBe(subscribeClient);
+    });
     it("handles async operations in handler", async () => {
         const handler = async (key, stub) => {
             await new Promise((resolve) => setTimeout(resolve, 5));

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

@@ -19,7 +19,7 @@ export { SyncedStateServer };
 const DEFAULT_SYNC_STATE_NAME = "syncedState";
 let SyncedStateProxyClass = null;
 async function getSyncedStateProxy() {
-    var _SyncedStateProxy_instances, _SyncedStateProxy_stub, _SyncedStateProxy_keyHandler, _SyncedStateProxy_requestInfo, _SyncedStateProxy_transformKey, _SyncedStateProxy_callHandler, _a;
+    var _SyncedStateProxy_instances, _SyncedStateProxy_stub, _SyncedStateProxy_keyHandler, _SyncedStateProxy_requestInfo, _SyncedStateProxy_subscriptionClients, _SyncedStateProxy_transformKey, _SyncedStateProxy_callHandler, _a;
     const { RpcTarget, newWorkersRpcResponse } = await loadCapnweb();
     if (!SyncedStateProxyClass) {
         SyncedStateProxyClass = (_a = class SyncedStateProxy extends RpcTarget {
@@ -29,6 +29,9 @@ async function getSyncedStateProxy() {
                     _SyncedStateProxy_stub.set(this, void 0);
                     _SyncedStateProxy_keyHandler.set(this, void 0);
                     _SyncedStateProxy_requestInfo.set(this, void 0);
+                    // Map original RPC callbacks to the duplicated callbacks sent to the DO
+                    // so unsubscribe uses the same identity that subscribe registered.
+                    _SyncedStateProxy_subscriptionClients.set(this, new Map());
                     __classPrivateFieldSet(this, _SyncedStateProxy_stub, stub, "f");
                     __classPrivateFieldSet(this, _SyncedStateProxy_keyHandler, keyHandler, "f");
                     __classPrivateFieldSet(this, _SyncedStateProxy_requestInfo, requestInfo, "f");
@@ -54,7 +57,24 @@ async function getSyncedStateProxy() {
                     // 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);
+                    let clientsForKey = __classPrivateFieldGet(this, _SyncedStateProxy_subscriptionClients, "f").get(transformedKey);
+                    if (!clientsForKey) {
+                        clientsForKey = new Map();
+                        __classPrivateFieldGet(this, _SyncedStateProxy_subscriptionClients, "f").set(transformedKey, clientsForKey);
+                    }
+                    clientsForKey.set(client, clientToPass);
+                    try {
+                        return await __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").subscribe(transformedKey, clientToPass);
+                    }
+                    catch (error) {
+                        if (clientsForKey.get(client) === clientToPass) {
+                            clientsForKey.delete(client);
+                            if (clientsForKey.size === 0) {
+                                __classPrivateFieldGet(this, _SyncedStateProxy_subscriptionClients, "f").delete(transformedKey);
+                            }
+                        }
+                        throw error;
+                    }
                 }
                 async unsubscribe(key, client) {
                     const transformedKey = await __classPrivateFieldGet(this, _SyncedStateProxy_instances, "m", _SyncedStateProxy_transformKey).call(this, key);
@@ -65,18 +85,29 @@ async function getSyncedStateProxy() {
                     if (unsubscribeHandler) {
                         __classPrivateFieldGet(this, _SyncedStateProxy_instances, "m", _SyncedStateProxy_callHandler).call(this, unsubscribeHandler, transformedKey, __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f"));
                     }
+                    const clientsForKey = __classPrivateFieldGet(this, _SyncedStateProxy_subscriptionClients, "f").get(transformedKey);
+                    const clientToPass = clientsForKey?.get(client) ?? client;
                     try {
-                        await __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").unsubscribe(transformedKey, client);
+                        await __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").unsubscribe(transformedKey, clientToPass);
                     }
                     catch (error) {
                         // Ignore errors during unsubscribe - handler has already been called
                         // This prevents RPC stub disposal errors from propagating
                     }
+                    finally {
+                        if (clientsForKey && clientsForKey.get(client) === clientToPass) {
+                            clientsForKey.delete(client);
+                            if (clientsForKey.size === 0) {
+                                __classPrivateFieldGet(this, _SyncedStateProxy_subscriptionClients, "f").delete(transformedKey);
+                            }
+                        }
+                    }
                 }
             },
             _SyncedStateProxy_stub = new WeakMap(),
             _SyncedStateProxy_keyHandler = new WeakMap(),
             _SyncedStateProxy_requestInfo = new WeakMap(),
+            _SyncedStateProxy_subscriptionClients = new WeakMap(),
             _SyncedStateProxy_instances = new WeakSet(),
             _SyncedStateProxy_transformKey = 
             /**

package/dist/vite/miniflareHMRPlugin.mjs

@@ -7,7 +7,7 @@ import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { hasDirective as sourceHasDirective } from "./hasDirective.mjs";
 import { invalidateModule } from "./invalidateModule.mjs";
 import { isJsFile } from "./isJsFile.mjs";
-import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
+import { VIRTUAL_SSR_PREFIX } from "./ssrVirtualModule.mjs";
 const log = debug("rwsdk:vite:hmr-plugin");
 let hasErrored = false;
 const hasDirective = async (filepath, directive) => {

package/dist/vite/ssrBridgePlugin.d.mts

@@ -1,5 +1,4 @@
 import type { Plugin } from "vite";
-export declare const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
 export declare const ssrBridgePlugin: ({ clientFiles, serverFiles, }: {
     clientFiles: Set<string>;
     serverFiles: Set<string>;

package/dist/vite/ssrBridgePlugin.mjs

@@ -3,8 +3,8 @@ import MagicString from "magic-string";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { externalModulesSet } from "./constants.mjs";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
+import { isVirtualSsrModuleId, normalizeVirtualSsrModuleId, VIRTUAL_SSR_PREFIX, } from "./ssrVirtualModule.mjs";
 const log = debug("rwsdk:vite:ssr-bridge-plugin");
-export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
 export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
     let devServer;
     let isDev = false;
@@ -63,10 +63,11 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                             process.env.VERBOSE &&
                                 log("Esbuild onResolve called for path=%s, args=%O", args.path, args);
                             if (args.path === "rwsdk/__ssr_bridge" ||
-                                args.path.startsWith(VIRTUAL_SSR_PREFIX)) {
-                                log("Marking as external: %s", args.path);
+                                isVirtualSsrModuleId(args.path)) {
+                                const path = normalizeVirtualSsrModuleId(args.path) ?? args.path;
+                                log("Marking as external: %s", path);
                                 return {
-                                    path: args.path,
+                                    path,
                                     external: true,
                                 };
                             }
@@ -98,14 +99,15 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 // context(justinvdm, 27 May 2025): In dev, we need to dynamically load
                 // SSR modules, so we return the virtual id so that the dynamic loading
                 // can happen in load()
-                if (id.startsWith(VIRTUAL_SSR_PREFIX)) {
-                    if (id.endsWith(".css")) {
-                        const newId = id + ".js";
+                const virtualSsrId = normalizeVirtualSsrModuleId(id);
+                if (virtualSsrId) {
+                    if (virtualSsrId.endsWith(".css")) {
+                        const newId = virtualSsrId + ".js";
                         log("Virtual CSS module, adding .js suffix. old: %s, new: %s", id, newId);
                         return newId;
                     }
-                    log("Returning virtual SSR id for dev: %s", id);
-                    return id;
+                    log("Returning virtual SSR id for dev: %s", virtualSsrId);
+                    return virtualSsrId;
                 }
                 // context(justinvdm, 28 May 2025): The SSR bridge module is a special case -
                 // it is the entry point for all SSR modules, so to trigger the
@@ -119,10 +121,11 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
             else {
                 // In build mode, the behavior depends on the build pass
-                if (id.startsWith(VIRTUAL_SSR_PREFIX)) {
+                const virtualSsrId = normalizeVirtualSsrModuleId(id);
+                if (virtualSsrId) {
                     if (this.environment.name === "worker") {
                         log("Virtual SSR module case (build-worker pass): resolving to external");
-                        return { id, external: true };
+                        return { id: virtualSsrId, external: true };
                     }
                 }
                 if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
@@ -141,9 +144,9 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
         },
         async load(id) {
-            if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
-                this.environment.name === "worker") {
-                const realId = id.slice(VIRTUAL_SSR_PREFIX.length);
+            const virtualSsrId = normalizeVirtualSsrModuleId(id);
+            if (virtualSsrId && this.environment.name === "worker") {
+                const realId = virtualSsrId.slice(VIRTUAL_SSR_PREFIX.length);
                 let idForFetch = realId.endsWith(".css.js")
                     ? realId.slice(0, -3)
                     : realId;

package/dist/vite/ssrVirtualModule.d.mts

@@ -0,0 +1,3 @@
+export declare const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
+export declare function normalizeVirtualSsrModuleId(id: string): string | undefined;
+export declare function isVirtualSsrModuleId(id: string): boolean;

package/dist/vite/ssrVirtualModule.mjs

@@ -0,0 +1,11 @@
+const VITE_ID_PREFIX = "/@id/";
+export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
+export function normalizeVirtualSsrModuleId(id) {
+    const normalizedId = id.startsWith(VITE_ID_PREFIX)
+        ? id.slice(VITE_ID_PREFIX.length)
+        : id;
+    return normalizedId.startsWith(VIRTUAL_SSR_PREFIX) ? normalizedId : undefined;
+}
+export function isVirtualSsrModuleId(id) {
+    return normalizeVirtualSsrModuleId(id) !== undefined;
+}

package/dist/vite/transformJsxScriptTagsPlugin.hook.test.d.mts

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

package/dist/vite/transformJsxScriptTagsPlugin.hook.test.mjs

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { isVirtualSsrModuleId, normalizeVirtualSsrModuleId, VIRTUAL_SSR_PREFIX, } from "./ssrVirtualModule.mjs";
+import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
+describe("isVirtualSsrModuleId", () => {
+    it.each([
+        [`${VIRTUAL_SSR_PREFIX}/src/Preview.tsx`, true],
+        [`${VIRTUAL_SSR_PREFIX}rwsdk/__ssr_bridge`, true],
+        [`/@id/${VIRTUAL_SSR_PREFIX}/src/Preview.tsx`, true],
+        [`/src/${VIRTUAL_SSR_PREFIX}Preview.tsx`, false],
+        ["/src/Preview.tsx", false],
+    ])("identifies %s as virtual SSR module id: %s", (id, expected) => {
+        expect(isVirtualSsrModuleId(id)).toBe(expected);
+    });
+    it("normalizes Vite /@id/ virtual SSR module URLs to bare module ids", () => {
+        expect(normalizeVirtualSsrModuleId(`/@id/${VIRTUAL_SSR_PREFIX}/src/Preview.tsx`)).toBe(`${VIRTUAL_SSR_PREFIX}/src/Preview.tsx`);
+    });
+});
+describe("transformJsxScriptTagsPlugin transform hook", () => {
+    function createPlugin() {
+        const clientEntryPoints = new Set();
+        const plugin = transformJsxScriptTagsPlugin({
+            clientEntryPoints,
+            projectRootDir: "/project/root/dir",
+        });
+        const configResolved = plugin.configResolved;
+        if (typeof configResolved === "function") {
+            configResolved.call({}, { command: "serve", base: "/" });
+        }
+        else {
+            configResolved?.handler.call({}, { command: "serve", base: "/" });
+        }
+        const transform = typeof plugin.transform === "function"
+            ? plugin.transform
+            : plugin.transform?.handler;
+        if (!transform) {
+            throw new Error("Expected transform hook to be defined");
+        }
+        return { clientEntryPoints, transform: transform };
+    }
+    it.each([
+        `${VIRTUAL_SSR_PREFIX}/src/Preview.tsx`,
+        `/@id/${VIRTUAL_SSR_PREFIX}/src/Preview.tsx`,
+    ])("skips virtual SSR bridge module ids in worker: %s", async (id) => {
+        // Regression for #1210: virtual SSR bridge modules have .tsx ids but are
+        // already transformed by the ssr environment, so the worker transform must
+        // not run script-tag discovery on them again.
+        const { clientEntryPoints, transform } = createPlugin();
+        const ssrBridgeCode = `
+      import { jsx } from "react/jsx-runtime";
+      const __vite_ssr_import_0__ = await __vite_ssr_import__("react/jsx-runtime", { importedNames: ["jsx"] });
+      export function Preview() {
+        return jsx("script", { async: true, src: "https://example.com/a.js" });
+      }
+    `;
+        const result = await transform.call({ environment: { name: "worker" } }, ssrBridgeCode, id);
+        expect(result).toBeNull();
+        expect(clientEntryPoints.size).toBe(0);
+    });
+    it("still transforms non-bridge worker .tsx modules", async () => {
+        const { transform } = createPlugin();
+        const code = `
+      import { jsx } from "react/jsx-runtime";
+      export function Preview() {
+        return jsx("script", { async: true, src: "https://example.com/a.js" });
+      }
+    `;
+        const result = await transform.call({ environment: { name: "worker" } }, code, "/src/Preview.tsx");
+        expect(result).toBeTruthy();
+        expect(typeof result === "object" && result !== null && "code" in result
+            ? result.code
+            : "").toContain("nonce: requestInfo.rw.nonce");
+    });
+});

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -2,6 +2,7 @@ import debug from "debug";
 import { Node, Project, SyntaxKind, } from "ts-morph";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { stripBase } from "../lib/stripBase.mjs";
+import { isVirtualSsrModuleId } from "./ssrVirtualModule.mjs";
 const log = debug("rwsdk:vite:transform-jsx-script-tags");
 function transformAssetPath(importPath, projectRootDir, base) {
     if (process.env.VITE_IS_DEV_SERVER === "1") {
@@ -336,6 +337,10 @@ export const transformJsxScriptTagsPlugin = ({ clientEntryPoints, projectRootDir
                 return null;
             }
             if (this.environment?.name === "worker" &&
+                // context(peterp, 29 May 2026): SSR bridge modules are already
+                // transformed by the `ssr` environment; rerunning script-tag discovery
+                // in the worker injects duplicate imports into virtual SSR modules.
+                !isVirtualSsrModuleId(id) &&
                 id.endsWith(".tsx") &&
                 hasJsxFunctions(code)) {
                 log("Transforming JSX script tags in %s", id);

package/dist/vite/transformJsxScriptTagsPlugin.test.mjs

@@ -1,10 +1,11 @@
-import jsBeautify from "js-beautify";
+import ts from "typescript";
 import { beforeEach, describe, expect, it } from "vitest";
 import stubEnvVars from "../lib/testUtils/stubEnvVars.mjs";
 import { transformJsxScriptTagsCode } from "./transformJsxScriptTagsPlugin.mjs";
-// Helper function to normalize code formatting for test comparisons
+// Helper function to normalize code formatting for test comparisons.
 function normalizeCode(code) {
-    return jsBeautify(code, { indent_size: 2 });
+    const source = ts.createSourceFile("test.tsx", code, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+    return ts.createPrinter({ removeComments: false }).printFile(source).trim();
 }
 stubEnvVars();
 beforeEach(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -182,6 +182,7 @@
     "magic-string": "~0.30.21",
     "picocolors": "~1.1.1",
     "proper-lockfile": "~4.1.2",
+    "playwright-core": "1.60.0",
     "puppeteer-core": "~24.42.0",
     "react-is": "~19.2.6",
     "rsc-html-stream": "~0.0.7",
@@ -212,11 +213,9 @@
     "wrangler": "^4.85.0",
     "capnweb": "~0.5.0",
     "@types/debug": "~4.1.13",
-    "@types/js-beautify": "~1.14.3",
     "@types/lodash": "~4.17.24",
     "@types/node": "~25.6.0",
     "@types/proper-lockfile": "~4.1.4",
-    "js-beautify": "~1.15.4",
     "semver": "~7.7.4",
     "tsx": "~4.21.0",
     "typescript": "~6.0.3",