rwsdk 1.0.0-beta.3 → 1.0.0-beta.30

package/dist/lib/e2e/environment.mjs

@@ -1,19 +1,88 @@
+import { createHash } from "crypto";
 import debug from "debug";
 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 } from "./constants.mjs";
 import { retry } from "./retry.mjs";
-import { INSTALL_DEPENDENCIES_RETRIES } from "./testHarness.mjs";
+import { ensureTmpDir } from "./utils.mjs";
 const log = debug("rwsdk:e2e:environment");
+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
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/--+/g, "-")
+        .replace(/^-|-$/g, "");
+}
 const createSdkTarball = async () => {
     const existingTarballPath = process.env.RWSKD_SMOKE_TEST_TARBALL_PATH;
     if (existingTarballPath) {
@@ -28,15 +97,32 @@ const createSdkTarball = async () => {
             }, // No-op cleanup
         };
     }
-    const packResult = await $({ cwd: ROOT_DIR, stdio: "pipe" }) `npm pack`;
-    const tarballName = packResult.stdout?.trim();
-    const tarballPath = path.join(ROOT_DIR, tarballName);
-    log(`📦 Created tarball: ${tarballPath}`);
+    // Create a temporary directory to receive the tarball, ensuring a stable path.
+    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",
+    }) `npm pack --pack-destination=${tempDir}`;
+    // We need to determine the tarball's name, as it's version-dependent.
+    // Running `npm pack --dry-run` gives us the filename without creating a file.
+    const packDryRun = await $({
+        cwd: ROOT_DIR,
+        stdio: "pipe",
+    }) `npm pack --dry-run`;
+    const tarballName = packDryRun.stdout?.trim();
+    const tarballPath = path.join(tempDir, tarballName);
+    if (!fs.existsSync(tarballPath)) {
+        throw new Error(`Tarball was not created in the expected location: ${tarballPath}`);
+    }
+    log(`📦 Created tarball in stable temp location: ${tarballPath}`);
     const cleanupTarball = async () => {
-        if (fs.existsSync(tarballPath)) {
-            log(`🧹 Cleaning up tarball: ${tarballPath}`);
-            await fs.promises.rm(tarballPath, { force: true });
-        }
+        log(`🧹 Cleaning up tarball directory: ${tempDir}`);
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
     };
     return { tarballPath, cleanupTarball };
 };
@@ -58,8 +144,13 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         // Determine the source directory to copy from
         const sourceDir = monorepoRoot || projectDir;
         // Create unique project directory name
+        // Format: {projectName}-t-{hash} (kept under 54 chars for Cloudflare limit)
         const originalDirName = basename(sourceDir);
-        const workerName = `${originalDirName}-test-${resourceUniqueKey}`;
+        const slugified = slugify(originalDirName);
+        // Truncate project name to leave room for "-t-" (3 chars) + hash (8 chars) = 11 chars
+        // Max project name: 54 - 11 = 43 chars
+        const truncatedProjectName = slugified.substring(0, 43);
+        const workerName = `${truncatedProjectName}-t-${resourceUniqueKey}`;
         const tempCopyRoot = resolve(tempDir.path, workerName);
         // If it's a monorepo, the targetDir for commands is a subdirectory
         const targetDir = monorepoRoot
@@ -115,7 +206,9 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
                 const workspaces = rwsdkWs.workspaces;
                 if (packageManager === "pnpm") {
                     const pnpmWsPath = join(tempCopyRoot, "pnpm-workspace.yaml");
-                    const pnpmWsConfig = `packages:\n${workspaces.map((w) => `  - '${w}'`).join("\n")}\n`;
+                    const pnpmWsConfig = `packages:\n${workspaces
+                        .map((w) => `  - '${w}'`)
+                        .join("\n")}\n`;
                     await fs.promises.writeFile(pnpmWsPath, pnpmWsConfig);
                     log("Created pnpm-workspace.yaml");
                 }
@@ -133,31 +226,32 @@ 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");
         }
         await setTarballDependency(targetDir, tarballFilename);
         // Install dependencies in the target directory
         const installDir = monorepoRoot ? tempCopyRoot : targetDir;
-        await retry(() => installDependencies(installDir, packageManager), {
+        await retry(() => installDependencies(installDir, packageManager, projectDir, monorepoRoot), {
             retries: INSTALL_DEPENDENCIES_RETRIES,
             delay: 1000,
         });
@@ -168,9 +262,61 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         await cleanupTarball();
     }
 }
-async function installDependencies(targetDir, packageManager = "pnpm") {
-    console.log(`📦 Installing project dependencies in ${targetDir} using ${packageManager}...`);
-    try {
+async function installDependencies(targetDir, packageManager = "pnpm", projectDir, monorepoRoot) {
+    let cacheRoot = null;
+    let nodeModulesCachePath = null;
+    if (IS_CACHE_ENABLED) {
+        const dependencyHash = await getProjectDependencyHash(monorepoRoot || projectDir);
+        const cacheDirName = monorepoRoot
+            ? basename(monorepoRoot)
+            : basename(projectDir);
+        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 dependencies: Found cached node_modules. Hard-linking from ${nodeModulesCachePath}`);
+            try {
+                const destNodeModules = join(targetDir, "node_modules");
+                if (process.platform === "win32") {
+                    await copy(nodeModulesCachePath, destNodeModules);
+                }
+                else {
+                    // On non-windows, use cp -al for performance
+                    await $("cp", ["-al", nodeModulesCachePath, targetDir]);
+                }
+                console.log(`✅ Cache restored successfully.`);
+                console.log(`📦 Installing local SDK into cached node_modules...`);
+                await runInstall(targetDir, packageManager, true);
+                return;
+            }
+            catch (e) {
+                console.warn(`⚠️ Cache restore failed. Error: ${e.message}. Proceeding with clean install.`);
+            }
+        }
+        else {
+            console.log(`ℹ️ CACHE MISS for dependencies: No cached node_modules found at ${nodeModulesCachePath}. Proceeding with clean installation.`);
+        }
+    }
+    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,
+        });
+        if (process.platform === "win32") {
+            await copy(join(targetDir, "node_modules"), nodeModulesCachePath);
+        }
+        else {
+            await $("cp", [
+                "-al",
+                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([
@@ -183,51 +329,42 @@ async function installDependencies(targetDir, packageManager = "pnpm") {
             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",
-                });
-            }
+    }
+    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",
+            });
         }
-        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");
-        // 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];
+    // 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/index.d.mts

@@ -1,3 +1,4 @@
+export * from "../$.mjs";
 export * from "./browser.mjs";
 export * from "./dev.mjs";
 export * from "./environment.mjs";

package/dist/lib/e2e/index.mjs

@@ -1,3 +1,4 @@
+export * from "../$.mjs";
 export * from "./browser.mjs";
 export * from "./dev.mjs";
 export * from "./environment.mjs";

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

@@ -4,5 +4,5 @@ export interface PollOptions {
     minTries: number;
     onRetry?: (error: unknown, tries: number) => void;
 }
-export declare function poll(fn: () => Promise<boolean>, options?: Partial<PollOptions>): Promise<void>;
+export declare function poll(fn: () => boolean | Promise<boolean>, options?: Partial<PollOptions>): Promise<void>;
 export declare function pollValue<T>(fn: () => Promise<T>, options?: Partial<PollOptions>): Promise<T>;

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

@@ -39,6 +39,7 @@ export declare function runRelease(cwd: string, projectDir: string, resourceUniq
 /**
  * Check if a resource name includes a specific resource unique key
  * This is used to identify resources created during our tests
+ * Handles both full format (adjective-animal-hash) and hash-only format
  */
 export declare function isRelatedToTest(resourceName: string, resourceUniqueKey: string): boolean;
 /**

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) => {
@@ -274,9 +245,15 @@ export async function runRelease(cwd, projectDir, resourceUniqueKey) {
         await ensureCloudflareAccountId(cwd, projectDir);
         // Extract worker name from directory name to ensure consistency
         const dirName = cwd ? basename(cwd) : "unknown-worker";
+        // Extract hash part from resourceUniqueKey for matching
+        // resourceUniqueKey format is typically "adjective-animal-hash" or just "hash"
+        const hashPart = resourceUniqueKey.includes("-")
+            ? resourceUniqueKey.split("-").pop() || resourceUniqueKey.substring(0, 8)
+            : resourceUniqueKey.substring(0, 8);
+        const uniqueKeyForMatching = hashPart.substring(0, 8);
         // Ensure resource unique key is included in worker name for tracking
-        if (resourceUniqueKey && !dirName.includes(resourceUniqueKey)) {
-            log(`Worker name doesn't contain our unique key, this is unexpected: ${dirName}, key: ${resourceUniqueKey}`);
+        if (resourceUniqueKey && !dirName.includes(uniqueKeyForMatching)) {
+            log(`Worker name doesn't contain our unique key, this is unexpected: ${dirName}, key: ${uniqueKeyForMatching}`);
             console.log(`⚠️ Worker name doesn't contain our unique key. This might cause cleanup issues.`);
         }
         // Ensure the worker name in wrangler.jsonc matches our unique name
@@ -405,9 +382,16 @@ export async function runRelease(cwd, projectDir, resourceUniqueKey) {
 /**
  * Check if a resource name includes a specific resource unique key
  * This is used to identify resources created during our tests
+ * Handles both full format (adjective-animal-hash) and hash-only format
  */
 export function isRelatedToTest(resourceName, resourceUniqueKey) {
-    return resourceName.includes(resourceUniqueKey);
+    // Extract hash part if resourceUniqueKey contains dashes (full format)
+    // Otherwise use as-is (hash-only format)
+    const hashPart = resourceUniqueKey.includes("-")
+        ? resourceUniqueKey.split("-").pop() || resourceUniqueKey.substring(0, 8)
+        : resourceUniqueKey;
+    const uniqueKeyForMatching = hashPart.substring(0, 8);
+    return resourceName.includes(uniqueKeyForMatching);
 }
 /**
  * Delete the worker using wrangler

package/dist/lib/e2e/tarball.mjs

@@ -2,34 +2,9 @@ import { createHash } from "crypto";
 import { $ } from "execa";
 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";
 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
  */
@@ -90,21 +65,14 @@ async function copyWranglerCache(targetDir, sdkRoot) {
 export async function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager = "pnpm", }) {
     log(`🚀 Setting up tarball environment for ${projectDir}`);
     // Generate a resource unique key for this test run
-    const uniqueNameSuffix = uniqueNamesGenerator({
-        dictionaries: [adjectives, animals],
-        separator: "-",
-        length: 2,
-        style: "lowerCase",
-    });
-    // Create a short unique hash based on the timestamp
+    // Use just the hash to keep worker names short (under Cloudflare's 54 char limit)
     const hash = createHash("md5")
         .update(Date.now().toString())
         .digest("hex")
         .substring(0, 8);
-    const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
+    const resourceUniqueKey = 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);