rwsdk 1.2.8 → 1.2.10

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