flowstride 1.0.20-rc.6 → 1.0.21

package/dist/runner/flow_worker.js

@@ -37,6 +37,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowWorker = void 0;
+const runtime_1 = require("../native/runtime");
+const deadline_1 = require("../ci/deadline");
+const replayRequest_1 = require("../utils/replayRequest");
 const projectPaths_1 = require("../utils/projectPaths");
 const redaction_1 = require("../security/redaction");
 const fs = __importStar(require("fs"));
@@ -55,10 +58,16 @@ class FlowWorker extends events_1.EventEmitter {
     store;
     sessions;
     pluginManager;
+    static nativeBrowserProtocol = 2;
     isSilent = process.env.FLOWSTRIDE_PARALLEL === "true";
     isAborted = false;
     bailTriggered = false;
     isDebugHalted = false;
+    native;
+    attempt = 1;
+    maxAttempts = 1;
+    fallbackStream;
+    interceptedContexts = new WeakSet();
     currentStepContext = "Initializing...";
     currentFileName = "System";
     activeAudioPath = undefined;
@@ -77,8 +86,12 @@ class FlowWorker extends events_1.EventEmitter {
         this.store = store;
         this.sessions = sessions;
         this.pluginManager = pluginManager;
+        this.native = new runtime_1.NativeRuntime(web, config);
+        this.web.onPageChanged = async () => { await this.startStreaming(); await this.setupNetworkInterception(); };
     }
     broadcast(type, payload) {
+        if (["STEP_ADD", "STEP_UPDATE", "LOG_EVENT"].includes(type))
+            payload = { ...payload, attempt: this.attempt, profile: this.web.activeProfile || "default" };
         const secrets = [this.config.machineToken || '', ...(this.dataGen?.sensitiveValues?.() || []), ...Object.entries(process.env).filter(([key]) => /password|token|secret|api.?key/i.test(key)).map(([, value]) => String(value)), ...Object.entries(this.localVariables).filter(([key]) => /password|passcode|token|secret|otp|api.?key/i.test(key)).map(([, value]) => String(value))];
         this.emit('worker_event', { type, payload: (0, redaction_1.redactWorkerPayload)(type, payload, secrets, this.config.ci === false) });
     }
@@ -282,6 +295,7 @@ class FlowWorker extends events_1.EventEmitter {
             url: cleanUrl,
             requestHeaders: formattedHeaders,
             requestBody: parsedReqBody,
+            rawReplayRequest: { method: method.toUpperCase(), url: cleanUrl, headers: formattedHeaders, body: rawBodyString },
             responseStatus: state.status,
             responseHeaders: state.headers,
             responseBody: state.body,
@@ -304,33 +318,11 @@ class FlowWorker extends events_1.EventEmitter {
         });
     }
     async handleReplayRequest(payload) {
+        const requestId = typeof payload?.requestId === 'string' ? payload.requestId : undefined;
         try {
-            let parsedHeaders = undefined;
-            let parsedBody = undefined;
-            try {
-                if (payload.headers)
-                    parsedHeaders = JSON.parse(payload.headers);
-            }
-            catch (e) { }
-            try {
-                if (payload.body)
-                    parsedBody = JSON.parse(payload.body);
-            }
-            catch (e) {
-                parsedBody = payload.body;
-            }
-            const fetchOptions = {
-                method: payload.method,
-                headers: parsedHeaders,
-            };
-            if (parsedBody && payload.method !== "GET" && payload.method !== "HEAD") {
-                fetchOptions.body =
-                    typeof parsedBody === "string"
-                        ? parsedBody
-                        : JSON.stringify(parsedBody);
-            }
-            const response = await fetch(payload.url, fetchOptions);
-            const status = response.status;
+            const { url, options } = (0, replayRequest_1.buildReplayRequest)(payload);
+            options.signal = AbortSignal.timeout(this.config.timeout || 30000);
+            const response = await fetch(url, options);
             const text = await response.text();
             let responseBody;
             try {
@@ -339,17 +331,18 @@ class FlowWorker extends events_1.EventEmitter {
             catch {
                 responseBody = text;
             }
-            this.broadcast("REPLAY_RES", {
-                status,
-                responseBody,
+            this.broadcast('REPLAY_RES', {
+                status: response.status, responseBody, error: null, requestId,
                 fileName: this.currentFileName,
             });
         }
         catch (error) {
-            this.broadcast("REPLAY_RES", {
-                status: 500,
-                responseBody: { error: error.message },
-                fileName: this.currentFileName,
+            const code = error instanceof replayRequest_1.ReplayRequestError ? 'REPLAY_INVALID_REQUEST'
+                : error?.name === 'TimeoutError' ? 'REPLAY_TIMEOUT' : 'REPLAY_NETWORK_ERROR';
+            const message = (0, redaction_1.redactText)(String(error?.message || 'Replay request failed'), [this.config.machineToken || '']);
+            this.broadcast('REPLAY_RES', {
+                status: null, error: code, requestId,
+                responseBody: { error: message, code }, fileName: this.currentFileName,
             });
         }
     }
@@ -412,7 +405,13 @@ class FlowWorker extends events_1.EventEmitter {
                     this.localBrowserSessions = {};
                     this.api.resetState();
                     this.dataGen = new data_generators_1.DataGenerators();
+                    await this.native.dispose();
                     await this.web.initialise(this.activeAudioPath);
+                    if (typeof this.web.getBrowserInfo === 'function') {
+                        const browser = this.web.getBrowserInfo();
+                        console.log(`[Browser]: ${browser.engine} ${browser.version}; ${browser.headless ? 'headless' : 'headed'}; ${fileName}`);
+                        this.broadcast('BROWSER_INFO', { ...browser, fileName });
+                    }
                     await this.startStreaming();
                     await this.setupNetworkInterception();
                     const content = fs.readFileSync(filePath, "utf8");
@@ -471,7 +470,7 @@ class FlowWorker extends events_1.EventEmitter {
                                 scenarioName: s.name,
                                 fileName: this.currentFileName,
                             });
-                            await this.runScenario(s, f.declarations);
+                            await this.runScenarioWithRetries(s, f.declarations);
                             if (this.isDebugHalted || this.bailTriggered)
                                 break;
                             await this.web
@@ -500,6 +499,7 @@ class FlowWorker extends events_1.EventEmitter {
                         const targetVideoPath = path.join(mockCloudDir, `${baseName}.webm`);
                         for (const message of this.web.pageErrors || [])
                             this.broadcast('BROWSER_ERROR', { message, fileName: this.currentFileName });
+                        await this.native.dispose();
                         await this.web.shutdown(targetVideoPath);
                         if (!this.isSilent)
                             console.log(chalk_1.default.gray(`      [Cloud Sync]: Video safely encoded and preserved for ${this.currentFileName}`));
@@ -523,6 +523,7 @@ class FlowWorker extends events_1.EventEmitter {
                         const targetVideoPath = path.join(mockCloudDir, `${baseName}.webm`);
                         for (const message of this.web.pageErrors || [])
                             this.broadcast('BROWSER_ERROR', { message, fileName: this.currentFileName });
+                        await this.native.dispose();
                         await this.web.shutdown(targetVideoPath);
                         if (!this.isSilent)
                             console.log(chalk_1.default.gray(`      [Cloud Sync]: Video safely encoded and preserved for ${this.currentFileName}`));
@@ -549,6 +550,7 @@ class FlowWorker extends events_1.EventEmitter {
                 try {
                     const directory = path.join(process.cwd(), '.flowstride', 'artifacts');
                     fs.mkdirSync(directory, { recursive: true });
+                    await this.native.dispose();
                     await this.web.shutdown(path.join(directory, (0, projectPaths_1.videoFileName)(this.currentFileName)));
                 }
                 catch (error) {
@@ -558,9 +560,52 @@ class FlowWorker extends events_1.EventEmitter {
             process.removeListener("SIGINT", sigintHandler);
         }
     }
+    async runScenarioWithRetries(scenario, declarations) {
+        this.maxAttempts = (this.config.retries || 0) + 1;
+        const baseline = this.maxAttempts > 1 ? await this.web.checkpointProfiles() : undefined;
+        const variables = this.maxAttempts > 1 ? structuredClone(this.localVariables) : {}, sessions = this.maxAttempts > 1 ? structuredClone(this.localBrowserSessions) : {};
+        const globals = this.maxAttempts > 1 ? structuredClone(FlowWorker.globalVariables) : {}, globalSessions = this.maxAttempts > 1 ? structuredClone(FlowWorker.globalBrowserSessions) : {};
+        const storeState = this.maxAttempts > 1 ? structuredClone(this.store.getAll?.()) : undefined;
+        const apiState = this.maxAttempts > 1 ? this.api.checkpointState?.() : undefined;
+        for (this.attempt = 1; this.attempt <= this.maxAttempts; this.attempt++) {
+            if (this.isAborted || this.isDebugHalted)
+                break;
+            if (this.attempt > 1) {
+                await this.native.dispose();
+                if (apiState)
+                    this.api.restoreState(apiState);
+                else
+                    this.api.resetState();
+                this.localVariables = structuredClone(variables);
+                this.localBrowserSessions = structuredClone(sessions);
+                FlowWorker.globalVariables = structuredClone(globals);
+                FlowWorker.globalBrowserSessions = structuredClone(globalSessions);
+                if (storeState) {
+                    this.store.clear();
+                    for (const [key, value] of Object.entries(structuredClone(storeState)))
+                        this.store.set(key, value);
+                }
+                await this.web.restoreProfiles(baseline);
+            }
+            const started = Date.now();
+            this.broadcast('SCENARIO_ATTEMPT', { fileName: this.currentFileName, scenario: scenario.name, attempt: this.attempt });
+            const errorIndex = this.web.pageErrors?.length || 0;
+            const completed = await this.runScenario(structuredClone(scenario), declarations);
+            const browserErrors = this.web.pageErrors?.slice(errorIndex) || [];
+            const passed = completed && (this.config.browserErrors === 'record' || !browserErrors.length);
+            this.broadcast('SCENARIO_RESULT', { fileName: this.currentFileName, scenario: scenario.name, attempt: this.attempt, status: this.isAborted ? 'interrupted' : passed ? 'passed' : 'failed', flaky: passed && this.attempt > 1, browserErrors, duration: Date.now() - started });
+            if (passed || this.isAborted || this.isDebugHalted)
+                break;
+            if (this.attempt < this.maxAttempts)
+                this.web.pageErrors?.splice(errorIndex);
+        }
+        this.attempt = 1;
+        this.maxAttempts = 1;
+    }
     async runScenario(scenario, globalDeclarations = []) {
         let hasScenarioFailed = false;
-        for (const step of scenario.steps) {
+        for (const originalStep of scenario.steps) {
+            const step = structuredClone(originalStep);
             if (this.isAborted)
                 break;
             const blockName = step.blockDescription.split(" ")[0];
@@ -615,11 +660,13 @@ class FlowWorker extends events_1.EventEmitter {
             try {
                 await this.executeStep(step.action, step.payload, scenario.declarations, globalDeclarations);
                 const stepContext = await this.captureStepContext(step.payload);
+                const domSnapshot = await this.native.captureDOM(step.id).catch(() => undefined);
                 spinner.succeed();
                 this.broadcast("STEP_UPDATE", {
                     id: step.id,
                     status: "passed",
                     screenshot: stepContext.screenshot,
+                    domSnapshot,
                     fileName: this.currentFileName,
                 });
                 if (step.isStop) {
@@ -634,6 +681,7 @@ class FlowWorker extends events_1.EventEmitter {
                 if (this.isAborted)
                     break;
                 const stepContext = await this.captureStepContext(step.payload);
+                const domSnapshot = await this.native.captureDOM(step.id).catch(() => undefined);
                 let strippedDom = "";
                 try {
                     const page = this.web.getPage();
@@ -655,6 +703,7 @@ class FlowWorker extends events_1.EventEmitter {
                         id: step.id,
                         status: "skipped",
                         screenshot: stepContext.screenshot,
+                        domSnapshot,
                         fileName: this.currentFileName,
                     });
                     continue;
@@ -702,15 +751,17 @@ class FlowWorker extends events_1.EventEmitter {
                     id: step.id,
                     status: "failed",
                     screenshot: stepContext.screenshot,
+                    domSnapshot,
                     fileName: this.currentFileName,
                 });
                 hasScenarioFailed = true;
-                if (this.config.bail && !this.bailTriggered) {
+                if (this.config.bail && this.attempt >= this.maxAttempts && !this.bailTriggered) {
                     this.bailTriggered = true;
                     this.broadcast('BAIL', { fileName: this.currentFileName, id: step.id });
                 }
             }
         }
+        return !hasScenarioFailed;
     }
     async waitForPipeline() {
         if (!this.activeAudioPath || !fs.existsSync(this.activeAudioPath)) {
@@ -757,6 +808,12 @@ class FlowWorker extends events_1.EventEmitter {
             ].join(", ");
         }
         switch (action) {
+            case 'native': {
+                const result = await (0, deadline_1.withDeadline)(this.native.execute(payload.pluginMethod, payload.data), this.config.timeout);
+                if (payload.saveAs)
+                    this.localVariables[payload.saveAs] = result;
+                break;
+            }
             case "extract":
                 if (["resBody", "resHeader", "cookie"].includes(payload.target)) {
                     this.processExtractions([
@@ -872,6 +929,7 @@ class FlowWorker extends events_1.EventEmitter {
                         localStorage: stateToSave.localStorage || {},
                         sessionStorage: stateToSave.sessionStorage || {},
                         fallbackDomain,
+                        storageOrigin: stateToSave.storageOrigin,
                     };
                     if (payload.isGlobal) {
                         FlowWorker.globalBrowserSessions[payload.name] = hybridState;
@@ -920,7 +978,7 @@ class FlowWorker extends events_1.EventEmitter {
                     }
                     if (!loadedState)
                         throw new Error(`State Error: The session "${payload.name}" does not exist in memory or on disk.`);
-                    await this.web.injectStorage(loadedState.cookies, loadedState.localStorage, loadedState.fallbackDomain);
+                    await this.web.injectStorage(loadedState.cookies, loadedState.localStorage, loadedState.fallbackDomain, loadedState.sessionStorage, loadedState.storageOrigin);
                 }
                 break;
             case "open":
@@ -1170,6 +1228,27 @@ class FlowWorker extends events_1.EventEmitter {
                     await this.web.expectText(payload.selector, payload.fuzzy, payload.elementType);
                 else if (expectType === "value")
                     await this.web.expectValue(payload.selector, payload.text, payload.elementType);
+                else if (expectType === "attribute") {
+                    const deadline = Date.now() + this.config.timeout;
+                    let actual = null;
+                    const failure = () => `Attribute assertion failed: ${payload.attribute} on ${payload.selector}. Expected ${payload.fuzzy ? 'to contain ' : ''}${JSON.stringify(payload.text)}, received ${JSON.stringify(actual)}.`;
+                    while (true) {
+                        const remaining = deadline - Date.now();
+                        if (remaining <= 0)
+                            throw new Error(failure());
+                        try {
+                            actual = await (0, deadline_1.withDeadline)(this.web.getAttribute(payload.selector, payload.attribute, payload.elementType), remaining);
+                        }
+                        catch (error) {
+                            throw new Error(`${failure()}\n${error instanceof Error ? error.message : String(error)}`, { cause: error });
+                        }
+                        if (actual !== null && (payload.fuzzy ? actual.includes(payload.text) : actual === payload.text))
+                            break;
+                        if (Date.now() >= deadline)
+                            throw new Error(failure());
+                        await new Promise(resolve => setTimeout(resolve, Math.max(0, Math.min(50, deadline - Date.now()))));
+                    }
+                }
                 else if (expectType === "transcript")
                     await this.web.expectTranscript(payload.text);
                 break;
@@ -1177,6 +1256,9 @@ class FlowWorker extends events_1.EventEmitter {
     }
     async setupNetworkInterception() {
         const context = this.web.getPage().context();
+        if (this.interceptedContexts.has(context))
+            return;
+        this.interceptedContexts.add(context);
         context.on("response", async (response) => {
             const lockedFileName = this.currentFileName;
             const request = response.request();
@@ -1211,6 +1293,7 @@ class FlowWorker extends events_1.EventEmitter {
                 url: request.url(),
                 requestHeaders: requestHeaders,
                 requestBody: requestBody,
+                rawReplayRequest: { method: request.method(), url: request.url(), headers: requestHeaders, body: rawPostData },
                 responseStatus: response.status(),
                 responseHeaders: response.headers(),
                 responseBody: responseBody,
@@ -1234,8 +1317,27 @@ class FlowWorker extends events_1.EventEmitter {
         });
     }
     async startStreaming() {
+        clearInterval(this.fallbackStream);
         if (this.config.ci)
             return;
+        if (this.config.browser && this.config.browser !== 'chromium') {
+            const page = this.web.getPage();
+            let busy = false;
+            this.fallbackStream = setInterval(async () => {
+                if (busy || page.isClosed())
+                    return;
+                busy = true;
+                try {
+                    this.broadcast('BROWSER_FRAME', { base64: (await page.screenshot({ type: 'jpeg', quality: 60 })).toString('base64'), fileName: this.currentFileName });
+                }
+                catch { }
+                finally {
+                    busy = false;
+                }
+            }, 250);
+            this.fallbackStream.unref();
+            return;
+        }
         const page = this.web.getPage();
         if (this.currentCdpSession) {
             await this.currentCdpSession.detach().catch(() => { });
@@ -1256,6 +1358,8 @@ class FlowWorker extends events_1.EventEmitter {
         });
     }
     async shutdown() {
+        clearInterval(this.fallbackStream);
+        await this.native.dispose();
         try {
             await this.web.shutdown();
         }

package/dist/security/redaction.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.redactText = redactText;
 exports.redactPayload = redactPayload;
 exports.redactWorkerPayload = redactWorkerPayload;
-const sensitive = /password|passcode|secret|token|authorization|cookie|api.?key|master.?key|otp|email|curlString|strippedDom/i;
+const sensitive = /password|passcode|secret|token|authorization|cookie|api.?key|master.?key|otp|email|curlString|rawReplayRequest|strippedDom/i;
 function redactText(input, secrets = []) {
     let value = String(input);
     for (const secret of secrets.filter(s => typeof s === 'string' && s.length >= 4).sort((a, b) => b.length - a.length))
@@ -44,6 +44,8 @@ function redactWorkerPayload(type, payload, secrets, localDebug = false) {
         return result;
     if (type === 'LOG_EVENT' && ['REST', 'GRAPHQL'].includes(payload.type) && typeof payload.details?.curlString === 'string') {
         result.details.rawCurlString = payload.details.curlString;
+        if (payload.details.rawReplayRequest)
+            result.details.rawReplayRequest = payload.details.rawReplayRequest;
     }
     return result;
 }

package/dist/sessions/manager.js

@@ -35,7 +35,7 @@ class SessionManager {
         data.lastUsedAt = Date.now();
         this.vault.save(`session_${name}`, data);
         this.activeSession = data;
-        await this.web.injectStorage(data.cookies, data.localStorage);
+        await this.web.injectStorage(data.cookies, data.localStorage, undefined, data.sessionStorage, data.storageOrigin);
         const definition = this.definitions.get(name);
         if (definition?.inject?.api) {
             const { headerName, template } = definition.inject.api;
@@ -64,6 +64,8 @@ class SessionManager {
             tokens: this.activeSession?.tokens || {},
             cookies: state.cookies,
             localStorage: state.localStorage,
+            sessionStorage: state.sessionStorage,
+            storageOrigin: state.storageOrigin,
             createdAt: Date.now(),
             lastUsedAt: Date.now(),
             persist,

package/dist/types/index.d.ts

@@ -1,4 +1,14 @@
 export interface FlowstrideConfig {
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    browserOptions?: import('playwright').BrowserContextOptions;
+    retries?: number;
+    failOnFlaky?: boolean;
+    trace?: boolean;
+    har?: boolean;
+    domSnapshots?: boolean;
+    shard?: string;
+    shardHistory?: string;
+    updateBaselines?: boolean;
     ci?: boolean;
     flowRoot?: string;
     projectRoot?: string;
@@ -53,6 +63,8 @@ export interface SessionData {
     tokens: Record<string, any>;
     cookies?: any[];
     localStorage?: Record<string, string>;
+    sessionStorage?: Record<string, string>;
+    storageOrigin?: string;
     createdAt: number;
     lastUsedAt: number;
     persist: boolean;

package/dist/utils/replayRequest.d.ts

@@ -0,0 +1,8 @@
+export declare class ReplayRequestError extends Error {
+    constructor(message: string);
+}
+/** Browser protocol metadata is not a portable set of Fetch request headers. */
+export declare function buildReplayRequest(payload: any): {
+    url: string;
+    options: RequestInit;
+};

package/dist/utils/replayRequest.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayRequestError = void 0;
+exports.buildReplayRequest = buildReplayRequest;
+class ReplayRequestError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ReplayRequestError';
+    }
+}
+exports.ReplayRequestError = ReplayRequestError;
+/** Browser protocol metadata is not a portable set of Fetch request headers. */
+function buildReplayRequest(payload) {
+    let url;
+    try {
+        url = new URL(payload?.url);
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
+            throw new Error();
+    }
+    catch {
+        throw new ReplayRequestError('Replay URL must use HTTP or HTTPS without embedded credentials.');
+    }
+    const method = typeof payload?.method === 'string' ? payload.method.toUpperCase() : 'GET';
+    if (!/^[!#$%&'*+.^_`|~0-9A-Z-]+$/.test(method) || ['CONNECT', 'TRACE', 'TRACK'].includes(method)) {
+        throw new ReplayRequestError('Replay method is not supported.');
+    }
+    let supplied = payload?.headers;
+    if (typeof supplied === 'string') {
+        try {
+            supplied = supplied.trim() ? JSON.parse(supplied) : {};
+        }
+        catch {
+            throw new ReplayRequestError('Replay headers must be a valid JSON object.');
+        }
+    }
+    if (supplied === undefined)
+        supplied = {};
+    if (!supplied || typeof supplied !== 'object' || Array.isArray(supplied)) {
+        throw new ReplayRequestError('Replay headers must be a JSON object of string values.');
+    }
+    // Fetch owns the destination, framing and supported compression. Recompute
+    // Content-Length after edits and remove all Connection-nominated fields too.
+    const excluded = new Set([
+        'host', 'content-length', 'accept-encoding', 'connection', 'keep-alive',
+        'proxy-connection', 'proxy-authenticate', 'proxy-authorization', 'te',
+        'trailer', 'transfer-encoding', 'upgrade', 'expect',
+    ]);
+    for (const [name, value] of Object.entries(supplied)) {
+        if (name.toLowerCase() === 'connection' && typeof value === 'string') {
+            for (const field of value.split(','))
+                excluded.add(field.trim().toLowerCase());
+        }
+    }
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(supplied)) {
+        if (name.startsWith(':') || excluded.has(name.toLowerCase()))
+            continue;
+        if (typeof value !== 'string')
+            throw new ReplayRequestError('Replay header values must be strings.');
+        try {
+            headers.append(name, value);
+        }
+        catch {
+            throw new ReplayRequestError('Replay headers contain an invalid name or value.');
+        }
+    }
+    const options = { method, headers };
+    if (!['GET', 'HEAD'].includes(method) && payload?.body !== undefined && payload.body !== null) {
+        try {
+            options.body = typeof payload.body === 'string' ? payload.body : JSON.stringify(payload.body);
+        }
+        catch {
+            throw new ReplayRequestError('Replay body cannot be serialized.');
+        }
+    }
+    return { url: url.href, options };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowstride",
-  "version": "1.0.20-rc.6",
+  "version": "1.0.21",
   "description": "An opensource flowfirst test automation framework",
   "workspaces": [
     "packages/flowstride_report"
@@ -11,7 +11,8 @@
     "dist",
     "src/ui/dist",
     "NATIVE_CI.md",
-    "examples/native-game"
+    "examples/native-game",
+    "NATIVE_BROWSER.md"
   ],
   "bin": {
     "flowstride": "dist/cli/index.js"
@@ -27,8 +28,11 @@
     "verify:candidate": "node scripts/verify-candidate.cjs",
     "test:dashboard:unit": "node --test tests/dashboard/store.test.cjs",
     "test:dashboard": "node --test --test-concurrency=1 tests/dashboard/*.test.cjs",
-    "test:unit": "node --test tests/native/core.test.cjs tests/native/combined.test.cjs tests/native/curl.test.cjs tests/native/upload.test.cjs tests/dashboard/store.test.cjs",
-    "test:security": "node --test tests/manual-security.test.cjs tests/native/curl.test.cjs tests/native/combined.test.cjs"
+    "test:unit": "node --test tests/native/core.test.cjs tests/native/combined.test.cjs tests/native/curl.test.cjs tests/native/upload.test.cjs tests/dashboard/store.test.cjs tests/native/replay.test.cjs tests/dashboard/replay.test.cjs tests/native/assertions-sessions.test.cjs tests/native/capabilities.test.cjs tests/native/browser-selection.unit.test.cjs",
+    "test:security": "node --test tests/manual-security.test.cjs tests/native/curl.test.cjs tests/native/combined.test.cjs tests/native/replay.test.cjs tests/native/assertions-sessions.test.cjs tests/native/capabilities.test.cjs tests/native/browser-selection.unit.test.cjs",
+    "test:replay": "node --test tests/native/replay.test.cjs tests/dashboard/replay.test.cjs tests/dashboard/curl.browser.test.cjs",
+    "test:assertions-sessions": "node --test --test-concurrency=1 tests/native/assertions-sessions*.test.cjs",
+    "test:capabilities": "node --test --test-concurrency=1 tests/native/capabilities*.test.cjs"
   },
   "keywords": [
     "automation",
@@ -42,33 +46,42 @@
     "node": ">=22.12.0"
   },
   "dependencies": {
+    "@axe-core/playwright": "4.14.0",
     "@inquirer/prompts": "^7.10.1",
+    "@vitejs/plugin-react": "6.1.2",
+    "@vitejs/plugin-vue": "6.0.10",
     "axios": "^1.20.0",
     "chalk": "^4.1.2",
     "commander": "^11.0.0",
+    "dom-accessibility-api": "0.7.1",
     "dotenv": "^17.4.2",
     "open": "^11.0.0",
     "ora": "^5.4.1",
     "playwright": "1.59.1",
+    "playwright-core": "1.59.1",
     "playwright-extra": "^4.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "sanitize-html": "2.18.1",
     "tar": "^7.5.22",
     "ts-node": "^10.9.2",
     "undici": "^7.30.1",
+    "vite": "8.3.5",
     "ws": "^8.22.0",
-    "sanitize-html": "2.18.1",
-    "zod": "4.4.3"
+    "zod": "4.6.7"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
+    "@types/sanitize-html": "2.16.2",
     "@types/ws": "^8.18.1",
-    "typescript": "^5.9.3",
-    "@types/sanitize-html": "2.16.2"
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "three": "0.186.1",
+    "typescript": "^5.9.3"
   },
   "optionalDependencies": {
     "@rolldown/binding-darwin-arm64": "^0.15.1"
   },
   "publishConfig": {
-    "tag": "next"
+    "tag": "latest"
   }
 }