rwsdk 0.1.16 → 0.1.17

package/dist/lib/$.d.mts

@@ -0,0 +1,8 @@
+export declare const $: import("execa").ExecaScriptMethod<{
+    stdio: "inherit" | "pipe";
+}>;
+export declare const $sh: import("execa").ExecaScriptMethod<{
+    stdio: "inherit" | "pipe";
+} & {
+    shell: true;
+}>;

package/dist/lib/$.mjs

@@ -0,0 +1,5 @@
+import { $ as base } from "execa";
+export const $ = base({
+    stdio: process.env.VERBOSE || process.env.CI ? "inherit" : "pipe",
+});
+export const $sh = $({ shell: true });

package/dist/lib/compileTsModule.d.mts

@@ -0,0 +1 @@
+export declare const compileTsModule: (tsCode: string) => string;

package/dist/lib/compileTsModule.mjs

@@ -0,0 +1,27 @@
+import ts from "typescript";
+import path from "path";
+export const compileTsModule = (tsCode) => {
+    const tsConfigPath = "./tsconfig.json";
+    // Find the nearest tsconfig.json
+    const configPath = ts.findConfigFile(path.dirname(tsConfigPath), ts.sys.fileExists, path.basename(tsConfigPath));
+    if (!configPath) {
+        throw new Error(`Could not find a valid tsconfig.json at path: ${tsConfigPath}`);
+    }
+    // Read and parse tsconfig.json
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.error) {
+        throw new Error(`Error reading tsconfig.json: ${ts.formatDiagnostic(configFile.error, ts.createCompilerHost({}))}`);
+    }
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+    const compilerOptions = parsedConfig.options;
+    // Transpile the TypeScript code using the compiler options
+    const output = ts.transpileModule(tsCode, {
+        compilerOptions,
+        reportDiagnostics: true,
+    });
+    if (output.diagnostics && output.diagnostics.length) {
+        const diagnosticMessages = output.diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+        throw new Error(`TypeScript Compilation Errors:\n${diagnosticMessages.join("\n")}`);
+    }
+    return output.outputText; // Compiled JavaScript code
+};

package/dist/lib/constants.d.mts

@@ -0,0 +1,4 @@
+export declare const ROOT_DIR: string;
+export declare const SRC_DIR: string;
+export declare const DIST_DIR: string;
+export declare const SSR_BRIDGE_PATH: string;

package/dist/lib/constants.mjs

@@ -0,0 +1,6 @@
+import { resolve } from "node:path";
+const __dirname = new URL(".", import.meta.url).pathname;
+export const ROOT_DIR = resolve(__dirname, "..", "..");
+export const SRC_DIR = resolve(ROOT_DIR, "src");
+export const DIST_DIR = resolve(ROOT_DIR, "dist");
+export const SSR_BRIDGE_PATH = resolve(DIST_DIR, "worker", "__ssr_bridge.js");

package/dist/lib/findWranglerConfig.d.mts

@@ -0,0 +1 @@
+export declare const findWranglerConfig: (projectRootDir: string) => Promise<string>;

package/dist/lib/findWranglerConfig.mjs

@@ -0,0 +1,12 @@
+import { pathExists } from "fs-extra";
+import { resolve } from "path";
+export const findWranglerConfig = async (projectRootDir) => {
+    const configFiles = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
+    for (const file of configFiles) {
+        const fullPath = resolve(projectRootDir, file);
+        if (await pathExists(fullPath)) {
+            return fullPath;
+        }
+    }
+    throw new Error("No wrangler configuration file found.");
+};

package/dist/lib/getShortName.d.mts

@@ -0,0 +1 @@
+export declare const getShortName: (file: string, root: string) => string;

package/dist/lib/getShortName.mjs

@@ -0,0 +1,2 @@
+import { relative } from "node:path";
+export const getShortName = (file, root) => file.startsWith(root) ? relative(root, file) : file;

package/dist/lib/getSrcPaths.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Gets all source file paths by parsing tsconfig.json using TypeScript's compiler API.
+ * Falls back to a glob pattern if tsconfig parsing fails.
+ *
+ * @param rootDir - The root directory to search from (defaults to current working directory)
+ * @returns Promise<string[]> - Array of source file paths
+ */
+export declare function getSrcPaths(rootDir?: string): Promise<string[]>;
+/**
+ * Synchronous version of getSrcPaths
+ *
+ * @param rootDir - The root directory to search from (defaults to current working directory)
+ * @returns string[] - Array of source file paths
+ */
+export declare function getSrcPathsSync(rootDir?: string): string[];

package/dist/lib/getSrcPaths.js

@@ -0,0 +1,80 @@
+import ts from "typescript";
+import path from "path";
+import { glob } from "glob";
+/**
+ * Gets all source file paths by parsing tsconfig.json using TypeScript's compiler API.
+ * Falls back to a glob pattern if tsconfig parsing fails.
+ *
+ * @param rootDir - The root directory to search from (defaults to current working directory)
+ * @returns Promise<string[]> - Array of source file paths
+ */
+export async function getSrcPaths(rootDir = process.cwd()) {
+    try {
+        const configPath = ts.findConfigFile(rootDir, ts.sys.fileExists, "tsconfig.json");
+        if (configPath) {
+            const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+            if (!configFile.error) {
+                // Parse tsconfig
+                const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+                if (parsed.fileNames && parsed.fileNames.length > 0) {
+                    return parsed.fileNames;
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn("Failed to parse tsconfig.json, falling back to glob pattern:", error);
+    }
+    // Fallback to glob pattern
+    try {
+        const globPattern = path.join(rootDir, "src/**/*.{ts,mts,tsx,jsx,mjs,js}");
+        const files = await glob(globPattern, {
+            ignore: ["**/node_modules/**", "**/dist/**", "**/*.d.ts"],
+            absolute: true,
+            nodir: true,
+        });
+        return files;
+    }
+    catch (error) {
+        console.error("Failed to get source paths with glob pattern:", error);
+        return [];
+    }
+}
+/**
+ * Synchronous version of getSrcPaths
+ *
+ * @param rootDir - The root directory to search from (defaults to current working directory)
+ * @returns string[] - Array of source file paths
+ */
+export function getSrcPathsSync(rootDir = process.cwd()) {
+    try {
+        // Try TypeScript compiler API approach first
+        const configPath = ts.findConfigFile(rootDir, ts.sys.fileExists, "tsconfig.json");
+        if (configPath) {
+            const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+            if (!configFile.error) {
+                // Parse tsconfig
+                const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+                if (parsed.fileNames && parsed.fileNames.length > 0) {
+                    return parsed.fileNames;
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn("Failed to parse tsconfig.json, falling back to glob pattern:", error);
+    }
+    // Fallback to glob pattern
+    try {
+        const globPattern = path.join(rootDir, "src/**/*.{ts,mts,tsx,jsx,mjs,js}");
+        const files = glob.sync(globPattern, {
+            ignore: ["**/node_modules/**", "**/dist/**", "**/*.d.ts"],
+            absolute: true,
+        });
+        return files;
+    }
+    catch (error) {
+        console.error("Failed to get source paths with glob pattern:", error);
+        return [];
+    }
+}

package/dist/lib/hasPkgScript.d.mts

@@ -0,0 +1 @@
+export declare const hasPkgScript: (projectRootDir: string, script: string) => Promise<any>;

package/dist/lib/hasPkgScript.mjs

@@ -0,0 +1,9 @@
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+let pkg;
+export const hasPkgScript = async (projectRootDir, script) => {
+    if (!pkg) {
+        pkg = JSON.parse(await readFile(resolve(projectRootDir, "package.json"), "utf-8"));
+    }
+    return pkg.scripts?.[script];
+};

package/dist/lib/jsonUtils.d.mts

@@ -0,0 +1,28 @@
+/**
+ * Utility functions for working with JSON in CLI output
+ */
+/**
+ * Attempt to extract the last JSON object or array from a string by
+ * first finding closing braces/brackets and then matching them to their
+ * opening counterparts.
+ *
+ * @param output - The string to parse
+ * @returns JSON object or null if invalid
+ */
+export declare function extractLastJson(output: string | undefined): any;
+/**
+ * Extract all valid JSON objects or arrays from a string
+ *
+ * @param input - The string that might contain multiple JSON objects
+ * @returns Array of parsed JSON objects
+ */
+export declare function extractAllJson(input: string | undefined): any[];
+/**
+ * Safely parses JSON from a string that might include other content
+ *
+ * @param input - The string that might contain JSON
+ * @param defaultValue - Default value to return if no JSON is found
+ * @param findUuid - If true, look for an object with a uuid property
+ * @returns The parsed JSON or the default value
+ */
+export declare function parseJson<T>(input: string | undefined, defaultValue: T, findUuid?: boolean): T;

package/dist/lib/jsonUtils.mjs

@@ -0,0 +1,167 @@
+/**
+ * Utility functions for working with JSON in CLI output
+ */
+/**
+ * Attempt to extract the last JSON object or array from a string by
+ * first finding closing braces/brackets and then matching them to their
+ * opening counterparts.
+ *
+ * @param output - The string to parse
+ * @returns JSON object or null if invalid
+ */
+export function extractLastJson(output) {
+    if (!output)
+        return null;
+    try {
+        // First try a direct parse of the entire output
+        // (in case it's already valid JSON with no surrounding text)
+        try {
+            return JSON.parse(output);
+        }
+        catch (e) {
+            // If that fails, try more complex extraction
+        }
+        // Start from the end of the string to find closing braces/brackets
+        for (let i = output.length - 1; i >= 0; i--) {
+            // Look for closing braces/brackets
+            if (output[i] === "}" || output[i] === "]") {
+                const closingChar = output[i];
+                const openingChar = closingChar === "}" ? "{" : "[";
+                // Find the matching opening brace/bracket
+                let balance = 1; // Start with 1 since we've already found a closing char
+                let j = i - 1;
+                while (j >= 0 && balance > 0) {
+                    if (output[j] === closingChar) {
+                        balance++;
+                    }
+                    else if (output[j] === openingChar) {
+                        balance--;
+                        // If balance is 0, we found the matching opening char
+                        if (balance === 0) {
+                            // Extract the potential JSON and try to parse it
+                            const extracted = output.substring(j, i + 1);
+                            try {
+                                const parsed = JSON.parse(extracted);
+                                return parsed;
+                            }
+                            catch (e) {
+                                // Not valid JSON, continue
+                                break;
+                            }
+                        }
+                    }
+                    j--;
+                }
+            }
+        }
+        // If we reach here, no valid JSON was found
+        return null;
+    }
+    catch (error) {
+        console.error("Error extracting last JSON:", error);
+        return null;
+    }
+}
+/**
+ * Extract all valid JSON objects or arrays from a string
+ *
+ * @param input - The string that might contain multiple JSON objects
+ * @returns Array of parsed JSON objects
+ */
+export function extractAllJson(input) {
+    if (!input)
+        return [];
+    const results = [];
+    let remainingText = input;
+    // Try to extract JSON objects until no more are found
+    while (remainingText.length > 0) {
+        // Find opening braces/brackets
+        const openBracePos = remainingText.indexOf("{");
+        const openBracketPos = remainingText.indexOf("[");
+        // Determine which comes first (if any)
+        let startPos = -1;
+        let openChar = "";
+        let closeChar = "";
+        if (openBracePos >= 0 &&
+            (openBracketPos < 0 || openBracePos < openBracketPos)) {
+            startPos = openBracePos;
+            openChar = "{";
+            closeChar = "}";
+        }
+        else if (openBracketPos >= 0) {
+            startPos = openBracketPos;
+            openChar = "[";
+            closeChar = "]";
+        }
+        else {
+            // No more opening braces/brackets
+            break;
+        }
+        // Cut off the text before the opening character
+        remainingText = remainingText.substring(startPos);
+        // Find the matching closing character
+        let balance = 1;
+        let endPos = 1; // Start after the opening character
+        while (endPos < remainingText.length && balance > 0) {
+            if (remainingText[endPos] === openChar) {
+                balance++;
+            }
+            else if (remainingText[endPos] === closeChar) {
+                balance--;
+            }
+            endPos++;
+        }
+        // Check if we found a complete JSON object
+        if (balance === 0) {
+            const potentialJson = remainingText.substring(0, endPos);
+            try {
+                const parsed = JSON.parse(potentialJson);
+                results.push(parsed);
+            }
+            catch (e) {
+                // Not valid JSON, just ignore
+            }
+            // Continue with text after this JSON object
+            remainingText = remainingText.substring(endPos);
+        }
+        else {
+            // Unbalanced braces/brackets, skip this one
+            remainingText = remainingText.substring(1);
+        }
+    }
+    return results;
+}
+/**
+ * Safely parses JSON from a string that might include other content
+ *
+ * @param input - The string that might contain JSON
+ * @param defaultValue - Default value to return if no JSON is found
+ * @param findUuid - If true, look for an object with a uuid property
+ * @returns The parsed JSON or the default value
+ */
+export function parseJson(input, defaultValue, findUuid = false) {
+    try {
+        // Try to find the last complete JSON object
+        const lastJson = extractLastJson(input);
+        if (lastJson !== null) {
+            if (!findUuid || lastJson.uuid) {
+                return lastJson;
+            }
+        }
+        // If we need to find an object with a uuid property, try extracting all JSON objects
+        if (findUuid) {
+            const allJson = extractAllJson(input);
+            // Look for an object that has a uuid property
+            for (const json of allJson) {
+                if (json && json.uuid) {
+                    return json;
+                }
+            }
+        }
+        return defaultValue;
+    }
+    catch (error) {
+        console.error("Error in parseJson:", error);
+        return defaultValue;
+    }
+}

package/dist/lib/setupEnvFiles.d.mts

@@ -0,0 +1,4 @@
+export type EnvSetupOptions = {
+    rootDir: string;
+};
+export declare function setupEnvFiles({ rootDir, }: EnvSetupOptions): Promise<void>;

package/dist/lib/setupEnvFiles.mjs

@@ -0,0 +1,31 @@
+import { resolve } from "node:path";
+import { symlink, copyFile } from "node:fs/promises";
+import { pathExists } from "fs-extra";
+export async function setupEnvFiles({ rootDir, }) {
+    const envPath = resolve(rootDir, ".env");
+    const devVarsPath = resolve(rootDir, ".dev.vars");
+    const envExamplePath = resolve(rootDir, ".env.example");
+    const envExists = await pathExists(envPath);
+    const devVarsExists = await pathExists(devVarsPath);
+    const envExampleExists = await pathExists(envExamplePath);
+    // If .env.example exists but .env doesn't, copy from example to .env
+    if (!envExists && !devVarsExists && envExampleExists) {
+        try {
+            await copyFile(envExamplePath, envPath);
+            console.log("Created .env file from .env.example");
+        }
+        catch (error) {
+            console.warn("Failed to copy .env.example to .env:", error);
+        }
+    }
+    // Create symlink from .env to .dev.vars if needed
+    if ((await pathExists(envPath)) && !devVarsExists) {
+        try {
+            await symlink(envPath, devVarsPath);
+            console.log("Created symlink from .env to .dev.vars");
+        }
+        catch (error) {
+            console.warn("Failed to create symlink from .env to .dev.vars:", error);
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import { SmokeTestOptions, StreamCapturer } from "./types.mjs";
+export declare const capturer: StreamCapturer;
+/**
+ * Sets up the artifacts directory with a clean structure
+ */
+export declare function setupArtifactsDirectory(artifactDir: string, options?: SmokeTestOptions): Promise<void>;
+/**
+ * Helper function to take and save a screenshot with a descriptive name
+ */
+export declare function takeScreenshot(page: any, url: string, artifactDir: string, status: string): Promise<void>;

package/dist/lib/smokeTests/artifacts.mjs

@@ -0,0 +1,164 @@
+import * as fs from "fs/promises";
+import { join } from "path";
+import { mkdirp, pathExists } from "fs-extra";
+import { createWriteStream, existsSync, mkdirSync } from "fs";
+import { log } from "./constants.mjs";
+// Stream capturer for logging
+export const capturer = {
+    stdoutLogFile: null,
+    stderrLogFile: null,
+    combinedLogFile: null,
+    // @ts-ignore - TS doesn't like this binding but it works as expected
+    originalStdoutWrite: process.stdout.write.bind(process.stdout),
+    // @ts-ignore - TS doesn't like this binding but it works as expected
+    originalStderrWrite: process.stderr.write.bind(process.stderr),
+    start(artifactDir) {
+        // Create logs directory in the artifacts directory
+        const logsDir = join(artifactDir, "logs");
+        try {
+            // Synchronously create directory to ensure it exists before writing
+            if (!existsSync(logsDir)) {
+                mkdirSync(logsDir, { recursive: true });
+            }
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            try {
+                this.stdoutLogFile = createWriteStream(join(logsDir, `stdout-${timestamp}.log`), { flags: "a" });
+                this.stderrLogFile = createWriteStream(join(logsDir, `stderr-${timestamp}.log`), { flags: "a" });
+                this.combinedLogFile = createWriteStream(join(logsDir, `combined-${timestamp}.log`), { flags: "a" });
+                // Verify the streams are working
+                this.stdoutLogFile.write("Log capture started\n");
+                this.stderrLogFile.write("Log capture started\n");
+                this.combinedLogFile.write("Log capture started\n");
+                // Capture stdout
+                // @ts-ignore - TS doesn't like dynamically modifying process streams
+                process.stdout.write = (chunk, encoding, callback) => {
+                    if (this.stdoutLogFile && this.stdoutLogFile.writable)
+                        this.stdoutLogFile.write(chunk, encoding ?? "utf-8");
+                    if (this.combinedLogFile && this.combinedLogFile.writable)
+                        this.combinedLogFile.write(chunk, encoding ?? "utf-8");
+                    return this.originalStdoutWrite(chunk, encoding ?? "utf-8", callback);
+                };
+                // Capture stderr
+                // @ts-ignore - TS doesn't like dynamically modifying process streams
+                process.stderr.write = (chunk, encoding, callback) => {
+                    if (this.stderrLogFile && this.stderrLogFile.writable)
+                        this.stderrLogFile.write(chunk, encoding ?? "utf-8");
+                    if (this.combinedLogFile && this.combinedLogFile.writable)
+                        this.combinedLogFile.write(chunk, encoding ?? "utf-8");
+                    return this.originalStderrWrite(chunk, encoding ?? "utf-8", callback);
+                };
+                console.log(`📝 Log files created in ${logsDir}`);
+            }
+            catch (streamError) {
+                console.error(`Failed to create log streams: ${streamError}`);
+                // Clean up any partially created log files
+                this.stop();
+            }
+        }
+        catch (error) {
+            console.error(`Failed to set up log capturing: ${error}`);
+        }
+    },
+    stop() {
+        // Restore original write functions
+        // @ts-ignore - TS doesn't like dynamically modifying process streams
+        process.stdout.write = this.originalStdoutWrite;
+        // @ts-ignore - TS doesn't like dynamically modifying process streams
+        process.stderr.write = this.originalStderrWrite;
+        // Close log files
+        if (this.stdoutLogFile) {
+            try {
+                this.stdoutLogFile.end();
+            }
+            catch (e) {
+                console.error(`Error closing stdout log file: ${e}`);
+            }
+        }
+        if (this.stderrLogFile) {
+            try {
+                this.stderrLogFile.end();
+            }
+            catch (e) {
+                console.error(`Error closing stderr log file: ${e}`);
+            }
+        }
+        if (this.combinedLogFile) {
+            try {
+                this.combinedLogFile.end();
+            }
+            catch (e) {
+                console.error(`Error closing combined log file: ${e}`);
+            }
+        }
+        this.stdoutLogFile = null;
+        this.stderrLogFile = null;
+        this.combinedLogFile = null;
+    },
+};
+/**
+ * Sets up the artifacts directory with a clean structure
+ */
+export async function setupArtifactsDirectory(artifactDir, options) {
+    log("Setting up artifacts directory: %s", artifactDir);
+    console.log(`📁 Setting up artifacts directory: ${artifactDir}`);
+    // Check if directory exists
+    const exists = await pathExists(artifactDir);
+    if (exists) {
+        log("Artifacts directory already exists, removing it");
+        console.log(`🧹 Cleaning existing artifacts directory`);
+        try {
+            await fs.rm(artifactDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            log("Error removing existing artifacts directory: %O", error);
+            console.error(`⚠️ Could not remove existing artifacts directory: ${error instanceof Error ? error.message : String(error)}`);
+            // Non-fatal error, continue
+        }
+    }
+    // Create main artifacts directory
+    await mkdirp(artifactDir);
+    log("Created artifacts directory: %s", artifactDir);
+    // Create standard subdirectories
+    const subdirs = ["screenshots", "reports", "logs"];
+    // Only create project directory if copyProject is enabled
+    if (options?.copyProject) {
+        subdirs.push("project");
+    }
+    for (const subdir of subdirs) {
+        const dirPath = join(artifactDir, subdir);
+        await mkdirp(dirPath);
+        log("Created artifacts subdirectory: %s", dirPath);
+    }
+    console.log(`✅ Artifacts directory structure created`);
+    // Ensure logs directory exists and has correct permissions before capturing logs
+    try {
+        const logsDir = join(artifactDir, "logs");
+        // Double-check permissions by writing a test file
+        const testLogPath = join(logsDir, "test-log-permissions.txt");
+        await fs.writeFile(testLogPath, "Testing log directory permissions\n");
+        await fs.unlink(testLogPath);
+        log("Log directory permissions verified");
+    }
+    catch (error) {
+        log("Error verifying log directory permissions: %O", error);
+        console.error(`⚠️ Warning: Log directory permissions issue: ${error instanceof Error ? error.message : String(error)}`);
+        // Not fatal, try to proceed anyway
+    }
+    // Start capturing logs
+    capturer.start(artifactDir);
+}
+/**
+ * Helper function to take and save a screenshot with a descriptive name
+ */
+export async function takeScreenshot(page, url, artifactDir, status) {
+    // Use the standardized screenshots directory
+    const screenshotsDir = join(artifactDir, "screenshots");
+    log("Saving screenshot to: %s", screenshotsDir);
+    // Create a more descriptive filename with timestamp and test result
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const urlIdentifier = new URL(url).hostname.replace(/\./g, "-");
+    const screenshotPath = join(screenshotsDir, `smoke-test-${urlIdentifier}-${status}-${timestamp}.png`);
+    log("Taking screenshot: %s", screenshotPath);
+    await page.screenshot({ path: screenshotPath, fullPage: true });
+    console.log(`📸 Screenshot saved to ${screenshotPath}`);
+}

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

@@ -0,0 +1,48 @@
+import { SmokeTestOptions, SmokeTestResult } from "./types.mjs";
+import type { Page, Browser } from "puppeteer-core";
+/**
+ * Launch a browser instance
+ */
+export declare function launchBrowser(browserPath?: string, headless?: boolean): Promise<Browser>;
+/**
+ * Get the browser executable path
+ */
+export declare function getBrowserPath(testOptions?: SmokeTestOptions): Promise<string>;
+/**
+ * Check a URL by performing smoke tests and realtime upgrade
+ */
+export declare function checkUrl(url: string, artifactDir: string, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, environment?: string, realtime?: boolean, targetDir?: string, skipHmr?: boolean): Promise<void>;
+/**
+ * Check smoke test status for a specific URL
+ */
+export declare function checkUrlSmoke(page: Page, url: string, isRealtime: boolean, bail: boolean | undefined, skipClient: boolean | undefined, environment: string | undefined, timestampState: {
+    initialServerValue: number;
+    clientUpdatedValue: number | null;
+}, targetDir?: string, skipHmr?: boolean): Promise<void>;
+/**
+ * Check server-side smoke test status
+ */
+export declare function checkServerSmoke(page: Page, phase?: string, environment?: string, bail?: boolean, expectedTimestamp?: number, isServerRenderCheck?: boolean): Promise<SmokeTestResult>;
+/**
+ * Check client-side smoke test if refresh button is available
+ */
+export declare function checkClientSmoke(page: Page, phase?: string, environment?: string, bail?: boolean): Promise<SmokeTestResult | null>;
+/**
+ * Upgrade to realtime mode
+ */
+export declare function upgradeToRealtime(page: Page, environment?: string, // Add environment parameter with default
+bail?: boolean): Promise<void>;
+/**
+ * DRY: checkServerUp now checks both root and custom path if needed
+ */
+export declare function checkServerUp(baseUrl: string, customPath?: string, retries?: number, bail?: boolean): Promise<boolean>;
+/**
+ * HMR test for server component
+ * Updates the server component and verifies that HMR applies the changes
+ */
+export declare function testServerComponentHmr(page: Page, targetDir: string, phase?: string, environment?: string, bail?: boolean): Promise<boolean>;
+/**
+ * HMR test for client component
+ * Updates the client component and verifies that HMR applies the changes
+ */
+export declare function testClientComponentHmr(page: Page, targetDir: string, phase?: string, environment?: string, bail?: boolean): Promise<boolean>;