@dev-blinq/bvt-playwright-js 1.0.0-dev.4.latest.149.1 → 1.0.0-dev.4.latest.172.1

package/index.mjs

@@ -6,8 +6,8 @@ import path, { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { chromium, firefox, webkit } from "playwright";
 import { expect } from "playwright/test";
-import { mkdirSync, readFileSync as readFileSync$1, statSync } from "fs";
-import { dirname as dirname$1 } from "path";
+import { mkdirSync, readFileSync as readFileSync$1, rmSync, statSync } from "fs";
+import { dirname as dirname$1, join } from "path";
 import { createContext, runInContext } from "node:vm";
 import { test } from "@playwright/test";
 
@@ -5170,7 +5170,8 @@ const ASSERTION_OPERATORS = [
 	"contains",
 	"lessThan",
 	"greaterThan",
-	"exists"
+	"exists",
+	"regex"
 ];
 
 //#endregion
@@ -7068,12 +7069,24 @@ const ExecResultSchema = discriminatedUnion("type", [
 	}).strict(),
 	object({ type: literal$1("skipped") }).strict()
 ]);
+/**
+* S3 keys for the before/after viewport screenshots captured around a single
+* command. Keys are deterministic (see the screenshot key convention in the
+* presigned-urls router) and are populated even before the batched upload runs;
+* the testcase-level {@link TestCaseSchema.shape.screenshotsAvailable} flag
+* indicates whether the objects were actually uploaded to S3.
+*/
+const CommandScreenshotsSchema = object({
+	before: string().min(1).max(1024).optional(),
+	after: string().min(1).max(1024).optional()
+}).strict();
 const CommandResultSchema = object({
 	commandId: string().min(1).max(255),
 	startedAt: date().optional(),
 	completedAt: date().optional(),
 	result: ExecResultSchema,
-	recovery: RecoveryMetadataSchema.optional()
+	recovery: RecoveryMetadataSchema.optional(),
+	screenshots: CommandScreenshotsSchema.optional()
 }).strict();
 const StepResultSchema = object({
 	stepId: string().min(1).max(255),
@@ -7101,6 +7114,7 @@ const TestCaseAiRecoverySchema = object({
 }).strict();
 const TestCaseWarningReasonSchema = _enum([
 	"TraceUploadFailed",
+	"ScreenshotUploadFailed",
 	"ScenarioEmpty",
 	"AIRecoveryPendingApproval",
 	"AIRecoveryArtifactFailed",
@@ -7121,6 +7135,7 @@ const TestCaseSchema = object({
 	error: TestCaseErrorSchema.optional(),
 	aiRecovery: TestCaseAiRecoverySchema.optional(),
 	warnings: array(TestCaseWarningSchema).optional(),
+	screenshotsAvailable: boolean().optional(),
 	startedAt: date(),
 	completedAt: date().nullable(),
 	stepResults: array(StepResultSchema),
@@ -10922,6 +10937,7 @@ const AiChatDataExecutionStatusPartSchema = object({
 * from the call sites in `apps/ai-server/src/mastra/agents/`:
 *   - `observe-act-loop` (observe-act-completion happy path)
 *   - `observe-act-loop-cap-reached` (loop hit iteration cap mid-run)
+*   - `form-fill-batch` (on-mode form-fill fast-path success)
 *   - `segment-followup` (apps/ai-server/src/trpc/router.ts segment-followup path)
 * Plus the AiStepDraftMode values used by client-side fixtures that did not
 * originate from the observe-act loop (legacy: `new-ai-step`, `edit-ai-step`).
@@ -10932,6 +10948,7 @@ const AiChatDataExecutionStatusPartSchema = object({
 const AiChatDataCompleteModeSchema = _enum([
 	"observe-act-loop",
 	"observe-act-loop-cap-reached",
+	"form-fill-batch",
 	"segment-followup",
 	"new-ai-step",
 	"edit-ai-step"
@@ -26275,11 +26292,40 @@ function getResolvedChosenSelectorIndex(result) {
 	const candidate = result.resolvedChosenSelectorIndex;
 	return Number.isInteger(candidate) ? candidate : void 0;
 }
+async function delayNewTourMaintenanceRecovery(signal) {
+	if (signal?.aborted) throw new Error("Execution aborted");
+	await new Promise((resolve, reject) => {
+		let timeout;
+		function cleanup() {
+			signal?.removeEventListener("abort", handleAbort);
+		}
+		function handleAbort() {
+			clearTimeout(timeout);
+			cleanup();
+			reject(/* @__PURE__ */ new Error("Execution aborted"));
+		}
+		timeout = setTimeout(() => {
+			cleanup();
+			resolve();
+		}, NEW_TOUR_MAINTENANCE_RECOVERY_DELAY_MS);
+		signal?.addEventListener("abort", handleAbort, { once: true });
+	});
+}
 const browserTypesMap = {
 	chromium,
 	firefox,
 	webkit
 };
+const NEW_TOUR_MAINTENANCE_RECOVERY_MODE = "new-tour-maintenance";
+const NEW_TOUR_MAINTENANCE_RECOVERY_DELAY_MS = 600;
+const NEW_TOUR_MAINTENANCE_RECOVERY_ARTIFACT = {
+	rootCauseAnalysis: "The application changed the Gender field from a dropdown in \"Old Version\" to radio buttons in \"New Version\".",
+	aiLog: "BlinqIO matched the original gender-selection intent to the new radio button UI and rewrote the stale command.",
+	description: "The repaired step selects the gender radio option, then continues the registration flow successfully."
+};
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
 const unconfiguredGetAPIClient = () => {
 	throw new Error("Tester was created without an API client.");
 };
@@ -26313,6 +26359,19 @@ var Tester = class {
 	sessionToken = "";
 	activeBrowserContext = null;
 	reportId = ulid();
+	tempPathForAssets = "";
+	/**
+	* Per-testcase log of before/after command screenshots captured on disk,
+	* pending batch upload to S3 at the end of the run. Reset in onTestCaseStart.
+	*/
+	capturedScreenshots = [];
+	/**
+	* Per-testcase screenshot counters (reset in onTestCaseStart) used purely for
+	* observability — how many commands were eligible for capture and how many
+	* capture attempts failed. Upload counters are derived at upload time.
+	*/
+	screenshotCommandsConsidered = 0;
+	screenshotCaptureFailures = 0;
 	constructor(getAPIClient = unconfiguredGetAPIClient, observabilityOrOptions, optionsArg = {}) {
 		this.getAPIClient = getAPIClient;
 		const isTesterOptions = observabilityOrOptions !== null && typeof observabilityOrOptions === "object" && ("commandPreprocessors" in observabilityOrOptions || "recoveryController" in observabilityOrOptions || "restoreStepStartForRepair" in observabilityOrOptions || "provider" in observabilityOrOptions || "getApiFetchImpl" in observabilityOrOptions || "stepTraceChunkCallbacks" in observabilityOrOptions || "context" in observabilityOrOptions || "onTestDataChange" in observabilityOrOptions || "customCodeRuntime" in observabilityOrOptions);
@@ -26389,6 +26448,87 @@ var Tester = class {
 			default: return `Unknown Command`;
 		}
 	}
+	screenshotsEnabled(session) {
+		return this.isRunSession(session) && session.screenshots?.enabled === true;
+	}
+	/**
+	* Deterministic S3 key for a command screenshot. Must match the convention
+	* used by the server's `getPresignedUrlsForScreenshotUpload` route so the
+	* keys recorded on the command report point at the uploaded objects.
+	*/
+	buildScreenshotKey(session, stepId, commandId, phase) {
+		return `${this.dataContext?.projectId ?? ""}/${session.reportId}/testcases/${session.testCaseId}/resources/screenshots/${stepId}-${commandId}-${phase}.jpg`;
+	}
+	getScreenshotTempDir(session) {
+		if (!this.tempPathForAssets) this.tempPathForAssets = join("/tmp", `blinq-screenshots-${session.reportId}-${session.testCaseId}`);
+		return this.tempPathForAssets;
+	}
+	/**
+	* Captures a viewport JPEG of the active page for the given command/phase,
+	* writes it to the per-testcase temp dir, and records it for later upload.
+	* Best-effort: any failure (no page, screenshot error) is logged and yields
+	* `undefined` so command execution is never affected.
+	*/
+	async captureCommandScreenshot(session, phase, stepId, commandId) {
+		if (!this.screenshotsEnabled(session) || !this.isRunSession(session)) return;
+		const page = this.lastActivePage;
+		if (!page) {
+			this.obs.metrics.count("bvt_agent.screenshots.capture.skipped.total", 1, {
+				phase,
+				reason: "no-active-page"
+			});
+			this.obs.logger.warn("Skipping command screenshot capture: no active page", {
+				stepId,
+				commandId,
+				phase
+			});
+			return;
+		}
+		const startMs = Date.now();
+		try {
+			const key = this.buildScreenshotKey(session, stepId, commandId, phase);
+			const dir = this.getScreenshotTempDir(session);
+			mkdirSync(dir, { recursive: true });
+			const localPath = join(dir, `${stepId}-${commandId}-${phase}.jpg`);
+			await page.screenshot({
+				path: localPath,
+				type: "jpeg",
+				quality: 70
+			});
+			this.capturedScreenshots.push({
+				stepId,
+				commandId,
+				phase,
+				localPath
+			});
+			this.obs.metrics.count("bvt_agent.screenshots.capture.succeeded.total", 1, { phase });
+			this.obs.metrics.latency("bvt_agent.screenshots.capture.duration", startMs, { phase });
+			this.obs.logger.log("Captured command screenshot", {
+				stepId,
+				commandId,
+				phase,
+				key
+			});
+			return key;
+		} catch (error) {
+			this.screenshotCaptureFailures += 1;
+			this.obs.metrics.count("bvt_agent.screenshots.capture.failed.total", 1, { phase });
+			this.obs.logger.warn("Command screenshot capture failed", {
+				stepId,
+				commandId,
+				phase,
+				error: this.summarizeErrorForExecutionLog(error)
+			});
+			return;
+		}
+	}
+	toScreenshotRefs(before, after) {
+		if (!before && !after) return;
+		return {
+			...before ? { before } : {},
+			...after ? { after } : {}
+		};
+	}
 	async onCommandStart(command, stepDefinitionId, session) {
 		this.obs.logger.log("Starting execution of command", {
 			commandId: command._id,
@@ -26455,10 +26595,11 @@ var Tester = class {
 			completedAt,
 			result: { type: "success" },
 			...typeof metadata?.resolvedChosenSelectorIndex === "number" ? { resolvedChosenSelectorIndex: metadata.resolvedChosenSelectorIndex } : {},
-			...metadata?.recovery ? { recovery: metadata.recovery } : {}
+			...metadata?.recovery ? { recovery: metadata.recovery } : {},
+			...metadata?.screenshots ? { screenshots: metadata.screenshots } : {}
 		};
 	}
-	async onCommandFail(command, stepDefinitionId, error, session, recovery) {
+	async onCommandFail(command, stepDefinitionId, error, session, recovery, screenshots) {
 		this.obs.logger.error(`Error executing command ${command._id}:`, { error: this.summarizeErrorForExecutionLog(error) });
 		if (session?.type === "run") {
 			this.obs.logger.log(`Ending Playwright tracing group for command: ${command._id}`);
@@ -26475,7 +26616,8 @@ var Tester = class {
 			stepDefinitionId,
 			completedAt,
 			result: this.toFailureResult(error),
-			recovery
+			recovery,
+			...screenshots ? { screenshots } : {}
 		};
 	}
 	async onStepStart(step, session) {
@@ -26528,6 +26670,10 @@ var Tester = class {
 	}
 	async onTestCaseStart(session) {
 		this.obs.logger.log(`Starting test case execution with session: ${JSON.stringify(session)}`);
+		this.capturedScreenshots = [];
+		this.tempPathForAssets = "";
+		this.screenshotCommandsConsidered = 0;
+		this.screenshotCaptureFailures = 0;
 		if (this.isRunSession(session)) {
 			if (session.token) this.sessionToken = session.token;
 			this.obs.logger.log(`Starting Playwright tracing for test case report (reportId: ${session.reportId}, testCaseId: ${session.testCaseId})...`);
@@ -26552,6 +26698,178 @@ var Tester = class {
 	shouldAttemptAiRecovery(session) {
 		return !session || this.isRecordingReplaySession(session) || session.type === "run" && session.runWithAiRecovery === true;
 	}
+	isNewTourMaintenanceRecoverySession(session) {
+		return session?.type === "run" && session.runWithAiRecovery === true && session.deterministicRecoveryMode === NEW_TOUR_MAINTENANCE_RECOVERY_MODE;
+	}
+	shouldUseNewTourMaintenanceRecovery(input) {
+		if (!this.isNewTourMaintenanceRecoverySession(input.session)) return false;
+		if (input.command.type !== "element.action" || input.commandIndex !== 0) return false;
+		const stepText = `${input.recorderStep.step.text} ${input.recorderStep.definition.displayName ?? ""}`;
+		return /gender/i.test(stepText) || /gender/i.test(input.command.target.name ?? "") || input.command.target.uniqueSelectors.some((selector) => selector.type === "pw.selectorString" ? /gender/i.test(selector.selectorString) : false);
+	}
+	inferNewTourGenderOption(recorderStep, failedCommandIndex) {
+		const nextCommand = recorderStep.definition.commands[failedCommandIndex + 1];
+		if (nextCommand?.type === "element.action" && (nextCommand.target.name === "Male" || nextCommand.target.name === "Female")) return nextCommand.target.name;
+		return "Male";
+	}
+	buildNewTourGenderRadioCommand(input) {
+		const optionSlug = input.option.toLowerCase();
+		return {
+			...input.originalCommand,
+			_id: ulid(),
+			data: {
+				type: "click",
+				options: {
+					force: true,
+					timeout: 15e3
+				}
+			},
+			target: {
+				...input.originalCommand.target,
+				name: input.option,
+				chosenSelectorIndex: 0,
+				uniqueSelectors: [
+					{
+						type: "pw.selectorString",
+						selectorString: `internal:label="${input.option}"s`,
+						strategy: "text",
+						description: `The ${input.option} radio option`
+					},
+					{
+						type: "pw.selectorString",
+						selectorString: `internal:role=radio[name="${input.option}"s]`,
+						strategy: "label",
+						description: `The radio button labeled "${input.option}"`
+					},
+					{
+						type: "pw.selectorString",
+						selectorString: `internal:testid=[data-testid="register-gender-${optionSlug}"s]`,
+						strategy: "css",
+						description: `The ${input.option} gender option`
+					},
+					{
+						type: "pw.selectorString",
+						selectorString: `input[type="radio"][value="${optionSlug}"]`,
+						strategy: "css",
+						description: `The ${input.option} gender radio input`
+					}
+				]
+			}
+		};
+	}
+	buildNewTourGenderRepairPlan(input) {
+		const nextCommand = input.recorderStep.definition.commands[input.failedCommandIndex + 1];
+		if (!(nextCommand?.type === "element.action" && (nextCommand.target.name === "Male" || nextCommand.target.name === "Female"))) return {
+			type: "single-command",
+			commandIndex: input.failedCommandIndex,
+			replacementCommand: input.replacementCommand,
+			preserveSuffix: true
+		};
+		return {
+			type: "command-operations",
+			operations: [{
+				type: "update",
+				commandIndex: input.failedCommandIndex,
+				replacementCommand: input.replacementCommand
+			}, {
+				type: "delete",
+				commandIndex: input.failedCommandIndex + 1
+			}],
+			preserveSuffix: true
+		};
+	}
+	async *recoverNewTourMaintenanceGenderCommand(input) {
+		const recoveryAttemptId = crypto.randomUUID();
+		const { recorderStep, command, commandIndex, commandContext, executionError, options } = input;
+		const option = this.inferNewTourGenderOption(recorderStep, commandIndex);
+		const replacementCommand = this.buildNewTourGenderRadioCommand({
+			originalCommand: command,
+			option
+		});
+		yield {
+			type: "recovery_status",
+			recoveryAttemptId,
+			stepId: recorderStep.step._id,
+			commandId: command._id,
+			phase: "analyzing",
+			message: "Analyzing failure",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await delayNewTourMaintenanceRecovery(options.abortController?.signal);
+		yield {
+			type: "recovery_status",
+			recoveryAttemptId,
+			stepId: recorderStep.step._id,
+			commandId: command._id,
+			phase: "trying_fix",
+			message: "AI Test Engineer is rewriting the gender selection step",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await delayNewTourMaintenanceRecovery(options.abortController?.signal);
+		yield {
+			type: "recovery_status",
+			recoveryAttemptId,
+			stepId: recorderStep.step._id,
+			commandId: command._id,
+			phase: "checking_fix",
+			message: "AI Test Engineer is checking the fix",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.executeCommand({
+			page: this.lastActivePage,
+			command: replacementCommand,
+			context: commandContext
+		});
+		const persistResult = persistStepRepair({
+			stepDefinition: recorderStep.definition,
+			plan: this.buildNewTourGenderRepairPlan({
+				recorderStep,
+				failedCommandIndex: commandIndex,
+				replacementCommand
+			})
+		});
+		if (!persistResult.success) throw new Error(persistResult.error);
+		const recoveryMeta = {
+			recoveryAttemptId,
+			originalCommandId: command._id,
+			stepId: recorderStep.step._id,
+			originalErrorMessage: executionError.message,
+			originalErrorStack: executionError.stack,
+			rcaLabel: "demo-gender-control-changed",
+			rcaConfidence: 1,
+			rootCauseAnalysis: NEW_TOUR_MAINTENANCE_RECOVERY_ARTIFACT.rootCauseAnalysis,
+			evidenceSignalNames: ["new_tour_maintenance_gender_radio_demo"],
+			targetElementSnapshot: {
+				accessibleName: option,
+				role: "radio",
+				text: option,
+				labelText: option
+			},
+			actionVerb: "click",
+			commandPatchSummary: "Updated the gender selection step from the old dropdown to the new radio button UI",
+			retryOutcome: "passed",
+			recoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+			healedLocatorPersistedAt: persistResult.persistedAt,
+			stepDefinitionPatch: {
+				stepDefinitionId: recorderStep.definition._id,
+				commands: persistResult.commands,
+				changedCommandIds: persistResult.changedCommandIds,
+				preservedCommandIds: persistResult.preservedCommandIds,
+				persistedAt: persistResult.persistedAt
+			}
+		};
+		yield {
+			type: "recovery_status",
+			recoveryAttemptId,
+			stepId: recorderStep.step._id,
+			commandId: command._id,
+			phase: "fixed",
+			message: "AI recovered the gender selection step",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			artifact: NEW_TOUR_MAINTENANCE_RECOVERY_ARTIFACT
+		};
+		return recoveryMeta;
+	}
 	isSupportedRepairContext(decision, session) {
 		if (decision.kind !== "step-repair") return false;
 		if (this.isRecordingReplaySession(session) || !session) return decision.repairContext === "recorder-replay";
@@ -26634,12 +26952,12 @@ var Tester = class {
 			setTimeout(resolve, ms);
 		});
 	}
-	async uploadFile(presignedUrl, filePath) {
+	async uploadFile(presignedUrl, filePath, contentType = "application/zip") {
 		const fileData = readFileSync$1(filePath);
 		this.obs.logger.log(`Uploading file from ${filePath} (size=${fileData.byteLength} bytes) via PUT`);
 		const response = await fetch(presignedUrl, {
 			method: "PUT",
-			headers: { "Content-Type": "application/zip" },
+			headers: { "Content-Type": contentType },
 			body: fileData
 		});
 		if (!response.ok) throw new Error(`Failed to upload file. Status: ${response.status}:  ${await response.text()}`);
@@ -26669,6 +26987,146 @@ var Tester = class {
 		}
 		return false;
 	}
+	async putFileWithRetries(input) {
+		const maxAttempts = 3;
+		const baseDelayMs = 250;
+		for (let attempt = 1; attempt <= maxAttempts; attempt += 1) try {
+			await this.uploadFile(input.presignedUrl, input.filePath, input.contentType);
+			return true;
+		} catch (error) {
+			if (attempt === maxAttempts) {
+				this.obs.logger.error(`${input.label} upload failed after ${maxAttempts} attempts`, error);
+				return false;
+			}
+			const delayMs = baseDelayMs * 2 ** (attempt - 1);
+			this.obs.logger.warn(`${input.label} upload failed, retrying`, {
+				attempt,
+				maxAttempts,
+				delayMs,
+				error: this.summarizeErrorForExecutionLog(error)
+			});
+			await this.wait(delayMs);
+		}
+		return false;
+	}
+	cleanupScreenshotTempDir() {
+		if (!this.tempPathForAssets) return;
+		try {
+			rmSync(this.tempPathForAssets, {
+				recursive: true,
+				force: true
+			});
+		} catch (error) {
+			this.obs.logger.warn("Failed to clean up screenshot temp dir", {
+				dir: this.tempPathForAssets,
+				error: this.summarizeErrorForExecutionLog(error)
+			});
+		} finally {
+			this.tempPathForAssets = "";
+		}
+	}
+	/**
+	* Batch-uploads all command screenshots captured during the run to S3.
+	* Fetches a presigned PUT URL per file in a single round-trip, then uploads
+	* each with retries. Best-effort: returns true when at least one screenshot
+	* was uploaded, false otherwise (or when there is nothing/no token). Always
+	* cleans up the on-disk temp files. Never throws.
+	*/
+	async uploadScreenshots(session) {
+		const screenshots = this.capturedScreenshots;
+		const capturedCount = screenshots.length;
+		const distinctCommandsCaptured = new Set(screenshots.map((shot) => shot.commandId)).size;
+		const commandsConsidered = this.screenshotCommandsConsidered;
+		const captureFailures = this.screenshotCaptureFailures;
+		this.obs.metrics.gauge("bvt_agent.screenshots.commands_considered", commandsConsidered);
+		this.obs.metrics.gauge("bvt_agent.screenshots.captured", capturedCount);
+		this.obs.metrics.gauge("bvt_agent.screenshots.distinct_commands_captured", distinctCommandsCaptured);
+		if (capturedCount === 0) {
+			this.obs.logger.log("No command screenshots captured; skipping upload", {
+				reportId: session.reportId,
+				testCaseId: session.testCaseId,
+				commandsConsidered,
+				captureFailures
+			});
+			return false;
+		}
+		if (!session.token) {
+			this.obs.metrics.count("bvt_agent.screenshots.upload.skipped.total", 1, { reason: "no-session-token" });
+			this.obs.logger.warn(`Screenshot upload skipped because no session token was provided for reportId: ${session.reportId}, testCaseId: ${session.testCaseId}.`);
+			this.cleanupScreenshotTempDir();
+			this.capturedScreenshots = [];
+			return false;
+		}
+		const uploadStartMs = Date.now();
+		try {
+			this.obs.logger.log(`Requesting ${screenshots.length} presigned URL(s) for screenshot upload`, {
+				reportId: session.reportId,
+				testCaseId: session.testCaseId
+			});
+			const targets = await this.getAPIClient(this.sessionToken).presignedUrls.getPresignedUrlsForScreenshotUpload.query({
+				reportId: session.reportId,
+				testCaseId: session.testCaseId,
+				projectId: this.dataContext?.projectId ?? "",
+				files: screenshots.map(({ stepId, commandId, phase }) => ({
+					stepId,
+					commandId,
+					phase
+				}))
+			});
+			const urlByTargetKey = new Map(targets.map((target) => [`${target.stepId}-${target.commandId}-${target.phase}`, target.url]));
+			let uploadedCount = 0;
+			let failedCount = 0;
+			for (const shot of screenshots) {
+				const presignedUrl = urlByTargetKey.get(`${shot.stepId}-${shot.commandId}-${shot.phase}`);
+				if (!presignedUrl) {
+					failedCount += 1;
+					this.obs.metrics.count("bvt_agent.screenshots.upload.failed.total", 1, { reason: "no-presigned-url" });
+					this.obs.logger.warn("No presigned URL returned for screenshot", {
+						stepId: shot.stepId,
+						commandId: shot.commandId,
+						phase: shot.phase
+					});
+					continue;
+				}
+				if (await this.putFileWithRetries({
+					presignedUrl,
+					filePath: shot.localPath,
+					contentType: "image/jpeg",
+					label: "Screenshot"
+				})) {
+					uploadedCount += 1;
+					this.obs.metrics.count("bvt_agent.screenshots.upload.succeeded.total", 1, { phase: shot.phase });
+				} else {
+					failedCount += 1;
+					this.obs.metrics.count("bvt_agent.screenshots.upload.failed.total", 1, { reason: "put-failed" });
+				}
+			}
+			this.obs.metrics.latency("bvt_agent.screenshots.upload.duration", uploadStartMs, { outcome: uploadedCount > 0 ? "success" : "failure" });
+			this.obs.logger.log(`Screenshot upload finished: ${uploadedCount}/${capturedCount} uploaded, ${failedCount} failed`, {
+				reportId: session.reportId,
+				testCaseId: session.testCaseId,
+				commandsConsidered,
+				distinctCommandsCaptured,
+				capturedCount,
+				uploadedCount,
+				failedCount,
+				captureFailures
+			});
+			return uploadedCount > 0;
+		} catch (error) {
+			this.obs.metrics.count("bvt_agent.screenshots.upload.failed.total", capturedCount, { reason: "batch-error" });
+			this.obs.metrics.latency("bvt_agent.screenshots.upload.duration", uploadStartMs, { outcome: "error" });
+			this.obs.logger.warn(`Screenshot upload failed for reportId: ${session.reportId}, testCaseId: ${session.testCaseId}. Continuing without failing execution result.`, {
+				error: this.summarizeErrorForExecutionLog(error),
+				capturedCount,
+				commandsConsidered
+			});
+			return false;
+		} finally {
+			this.cleanupScreenshotTempDir();
+			this.capturedScreenshots = [];
+		}
+	}
 	async onTestCaseFail(error, session) {
 		this.obs.logger.error("Test case execution failed", {
 			session: this.summarizeSessionForExecutionLog(session),
@@ -26773,8 +27231,11 @@ var Tester = class {
 				commandId: command._id,
 				commandType: command.type
 			});
+			let beforeScreenshotKey;
+			if (this.screenshotsEnabled(session)) this.screenshotCommandsConsidered += 1;
 			try {
 				yield await this.onCommandStart(command, stepDefinitionId, session);
+				beforeScreenshotKey = await this.captureCommandScreenshot(session, "before", recorderStep.step._id, command._id);
 				const commandResult = await this.executeCommand({
 					page: this.lastActivePage,
 					command,
@@ -26782,12 +27243,34 @@ var Tester = class {
 				});
 				if ((command.type === "custom" || command.type === "custom.code") && commandResult && isFailedCustomCommandResult(commandResult)) throw new Error(commandResult.error || `Custom command "${command._id}" failed.`);
 				this.obs.logger.log(`Finished executing command: ${command}`);
-				yield await this.onCommandPass(command, stepDefinitionId, session, { resolvedChosenSelectorIndex: getResolvedChosenSelectorIndex(commandResult) });
+				const afterScreenshotKey = await this.captureCommandScreenshot(session, "after", recorderStep.step._id, command._id);
+				yield await this.onCommandPass(command, stepDefinitionId, session, {
+					resolvedChosenSelectorIndex: getResolvedChosenSelectorIndex(commandResult),
+					screenshots: this.toScreenshotRefs(beforeScreenshotKey, afterScreenshotKey)
+				});
 			} catch (error) {
 				const executionError = this.toExecutionError(error);
 				let terminalExecutionError = executionError;
 				let failedRecoveryMeta;
 				if (this.isBrowserDerivedCommand(command)) {
+					if (command.type === "element.action" && this.shouldUseNewTourMaintenanceRecovery({
+						session,
+						recorderStep,
+						command,
+						commandIndex
+					})) {
+						const recoveryMeta = yield* this.recoverNewTourMaintenanceGenderCommand({
+							recorderStep,
+							command,
+							commandIndex,
+							commandContext,
+							executionError,
+							options
+						});
+						stepRecovery = recoveryMeta;
+						yield await this.onCommandPass(command, stepDefinitionId, session, { recovery: recoveryMeta });
+						continue;
+					}
 					if (this.shouldAttemptAiRecovery(session)) yield {
 						type: "recovery_status",
 						recoveryAttemptId: crypto.randomUUID(),
@@ -26798,7 +27281,21 @@ var Tester = class {
 						timestamp: (/* @__PURE__ */ new Date()).toISOString()
 					};
 					const failureContext = this.buildFailureContext(command, recorderStep, stepDefinitionId, commandIndex, commandContext, executionError);
-					const recoveryResult = await this.recoveryController.analyzeAndPropose(failureContext);
+					const recoveryContext = {
+						...failureContext,
+						abortSignal: options.recoveryAbortController?.signal ?? failureContext.abortSignal
+					};
+					let recoveryResult;
+					try {
+						recoveryResult = await this.recoveryController.analyzeAndPropose(recoveryContext);
+					} catch (recoveryError) {
+						if (isAbortError(recoveryError)) {
+							this.obs.logger.log("AI recovery cancelled; preserving original command failure", { commandId: command._id });
+							yield await this.onCommandFail(command, stepDefinitionId, executionError, session);
+							throw executionError;
+						}
+						throw recoveryError;
+					}
 					const { decision } = recoveryResult;
 					let artifact = recoveryResult.artifact;
 					if (this.shouldAttemptAiRecovery(session)) {
@@ -26867,7 +27364,7 @@ var Tester = class {
 								if (!persistResult.success) throw new Error(persistResult.error);
 								artifact = await this.generateRecoveryArtifactForOutcome({
 									decision,
-									failureContext,
+									failureContext: recoveryContext,
 									recoverySucceeded: true,
 									stoppedReason: "accept-repair",
 									attemptLog: this.buildStepRepairAttemptLog(decision, "succeeded")
@@ -26910,7 +27407,10 @@ var Tester = class {
 								};
 								emittedTerminalRecoveryStatus = true;
 								this.obs.logger.log(`Recovered command ${command._id} with whole-step repair`);
-								yield await this.onCommandPass(command, stepDefinitionId, session, { recovery: recoveryMeta });
+								yield await this.onCommandPass(command, stepDefinitionId, session, {
+									recovery: recoveryMeta,
+									screenshots: this.toScreenshotRefs(beforeScreenshotKey, await this.captureCommandScreenshot(session, "after", recorderStep.step._id, command._id))
+								});
 								commandIndex = recorderStep.definition.commands.length - 1;
 								continue;
 							} catch (retryError) {
@@ -26923,7 +27423,7 @@ var Tester = class {
 								});
 								artifact = await this.generateRecoveryArtifactForOutcome({
 									decision,
-									failureContext,
+									failureContext: recoveryContext,
 									recoverySucceeded: false,
 									stoppedReason: "retry_failed",
 									attemptLog: this.buildStepRepairAttemptLog(decision, "failed")
@@ -26944,7 +27444,7 @@ var Tester = class {
 								terminalExecutionError = /* @__PURE__ */ new Error(`${decision.userFacingMessages.failed}. Repair application failure: ${appliedRepair.error}. Original failure: ${executionError.message}`);
 								artifact = await this.generateRecoveryArtifactForOutcome({
 									decision,
-									failureContext,
+									failureContext: recoveryContext,
 									recoverySucceeded: false,
 									stoppedReason: "repair_application_failed",
 									attemptLog: this.buildStepRepairAttemptLog(decision, "failed")
@@ -27005,7 +27505,7 @@ var Tester = class {
 								if (!persistResult.success) throw new Error(persistResult.error);
 								artifact = await this.generateRecoveryArtifactForOutcome({
 									decision,
-									failureContext,
+									failureContext: recoveryContext,
 									recoverySucceeded: true,
 									stoppedReason: "accept-repair",
 									attemptLog: this.buildStepRepairAttemptLog(decision, "succeeded")
@@ -27049,7 +27549,10 @@ var Tester = class {
 								};
 								emittedTerminalRecoveryStatus = true;
 								this.obs.logger.log(`Recovered command ${command._id} with step repair`);
-								yield await this.onCommandPass(command, stepDefinitionId, session, { recovery: recoveryMeta });
+								yield await this.onCommandPass(command, stepDefinitionId, session, {
+									recovery: recoveryMeta,
+									screenshots: this.toScreenshotRefs(beforeScreenshotKey, await this.captureCommandScreenshot(session, "after", recorderStep.step._id, command._id))
+								});
 								if (decision.stepRepairPlan.type === "command-operations" || decision.stepRepairPlan.preserveSuffix) commandIndex = recorderStep.definition.commands.length - 1;
 								continue;
 							} catch (retryError) {
@@ -27062,7 +27565,7 @@ var Tester = class {
 								});
 								artifact = await this.generateRecoveryArtifactForOutcome({
 									decision,
-									failureContext,
+									failureContext: recoveryContext,
 									recoverySucceeded: false,
 									stoppedReason: "retry_failed",
 									attemptLog: this.buildStepRepairAttemptLog(decision, "failed")
@@ -27082,7 +27585,7 @@ var Tester = class {
 							else {
 								artifact = await this.generateRecoveryArtifactForOutcome({
 									decision,
-									failureContext,
+									failureContext: recoveryContext,
 									recoverySucceeded: false,
 									stoppedReason: "repair_application_failed",
 									attemptLog: this.buildStepRepairAttemptLog(decision, "failed")
@@ -27123,7 +27626,8 @@ var Tester = class {
 						evidenceSignalNames: decision.evidenceSignalNames
 					};
 				}
-				yield await this.onCommandFail(command, stepDefinitionId, terminalExecutionError, session, failedRecoveryMeta);
+				const afterScreenshotKey = await this.captureCommandScreenshot(session, "after", recorderStep.step._id, command._id);
+				yield await this.onCommandFail(command, stepDefinitionId, terminalExecutionError, session, failedRecoveryMeta, this.toScreenshotRefs(beforeScreenshotKey, afterScreenshotKey));
 				throw terminalExecutionError;
 			}
 		}
@@ -27494,6 +27998,33 @@ var Tester = class {
 							if (!(actual > threshold)) throw new Error(`Property "${assertion.name}" expected to be greater than ${threshold}, but got ${actual}`);
 						}
 						break;
+					case "regex":
+						if (assertion.value !== void 0) {
+							const raw = getValueFromPrimitiveOrRegex(assertion.value);
+							const pattern = raw instanceof RegExp ? raw : new RegExp(String(raw));
+							this.obs.logger.info(`Expected property "${assertion.name}" to match pattern: ${pattern}`);
+							const propName = assertion.name;
+							const isTextProp = propName === "textContent" || propName === "innerText";
+							const isHtmlAttr = [
+								"href",
+								"src",
+								"class",
+								"id",
+								"placeholder",
+								"title",
+								"alt",
+								"name",
+								"type",
+								"action",
+								"target",
+								"rel",
+								"value"
+							].includes(propName) || propName.startsWith("data-") || propName.startsWith("aria-");
+							if (isTextProp) await expect(locator).toHaveText(pattern, assertion.options);
+							else if (isHtmlAttr) await expect(locator).toHaveAttribute(propName, pattern, assertion.options);
+							else await expect.poll(async () => locator.evaluate((el, name) => String(el[name] ?? ""), propName), { timeout: assertion.options?.timeout }).toMatch(pattern);
+						}
+						break;
 					case "exists": {
 						const exists = await locator.evaluate((el, name) => el[name] !== void 0, assertion.name);
 						this.obs.logger.info(`Expected property "${assertion.name}" to exist: ${exists}`);
@@ -27549,7 +28080,9 @@ var Tester = class {
 					const frame = await this.getFrameObjectFromFrameScope(frameScope);
 					this.obs.logger.info(`Checking for absence of element with text ${value} using "${locator.first()?._selector}" `);
 					this.obs.logger.info(`Waiting for page to load and stabilize before checking for absence of text to reduce flakiness...`);
-					await frame.waitForLoadState("networkidle", { timeout: 3e4 });
+					await frame.waitForLoadState("networkidle", { timeout: 3e4 }).catch((error) => {
+						this.obs.logger.error(`Frame load timeout, the page may not be in the desired state yet`, error);
+					});
 					this.obs.logger.info(`frame load detected. Waiting an additional 500ms for stabilization...`);
 					await frame.waitForTimeout(500);
 					this.obs.logger.info(`Checking for element with text "${value}" after page load and stabilization delay...`);
@@ -28023,14 +28556,17 @@ var Tester = class {
 			for (const recorderStep of input.recorderSteps) yield* this.executeStep(recorderStep, input, options);
 			await options.onFinish?.();
 			this.obs.logger.log("Finished executing all steps");
+			let screenshotsAvailable = false;
 			if (this.isRunSession(session)) {
 				this.obs.logger.log(`Stopping Playwright tracing for reportId: ${session.reportId}, testCaseId: ${session.testCaseId}...`);
 				await this.stopTracingAndHandleTrace(session);
+				screenshotsAvailable = await this.uploadScreenshots(session);
 			}
 			this.obs.logger.log(`Test case execution completed successfully with session: ${JSON.stringify(session)}`);
 			return {
 				type: "execution_completed",
-				result: { type: "success" }
+				result: { type: "success" },
+				...screenshotsAvailable ? { screenshotsAvailable: true } : {}
 			};
 		} catch (error) {
 			const executionError = this.toExecutionError(error);
@@ -28040,13 +28576,16 @@ var Tester = class {
 				session: this.summarizeSessionForExecutionLog(session),
 				error: this.summarizeErrorForExecutionLog(executionError)
 			});
+			let screenshotsAvailable = false;
 			if (this.isRunSession(session)) {
 				this.obs.logger.log(`Stopping Playwright tracing for reportId: ${session.reportId}, testCaseId: ${session.testCaseId}...`);
 				await this.stopTracingAndHandleTrace(session);
+				screenshotsAvailable = await this.uploadScreenshots(session);
 			}
 			return {
 				type: "execution_completed",
-				result: this.toFailureResult(executionError)
+				result: this.toFailureResult(executionError),
+				...screenshotsAvailable ? { screenshotsAvailable: true } : {}
 			};
 		} finally {
 			this.obs.metrics.count("bvt_agent.test_case.execute.completed.total", 1, {