rwsdk 1.2.8 → 1.2.9

package/dist/lib/e2e/browser.d.mts

@@ -4,6 +4,10 @@ import { SmokeTestOptions } from "./types.mjs";
  * Launch a browser instance
  */
 export declare function launchBrowser(browserPath?: string, headless?: boolean): Promise<Browser>;
+/**
+ * Check if a server is up, trying localhost and loopback host variants.
+ */
+export declare function checkServerUp(baseUrl: string, customPath?: string, retries?: number, includeRoot?: boolean): Promise<string>;
 /**
  * Get the browser executable path
  */

package/dist/lib/e2e/browser.mjs

@@ -2,7 +2,9 @@ import { computeExecutablePath, detectBrowserPlatform, install, Browser as Puppe
 import debug from "debug";
 import { mkdirp, pathExists } from "fs-extra";
 import { join } from "path";
+import { chromium as playwrightChromium } from "playwright-core";
 import puppeteer from "puppeteer-core";
+import { $ } from "../$.mjs";
 import { ensureTmpDir } from "./utils.mjs";
 const log = debug("rwsdk:e2e:browser");
 /**
@@ -26,6 +28,52 @@ export async function launchBrowser(browserPath, headless = true) {
         args: ["--no-sandbox", "--disable-setuid-sandbox"],
     });
 }
+/**
+ * Check if a server is up, trying localhost and loopback host variants.
+ */
+export async function checkServerUp(baseUrl, customPath = "/", retries = 30, includeRoot = true) {
+    const pathsToCheck = includeRoot ? ["/"] : [];
+    if (customPath !== "/" && customPath !== "") {
+        pathsToCheck.push(customPath);
+    }
+    if (pathsToCheck.length === 0) {
+        pathsToCheck.push("/");
+    }
+    for (const path of pathsToCheck) {
+        const normalizedPath = path.startsWith("/") ? path : "/" + path;
+        const baseUrlObject = new URL(baseUrl);
+        const candidateBaseUrls = Array.from(new Set([
+            baseUrl,
+            `${baseUrlObject.protocol}//127.0.0.1:${baseUrlObject.port}`,
+            `${baseUrlObject.protocol}//[::1]:${baseUrlObject.port}`,
+        ]));
+        const candidateUrls = candidateBaseUrls.map((candidateBaseUrl) => candidateBaseUrl + normalizedPath);
+        log("Checking if server is up at %s (max retries: %d)", candidateUrls[0], retries);
+        for (let i = 0; i < retries; i++) {
+            for (const candidateUrl of candidateUrls) {
+                try {
+                    log("Attempt %d/%d to check server at %s", i + 1, retries, candidateUrl);
+                    console.log(`Checking if server is up at ${candidateUrl} (attempt ${i + 1}/${retries})...`);
+                    await $ `curl --max-time 1 -s -o /dev/null -w "%{http_code}" ${candidateUrl}`;
+                    log("Server is up at %s", candidateUrl);
+                    console.log(`✅ Server is up at ${candidateUrl}`);
+                    return candidateUrl;
+                }
+                catch {
+                    // Try the next host variant.
+                }
+            }
+            if (i === retries - 1) {
+                log("ERROR: Server at %s did not become available after %d attempts", candidateUrls[0], retries);
+                throw new Error(`Server at ${candidateUrls[0]} did not become available after ${retries} attempts`);
+            }
+            log("Server not up yet, retrying in 2 seconds");
+            console.log(`Server not up yet, retrying in 2 seconds...`);
+            await new Promise((resolve) => setTimeout(() => resolve(), 2000));
+        }
+    }
+    return "";
+}
 /**
  * Get the browser executable path
  */
@@ -36,6 +84,16 @@ export async function getBrowserPath(testOptions) {
         console.log(`Using Chrome from environment variable: ${process.env.CHROME_PATH}`);
         return process.env.CHROME_PATH;
     }
+    try {
+        const playwrightPath = playwrightChromium.executablePath();
+        if (await pathExists(playwrightPath)) {
+            console.log(`Found Playwright Chrome at: ${playwrightPath}`);
+            return playwrightPath;
+        }
+    }
+    catch (error) {
+        log("Playwright browser path unavailable: %O", error);
+    }
     // Detect platform
     log("Detecting platform");
     const platform = detectBrowserPlatform();

package/dist/lib/e2e/constants.d.mts

@@ -1,4 +1,5 @@
 export declare const IS_CI: boolean;
+export declare const IS_PULL_REQUEST: boolean;
 export declare const RWSDK_SKIP_DEV: boolean;
 export declare const RWSDK_SKIP_DEPLOY: boolean;
 export declare const IS_DEBUG_MODE: boolean;
@@ -6,6 +7,7 @@ export declare const SETUP_PLAYGROUND_ENV_TIMEOUT: number;
 export declare const DEPLOYMENT_TIMEOUT: number;
 export declare const DEPLOYMENT_MIN_TRIES: number;
 export declare const DEPLOYMENT_CHECK_TIMEOUT: number;
+export declare const PREVIEW_SERVER_TIMEOUT: number;
 export declare const PUPPETEER_TIMEOUT: number;
 export declare const HYDRATION_TIMEOUT: number;
 export declare const DEV_SERVER_TIMEOUT: number;

package/dist/lib/e2e/constants.mjs

@@ -5,6 +5,7 @@ export const IS_CI = !!((process.env.CI && !process.env.NOT_CI) ||
     process.env.TRAVIS ||
     process.env.JENKINS_URL ||
     process.env.NETLIFY);
+export const IS_PULL_REQUEST = process.env.GITHUB_EVENT_NAME === "pull_request";
 export const RWSDK_SKIP_DEV = Boolean(process.env.RWSDK_SKIP_DEV);
 export const RWSDK_SKIP_DEPLOY = process.env.RWSDK_SKIP_DEPLOY === "true" ||
     process.env.RWSDK_SKIP_DEPLOY === "1";
@@ -33,6 +34,11 @@ export const DEPLOYMENT_CHECK_TIMEOUT = process.env
     : IS_DEBUG_MODE
         ? 30 * 1000
         : 5 * 60 * 1000;
+export const PREVIEW_SERVER_TIMEOUT = process.env.RWSDK_PREVIEW_SERVER_TIMEOUT
+    ? parseInt(process.env.RWSDK_PREVIEW_SERVER_TIMEOUT, 10)
+    : IS_DEBUG_MODE
+        ? 60 * 1000
+        : 10 * 60 * 1000;
 export const PUPPETEER_TIMEOUT = process.env.RWSDK_PUPPETEER_TIMEOUT
     ? parseInt(process.env.RWSDK_PUPPETEER_TIMEOUT, 10)
     : IS_DEBUG_MODE

package/dist/lib/e2e/dev.mjs

@@ -1,7 +1,7 @@
 import debug from "debug";
 import { setTimeout as sleep } from "node:timers/promises";
 import { $, $sh } from "../../lib/$.mjs";
-import { poll } from "./poll.mjs";
+import { checkServerUp } from "./browser.mjs";
 import { IS_DEBUG_MODE } from "./constants.mjs";
 const DEV_SERVER_CHECK_TIMEOUT = process.env.RWSDK_DEV_SERVER_CHECK_TIMEOUT
     ? parseInt(process.env.RWSDK_DEV_SERVER_CHECK_TIMEOUT, 10)
@@ -205,23 +205,12 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         // Wait for the URL
         const serverUrl = await waitForUrl();
         console.log(`✅ Development server started at ${serverUrl}`);
-        // Poll the URL to ensure it's live before proceeding
-        await poll(async () => {
-            try {
-                const response = await fetch(serverUrl, {
-                    signal: AbortSignal.timeout(1000),
-                });
-                // We consider any response (even 4xx or 5xx) as success,
-                // as it means the worker is routable.
-                return response.status > 0;
-            }
-            catch (e) {
-                return false;
-            }
-        }, {
-            timeout: DEV_SERVER_CHECK_TIMEOUT,
-        });
-        return { url: serverUrl, stopDev };
+        // context(justinvdm, 2026-05-13): Probe the debug endpoint instead of
+        // the app root because the root response can take several seconds to wake
+        // up even after Vite prints its local URL.
+        const readinessRetries = Math.max(1, Math.ceil(DEV_SERVER_CHECK_TIMEOUT / 2000));
+        const reachableDebugUrl = await checkServerUp(serverUrl, "/__debug", readinessRetries, false);
+        return { url: new URL(reachableDebugUrl).origin, stopDev };
     }
     catch (error) {
         // Make sure to try to stop the server on error

package/dist/lib/e2e/release.d.mts

@@ -36,6 +36,13 @@ export declare function runRelease(cwd: string, projectDir: string, resourceUniq
     url: string;
     workerName: string;
 }>;
+/**
+ * Run a local production preview server (build + preview) and return the URL.
+ */
+export declare function runPreviewServer(packageManager?: string, cwd?: string): Promise<{
+    url: string;
+    stopPreview: () => Promise<void>;
+}>;
 /**
  * Check if a resource name includes a specific resource unique key
  * This is used to identify resources created during our tests

package/dist/lib/e2e/release.mjs

@@ -5,10 +5,11 @@ import { pathExists } from "fs-extra";
 import * as fs from "fs/promises";
 import { parse as parseJsonc } from "jsonc-parser";
 import { setTimeout } from "node:timers/promises";
-import { basename, dirname, join, resolve } from "path";
+import { basename, dirname, join, relative, resolve } from "path";
 import { $ } from "../../lib/$.mjs";
+import { checkServerUp } from "./browser.mjs";
 import { extractLastJson, parseJson } from "../../lib/jsonUtils.mjs";
-import { IS_DEBUG_MODE } from "./constants.mjs";
+import { IS_DEBUG_MODE, PREVIEW_SERVER_TIMEOUT } from "./constants.mjs";
 const log = debug("rwsdk:e2e:release");
 /**
  * Find wrangler cache by searching up the directory tree for node_modules/.cache/wrangler
@@ -400,6 +401,81 @@ export async function runRelease(cwd, projectDir, resourceUniqueKey) {
         throw error;
     }
 }
+/**
+ * Run a local production preview server (build + preview) and return the URL.
+ */
+export async function runPreviewServer(packageManager = "pnpm", cwd) {
+    console.log("🚀 Building for production preview...");
+    const pm = packageManager === "yarn-classic" ? "yarn" : packageManager;
+    await $(pm, ["run", "build"], {
+        cwd: cwd || process.cwd(),
+        stdio: "pipe",
+        env: { ...process.env, NODE_ENV: "production" },
+    });
+    console.log("✅ Build complete. Starting preview server...");
+    let previewProcess = null;
+    let isErrorExpected = false;
+    const stopPreview = async () => {
+        isErrorExpected = true;
+        if (!previewProcess || !previewProcess.pid) {
+            return;
+        }
+        console.log("Stopping preview server...");
+        if (process.platform !== "win32") {
+            try {
+                process.kill(-previewProcess.pid, "SIGKILL");
+            }
+            catch { }
+        }
+        await previewProcess.catch(() => { });
+        console.log("Preview server stopped");
+    };
+    previewProcess = $(pm, ["run", "preview", "--", "--port", "4173", "--strictPort"], {
+        all: true,
+        detached: process.platform !== "win32",
+        cleanup: true,
+        forceKillAfterTimeout: 2000,
+        cwd: cwd || process.cwd(),
+        env: { ...process.env, NODE_ENV: "production" },
+        stdio: "pipe",
+    });
+    previewProcess.catch((error) => {
+        if (!isErrorExpected) {
+            log("Preview server process exited unexpectedly: %O", error);
+        }
+    });
+    const ensurePreviewDeployConfig = async () => {
+        const deployConfigPath = resolve(cwd || process.cwd(), ".wrangler/deploy/config.json");
+        if (await pathExists(deployConfigPath)) {
+            return;
+        }
+        let workerConfigPath = null;
+        for (const candidate of ["wrangler.jsonc", "wrangler.json"]) {
+            const resolvedCandidate = resolve(cwd || process.cwd(), candidate);
+            if (await pathExists(resolvedCandidate)) {
+                workerConfigPath = resolvedCandidate;
+                break;
+            }
+        }
+        if (!workerConfigPath) {
+            throw new Error(`Unable to create preview deploy config because no wrangler.jsonc or wrangler.json was found in ${cwd || process.cwd()}`);
+        }
+        await fs.mkdir(dirname(deployConfigPath), { recursive: true });
+        const deployConfig = {
+            configPath: relative(dirname(deployConfigPath), workerConfigPath),
+            auxiliaryWorkers: [],
+        };
+        await fs.writeFile(deployConfigPath, JSON.stringify(deployConfig, null, 2));
+    };
+    await ensurePreviewDeployConfig();
+    // context(justinvdm, 2026-05-13): Give the CI preview path the same
+    // readiness budget as the dev server so local agent-ci runs can absorb build
+    // and startup latency without falling back to Cloudflare.
+    const reachableDebugUrl = await checkServerUp("http://localhost:4173", "/__debug", Math.max(1, Math.ceil(PREVIEW_SERVER_TIMEOUT / 2000)), false);
+    const serverUrl = new URL(reachableDebugUrl).origin;
+    console.log(`✅ Preview server started at ${serverUrl}`);
+    return { url: serverUrl, stopPreview };
+}
 /**
  * Check if a resource name includes a specific resource unique key
  * This is used to identify resources created during our tests

package/dist/lib/e2e/tarball.mjs

@@ -3,6 +3,7 @@ import { $ } from "execa";
 import fs from "node:fs";
 import path from "node:path";
 import { ROOT_DIR } from "../constants.mjs";
+import { IS_CI } from "./constants.mjs";
 import { copyProjectToTempDir } from "./environment.mjs";
 const log = (message) => console.log(message);
 /**
@@ -51,7 +52,9 @@ async function copyWranglerCache(targetDir, sdkRoot) {
             log(`  ✅ Wrangler cache copied successfully`);
         }
         else {
-            log(`  ⚠️ No wrangler cache found in monorepo, deployment tests may require authentication`);
+            log(IS_CI
+                ? `  ℹ️ No wrangler cache found in monorepo; CI preview tests do not require it`
+                : `  ⚠️ No wrangler cache found in monorepo, deployment tests may require authentication`);
         }
     }
     catch (error) {

package/dist/lib/e2e/testHarness.d.mts

@@ -66,13 +66,7 @@ export declare function createDevServer(): {
  */
 export declare function createDeployment(): {
     projectDir: string;
-    start: () => Promise<{
-        url: string;
-        workerName: string;
-        resourceUniqueKey: string;
-        projectDir: string;
-        cleanup: () => Promise<void>;
-    }>;
+    start: () => Promise<DeploymentInstance>;
 };
 /**
  * Executes a test function with a retry mechanism for specific error codes.

package/dist/lib/e2e/testHarness.mjs

@@ -4,10 +4,10 @@ import puppeteer from "puppeteer-core";
 import { fileURLToPath } from "url";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, test, } from "vitest";
 import { launchBrowser } from "./browser.mjs";
-import { DEPLOYMENT_CHECK_TIMEOUT, DEPLOYMENT_MIN_TRIES, DEPLOYMENT_TIMEOUT, DEV_SERVER_MIN_TRIES, DEV_SERVER_TIMEOUT, HYDRATION_TIMEOUT, INSTALL_DEPENDENCIES_RETRIES, PUPPETEER_TIMEOUT, SETUP_PLAYGROUND_ENV_TIMEOUT, SETUP_WAIT_TIMEOUT, TEST_MAX_RETRIES, TEST_MAX_RETRIES_PER_CODE, } from "./constants.mjs";
+import { DEPLOYMENT_CHECK_TIMEOUT, DEPLOYMENT_MIN_TRIES, DEPLOYMENT_TIMEOUT, DEV_SERVER_MIN_TRIES, DEV_SERVER_TIMEOUT, HYDRATION_TIMEOUT, INSTALL_DEPENDENCIES_RETRIES, IS_PULL_REQUEST, PUPPETEER_TIMEOUT, SETUP_PLAYGROUND_ENV_TIMEOUT, SETUP_WAIT_TIMEOUT, TEST_MAX_RETRIES, TEST_MAX_RETRIES_PER_CODE, } from "./constants.mjs";
 import { runDevServer } from "./dev.mjs";
 import { poll, pollValue } from "./poll.mjs";
-import { deleteD1Database, deleteWorker, isRelatedToTest, runRelease, } from "./release.mjs";
+import { deleteD1Database, deleteWorker, isRelatedToTest, runPreviewServer, runRelease, } from "./release.mjs";
 import { setupTarballEnvironment } from "./tarball.mjs";
 import { ensureTmpDir } from "./utils.mjs";
 export { DEPLOYMENT_CHECK_TIMEOUT, DEPLOYMENT_MIN_TRIES, DEPLOYMENT_TIMEOUT, DEV_SERVER_MIN_TRIES, DEV_SERVER_TIMEOUT, HYDRATION_TIMEOUT, INSTALL_DEPENDENCIES_RETRIES, PUPPETEER_TIMEOUT, SETUP_PLAYGROUND_ENV_TIMEOUT, SETUP_WAIT_TIMEOUT, TEST_MAX_RETRIES, TEST_MAX_RETRIES_PER_CODE, };
@@ -221,15 +221,34 @@ export function createDeployment() {
             if (SKIP_DEPLOYMENT_TESTS) {
                 throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
             }
+            const dirName = basename(projectDir);
+            // Match formats: {projectName}-t-{hash}, {projectName}-test-{hash}, or {projectName}-e2e-test-{hash}
+            const match = dirName.match(/-t-([a-f0-9]+)$/) ||
+                dirName.match(/-test-([a-f0-9]+)$/) ||
+                dirName.match(/-e2e-test-([a-f0-9]+)$/);
+            const resourceUniqueKey = match
+                ? match[1]
+                : Math.random().toString(36).substring(2, 15);
+            if (IS_PULL_REQUEST) {
+                console.log("PR mode detected — using local preview instead of deploy");
+                const previewResult = await runPreviewServer(process.env.PACKAGE_MANAGER ||
+                    "pnpm", projectDir);
+                instance = {
+                    url: previewResult.url,
+                    workerName: `preview-${resourceUniqueKey}`,
+                    resourceUniqueKey,
+                    projectDir,
+                    cleanup: async () => {
+                        await previewResult.stopPreview().catch((error) => {
+                            console.warn(`Warning: Background preview cleanup failed: ${error.message}`);
+                        });
+                        return Promise.resolve();
+                    },
+                };
+                deploymentInstances.push(instance);
+                return instance;
+            }
             const newInstance = await pollValue(async () => {
-                const dirName = basename(projectDir);
-                // Match formats: {projectName}-t-{hash}, {projectName}-test-{hash}, or {projectName}-e2e-test-{hash}
-                const match = dirName.match(/-t-([a-f0-9]+)$/) ||
-                    dirName.match(/-test-([a-f0-9]+)$/) ||
-                    dirName.match(/-e2e-test-([a-f0-9]+)$/);
-                const resourceUniqueKey = match
-                    ? match[1]
-                    : Math.random().toString(36).substring(2, 15);
                 const deployResult = await runRelease(projectDir, projectDir, resourceUniqueKey);
                 // A fresh *.workers.dev subdomain can return 200 with Cloudflare's
                 // "There is nothing here yet" placeholder before the worker code
@@ -273,6 +292,7 @@ export function createDeployment() {
                     console.log(`Retrying deployment creation (attempt ${tries})... Error: ${error.message}`);
                 },
             });
+            instance = newInstance;
             deploymentInstances.push(newInstance);
             return newInstance;
         },

package/dist/lib/smokeTests/browser.d.mts

@@ -37,7 +37,7 @@ bail?: boolean): Promise<void>;
 /**
  * DRY: checkServerUp now checks both root and custom path if needed
  */
-export declare function checkServerUp(baseUrl: string, customPath?: string, retries?: number, bail?: boolean): Promise<boolean>;
+export declare function checkServerUp(baseUrl: string, customPath?: string, retries?: number, bail?: boolean): Promise<string>;
 /**
  * HMR test for server component
  * Updates the server component and verifies that HMR applies the changes

package/dist/lib/smokeTests/browser.mjs

@@ -749,42 +749,48 @@ export async function checkServerUp(baseUrl, customPath = "/", retries = RETRIES
         pathsToCheck.push(customPath);
     }
     for (const path of pathsToCheck) {
-        const url = baseUrl + (path.startsWith("/") ? path : "/" + path);
-        log("Checking if server is up at %s (max retries: %d)", url, retries);
-        let up = false;
+        const normalizedPath = path.startsWith("/") ? path : "/" + path;
+        const baseUrlObject = new URL(baseUrl);
+        const candidateBaseUrls = Array.from(new Set([
+            baseUrl,
+            `${baseUrlObject.protocol}//127.0.0.1:${baseUrlObject.port}`,
+            `${baseUrlObject.protocol}//[::1]:${baseUrlObject.port}`,
+        ]));
+        const candidateUrls = candidateBaseUrls.map((candidateBaseUrl) => candidateBaseUrl + normalizedPath);
+        log("Checking if server is up at %s (max retries: %d)", candidateUrls[0], retries);
         for (let i = 0; i < retries; i++) {
-            try {
-                log("Attempt %d/%d to check server at %s", i + 1, retries, url);
-                console.log(`Checking if server is up at ${url} (attempt ${i + 1}/${retries})...`);
-                await $ `curl -s -o /dev/null -w "%{http_code}" ${url}`;
-                log("Server is up at %s", url);
-                console.log(`✅ Server is up at ${url}`);
-                up = true;
-                break;
+            for (const candidateUrl of candidateUrls) {
+                try {
+                    log("Attempt %d/%d to check server at %s", i + 1, retries, candidateUrl);
+                    console.log(`Checking if server is up at ${candidateUrl} (attempt ${i + 1}/${retries})...`);
+                    await $ `curl --max-time 1 -s -o /dev/null -w "%{http_code}" ${candidateUrl}`;
+                    log("Server is up at %s", candidateUrl);
+                    console.log(`✅ Server is up at ${candidateUrl}`);
+                    return candidateUrl;
+                }
+                catch {
+                    // Try the next host variant.
+                }
             }
-            catch (error) {
-                if (i === retries - 1) {
-                    log("ERROR: Server at %s did not become available after %d attempts", url, retries);
-                    const errorMessage = `Server at ${url} did not become available after ${retries} attempts`;
-                    if (bail) {
-                        // If bail is true, call fail() which will exit the process
-                        await fail(new Error(errorMessage), 1, `Server Availability Check: ${url}`);
-                        return false; // This will never be reached due to fail() exiting
-                    }
-                    else {
-                        // Otherwise throw an error that can be caught by the caller
-                        throw new Error(errorMessage);
-                    }
+            if (i === retries - 1) {
+                log("ERROR: Server at %s did not become available after %d attempts", candidateUrls[0], retries);
+                const errorMessage = `Server at ${candidateUrls[0]} did not become available after ${retries} attempts`;
+                if (bail) {
+                    // If bail is true, call fail() which will exit the process
+                    await fail(new Error(errorMessage), 1, `Server Availability Check: ${candidateUrls[0]}`);
+                    return ""; // This will never be reached due to fail() exiting
+                }
+                else {
+                    // Otherwise throw an error that can be caught by the caller
+                    throw new Error(errorMessage);
                 }
-                log("Server not up yet, retrying in 2 seconds");
-                console.log(`Server not up yet, retrying in 2 seconds...`);
-                await new Promise((resolve) => setTimeout(() => resolve(), 2000));
             }
+            log("Server not up yet, retrying in 2 seconds");
+            console.log(`Server not up yet, retrying in 2 seconds...`);
+            await new Promise((resolve) => setTimeout(() => resolve(), 2000));
         }
-        if (!up)
-            return false;
     }
-    return true;
+    return "";
 }
 /**
  * Perform only the realtime upgrade and tests without doing initial checks

package/dist/lib/smokeTests/release.d.mts

@@ -8,7 +8,14 @@ export declare function runRelease(cwd: string, projectDir: string, resourceUniq
     url: string;
     workerName: string;
 }>;
+/**
+ * Run the local preview server (build + preview) and return the URL
+ */
+export declare function runPreviewServer(packageManager?: string, cwd?: string): Promise<{
+    url: string;
+    stopPreview: () => Promise<void>;
+}>;
 /**
  * Runs tests against the production deployment
  */
-export declare function runReleaseTest(artifactDir: string, resources: TestResources, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, projectDir?: string, realtime?: boolean, skipHmr?: boolean, skipStyleTests?: boolean): Promise<void>;
+export declare function runReleaseTest(artifactDir: string, resources: TestResources, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, projectDir?: string, realtime?: boolean, skipHmr?: boolean, skipStyleTests?: boolean, ci?: boolean): Promise<void>;

package/dist/lib/smokeTests/release.mjs

@@ -1,7 +1,8 @@
 import { setTimeout } from "node:timers/promises";
-import { $expect, deleteD1Database, deleteWorker, isRelatedToTest, listD1Databases, runRelease as runE2ERelease, } from "../../lib/e2e/release.mjs";
+import { $expect, deleteD1Database, deleteWorker, isRelatedToTest, listD1Databases, runPreviewServer as runE2EPreviewServer, runRelease as runE2ERelease, } from "../../lib/e2e/release.mjs";
 import { checkServerUp, checkUrl } from "./browser.mjs";
 import { log } from "./constants.mjs";
+import { state } from "./state.mjs";
 export { $expect, deleteD1Database, deleteWorker, isRelatedToTest, listD1Databases, };
 /**
  * Run the release command to deploy to Cloudflare
@@ -9,6 +10,12 @@ export { $expect, deleteD1Database, deleteWorker, isRelatedToTest, listD1Databas
 export async function runRelease(cwd, projectDir, resourceUniqueKey) {
     return runE2ERelease(cwd, projectDir, resourceUniqueKey);
 }
+/**
+ * Run the local preview server (build + preview) and return the URL
+ */
+export async function runPreviewServer(packageManager = "pnpm", cwd) {
+    return runE2EPreviewServer(packageManager, cwd);
+}
 async function waitForDeploymentContent(baseUrl, { timeoutMs = 60_000, intervalMs = 2_000, } = {}) {
     const marker = "__RWSDK_CONTEXT";
     const deadline = Date.now() + timeoutMs;
@@ -41,46 +48,64 @@ async function waitForDeploymentContent(baseUrl, { timeoutMs = 60_000, intervalM
 /**
  * Runs tests against the production deployment
  */
-export async function runReleaseTest(artifactDir, resources, browserPath, headless = true, bail = false, skipClient = false, projectDir, realtime = false, skipHmr = false, skipStyleTests = false) {
+export async function runReleaseTest(artifactDir, resources, browserPath, headless = true, bail = false, skipClient = false, projectDir, realtime = false, skipHmr = false, skipStyleTests = false, ci = false) {
     log("Starting release test");
     console.log("\n🚀 Testing production deployment");
+    let url;
+    let stopPreview;
     try {
-        log("Running release process");
-        const { url, workerName } = await runRelease(resources.targetDir || "", projectDir || "", resources.resourceUniqueKey);
-        // Wait a moment before checking server availability
-        log("Waiting 1s before checking server...");
-        await setTimeout(1000);
-        // DRY: check both root and custom path
-        await checkServerUp(url, "/");
-        // A fresh *.workers.dev subdomain can return 200 with Cloudflare's
-        // "There is nothing here yet" placeholder before the worker code is
-        // globally propagated. Poll the URL until the response body contains
-        // an rwsdk-rendered marker so we don't run the browser tests against
-        // the placeholder.
-        await waitForDeploymentContent(url);
+        if (process.env.GITHUB_EVENT_NAME === "pull_request") {
+            log("PR mode detected — using local preview instead of deploy");
+            const previewResult = await runPreviewServer(state.options.packageManager, resources.targetDir || "");
+            url = previewResult.url;
+            stopPreview = previewResult.stopPreview;
+        }
+        else {
+            log("Running release process");
+            const { url: deployUrl, workerName } = await runRelease(resources.targetDir || "", projectDir || "", resources.resourceUniqueKey);
+            url = deployUrl;
+            // Wait a moment before checking server availability
+            log("Waiting 1s before checking server...");
+            await setTimeout(1000);
+            // DRY: check both root and custom path
+            await checkServerUp(url, "/");
+            // A fresh *.workers.dev subdomain can return 200 with Cloudflare's
+            // "There is nothing here yet" placeholder before the worker code is
+            // globally propagated. Poll the URL until the response body contains
+            // an rwsdk-rendered marker so we don't run the browser tests against
+            // the placeholder.
+            await waitForDeploymentContent(url);
+            // Store the worker name if we didn't set it earlier
+            if (resources && !resources.workerName) {
+                log("Storing worker name: %s", workerName);
+                resources.workerName = workerName;
+            }
+            // Mark that we created this worker during the test
+            if (resources) {
+                log("Marking worker %s as created during this test", workerName);
+                resources.workerCreatedDuringTest = true;
+                // Update the global state
+                if (resources.workerCreatedDuringTest !== undefined) {
+                    resources.workerCreatedDuringTest = true;
+                }
+            }
+        }
         // Now run the tests with the custom path
         const testUrl = new URL("/__smoke_test", url).toString();
         await checkUrl(testUrl, artifactDir, browserPath, headless, bail, skipClient, "Production", realtime, resources.targetDir, // Add target directory parameter
         true, // Always skip HMR in production
         skipStyleTests);
         log("Release test completed successfully");
-        // Store the worker name if we didn't set it earlier
-        if (resources && !resources.workerName) {
-            log("Storing worker name: %s", workerName);
-            resources.workerName = workerName;
-        }
-        // Mark that we created this worker during the test
-        if (resources) {
-            log("Marking worker %s as created during this test", workerName);
-            resources.workerCreatedDuringTest = true;
-            // Update the global state
-            if (resources.workerCreatedDuringTest !== undefined) {
-                resources.workerCreatedDuringTest = true;
-            }
-        }
     }
     catch (error) {
         log("Error during release testing: %O", error);
         throw error;
     }
+    finally {
+        if (stopPreview) {
+            await stopPreview().catch((e) => {
+                log("Error stopping preview server: %O", e);
+            });
+        }
+    }
 }

package/dist/lib/smokeTests/runSmokeTests.mjs

@@ -95,7 +95,7 @@ export async function runSmokeTests(options = {}) {
                 // Update status when release command runs
                 try {
                     console.log("\n🚀 Running release command smoke test");
-                    await runReleaseTest(options.artifactDir, resources, browserPath, options.headless !== false, options.bail, options.skipClient, options.projectDir, options.realtime, options.skipHmr, options.skipStyleTests);
+                    await runReleaseTest(options.artifactDir, resources, browserPath, options.headless !== false, options.bail, options.skipClient, options.projectDir, options.realtime, options.skipHmr, options.skipStyleTests, options.ci);
                     // Update release command status to PASSED
                     updateTestStatus("production", "releaseCommand", "PASSED");
                     // Mark that release tests have run successfully

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

@@ -9,6 +9,7 @@ export type RouteMiddleware<T extends RequestInfo = RequestInfo> = BivariantRout
 export type ExceptHandler<T extends RequestInfo = RequestInfo> = {
     __rwExcept: true;
     handler: (error: unknown, requestInfo: T) => MaybePromise<React.JSX.Element | Response | void>;
+    pathPattern?: string;
 };
 type RouteFunction<T extends RequestInfo = RequestInfo> = BivariantRouteHandler<T, MaybePromise<Response>>;
 type RouteComponent<T extends RequestInfo = RequestInfo> = BivariantRouteHandler<T, MaybePromise<React.JSX.Element | Response | void>>;

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/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.9",
   "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",