rwsdk 1.0.0-beta.23 → 1.0.0-beta.24

package/dist/lib/e2e/browser.mjs

@@ -1,14 +1,18 @@
 import { computeExecutablePath, detectBrowserPlatform, install, Browser as PuppeteerBrowser, resolveBuildId, } from "@puppeteer/browsers";
 import debug from "debug";
 import { mkdirp, pathExists } from "fs-extra";
-import * as os from "os";
 import { join } from "path";
 import puppeteer from "puppeteer-core";
+import { ensureTmpDir } from "./utils.mjs";
 const log = debug("rwsdk:e2e:browser");
 /**
  * Launch a browser instance
  */
 export async function launchBrowser(browserPath, headless = true) {
+    // Define a consistent cache directory path in system temp folder
+    const rwCacheDir = join(await ensureTmpDir(), "redwoodjs-smoke-test-cache");
+    await mkdirp(rwCacheDir);
+    log("Using cache directory: %s", rwCacheDir);
     // Get browser path if not provided
     if (!browserPath) {
         log("Getting browser executable path");
@@ -41,7 +45,7 @@ export async function getBrowserPath(testOptions) {
     }
     log("Detected platform: %s", platform);
     // Define a consistent cache directory path in system temp folder
-    const rwCacheDir = join(os.tmpdir(), "redwoodjs-smoke-test-cache");
+    const rwCacheDir = join(await ensureTmpDir(), "redwoodjs-smoke-test-cache");
     await mkdirp(rwCacheDir);
     log("Using cache directory: %s", rwCacheDir);
     // Determine browser type based on headless option

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

@@ -1,4 +1,6 @@
 export declare const IS_CI: boolean;
+export declare const RWSDK_SKIP_DEV: boolean;
+export declare const RWSDK_SKIP_DEPLOY: boolean;
 export declare const IS_DEBUG_MODE: boolean;
 export declare const SETUP_PLAYGROUND_ENV_TIMEOUT: number;
 export declare const DEPLOYMENT_TIMEOUT: number;

package/dist/lib/e2e/constants.mjs

@@ -5,6 +5,9 @@ export const IS_CI = !!((process.env.CI && !process.env.NOT_CI) ||
     process.env.TRAVIS ||
     process.env.JENKINS_URL ||
     process.env.NETLIFY);
+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";
 export const IS_DEBUG_MODE = process.env.RWSDK_E2E_DEBUG
     ? process.env.RWSDK_E2E_DEBUG === "true"
     : !IS_CI;

package/dist/lib/e2e/dev.mjs

@@ -73,21 +73,23 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         };
         const pm = getPackageManagerCommand(packageManager);
         // Use the provided cwd if available
-        devProcess = $({
+        devProcess = $(pm, ["run", "dev"], {
             all: true,
-            detached: true, // Re-enable for reliable process cleanup
+            // On Windows, detached: true prevents stdio from being captured.
+            // On Unix, it's required for reliable cleanup by killing the process group.
+            detached: process.platform !== "win32",
             cleanup: true, // Let execa handle cleanup
             forceKillAfterTimeout: 2000, // Force kill if graceful shutdown fails
             cwd: cwd || process.cwd(), // Use provided directory or current directory
             env, // Pass the updated environment variables
             stdio: "pipe", // Ensure streams are piped
-        }) `${pm} run dev`;
+        });
         devProcess.catch((error) => {
             if (!isErrorExpected) {
                 // Don't re-throw. The error will be handled gracefully by the polling
                 // logic in `waitForUrl`, which will detect that the process has exited.
                 // Re-throwing here would cause an unhandled promise rejection.
-                log("Dev server process exited unexpectedly:", error.shortMessage);
+                log("Dev server process exited unexpectedly: %O", error);
             }
         });
         log("Development server process spawned in directory: %s", cwd || process.cwd());
@@ -97,8 +99,9 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         // Listen for all output to get the URL
         const handleOutput = (data, source) => {
             const output = data.toString();
+            // Raw output for debugging
+            process.stdout.write(`[dev:${source}] ` + output);
             allOutput += output; // Accumulate all output
-            log("Received output from %s: %s", source, output.replace(/\n/g, "\\n"));
             if (!url) {
                 // Multiple patterns to catch different package manager outputs
                 const patterns = [
@@ -118,28 +121,17 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
                 ];
                 for (const pattern of patterns) {
                     const match = output.match(pattern);
-                    log("Testing pattern %s against output: %s", pattern.source, output.replace(/\n/g, "\\n"));
                     if (match) {
-                        log("Pattern matched: %s, groups: %o", pattern.source, match);
                         if (match[1] && match[1].startsWith("http")) {
                             url = match[1];
-                            log("Found development server URL with pattern %s: %s", pattern.source, url);
                             break;
                         }
                         else if (match[1] && /^\d+$/.test(match[1])) {
                             url = `http://localhost:${match[1]}`;
-                            log("Found development server URL with port pattern %s: %s", pattern.source, url);
                             break;
                         }
                     }
                 }
-                // Log potential matches for debugging
-                if (!url &&
-                    (output.includes("localhost") ||
-                        output.includes("Local") ||
-                        output.includes("server"))) {
-                    log("Potential URL pattern found but not matched: %s", output.trim());
-                }
             }
         };
         // Listen to all possible output streams
@@ -150,6 +142,15 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         // Also try listening to the raw process output
         if (devProcess.child) {
             log("Setting up child process stream listeners");
+            devProcess.child.on("spawn", () => {
+                log("Child process spawned successfully.");
+            });
+            devProcess.child.on("error", (err) => {
+                log("Child process error: %O", err);
+            });
+            devProcess.child.on("exit", (code, signal) => {
+                log("Child process exited with code %s and signal %s", code, signal);
+            });
             devProcess.child.stdout?.on("data", (data) => handleOutput(data, "child.stdout"));
             devProcess.child.stderr?.on("data", (data) => handleOutput(data, "child.stderr"));
         }

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

@@ -1,5 +1,7 @@
 import tmp from "tmp-promise";
 import { PackageManager } from "./types.mjs";
+export declare function getFilesRecursively(directory: string): Promise<string[]>;
+export declare function getDirectoryHash(directory: string): Promise<string>;
 /**
  * Copy project to a temporary directory with a unique name
  */

package/dist/lib/e2e/environment.mjs

@@ -4,22 +4,77 @@ import { copy, pathExists } from "fs-extra";
 import ignore from "ignore";
 import * as fs from "node:fs";
 import path from "node:path";
-import os from "os";
 import { basename, join, relative, resolve } from "path";
 import tmp from "tmp-promise";
 import { $ } from "../../lib/$.mjs";
 import { ROOT_DIR } from "../constants.mjs";
-import { INSTALL_DEPENDENCIES_RETRIES, IS_CI } from "./constants.mjs";
+import { INSTALL_DEPENDENCIES_RETRIES } from "./constants.mjs";
 import { retry } from "./retry.mjs";
+import { ensureTmpDir } from "./utils.mjs";
 const log = debug("rwsdk:e2e:environment");
-const IS_CACHE_ENABLED = process.env.RWSDK_E2E_CACHE
-    ? process.env.RWSDK_E2E_CACHE === "1"
-    : !IS_CI;
+const IS_CACHE_ENABLED = !process.env.RWSDK_E2E_CACHE_DISABLED;
 if (IS_CACHE_ENABLED) {
     log("E2E test caching is enabled.");
 }
+async function getProjectDependencyHash(projectDir) {
+    const hash = createHash("md5");
+    const dependencyFiles = [
+        "package.json",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "package-lock.json",
+    ];
+    for (const file of dependencyFiles) {
+        const filePath = path.join(projectDir, file);
+        if (await pathExists(filePath)) {
+            const data = await fs.promises.readFile(filePath);
+            hash.update(path.basename(filePath));
+            hash.update(data);
+        }
+    }
+    return hash.digest("hex");
+}
+export async function getFilesRecursively(directory) {
+    const entries = await fs.promises.readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map((entry) => {
+        const fullPath = path.join(directory, entry.name);
+        return entry.isDirectory() ? getFilesRecursively(fullPath) : fullPath;
+    }));
+    return files.flat();
+}
+export async function getDirectoryHash(directory) {
+    const hash = createHash("md5");
+    if (!(await pathExists(directory))) {
+        return "";
+    }
+    const files = await getFilesRecursively(directory);
+    files.sort();
+    for (const file of files) {
+        const relativePath = path.relative(directory, file);
+        const data = await fs.promises.readFile(file);
+        hash.update(relativePath.replace(/\\/g, "/")); // Normalize path separators
+        hash.update(data);
+    }
+    return hash.digest("hex");
+}
 const getTempDir = async () => {
-    return tmp.dir({ unsafeCleanup: true });
+    const tmpDir = await ensureTmpDir();
+    const projectsTempDir = path.join(tmpDir, "e2e-projects");
+    await fs.promises.mkdir(projectsTempDir, { recursive: true });
+    const tempDir = await tmp.dir({
+        unsafeCleanup: true,
+        tmpdir: projectsTempDir,
+    });
+    // context(justinvdm, 2 Nov 2025): On Windows CI, tmp.dir() can return a
+    // short path (e.g., RUNNER~1). Vite's internals may later resolve this to a
+    // long path (e.g., runneradmin), causing alias resolution to fail due to
+    // path mismatch. Using realpathSync ensures we always use the canonical
+    // path, avoiding this inconsistency.
+    if (process.platform === "win32") {
+        tempDir.path = fs.realpathSync.native(tempDir.path);
+    }
+    await fs.promises.mkdir(tempDir.path, { recursive: true });
+    return tempDir;
 };
 function slugify(str) {
     return str
@@ -43,7 +98,12 @@ const createSdkTarball = async () => {
         };
     }
     // Create a temporary directory to receive the tarball, ensuring a stable path.
-    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rwsdk-tarball-"));
+    let tempDir = await fs.promises.mkdtemp(path.join(await ensureTmpDir(), "rwsdk-tarball-"));
+    // context(justinvdm, 2 Nov 2025): Normalize the temp dir on Windows
+    // to prevent short/long path mismatches.
+    if (process.platform === "win32") {
+        tempDir = fs.realpathSync.native(tempDir);
+    }
     await $({
         cwd: ROOT_DIR,
         stdio: "pipe",
@@ -161,24 +221,25 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         log("⚙️  Configuring temp project to not use frozen lockfile...");
         const npmrcPath = join(targetDir, ".npmrc");
         await fs.promises.writeFile(npmrcPath, "frozen-lockfile=false\n");
+        const tmpDir = await ensureTmpDir();
         if (packageManager === "yarn") {
             const yarnrcPath = join(targetDir, ".yarnrc.yml");
-            const yarnCacheDir = path.join(os.tmpdir(), "yarn-cache");
+            const yarnCacheDir = path.join(tmpDir, "yarn-cache");
             await fs.promises.mkdir(yarnCacheDir, { recursive: true });
             const yarnConfig = [
                 // todo(justinvdm, 23-09-23): Support yarn pnpm
                 "nodeLinker: node-modules",
                 "enableImmutableInstalls: false",
-                `cacheFolder: "${yarnCacheDir}"`,
+                `cacheFolder: "${yarnCacheDir.replace(/\\/g, "/")}"`,
             ].join("\n");
             await fs.promises.writeFile(yarnrcPath, yarnConfig);
             log("Created .yarnrc.yml to allow lockfile changes for yarn");
         }
         if (packageManager === "yarn-classic") {
             const yarnrcPath = join(targetDir, ".yarnrc");
-            const yarnCacheDir = path.join(os.tmpdir(), "yarn-classic-cache");
+            const yarnCacheDir = path.join(tmpDir, "yarn-classic-cache");
             await fs.promises.mkdir(yarnCacheDir, { recursive: true });
-            const yarnConfig = `cache-folder "${yarnCacheDir}"`;
+            const yarnConfig = `cache-folder "${yarnCacheDir.replace(/\\/g, "/")}"`;
             await fs.promises.writeFile(yarnrcPath, yarnConfig);
             log("Created .yarnrc with cache-folder for yarn-classic");
         }
@@ -197,43 +258,45 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
     }
 }
 async function installDependencies(targetDir, packageManager = "pnpm", projectDir, monorepoRoot) {
+    let cacheRoot = null;
+    let nodeModulesCachePath = null;
     if (IS_CACHE_ENABLED) {
-        // Generate a checksum of the SDK's dist directory to factor into the cache key
-        const { stdout: sdkDistChecksum } = await $("find . -type f | sort | md5sum", {
-            shell: true,
-            cwd: path.join(ROOT_DIR, "dist"),
-        });
-        const projectIdentifier = monorepoRoot
-            ? `${monorepoRoot}-${projectDir}`
-            : projectDir;
-        const projectHash = createHash("md5")
-            .update(`${projectIdentifier}-${sdkDistChecksum}`)
-            .digest("hex")
-            .substring(0, 8);
+        const dependencyHash = await getProjectDependencyHash(monorepoRoot || projectDir);
         const cacheDirName = monorepoRoot
             ? basename(monorepoRoot)
             : basename(projectDir);
-        const cacheRoot = path.join(os.tmpdir(), "rwsdk-e2e-cache", `${cacheDirName}-${projectHash}`);
-        const nodeModulesCachePath = path.join(cacheRoot, "node_modules");
+        cacheRoot = path.join(await ensureTmpDir(), "rwsdk-e2e-cache", `${cacheDirName}-${dependencyHash.substring(0, 8)}`);
+        nodeModulesCachePath = path.join(cacheRoot, "node_modules");
         if (await pathExists(nodeModulesCachePath)) {
-            console.log(`✅ CACHE HIT for source "${projectIdentifier}": Found cached node_modules. Hard-linking from ${nodeModulesCachePath}`);
+            console.log(`✅ CACHE HIT for dependencies: Found cached node_modules. Hard-linking from ${nodeModulesCachePath}`);
             try {
-                // Use cp -al for a fast, hardlink-based copy
-                await $("cp", ["-al", nodeModulesCachePath, join(targetDir, "node_modules")], { stdio: "pipe" });
-                console.log(`✅ Hardlink copy created successfully.`);
+                await copy(nodeModulesCachePath, join(targetDir, "node_modules"));
+                console.log(`✅ Cache restored successfully.`);
+                console.log(`📦 Installing local SDK into cached node_modules...`);
+                // We still need to install the packed tarball
+                await runInstall(targetDir, packageManager, true);
+                return;
             }
             catch (e) {
-                console.warn(`⚠️ Hardlink copy failed, falling back to full copy. Error: ${e.message}`);
-                // Fallback to a regular copy if hardlinking fails (e.g., cross-device)
-                await copy(nodeModulesCachePath, join(targetDir, "node_modules"));
-                console.log(`✅ Full copy created successfully.`);
+                console.warn(`⚠️ Cache restore failed. Error: ${e.message}. Proceeding with clean install.`);
             }
-            return;
         }
-        console.log(`ℹ️ CACHE MISS for source "${projectIdentifier}": No cached node_modules found at ${nodeModulesCachePath}. Proceeding with installation.`);
+        else {
+            console.log(`ℹ️ CACHE MISS for dependencies: No cached node_modules found at ${nodeModulesCachePath}. Proceeding with clean installation.`);
+        }
     }
-    console.log(`📦 Installing project dependencies in ${targetDir} using ${packageManager}...`);
-    try {
+    await runInstall(targetDir, packageManager, false);
+    if (IS_CACHE_ENABLED && nodeModulesCachePath) {
+        console.log(`Caching node_modules to ${nodeModulesCachePath} for future runs...`);
+        await fs.promises.mkdir(path.dirname(nodeModulesCachePath), {
+            recursive: true,
+        });
+        await copy(join(targetDir, "node_modules"), nodeModulesCachePath);
+        console.log(`✅ node_modules cached successfully.`);
+    }
+}
+async function runInstall(targetDir, packageManager, isCacheHit) {
+    if (!isCacheHit) {
         // Clean up any pre-existing node_modules and lockfiles
         log("Cleaning up pre-existing node_modules and lockfiles...");
         await Promise.all([
@@ -246,78 +309,54 @@ async function installDependencies(targetDir, packageManager = "pnpm", projectDi
             fs.promises.rm(join(targetDir, "package-lock.json"), { force: true }),
         ]);
         log("Cleanup complete.");
-        if (packageManager.startsWith("yarn")) {
-            log(`Enabling corepack...`);
-            await $("corepack", ["enable"], { cwd: targetDir, stdio: "pipe" });
-            if (packageManager === "yarn") {
-                log(`Preparing yarn@stable with corepack...`);
-                await $("corepack", ["prepare", "yarn@stable", "--activate"], {
-                    cwd: targetDir,
-                    stdio: "pipe",
-                });
-            }
-            else if (packageManager === "yarn-classic") {
-                log(`Preparing yarn@1.22.19 with corepack...`);
-                await $("corepack", ["prepare", "yarn@1.x", "--activate"], {
-                    cwd: targetDir,
-                    stdio: "pipe",
-                });
-            }
-        }
-        const npmCacheDir = path.join(os.tmpdir(), "npm-cache");
-        await fs.promises.mkdir(npmCacheDir, { recursive: true });
-        const installCommand = {
-            pnpm: ["pnpm", "install"],
-            npm: ["npm", "install", "--cache", npmCacheDir],
-            yarn: ["yarn", "install"],
-            "yarn-classic": ["yarn"],
-        }[packageManager];
-        // Run install command in the target directory
-        log(`Running ${installCommand.join(" ")}`);
-        const [command, ...args] = installCommand;
-        const result = await $(command, args, {
-            cwd: targetDir,
-            stdio: "pipe", // Capture output
-            env: {
-                YARN_ENABLE_HARDENED_MODE: "0",
-            },
-        });
-        console.log("✅ Dependencies installed successfully");
-        // After successful install, populate the cache if enabled
-        if (IS_CACHE_ENABLED) {
-            // Re-calculate cache path to be safe
-            const { stdout: sdkDistChecksum } = await $("find . -type f | sort | md5sum", {
-                shell: true,
-                cwd: path.join(ROOT_DIR, "dist"),
-            });
-            const projectIdentifier = monorepoRoot
-                ? `${monorepoRoot}-${projectDir}`
-                : projectDir;
-            const projectHash = createHash("md5")
-                .update(`${projectIdentifier}-${sdkDistChecksum}`)
-                .digest("hex")
-                .substring(0, 8);
-            const cacheDirName = monorepoRoot
-                ? basename(monorepoRoot)
-                : basename(projectDir);
-            const cacheRoot = path.join(os.tmpdir(), "rwsdk-e2e-cache", `${cacheDirName}-${projectHash}`);
-            const nodeModulesCachePath = path.join(cacheRoot, "node_modules");
-            console.log(`Caching node_modules to ${nodeModulesCachePath} for future runs...`);
-            // Ensure parent directory exists
-            await fs.promises.mkdir(path.dirname(nodeModulesCachePath), {
-                recursive: true,
+    }
+    if (packageManager.startsWith("yarn")) {
+        log(`Enabling corepack...`);
+        await $("corepack", ["enable"], { cwd: targetDir, stdio: "pipe" });
+        if (packageManager === "yarn") {
+            log(`Preparing yarn@stable with corepack...`);
+            await $("corepack", ["prepare", "yarn@stable", "--activate"], {
+                cwd: targetDir,
+                stdio: "pipe",
             });
-            await copy(join(targetDir, "node_modules"), nodeModulesCachePath);
-            console.log(`✅ node_modules cached successfully.`);
         }
-        // Log installation details at debug level
-        if (result.stdout) {
-            log(`${packageManager} install output: %s`, result.stdout);
+        else if (packageManager === "yarn-classic") {
+            log(`Preparing yarn@1.22.19 with corepack...`);
+            await $("corepack", ["prepare", "yarn@1.x", "--activate"], {
+                cwd: targetDir,
+                stdio: "pipe",
+            });
         }
     }
-    catch (error) {
-        log("ERROR: Failed to install dependencies: %O", error);
-        console.error(`❌ Failed to install dependencies: ${error instanceof Error ? error.message : String(error)}`);
-        throw new Error(`Failed to install project dependencies. Please ensure the project can be installed with ${packageManager}.`);
+    const npmCacheDir = path.join(await ensureTmpDir(), "npm-cache");
+    await fs.promises.mkdir(npmCacheDir, { recursive: true });
+    const installCommand = {
+        pnpm: ["pnpm", "install", "--reporter=silent"],
+        npm: ["npm", "install", "--cache", npmCacheDir, "--silent"],
+        yarn: ["yarn", "install", "--silent"],
+        "yarn-classic": ["yarn", "--silent"],
+    }[packageManager];
+    if (isCacheHit && packageManager === "pnpm") {
+        // For pnpm, a targeted `install <tarball>` is much faster
+        // We need to find the tarball name first.
+        const files = await fs.promises.readdir(targetDir);
+        const tarball = files.find((f) => f.startsWith("rwsdk-") && f.endsWith(".tgz"));
+        if (tarball) {
+            installCommand[1] = `./${tarball}`;
+        }
+        else {
+            log("Could not find SDK tarball for targeted install, falling back to full install.");
+        }
     }
+    // Run install command in the target directory
+    log(`Running ${installCommand.join(" ")}`);
+    const [command, ...args] = installCommand;
+    await $(command, args, {
+        cwd: targetDir,
+        stdio: "pipe",
+        env: {
+            YARN_ENABLE_HARDENED_MODE: "0",
+        },
+    });
+    console.log("✅ Dependencies installed successfully");
 }

package/dist/lib/e2e/release.mjs

@@ -44,10 +44,6 @@ export async function $expect(command, expectations, options = {
     reject: true,
 }) {
     return new Promise((resolve, reject) => {
-        log("$expect starting with command: %s", command);
-        log("Working directory: %s", options.cwd ?? process.cwd());
-        log("Expected patterns: %O", expectations.map((e) => e.expect.toString()));
-        console.log(`Running command: ${command}`);
         // Spawn the process with pipes for interaction
         const childProcess = execaCommand(command, {
             cwd: options.cwd ?? process.cwd(),
@@ -55,7 +51,6 @@ export async function $expect(command, expectations, options = {
             reject: false, // Never reject so we can handle the error ourselves
             env: options.env ?? process.env,
         });
-        log("Process spawned with PID: %s", childProcess.pid);
         let stdout = "";
         let stderr = "";
         let buffer = "";
@@ -67,7 +62,6 @@ export async function $expect(command, expectations, options = {
         // Initialize match count for each pattern
         expectations.forEach(({ expect: expectPattern }) => {
             matchHistory.set(expectPattern, 0);
-            log("Initialized pattern match count for: %s", expectPattern.toString());
         });
         // Collect stdout
         childProcess.stdout?.on("data", (data) => {
@@ -85,9 +79,6 @@ export async function $expect(command, expectations, options = {
                     : new RegExp(expectPattern, "m");
                 // Only search in the unmatched portion of the buffer
                 const searchBuffer = buffer.substring(lastMatchIndex);
-                log("Testing pattern: %s against buffer from position %d (%d chars)", pattern.toString(), lastMatchIndex, searchBuffer.length);
-                // Enhanced debugging: show actual search buffer content
-                log("Search buffer content for debugging: %O", searchBuffer);
                 const match = searchBuffer.match(pattern);
                 if (match) {
                     // Found a match
@@ -98,30 +89,21 @@ export async function $expect(command, expectations, options = {
                     const matchStartPosition = lastMatchIndex + match.index;
                     const matchEndPosition = matchStartPosition + match[0].length;
                     lastMatchIndex = matchEndPosition;
-                    log(`Pattern matched: "${patternStr}" (occurrence #${matchCount + 1}) at position ${matchStartPosition}-${matchEndPosition}`);
-                    // Only send a response if one is specified
                     if (send) {
-                        log(`Sending response: "${send.replace(/\r/g, "\\r")}" to stdin`);
                         childProcess.stdin?.write(send);
                     }
-                    else {
-                        log(`Pattern "${patternStr}" matched (verification only)`);
-                    }
                     // Increment the match count for this pattern
                     matchHistory.set(expectPattern, matchCount + 1);
-                    log("Updated match count for %s: %d", patternStr, matchCount + 1);
                     // Move to the next expectation
                     currentExpectationIndex++;
                     // If we've processed all expectations but need to wait for stdin response,
                     // delay closing stdin until the next data event
                     if (currentExpectationIndex >= expectations.length && send) {
-                        log("All patterns matched, closing stdin after last response");
                         childProcess.stdin?.end();
                     }
                     break; // Exit the while loop to process next chunk
                 }
                 else {
-                    log("Pattern not matched. Attempting to diagnose the mismatch:");
                     // Try to find the closest substring that might partially match
                     const patternString = pattern.toString();
                     const patternCore = patternString.substring(1, patternString.lastIndexOf("/") > 0
@@ -132,7 +114,6 @@ export async function $expect(command, expectations, options = {
                         const partialPattern = patternCore.substring(0, i);
                         const partialRegex = new RegExp(partialPattern, "m");
                         const matches = partialRegex.test(searchBuffer);
-                        log("  Partial pattern '%s': %s", partialPattern, matches ? "matched" : "not matched");
                         // Once we find where the matching starts to fail, stop
                         if (!matches)
                             break;
@@ -144,7 +125,6 @@ export async function $expect(command, expectations, options = {
             // If all expectations have been matched, we can close stdin if not already closed
             if (currentExpectationIndex >= expectations.length &&
                 childProcess.stdin?.writable) {
-                log("All patterns matched, ensuring stdin is closed");
                 childProcess.stdin.end();
             }
         });
@@ -160,19 +140,10 @@ export async function $expect(command, expectations, options = {
         // Handle process completion
         childProcess.on("close", (code) => {
             log("Process closed with code: %s", code);
-            // Log the number of matches for each pattern
-            log("Pattern match summary:");
-            for (const [pattern, count] of matchHistory.entries()) {
-                log(`  - "${pattern.toString()}": ${count} matches`);
-            }
             // Check if any required patterns were not matched
             const unmatchedPatterns = Array.from(matchHistory.entries())
                 .filter(([_, count]) => count === 0)
                 .map(([pattern, _]) => pattern.toString());
-            if (unmatchedPatterns.length > 0) {
-                log("WARNING: Some expected patterns were not matched: %O", unmatchedPatterns);
-            }
-            log("$expect completed. Total stdout: %d bytes, stderr: %d bytes", stdout.length, stderr.length);
             resolve({ stdout, stderr, code });
         });
         childProcess.on("error", (err) => {

package/dist/lib/e2e/tarball.mjs

@@ -4,32 +4,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { adjectives, animals, uniqueNamesGenerator, } from "unique-names-generator";
 import { ROOT_DIR } from "../constants.mjs";
-import { copyProjectToTempDir } from "./environment.mjs";
+import { copyProjectToTempDir, } from "./environment.mjs";
 const log = (message) => console.log(message);
-async function verifyPackedContents(targetDir) {
-    log("  - Verifying installed package contents...");
-    const packageName = "rwsdk";
-    const installedDistPath = path.join(targetDir, "node_modules", packageName, "dist");
-    if (!fs.existsSync(installedDistPath)) {
-        throw new Error(`dist/ directory not found in installed package at ${installedDistPath}.`);
-    }
-    const { stdout: originalDistChecksumOut } = await $("find . -type f | sort | md5sum", {
-        shell: true,
-        cwd: path.join(ROOT_DIR, "dist"),
-    });
-    const originalDistChecksum = originalDistChecksumOut.split(" ")[0];
-    const { stdout: installedDistChecksumOut } = await $("find . -type f | sort | md5sum", {
-        shell: true,
-        cwd: installedDistPath,
-    });
-    const installedDistChecksum = installedDistChecksumOut.split(" ")[0];
-    log(`    - Original dist checksum: ${originalDistChecksum}`);
-    log(`    - Installed dist checksum: ${installedDistChecksum}`);
-    if (originalDistChecksum !== installedDistChecksum) {
-        throw new Error("File list in installed dist/ does not match original dist/.");
-    }
-    log("  ✅ Installed package contents match the local build.");
-}
 /**
  * Copies wrangler cache from monorepo to temp directory for deployment tests
  */
@@ -104,7 +80,6 @@ export async function setupTarballEnvironment({ projectDir, monorepoRoot, packag
     const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
     try {
         const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot);
-        await verifyPackedContents(targetDir);
         // Copy wrangler cache to improve deployment performance
         const sdkRoot = ROOT_DIR;
         await copyWranglerCache(targetDir, sdkRoot);

package/dist/lib/e2e/testHarness.mjs

@@ -1,9 +1,9 @@
 import fs from "fs-extra";
-import os from "os";
 import path, { basename, dirname, join as pathJoin } from "path";
 import puppeteer from "puppeteer-core";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, test, } from "vitest";
 import { launchBrowser } from "./browser.mjs";
+import { ensureTmpDir } from "./utils.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 { runDevServer } from "./dev.mjs";
 import { poll, pollValue } from "./poll.mjs";
@@ -34,16 +34,28 @@ function ensureHooksRegistered() {
     afterAll(async () => {
         const cleanupPromises = [];
         for (const instance of devInstances) {
-            cleanupPromises.push(instance.stopDev());
+            cleanupPromises.push(instance.stopDev().catch((error) => {
+                // Suppress all cleanup errors - they don't affect test results
+                console.warn(`Suppressing error during dev server cleanup: ${error instanceof Error ? error.message : String(error)}`);
+            }));
         }
         for (const instance of deploymentInstances) {
-            cleanupPromises.push(instance.cleanup());
+            cleanupPromises.push(instance.cleanup().catch((error) => {
+                // Suppress all cleanup errors - they don't affect test results
+                console.warn(`Suppressing error during deployment cleanup: ${error instanceof Error ? error.message : String(error)}`);
+            }));
         }
         if (globalDevPlaygroundEnv) {
-            cleanupPromises.push(globalDevPlaygroundEnv.cleanup());
+            cleanupPromises.push(globalDevPlaygroundEnv.cleanup().catch((error) => {
+                // Suppress all cleanup errors - they don't affect test results
+                console.warn(`Suppressing error during dev environment cleanup: ${error instanceof Error ? error.message : String(error)}`);
+            }));
         }
         if (globalDeployPlaygroundEnv) {
-            cleanupPromises.push(globalDeployPlaygroundEnv.cleanup());
+            cleanupPromises.push(globalDeployPlaygroundEnv.cleanup().catch((error) => {
+                // Suppress all cleanup errors - they don't affect test results
+                console.warn(`Suppressing error during deploy environment cleanup: ${error instanceof Error ? error.message : String(error)}`);
+            }));
         }
         await Promise.all(cleanupPromises);
         devInstances.length = 0;
@@ -128,7 +140,7 @@ export function setupPlaygroundEnvironment(options) {
         else {
             globalDevPlaygroundEnv = null;
         }
-        if (deploy) {
+        if (deploy && !SKIP_DEPLOYMENT_TESTS) {
             const deployEnv = await setupTarballEnvironment({
                 projectDir,
                 monorepoRoot,
@@ -313,7 +325,7 @@ function createTestRunner(testFn, envType) {
             let instance;
             let browser;
             beforeAll(async () => {
-                const tempDir = path.join(os.tmpdir(), "rwsdk-e2e-tests");
+                const tempDir = path.join(await ensureTmpDir(), "rwsdk-e2e-tests");
                 const wsEndpointFile = path.join(tempDir, "wsEndpoint");
                 try {
                     const wsEndpoint = await fs.readFile(wsEndpointFile, "utf-8");
@@ -386,7 +398,7 @@ function createSDKTestRunner() {
                 let page;
                 let browser;
                 beforeAll(async () => {
-                    const tempDir = path.join(os.tmpdir(), "rwsdk-e2e-tests");
+                    const tempDir = path.join(await ensureTmpDir(), "rwsdk-e2e-tests");
                     const wsEndpointFile = path.join(tempDir, "wsEndpoint");
                     try {
                         const wsEndpoint = await fs.readFile(wsEndpointFile, "utf-8");

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

@@ -0,0 +1 @@
+export declare function ensureTmpDir(): Promise<string>;

package/dist/lib/e2e/utils.mjs

@@ -0,0 +1,15 @@
+import { mkdirp } from "fs-extra";
+import os from "node:os";
+import fs from "node:fs";
+import path from "node:path";
+export async function ensureTmpDir() {
+    let baseTmpDir = os.tmpdir();
+    // context(justinvdm, 2 Nov 2025): Normalize the base temp dir on Windows
+    // to prevent short/long path mismatches that break Vite's alias resolution.
+    if (process.platform === "win32") {
+        baseTmpDir = fs.realpathSync.native(baseTmpDir);
+    }
+    const tmpDir = path.join(baseTmpDir, "rwsdk-e2e");
+    await mkdirp(tmpDir);
+    return tmpDir;
+}

package/dist/vite/redwoodPlugin.mjs

@@ -75,12 +75,10 @@ export const redwoodPlugin = async (options = {}) => {
     // context(justinvdm, 31 Mar 2025): We assume that if there is no .wrangler directory,
     // then this is fresh install, and we run `npm run dev:init` here.
     if (process.env.RWSDK_WORKER_RUN !== "1" &&
-        process.env.RWSDK_DEPLOY !== "1" &&
+        process.env.NODE_ENV !== "production" &&
         !(await pathExists(resolve(projectRootDir, ".wrangler"))) &&
         (await hasPkgScript(projectRootDir, "dev:init"))) {
         console.log("🚀 Project has no .wrangler directory yet, assuming fresh install: running `npm run dev:init`...");
-        // @ts-ignore
-        $.verbose = true;
         await $ `npm run dev:init`;
     }
     return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.23",
+  "version": "1.0.0-beta.24",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {