@capillarytech/cap-ui-utils 3.1.0 → 3.1.2

package/e2e/constants/common.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxLoginAttempts = exports.common = exports.WAIT_120S = exports.WAIT_90S = exports.WAIT_60S = exports.WAIT_30S = exports.FAILURE = exports.SUCCESS = exports.INFO = exports.SG_CLUSTERS = void 0;
+// Singapore clusters that require special handling
+exports.SG_CLUSTERS = ['sgcrm', 'sgcrmasia'];
+exports.INFO = "🟡";
+exports.SUCCESS = "🟢";
+exports.FAILURE = "🔴";
+exports.WAIT_30S = 30000;
+exports.WAIT_60S = 60000;
+exports.WAIT_90S = 90000;
+exports.WAIT_120S = 120000;
+exports.common = {
+    "cluster": process.env.cluster,
+    "validatorUrl": "http://127.0.0.1:4000",
+    "maxLoginAttempts": 3,
+    "sgClusters": exports.SG_CLUSTERS,
+    "isLoyaltyMigration": process.env.module === 'loyalty_migration',
+};
+// login.page.ts (shared) imports this by name; re-exported here so the toolkit
+// stays free of the data-heavy constants/constants aggregator (org/auth/endpoints).
+exports.maxLoginAttempts = exports.common.maxLoginAttempts;

package/e2e/index.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginPage = exports.BasePage = exports.lockService = exports.setupMock = exports.screenshotRecorderUtil = exports.requestRecorderUtil = exports.reportUploader = exports.logCollectorUtil = exports.dropdownUtil = exports.deletionRegistry = exports.debugMode = exports.automationBypass = exports.expectUtil = exports.antdVersion = exports.elementUtil = void 0;
+/**
+ * Shared WDIO E2E toolkit — the framework-agnostic, data-free helpers that were
+ * duplicated byte-for-byte across the product repos (wdio-ui-automation,
+ * garuda-ui, and every future migrated repo).
+ *
+ * Two ways to consume:
+ *   import { elementUtil, loginPage } from '@capillarytech/cap-ui-utils/e2e';
+ *   import elementUtil from '@capillarytech/cap-ui-utils/e2e/utils/elementUtil';
+ *
+ * NOT included yet (data-coupled — they read the per-repo `cons` org/auth/endpoint
+ * data via constants/constants): apiUtil, helperUtil, cookieUtil, navigationUtil,
+ * appNavigationUtil, requestRecorderService, home.page, testAndPreviewFlow.page.
+ * These need a small config-injection seam before they can move — see README.
+ */
+var elementUtil_1 = require("./utils/elementUtil");
+Object.defineProperty(exports, "elementUtil", { enumerable: true, get: function () { return __importDefault(elementUtil_1).default; } });
+var antdVersionUtil_1 = require("./utils/antdVersionUtil");
+Object.defineProperty(exports, "antdVersion", { enumerable: true, get: function () { return __importDefault(antdVersionUtil_1).default; } });
+var expectUtil_1 = require("./utils/expectUtil");
+Object.defineProperty(exports, "expectUtil", { enumerable: true, get: function () { return __importDefault(expectUtil_1).default; } });
+var automationBypassUtil_1 = require("./utils/automationBypassUtil");
+Object.defineProperty(exports, "automationBypass", { enumerable: true, get: function () { return __importDefault(automationBypassUtil_1).default; } });
+var debugModeUtil_1 = require("./utils/debugModeUtil");
+Object.defineProperty(exports, "debugMode", { enumerable: true, get: function () { return __importDefault(debugModeUtil_1).default; } });
+var deletionRegistry_1 = require("./utils/deletionRegistry");
+Object.defineProperty(exports, "deletionRegistry", { enumerable: true, get: function () { return __importDefault(deletionRegistry_1).default; } });
+var garudaDropdownUtil_1 = require("./utils/garudaDropdownUtil");
+Object.defineProperty(exports, "dropdownUtil", { enumerable: true, get: function () { return __importDefault(garudaDropdownUtil_1).default; } });
+var logCollectorUtil_1 = require("./utils/logCollectorUtil");
+Object.defineProperty(exports, "logCollectorUtil", { enumerable: true, get: function () { return __importDefault(logCollectorUtil_1).default; } });
+var reportUploader_1 = require("./utils/reportUploader");
+Object.defineProperty(exports, "reportUploader", { enumerable: true, get: function () { return __importDefault(reportUploader_1).default; } });
+var requestRecorderUtil_1 = require("./utils/requestRecorderUtil");
+Object.defineProperty(exports, "requestRecorderUtil", { enumerable: true, get: function () { return __importDefault(requestRecorderUtil_1).default; } });
+var screenshotRecorderUtil_1 = require("./utils/screenshotRecorderUtil");
+Object.defineProperty(exports, "screenshotRecorderUtil", { enumerable: true, get: function () { return __importDefault(screenshotRecorderUtil_1).default; } });
+var setupMock_1 = require("./utils/setupMock");
+Object.defineProperty(exports, "setupMock", { enumerable: true, get: function () { return __importDefault(setupMock_1).default; } });
+var lockService_1 = require("./services/lockService");
+Object.defineProperty(exports, "lockService", { enumerable: true, get: function () { return __importDefault(lockService_1).default; } });
+var base_page_1 = require("./pages/common/base.page");
+Object.defineProperty(exports, "BasePage", { enumerable: true, get: function () { return __importDefault(base_page_1).default; } });
+var login_page_1 = require("./pages/common/login.page");
+Object.defineProperty(exports, "loginPage", { enumerable: true, get: function () { return __importDefault(login_page_1).default; } });
+__exportStar(require("./constants/common"), exports);

package/e2e/pages/common/base.page.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BasePage {
+    async launchApplication(url) {
+        console.log('Browser Maximize');
+        browser.maximizeWindow();
+        console.log('Triggered navigate to', url);
+        await browser.navigateTo(url);
+        console.log('Navigated to URL: ', url);
+    }
+    async quitApplication() { await browser.closeWindow(); }
+}
+exports.default = BasePage;

package/e2e/pages/common/constant.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBPUSH = exports.EMAIL = void 0;
+exports.EMAIL = 'email';
+exports.WEBPUSH = 'webpush';

package/e2e/pages/common/login.page.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_page_1 = __importDefault(require("./base.page"));
+const elementUtil_1 = __importDefault(require("../../utils/elementUtil"));
+const common_1 = require("../../constants/common");
+const wdio_commands_1 = __importDefault(require("@rpii/wdio-commands"));
+class LoginPage extends base_page_1.default {
+    get isV2Login() { return process.env.V2_LOGIN === 'true'; }
+    get inputUserName() { return this.isV2Login ? $('#login-username') : $('#login_user'); }
+    get inputPassword() { return this.isV2Login ? $('#login-password') : $('#login_cred'); }
+    get buttonLogin() { return this.isV2Login ? $('//button[.="Sign in"]') : $('#c-login-btn'); }
+    get continueButton() { return $('//button[.="Continue"]'); }
+    // Post-login readiness marker. The MFE Navigation Host replaced the old
+    // Dashboard (which rendered ExplorePosts → "Explore features") with NewDashboard,
+    // so the sidebar shell testid is the reliable signal the home shell has mounted.
+    // Old text kept as a backward-compatible fallback for pre-MFE environments.
+    get exploreFeatures() { return $('//*[@data-testid="cap-navigation-spa-sidebar"] | //*[text()="Explore features"]'); }
+    async doLogin(url, username, password, loginTryCount = 0) {
+        try {
+            await browser.refresh();
+            await browser.pause(3000);
+            console.log('Browser launched');
+            await super.launchApplication(url);
+            if (loginTryCount > 0) {
+                let currentUrl = await browser.getUrl();
+                const isHome = currentUrl.includes("/home/ui");
+                if (isHome) {
+                    try {
+                        await (await this.exploreFeatures).waitForDisplayed({ timeout: 60000, interval: 5000 });
+                        console.log('-----Logged In-----');
+                        console.log('On retry login flow, /home/ui url and explore features text appeared after 60s probably, hence skipping entering username and password');
+                        return;
+                    }
+                    catch (e) {
+                        console.log('proceeding with retry');
+                    }
+                }
+            }
+            for (let i = 0; i <= 2; i++) {
+                try {
+                    await (await this.inputUserName).waitForDisplayed({ timeout: 60000 });
+                    await this.inputUserName.waitForEnabled({ timeout: 30000, timeoutMsg: "thrown from dologin", interval: 1000 });
+                    break;
+                }
+                catch (error) {
+                    console.log('Failed to load login page- Refreshing browser');
+                    await browser.refresh();
+                }
+            }
+            await elementUtil_1.default.enterText(await this.inputUserName, username);
+            if (this.isV2Login) {
+                await this.continueButton.waitForEnabled({ timeout: 10000 });
+                await elementUtil_1.default.elementClick(await this.continueButton);
+                await this.inputPassword.waitForDisplayed({ timeout: 30000 });
+            }
+            await elementUtil_1.default.enterText(await this.inputPassword, password);
+            await this.buttonLogin.waitForEnabled({ timeout: 10000 });
+            await elementUtil_1.default.elementClick(await this.buttonLogin);
+            await browser.waitUntil(async () => {
+                let currentUrl = await browser.getUrl();
+                return currentUrl.includes("/home/ui");
+            }, {
+                timeout: 60000,
+                timeoutMsg: 'expected url to include /home/ui',
+                interval: 1000,
+            });
+            console.log('-----Browsers current url contains home/ui after login-----');
+            await (await this.exploreFeatures).waitForDisplayed({ timeout: 60000, interval: 5000 });
+            console.log('-----Logged In-----');
+        }
+        catch (error) {
+            console.log('Throwed error from dologin, attempt #: ', loginTryCount, ', Error: ', error);
+            wdio_commands_1.default.logScreenshot("Failed to get the user logged in: " + error);
+            if (loginTryCount >= (common_1.maxLoginAttempts - 1)) {
+                console.log('Since login retry count exceeds 2. Exiting now.');
+                throw new Error("Failed to get the user logged in: " + error);
+            }
+            console.log('Retrying Login.. ');
+            await this.doLogin(url, username, password, ++loginTryCount);
+        }
+    }
+    async redirectHome(url) {
+        try {
+            await super.launchApplication(url);
+        }
+        catch (error) {
+            wdio_commands_1.default.logScreenshot("Exception logged: " + error);
+            throw new Error(error);
+        }
+    }
+}
+exports.default = new LoginPage();

package/e2e/services/{lockService.ts → lockService.js}

@@ -1,13 +1,34 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 // A publish section holds the lock for ~1-3 minutes; anything older than this
 // can only be a leftover from a run that died without releasing.
 const STALE_LOCK_TTL_MS = 15 * 60 * 1000;
-
 class LockService {
-    private baseLockDir: string;
-
     constructor() {
         // Lock/signal files default to <this dir>/locks, but can be redirected via LOCK_DIR so that
         // independent suite runs (e.g. staging v3 + nightly v6 in parallel) don't share signal files
@@ -19,16 +40,13 @@ class LockService {
             fs.mkdirSync(this.baseLockDir, { recursive: true });
         }
     }
-
     initialize() {
         this.cleanStaleLocks();
         console.log("Lock service initialized.");
     }
-
-    private getLockFilePath(lockName: string): string {
+    getLockFilePath(lockName) {
         return path.resolve(this.baseLockDir, `${lockName}.lock`);
     }
-
     /**
      * A lock is stale when its owner can no longer release it: the owning worker
      * process is dead (identifier format Test-<pid>-<timestamp>), or the file is
@@ -39,66 +57,62 @@ class LockService {
      * other. Locks owned by a live process are never touched, so a concurrently
      * running suite on this machine keeps its serialization.
      */
-    private isLockStale(lockFilePath: string): boolean {
-        let owner: string;
-        let mtimeMs: number;
+    isLockStale(lockFilePath) {
+        let owner;
+        let mtimeMs;
         try {
             owner = fs.readFileSync(lockFilePath, 'utf8');
             mtimeMs = fs.statSync(lockFilePath).mtimeMs;
-        } catch {
+        }
+        catch {
             return false; // vanished meanwhile — nothing to clean
         }
-        if (Date.now() - mtimeMs > STALE_LOCK_TTL_MS) return true;
+        // Probe the owner's liveness FIRST — a live owner must never lose its lock,
+        // regardless of age (slow cluster, retried publish, debug SETTLE_MS pauses).
+        // The TTL only applies when the owner is dead, unknown, or a reused pid.
         const match = /^Test-(\d+)-\d+$/.exec(owner.trim());
-        if (!match) return false; // unknown owner format — only TTL applies
+        if (!match)
+            return Date.now() - mtimeMs > STALE_LOCK_TTL_MS; // unknown format — TTL only
         try {
             process.kill(Number(match[1]), 0); // signal 0 = liveness probe, sends nothing
-            return false;
-        } catch (error) {
-            // ESRCH: no such process → stale. EPERM: process exists but is not ours.
-            return (error as NodeJS.ErrnoException).code !== 'EPERM';
+            return false; // owner alive — never steal
+        }
+        catch (error) {
+            // ESRCH: no such process → stale. EPERM: exists but not ours → TTL fallback (pid reuse).
+            if (error.code === 'EPERM') {
+                return Date.now() - mtimeMs > STALE_LOCK_TTL_MS;
+            }
+            return true;
         }
     }
-
-    private removeIfStale(lockFilePath: string): boolean {
-        if (!this.isLockStale(lockFilePath)) return false;
+    removeIfStale(lockFilePath) {
+        if (!this.isLockStale(lockFilePath))
+            return false;
         try {
             fs.unlinkSync(lockFilePath);
             console.log(`Removed stale lock '${path.basename(lockFilePath)}' (owner dead or TTL expired).`);
             return true;
-        } catch {
+        }
+        catch {
             return false; // another worker removed it first — fine
         }
     }
-
     /** Sweep all *.lock files in the lock dir, removing only stale ones. */
-    cleanStaleLocks(): void {
-        let lockFiles: string[];
+    cleanStaleLocks() {
+        let lockFiles;
         try {
             lockFiles = fs.readdirSync(this.baseLockDir).filter(file => file.endsWith('.lock'));
-        } catch {
+        }
+        catch {
             return;
         }
         for (const file of lockFiles) {
             this.removeIfStale(path.resolve(this.baseLockDir, file));
         }
     }
-
-    async acquireLock({
-        testIdentifier,
-        lockName,
-        maxRetries = 10,
-        retryInterval = 1000
-        }: {
-        testIdentifier: string;
-        lockName: string;
-        maxRetries?: number;
-        retryInterval?: number;
-        }): Promise<boolean> {
-
+    async acquireLock({ testIdentifier, lockName, maxRetries = 10, retryInterval = 1000 }) {
         const lockFilePath = this.getLockFilePath(lockName);
-
-        for (let retries = 0; ; retries++) {
+        for (let retries = 0;; retries++) {
             // Self-heal locks left by crashed workers, then try an atomic
             // create-exclusive: 'wx' fails with EEXIST if the file exists, so two
             // waiters can never both believe they own the lock.
@@ -107,17 +121,18 @@ class LockService {
                 fs.writeFileSync(lockFilePath, testIdentifier, { flag: 'wx' });
                 console.log(`Lock for '${lockName}' acquired by ${testIdentifier}.`);
                 return true;
-            } catch (error) {
-                if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST') {
                     console.error(`Failed to acquire lock for '${lockName}':`, error);
                     return false;
                 }
             }
-
             let currentLockOwner = 'unknown';
             try {
                 currentLockOwner = fs.readFileSync(lockFilePath, 'utf8');
-            } catch {
+            }
+            catch {
                 // released between attempts — next loop iteration will grab it
             }
             if (retries >= maxRetries) {
@@ -128,47 +143,40 @@ class LockService {
             await browser.pause(retryInterval);
         }
     }
-
-    releaseLock(testIdentifier: string, lockName: string): boolean {
+    releaseLock(testIdentifier, lockName) {
         const lockFilePath = this.getLockFilePath(lockName);
-
         if (!fs.existsSync(lockFilePath)) {
             console.log(`Lock for '${lockName}' is not acquired, nothing to release.`);
             return false;
         }
-
         const currentLockOwner = fs.readFileSync(lockFilePath, 'utf8');
-
         if (currentLockOwner !== testIdentifier) {
             console.log(`Lock for '${lockName}' cannot be released. Current owner is ${currentLockOwner}, but ${testIdentifier} is trying to release it.`);
             return false;
         }
-
         try {
             fs.unlinkSync(lockFilePath);
             console.log(`Lock for '${lockName}' released by ${testIdentifier}.`);
             return true;
-        } catch (error) {
+        }
+        catch (error) {
             console.error(`Failed to release lock for '${lockName}':`, error);
             return false;
         }
     }
-
-    isLocked(lockName: string): boolean {
+    isLocked(lockName) {
         const lockFilePath = this.getLockFilePath(lockName);
         return fs.existsSync(lockFilePath);
     }
-
     /**
      * Writes a signal file so another worker can detect completion.
      * The file persists until the next test run overwrites it.
      */
-    writeSignal(signalName: string, value: string = "ready"): void {
+    writeSignal(signalName, value = "ready") {
         const filePath = path.resolve(this.baseLockDir, `${signalName}.signal`);
         fs.writeFileSync(filePath, value);
         console.log(`Signal '${signalName}' written (value: ${value})`);
     }
-
     /**
      * Polls for a signal file written by another worker via writeSignal().
      * Skips "pending" values — waits until a terminal value (ready/skipped/failed) is written.
@@ -178,15 +186,10 @@ class LockService {
      * `ENOENT`) instead of a preceding `fs.existsSync` check, to avoid a TOCTOU
      * race condition.
      */
-    async waitForSignal(
-        signalName: string,
-        timeoutMs: number = 300000,
-        intervalMs: number = 5000,
-    ): Promise<string> {
+    async waitForSignal(signalName, timeoutMs = 300000, intervalMs = 5000) {
         const filePath = path.resolve(this.baseLockDir, `${signalName}.signal`);
         const deadline = Date.now() + timeoutMs;
         let elapsed = 0;
-
         while (Date.now() < deadline) {
             if (fs.existsSync(filePath)) {
                 const value = fs.readFileSync(filePath, 'utf8');
@@ -195,16 +198,14 @@ class LockService {
                     return value;
                 }
                 console.log(`Signal '${signalName}' is pending — waiting for terminal value... (${elapsed}ms elapsed)`);
-            } else {
+            }
+            else {
                 console.log(`Waiting for signal '${signalName}'... (${elapsed}ms elapsed, timeout: ${timeoutMs}ms)`);
             }
             await browser.pause(intervalMs);
             elapsed += intervalMs;
         }
-
         throw new Error(`Signal '${signalName}' not received within ${timeoutMs}ms`);
     }
-
 }
-
-export default new LockService();
+exports.default = new LockService();

package/e2e/utils/{antdVersionUtil.ts → antdVersionUtil.js}

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * antd-version detection for the antd v3/v5 -> v6 (new "unified" lib) migration.
  *
@@ -13,25 +15,7 @@
  * detect() below — change only that method if the marker ever moves.
  */
 class AntdVersionUtil {
-    // undefined = not yet detected; true/false = cached result for this worker.
-    private _isV6: boolean | undefined;
-
-    /**
-     * Detect whether the app under test is the new antd-v6 build, and cache it for
-     * the rest of the worker. Apps do not use antd directly — they render through
-     * the internal `cap-ui-library` CSS bundle, of which exactly ONE version (old
-     * or new=v6) is loaded per page. So the loaded `cap-ui-library` stylesheet IS
-     * the app's version. The new (v6) lib ships an `ant-row-legacy` selector that
-     * the old lib never does, so a single same-origin CSS scan is an exact,
-     * render-independent discriminator. The bundle is served from the same pod
-     * (same origin), so `cssRules` is always readable (no CORS).
-     */
-    // Stylesheet whose presence means the internal UI lib (old OR new) has loaded.
-    private static readonly LIB_HREF_MARKER = 'cap-ui-library';
-    // Selector shipped only by the new (v6) lib; absent from the old lib's CSS.
-    private static readonly V6_CSS_MARKER = 'ant-row-legacy';
-
-    async detect(): Promise<boolean> {
+    async detect() {
         // Runtime detection is DISABLED. selector() now always emits a combined
         // v6-first selector, so we no longer need to know the version. This stub
         // stays callable (wdio.conf's navigateTo hook and a campaigns getter call
@@ -123,7 +107,6 @@ class AntdVersionUtil {
         return this._isV6;
         --------------------------------------------------------------------- */
     }
-
     /**
      * Navigation hook (wired into a global `navigateTo` override in wdio.conf).
      * The antd version is a property of the PAGE that is loaded, not of the worker
@@ -135,14 +118,13 @@ class AntdVersionUtil {
      * switcher), so one of the detection markers is always present and the probe
      * resolves quickly rather than waiting out the timeout.
      */
-    async onNavigate(): Promise<void> {
+    async onNavigate() {
         // No-op while detection is disabled. selector() emits both variants, so
         // there is nothing to re-detect on navigation. Restore the two lines below
         // if runtime detection is re-enabled in detect().
         // this.reset();
         // await this.detect();
     }
-
     /**
      * Version flag for the FEW call sites that branch on the version directly
      * (different interaction model, not just a different locator) rather than
@@ -151,10 +133,9 @@ class AntdVersionUtil {
      * those branches take the v6 path. If the env is reverted to legacy, flip
      * this back (or restore detection in detect() and return this._isV6).
      */
-    get isV6(): boolean | undefined {
+    get isV6() {
         return true;
     }
-
     /**
      * Build one combined selector that matches EITHER the v6 or the legacy
      * variant, with the v6 variant placed FIRST. Runtime version detection is
@@ -171,20 +152,31 @@ class AntdVersionUtil {
      * the `,` list. A page is either v6 or legacy, so only one side ever matches;
      * ordering v6 first just expresses the preference.
      */
-    selector(legacy: string, v6: string): string {
-        const isXPath = (s: string) => /^\s*(\/|\.\/|\.\.\/|\()/.test(s);
+    selector(legacy, v6) {
+        const isXPath = (s) => /^\s*(\/|\.\/|\.\.\/|\()/.test(s);
         return isXPath(v6) ? `${v6} | ${legacy}` : `${v6}, ${legacy}`;
     }
-
     /** Resolve a legacy/v6 selector pair to a live element using the picked one. */
-    element(legacy: string, v6: string) {
+    element(legacy, v6) {
         return $(this.selector(legacy, v6));
     }
-
     /** Test hook: clear the cached detection (not used in normal runs). */
-    reset(): void {
+    reset() {
         this._isV6 = undefined;
     }
 }
-
-export default new AntdVersionUtil();
+/**
+ * Detect whether the app under test is the new antd-v6 build, and cache it for
+ * the rest of the worker. Apps do not use antd directly — they render through
+ * the internal `cap-ui-library` CSS bundle, of which exactly ONE version (old
+ * or new=v6) is loaded per page. So the loaded `cap-ui-library` stylesheet IS
+ * the app's version. The new (v6) lib ships an `ant-row-legacy` selector that
+ * the old lib never does, so a single same-origin CSS scan is an exact,
+ * render-independent discriminator. The bundle is served from the same pod
+ * (same origin), so `cssRules` is always readable (no CORS).
+ */
+// Stylesheet whose presence means the internal UI lib (old OR new) has loaded.
+AntdVersionUtil.LIB_HREF_MARKER = 'cap-ui-library';
+// Selector shipped only by the new (v6) lib; absent from the old lib's CSS.
+AntdVersionUtil.V6_CSS_MARKER = 'ant-row-legacy';
+exports.default = new AntdVersionUtil();

package/e2e/utils/{automationBypassUtil.ts → automationBypassUtil.js}

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Env-driven kill-switch that lets a module's automation be turned off without a
  * code change or a CI job edit. In prod the value is injected into the runner
@@ -20,9 +22,10 @@ class AutomationBypass {
      * must never break a run, so anything unparseable is logged and treated as
      * "nothing bypassed".
      */
-    private getBypassedModules(): string[] {
+    getBypassedModules() {
         const raw = (process.env.AUTOMATION_BYPASS_MODULES || '').trim();
-        if (!raw) return [];
+        if (!raw)
+            return [];
         try {
             const parsed = JSON.parse(raw);
             if (!Array.isArray(parsed)) {
@@ -30,17 +33,17 @@ class AutomationBypass {
                 return [];
             }
             return parsed.map((m) => String(m).trim()).filter(Boolean);
-        } catch (error) {
+        }
+        catch (error) {
             console.log(`[automation-bypass] Could not parse AUTOMATION_BYPASS_MODULES (${raw}): ${error}`);
             return [];
         }
     }
-
     /** True when the given module's automation should be bypassed. */
-    isBypassed(module: string | undefined = process.env.module): boolean {
-        if (!module) return false;
+    isBypassed(module = process.env.module) {
+        if (!module)
+            return false;
         return this.getBypassedModules().includes(module);
     }
 }
-
-export default new AutomationBypass();
+exports.default = new AutomationBypass();

package/e2e/utils/{debugModeUtil.ts → debugModeUtil.js}

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Central gate for the FULL_DEBUG capture feature (request-payload + screenshot
  * recording) and, indirectly, for whether the devtools automation protocol is
@@ -13,20 +15,20 @@
  */
 class DebugMode {
     /** Parse DEBUG_MODULES into a trimmed, non-empty module-name list. */
-    private getDebugModules(): string[] {
+    getDebugModules() {
         return (process.env.DEBUG_MODULES || '')
             .split(',')
             .map((m) => m.trim())
             .filter(Boolean);
     }
-
     /** True when request/screenshot capture should run for the current module. */
-    isCaptureEnabled(): boolean {
-        if (process.env.FULL_DEBUG_MODE !== 'true') return false;
+    isCaptureEnabled() {
+        if (process.env.FULL_DEBUG_MODE !== 'true')
+            return false;
         const modules = this.getDebugModules();
-        if (modules.length === 0) return true;
+        if (modules.length === 0)
+            return true;
         return modules.includes(process.env.module || '');
     }
 }
-
-export default new DebugMode();
+exports.default = new DebugMode();