rwsdk 1.0.0-alpha.10 → 1.0.0-alpha.12

package/dist/lib/e2e/dev.mjs

@@ -1,6 +1,10 @@
-import { setTimeout } from "node:timers/promises";
+import { setTimeout as sleep } from "node:timers/promises";
 import debug from "debug";
 import { $ } from "../../lib/$.mjs";
+import { poll } from "./poll.mjs";
+const DEV_SERVER_CHECK_TIMEOUT = process.env.RWSDK_DEV_SERVER_CHECK_TIMEOUT
+    ? parseInt(process.env.RWSDK_DEV_SERVER_CHECK_TIMEOUT, 10)
+    : 5 * 60 * 1000;
 const log = debug("rwsdk:e2e:dev");
 /**
  * Run the local development server and return the URL
@@ -12,59 +16,47 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
     let isErrorExpected = false;
     const stopDev = async () => {
         isErrorExpected = true;
-        if (!devProcess) {
-            log("No dev process to stop");
+        if (!devProcess || !devProcess.pid) {
+            log("No dev process to stop or PID is missing");
             return;
         }
         console.log("Stopping development server...");
         try {
-            // Send a regular termination signal first
-            devProcess.kill();
-            // Wait for the process to terminate with a timeout
-            const terminationTimeout = 5000; // 5 seconds timeout
-            const terminationPromise = Promise.race([
-                // Wait for natural process termination
-                (async () => {
-                    try {
-                        await devProcess;
-                        log("Dev server process was terminated normally");
-                        return true;
-                    }
-                    catch (e) {
-                        // Expected error when the process is killed
-                        log("Dev server process was terminated");
-                        return true;
-                    }
-                })(),
-                // Or timeout
-                (async () => {
-                    await setTimeout(terminationTimeout);
-                    return false;
-                })(),
-            ]);
-            // Check if process terminated within timeout
-            const terminated = await terminationPromise;
-            // If not terminated within timeout, force kill
-            if (!terminated) {
-                log("Dev server process did not terminate within timeout, force killing with SIGKILL");
-                console.log("⚠️ Development server not responding after 5 seconds timeout, force killing...");
-                // Try to kill with SIGKILL if the process still has a pid
-                if (devProcess.pid) {
-                    try {
-                        // Use process.kill with SIGKILL for a stronger termination
-                        process.kill(devProcess.pid, "SIGKILL");
-                        log("Sent SIGKILL to process %d", devProcess.pid);
-                    }
-                    catch (killError) {
-                        log("Error sending SIGKILL to process: %O", killError);
-                        // Non-fatal, as the process might already be gone
-                    }
-                }
-            }
+            // Send a regular termination signal to the entire process group first
+            process.kill(-devProcess.pid, "SIGTERM");
         }
         catch (e) {
-            // Process might already have exited
-            log("Could not kill dev server process: %O", e);
+            log("Could not send SIGTERM to dev server process group: %O", e);
+        }
+        // Wait for the process to terminate with a timeout
+        const terminationTimeout = 5000; // 5 seconds
+        const processExitPromise = devProcess.catch(() => {
+            // We expect this promise to reject when the process is killed,
+            // so we catch and ignore the error.
+        });
+        const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(undefined), terminationTimeout));
+        await Promise.race([processExitPromise, timeoutPromise]);
+        // Check if the process is still alive. We can't reliably check exitCode
+        // on a detached process, so we try sending a signal 0, which errors
+        // if the process doesn't exist.
+        let isAlive = true;
+        try {
+            // Sending signal 0 doesn't kill the process, but checks if it exists
+            process.kill(-devProcess.pid, 0);
+        }
+        catch (e) {
+            isAlive = false;
+        }
+        // If not terminated within timeout, force kill the entire process group
+        if (isAlive) {
+            log("Dev server process did not terminate within timeout, force killing with SIGKILL");
+            console.log("⚠️ Development server not responding after 5 seconds timeout, force killing...");
+            try {
+                process.kill(-devProcess.pid, "SIGKILL");
+            }
+            catch (e) {
+                log("Could not send SIGKILL to dev server process group: %O", e);
+            }
         }
         console.log("Development server stopped");
     };
@@ -96,7 +88,7 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         // Use the provided cwd if available
         devProcess = $({
             all: true,
-            detached: false, // Keep attached so we can access streams
+            detached: true, // Run in a new process group so we can kill the entire group
             cleanup: false, // Don't auto-kill on exit
             cwd: cwd || process.cwd(), // Use provided directory or current directory
             env, // Pass the updated environment variables
@@ -104,8 +96,10 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         }) `${pm} run dev`;
         devProcess.catch((error) => {
             if (!isErrorExpected) {
-                // Just throw the error, let the caller handle it.
-                throw error;
+                // 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("Development server process spawned in directory: %s", cwd || process.cwd());
@@ -211,7 +205,7 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
                     log("ERROR: Development server process exited with code %d. Final output: %s", devProcess.exitCode, allOutput);
                     throw new Error(`Development server process exited with code ${devProcess.exitCode}`);
                 }
-                await setTimeout(500); // Check every 500ms
+                await sleep(500); // Check every 500ms
             }
             log("ERROR: Timed out waiting for dev server URL. Final accumulated output: %s", allOutput);
             throw new Error("Timed out waiting for dev server URL");
@@ -219,6 +213,22 @@ 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 };
     }
     catch (error) {

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

@@ -7,7 +7,7 @@ export declare function setupTestEnvironment(options?: SmokeTestOptions): Promis
 /**
  * Copy project to a temporary directory with a unique name
  */
-export declare function copyProjectToTempDir(projectDir: string, resourceUniqueKey: string, packageManager?: PackageManager): Promise<{
+export declare function copyProjectToTempDir(projectDir: string, resourceUniqueKey: string, packageManager?: PackageManager, monorepoRoot?: string): Promise<{
     tempDir: tmp.DirectoryResult;
     targetDir: string;
     workerName: string;

package/dist/lib/e2e/environment.mjs

@@ -10,6 +10,8 @@ import { createHash } from "crypto";
 import { $ } from "../../lib/$.mjs";
 import { ROOT_DIR } from "../constants.mjs";
 import path from "node:path";
+import os from "os";
+import { retry } from "./retry.mjs";
 const log = debug("rwsdk:e2e:environment");
 const createSdkTarball = async () => {
     const packResult = await $({ cwd: ROOT_DIR, stdio: "pipe" }) `npm pack`;
@@ -24,11 +26,11 @@ const createSdkTarball = async () => {
     };
     return { tarballPath, cleanupTarball };
 };
-const setTarballDependency = async (targetDir, tarballPath) => {
+const setTarballDependency = async (targetDir, tarballName) => {
     const filePath = join(targetDir, "package.json");
     const packageJson = await fs.promises.readFile(filePath, "utf-8");
     const packageJsonContent = JSON.parse(packageJson);
-    packageJsonContent.dependencies.rwsdk = `file:${tarballPath}`;
+    packageJsonContent.dependencies.rwsdk = `file:${tarballName}`;
     await fs.promises.writeFile(filePath, JSON.stringify(packageJsonContent, null, 2));
 };
 /**
@@ -87,20 +89,26 @@ export async function setupTestEnvironment(options = {}) {
 /**
  * Copy project to a temporary directory with a unique name
  */
-export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager) {
+export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot) {
     const { tarballPath, cleanupTarball } = await createSdkTarball();
     try {
         log("Creating temporary directory for project");
         // Create a temporary directory
         const tempDir = await tmp.dir({ unsafeCleanup: true });
+        // Determine the source directory to copy from
+        const sourceDir = monorepoRoot || projectDir;
         // Create unique project directory name
-        const originalDirName = basename(projectDir);
+        const originalDirName = basename(sourceDir);
         const workerName = `${originalDirName}-test-${resourceUniqueKey}`;
-        const targetDir = resolve(tempDir.path, workerName);
-        console.log(`Copying project from ${projectDir} to ${targetDir}`);
+        const tempCopyRoot = resolve(tempDir.path, workerName);
+        // If it's a monorepo, the targetDir for commands is a subdirectory
+        const targetDir = monorepoRoot
+            ? resolve(tempCopyRoot, relative(monorepoRoot, projectDir))
+            : tempCopyRoot;
+        console.log(`Copying project from ${sourceDir} to ${tempCopyRoot}`);
         // Read project's .gitignore if it exists
         let ig = ignore();
-        const gitignorePath = join(projectDir, ".gitignore");
+        const gitignorePath = join(sourceDir, ".gitignore");
         if (await pathExists(gitignorePath)) {
             log("Found .gitignore file at %s", gitignorePath);
             const gitignoreContent = await fs.promises.readFile(gitignorePath, "utf-8");
@@ -123,10 +131,10 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         }
         // Copy the project directory, respecting .gitignore
         log("Starting copy process with ignored patterns");
-        await copy(projectDir, targetDir, {
+        await copy(sourceDir, tempCopyRoot, {
             filter: (src) => {
                 // Get path relative to project directory
-                const relativePath = relative(projectDir, src);
+                const relativePath = relative(sourceDir, src);
                 if (!relativePath)
                     return true; // Include the root directory
                 // Check against ignore patterns
@@ -135,6 +143,32 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
             },
         });
         log("Project copy completed successfully");
+        // Copy the SDK tarball into the target directory
+        const tarballFilename = basename(tarballPath);
+        const tempTarballPath = join(targetDir, tarballFilename);
+        await fs.promises.copyFile(tarballPath, tempTarballPath);
+        if (monorepoRoot) {
+            log("⚙️  Configuring monorepo workspace...");
+            const rwsdkWsPath = join(tempCopyRoot, "rwsdk-workspace.json");
+            if (await pathExists(rwsdkWsPath)) {
+                const rwsdkWs = JSON.parse(await fs.promises.readFile(rwsdkWsPath, "utf-8"));
+                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`;
+                    await fs.promises.writeFile(pnpmWsPath, pnpmWsConfig);
+                    log("Created pnpm-workspace.yaml");
+                }
+                else {
+                    // For npm and yarn, add a workspaces property to package.json
+                    const pkgJsonPath = join(tempCopyRoot, "package.json");
+                    const pkgJson = JSON.parse(await fs.promises.readFile(pkgJsonPath, "utf-8"));
+                    pkgJson.workspaces = workspaces;
+                    await fs.promises.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+                    log("Added workspaces to package.json");
+                }
+            }
+        }
         // Configure temp project to not use frozen lockfile
         log("⚙️  Configuring temp project to not use frozen lockfile...");
         const npmrcPath = join(targetDir, ".npmrc");
@@ -142,17 +176,24 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         // For yarn, create .yarnrc.yml to disable PnP and allow lockfile changes
         if (packageManager === "yarn") {
             const yarnrcPath = join(targetDir, ".yarnrc.yml");
+            const yarnCacheDir = path.join(os.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}"`,
             ].join("\n");
             await fs.promises.writeFile(yarnrcPath, yarnConfig);
             log("Created .yarnrc.yml to allow lockfile changes for yarn");
         }
-        await setTarballDependency(targetDir, tarballPath);
+        await setTarballDependency(targetDir, tarballFilename);
         // Install dependencies in the target directory
-        await installDependencies(targetDir, packageManager);
+        const installDir = monorepoRoot ? tempCopyRoot : targetDir;
+        await retry(() => installDependencies(installDir, packageManager), {
+            retries: 3,
+            delay: 1000,
+        });
         // Return the environment details
         return { tempDir, targetDir, workerName };
     }
@@ -193,9 +234,11 @@ async function installDependencies(targetDir, packageManager = "pnpm") {
                 });
             }
         }
+        const npmCacheDir = path.join(os.tmpdir(), "npm-cache");
+        await fs.promises.mkdir(npmCacheDir, { recursive: true });
         const installCommand = {
             pnpm: ["pnpm", "install"],
-            npm: ["npm", "install"],
+            npm: ["npm", "install", "--cache", npmCacheDir],
             yarn: ["yarn", "install"],
             "yarn-classic": ["yarn"],
         }[packageManager];

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

@@ -5,3 +5,4 @@ export * from "./dev.mjs";
 export * from "./browser.mjs";
 export * from "./release.mjs";
 export * from "./types.mjs";
+export * from "./poll.mjs";

package/dist/lib/e2e/index.mjs

@@ -5,3 +5,4 @@ export * from "./dev.mjs";
 export * from "./browser.mjs";
 export * from "./release.mjs";
 export * from "./types.mjs";
+export * from "./poll.mjs";

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

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

package/dist/lib/e2e/poll.mjs

@@ -0,0 +1,31 @@
+import { setTimeout } from "node:timers/promises";
+const POLL_TIMEOUT = process.env.RWSDK_POLL_TIMEOUT
+    ? parseInt(process.env.RWSDK_POLL_TIMEOUT, 10)
+    : 2 * 60 * 1000;
+export async function poll(fn, options = {}) {
+    const { timeout = POLL_TIMEOUT, interval = 100, minTries = 3, onRetry, } = options;
+    const startTime = Date.now();
+    let tries = 0;
+    while (Date.now() - startTime < timeout || tries < minTries) {
+        tries++;
+        try {
+            if (await fn()) {
+                return;
+            }
+        }
+        catch (error) {
+            onRetry?.(error, tries);
+            // Continue polling on errors
+        }
+        await setTimeout(interval);
+    }
+    throw new Error(`Polling timed out after ${Date.now() - startTime}ms and ${tries} attempts`);
+}
+export async function pollValue(fn, options = {}) {
+    let value;
+    await poll(async () => {
+        value = await fn();
+        return true;
+    }, options);
+    return value;
+}

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

@@ -0,0 +1,4 @@
+export declare function retry<T>(fn: () => Promise<T>, options: {
+    retries: number;
+    delay: number;
+}): Promise<T>;

package/dist/lib/e2e/retry.mjs

@@ -0,0 +1,16 @@
+import { setTimeout } from "node:timers/promises";
+const log = console.log;
+export async function retry(fn, options) {
+    let lastError;
+    for (let i = 0; i < options.retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            lastError = e;
+            log(`Attempt ${i + 1} failed. Retrying in ${options.delay}ms...`);
+            await setTimeout(options.delay);
+        }
+    }
+    throw lastError;
+}

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

@@ -0,0 +1,2 @@
+export { launchBrowser } from "./browser.mjs";
+export type { Browser } from "puppeteer-core";

package/dist/lib/e2e/setup.mjs

@@ -0,0 +1 @@
+export { launchBrowser } from "./browser.mjs";

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

@@ -1,5 +1,6 @@
 interface SetupTarballOptions {
     projectDir: string;
+    monorepoRoot?: string;
     packageManager?: "pnpm" | "npm" | "yarn";
 }
 interface TarballEnvironment {
@@ -9,5 +10,5 @@ interface TarballEnvironment {
 /**
  * Creates a tarball-based test environment similar to the release script approach
  */
-export declare function setupTarballEnvironment({ projectDir, packageManager, }: SetupTarballOptions): Promise<TarballEnvironment>;
+export declare function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager, }: SetupTarballOptions): Promise<TarballEnvironment>;
 export {};

package/dist/lib/e2e/tarball.mjs

@@ -63,7 +63,7 @@ async function copyWranglerCache(targetDir, sdkRoot) {
 /**
  * Creates a tarball-based test environment similar to the release script approach
  */
-export async function setupTarballEnvironment({ projectDir, packageManager = "pnpm", }) {
+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({
@@ -79,7 +79,7 @@ export async function setupTarballEnvironment({ projectDir, packageManager = "pn
         .substring(0, 8);
     const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
     try {
-        const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager);
+        const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot);
         // Copy wrangler cache to improve deployment performance
         const sdkRoot = ROOT_DIR;
         await copyWranglerCache(targetDir, sdkRoot);

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

@@ -1,8 +1,6 @@
-import type { Browser, Page } from "puppeteer-core";
-interface PlaygroundEnvironment {
-    projectDir: string;
-    cleanup: () => Promise<void>;
-}
+import { test } from "vitest";
+import { type Browser, type Page } from "puppeteer-core";
+export type { Browser, Page } from "puppeteer-core";
 interface DevServerInstance {
     url: string;
     stopDev: () => Promise<void>;
@@ -12,39 +10,48 @@ interface DeploymentInstance {
     workerName: string;
     resourceUniqueKey: string;
     projectDir: string;
+    cleanup: () => Promise<void>;
+}
+export interface SetupPlaygroundEnvironmentOptions {
+    /**
+     * The directory of the playground project to set up.
+     * Can be an absolute path, or a `import.meta.url` `file://` string.
+     * If not provided, it will be inferred from the test file's path.
+     */
+    sourceProjectDir?: string;
+    /**
+     * The root directory of the monorepo, if the project is part of one.
+     * This is used to correctly set up the test environment for monorepo projects.
+     */
+    monorepoRoot?: string;
+    /**
+     * Whether to provision a dev server for the test suite.
+     * @default true
+     */
+    dev?: boolean;
+    /**
+     * Whether to provision a deployment for the test suite.
+     * @default true
+     */
+    deploy?: boolean;
 }
 /**
- * Sets up a playground environment for the entire test suite.
- * Automatically registers beforeAll and afterAll hooks.
- *
- * @param sourceProjectDir - Explicit path to playground directory, or import.meta.url to auto-detect
- */
-export declare function setupPlaygroundEnvironment(sourceProjectDir?: string): void;
-/**
- * Gets the current playground environment.
- * Throws if no environment has been set up.
+ * A Vitest hook that sets up a playground environment for a test file.
+ * It creates a temporary directory, copies the playground project into it,
+ * and installs dependencies using a tarball of the SDK.
+ * This ensures that tests run in a clean, isolated environment.
  */
-export declare function getPlaygroundEnvironment(): PlaygroundEnvironment;
+export declare function setupPlaygroundEnvironment(options?: string | SetupPlaygroundEnvironmentOptions): void;
 /**
  * Creates a dev server instance using the shared playground environment.
  * Automatically registers cleanup to run after the test.
  */
-export declare function createDevServer(): Promise<DevServerInstance>;
+export declare function createDevServer(projectDir: string): Promise<DevServerInstance>;
 /**
  * Creates a deployment instance using the shared playground environment.
  * Automatically registers cleanup to run after the test.
  */
-export declare function createDeployment(): Promise<DeploymentInstance>;
-/**
- * Manually cleans up a deployment instance (deletes worker and D1 database).
- * This is optional since cleanup happens automatically after each test.
- */
-export declare function cleanupDeployment(deployment: DeploymentInstance): Promise<void>;
-/**
- * Creates a browser instance for testing.
- * Automatically registers cleanup to run after the test.
- */
-export declare function createBrowser(): Promise<Browser>;
+export declare function createDeployment(projectDir: string): Promise<DeploymentInstance>;
 /**
  * Executes a test function with a retry mechanism for specific error codes.
  * @param name - The name of the test, used for logging.
@@ -53,23 +60,24 @@ export declare function createBrowser(): Promise<Browser>;
  *                     return a cleanup function. The cleanup function will be
  *                     called automatically on failure.
  */
-export declare function runTestWithRetries(name: string, attemptFn: () => Promise<{
-    cleanup: () => Promise<void>;
-}>): Promise<void>;
+export declare function runTestWithRetries(name: string, attemptFn: () => Promise<void>): Promise<void>;
+declare function createTestRunner(testFn: (typeof test | typeof test.only)["concurrent"], envType: "dev" | "deploy"): (name: string, testLogic: (context: {
+    devServer?: DevServerInstance;
+    deployment?: DeploymentInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>) => void;
 /**
  * High-level test wrapper for dev server tests.
  * Automatically skips if RWSDK_SKIP_DEV=1
  */
-export declare function testDev(name: string, testFn: (context: {
-    devServer: DevServerInstance;
-    browser: Browser;
-    page: Page;
-    url: string;
-}) => Promise<void>): void;
+export declare function testDev(...args: Parameters<ReturnType<typeof createTestRunner>>): void;
 export declare namespace testDev {
     var skip: (name: string, testFn?: any) => void;
-    var only: (name: string, testFn: (context: {
-        devServer: DevServerInstance;
+    var only: (name: string, testLogic: (context: {
+        devServer?: DevServerInstance;
+        deployment?: DeploymentInstance;
         browser: Browser;
         page: Page;
         url: string;
@@ -79,16 +87,12 @@ export declare namespace testDev {
  * High-level test wrapper for deployment tests.
  * Automatically skips if RWSDK_SKIP_DEPLOY=1
  */
-export declare function testDeploy(name: string, testFn: (context: {
-    deployment: DeploymentInstance;
-    browser: Browser;
-    page: Page;
-    url: string;
-}) => Promise<void>): void;
+export declare function testDeploy(...args: Parameters<ReturnType<typeof createTestRunner>>): void;
 export declare namespace testDeploy {
     var skip: (name: string, testFn?: any) => void;
-    var only: (name: string, testFn: (context: {
-        deployment: DeploymentInstance;
+    var only: (name: string, testLogic: (context: {
+        devServer?: DevServerInstance;
+        deployment?: DeploymentInstance;
         browser: Browser;
         page: Page;
         url: string;
@@ -116,8 +120,13 @@ export declare namespace testDevAndDeploy {
     }) => Promise<void>) => void;
 }
 /**
- * Utility function for polling/retrying assertions
+ * Waits for the page to be fully loaded and hydrated.
+ * This should be used before any user interaction is simulated.
  */
-export declare function poll(fn: () => Promise<boolean>, timeout?: number, // 2 minutes
-interval?: number): Promise<void>;
-export {};
+export declare function waitForHydration(page: Page): Promise<void>;
+export declare function trackPageErrors(page: Page): {
+    get: () => {
+        consoleErrors: string[];
+        failedRequests: string[];
+    };
+};