intellitester 0.5.2 → 0.5.3

package/dist/{chunk-VWXGXFIM.js → chunk-7UYD5Q7D.js}

@@ -8,13 +8,13 @@ import { parsePhoneNumber, isValidPhoneNumber } from 'libphonenumber-js';
 import { createServer } from 'http';
 import * as fs3 from 'fs/promises';
 import fs3__default from 'fs/promises';
-import * as path5 from 'path';
-import path5__default from 'path';
+import * as path4 from 'path';
+import path4__default from 'path';
 import { chromium, webkit, firefox } from 'playwright';
 import prompts from 'prompts';
 import { Client, Users, TablesDB, Storage, Teams } from 'node-appwrite';
 import os from 'os';
-import { CompletionModel, Workflow, ChatMessage, runAgent } from 'blazen';
+import { CompletionModel, Workflow, runAgent, ChatMessage } from 'blazen';
 import { z } from 'zod';
 import { spawn } from 'child_process';
 import { existsSync, readFileSync, rmSync } from 'fs';
@@ -441,8 +441,8 @@ var TRACK_DIR = ".intellitester/track";
 var ACTIVE_TESTS_FILE = "ACTIVE_TESTS.json";
 var DEFAULT_STALE_MS = 2 * 60 * 60 * 1e3;
 var HEARTBEAT_MS = 15e3;
-var getTrackDir = (cwd, trackDir) => trackDir ? path5__default.resolve(cwd, trackDir) : path5__default.join(cwd, TRACK_DIR);
-var getActiveTestsPath = (cwd, trackDir) => path5__default.join(getTrackDir(cwd, trackDir), ACTIVE_TESTS_FILE);
+var getTrackDir = (cwd, trackDir) => trackDir ? path4__default.resolve(cwd, trackDir) : path4__default.join(cwd, TRACK_DIR);
+var getActiveTestsPath = (cwd, trackDir) => path4__default.join(getTrackDir(cwd, trackDir), ACTIVE_TESTS_FILE);
 var loadActiveTests = async (cwd, trackDir) => {
   const filePath = getActiveTestsPath(cwd, trackDir);
   try {
@@ -509,11 +509,11 @@ var cleanupOrphanedTrackFiles = async (cwd, state, trackDir) => {
   const dir = getTrackDir(cwd, trackDir);
   try {
     const files = await fs3__default.readdir(dir);
-    const activeFiles = new Set(Object.values(state.sessions).map((s) => path5__default.basename(s.trackFile)));
+    const activeFiles = new Set(Object.values(state.sessions).map((s) => path4__default.basename(s.trackFile)));
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
       if (activeFiles.has(file)) continue;
-      const filePath = path5__default.join(dir, file);
+      const filePath = path4__default.join(dir, file);
       try {
         const stat2 = await fs3__default.stat(filePath);
         const staleMs = Number(process.env.INTELLITESTER_STALE_TEST_MS ?? DEFAULT_STALE_MS);
@@ -560,7 +560,7 @@ async function initFileTracking(options) {
   const trackDir = options.trackDir;
   await fs3__default.mkdir(getTrackDir(cwd, trackDir), { recursive: true });
   await pruneStaleTests(cwd, options.cleanupConfig, trackDir);
-  const trackFile = path5__default.join(getTrackDir(cwd, trackDir), `TEST_SESSION_${options.sessionId}.jsonl`);
+  const trackFile = path4__default.join(getTrackDir(cwd, trackDir), `TEST_SESSION_${options.sessionId}.jsonl`);
   await fs3__default.writeFile(trackFile, "", "utf8");
   const state = await loadActiveTests(cwd, trackDir);
   state.sessions[options.sessionId] = {
@@ -1080,7 +1080,7 @@ var MIME_BY_EXTENSION = {
   ".webm": "video/webm"
 };
 function mimeFromName(name) {
-  const ext = path5__default.extname(name).toLowerCase();
+  const ext = path4__default.extname(name).toLowerCase();
   return MIME_BY_EXTENSION[ext] ?? "application/octet-stream";
 }
 function deriveFilenameFromUrl(url) {
@@ -1100,8 +1100,8 @@ async function downloadUrl(url) {
   const arrayBuffer = await response.arrayBuffer();
   const buffer = Buffer.from(arrayBuffer);
   const name = deriveFilenameFromUrl(url);
-  const tempDir = await fs3__default.mkdtemp(path5__default.join(os.tmpdir(), "intellitester-upload-"));
-  const tempPath = path5__default.join(tempDir, name);
+  const tempDir = await fs3__default.mkdtemp(path4__default.join(os.tmpdir(), "intellitester-upload-"));
+  const tempPath = path4__default.join(tempDir, name);
   await fs3__default.writeFile(tempPath, buffer);
   return { path: tempPath, tempDir };
 }
@@ -1112,8 +1112,8 @@ async function resolveOne(entry, context) {
       const downloaded = await downloadUrl(interpolated);
       return { kind: "path", path: downloaded.path, tempDir: downloaded.tempDir };
     }
-    const absolute = path5__default.isAbsolute(interpolated) ? interpolated : path5__default.resolve(
-      context.testFilePath ? path5__default.dirname(context.testFilePath) : process.cwd(),
+    const absolute = path4__default.isAbsolute(interpolated) ? interpolated : path4__default.resolve(
+      context.testFilePath ? path4__default.dirname(context.testFilePath) : process.cwd(),
       interpolated
     );
     try {
@@ -1156,7 +1156,7 @@ async function toPlaywrightFiles(resolved) {
       }
       const buffer = await fs3__default.readFile(r.path);
       return {
-        name: path5__default.basename(r.path),
+        name: path4__default.basename(r.path),
         mimeType: mimeFromName(r.path),
         buffer
       };
@@ -1635,9 +1635,9 @@ init_esm_shims();
 var INTELLITESTER_DIR = ".intellitester";
 var SERVERS_MARKER_FILE = "servers.json";
 var LEGACY_SINGLE_MARKER_FILE = "server.json";
-var getMarkerDir = (cwd) => path5.join(cwd, INTELLITESTER_DIR);
-var getMarkerPath = (cwd) => path5.join(getMarkerDir(cwd), SERVERS_MARKER_FILE);
-var getLegacyMarkerPath = (cwd) => path5.join(getMarkerDir(cwd), LEGACY_SINGLE_MARKER_FILE);
+var getMarkerDir = (cwd) => path4.join(cwd, INTELLITESTER_DIR);
+var getMarkerPath = (cwd) => path4.join(getMarkerDir(cwd), SERVERS_MARKER_FILE);
+var getLegacyMarkerPath = (cwd) => path4.join(getMarkerDir(cwd), LEGACY_SINGLE_MARKER_FILE);
 async function readMarkers(cwd) {
   try {
     const content = await fs3.readFile(getMarkerPath(cwd), "utf-8");
@@ -1729,7 +1729,7 @@ async function isServerRunning(url) {
 }
 async function readPackageJson(cwd) {
   try {
-    const packagePath = path5.join(cwd, "package.json");
+    const packagePath = path4.join(cwd, "package.json");
     const content = await fs3.readFile(packagePath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -1754,11 +1754,11 @@ function detectFramework(pkg) {
   return null;
 }
 async function detectPackageManager(cwd) {
-  const hasDenoLock = await fs3.stat(path5.join(cwd, "deno.lock")).catch(() => null);
-  const hasBunLockb = await fs3.stat(path5.join(cwd, "bun.lockb")).catch(() => null);
-  const hasBunLock = await fs3.stat(path5.join(cwd, "bun.lock")).catch(() => null);
-  const hasPnpmLock = await fs3.stat(path5.join(cwd, "pnpm-lock.yaml")).catch(() => null);
-  const hasYarnLock = await fs3.stat(path5.join(cwd, "yarn.lock")).catch(() => null);
+  const hasDenoLock = await fs3.stat(path4.join(cwd, "deno.lock")).catch(() => null);
+  const hasBunLockb = await fs3.stat(path4.join(cwd, "bun.lockb")).catch(() => null);
+  const hasBunLock = await fs3.stat(path4.join(cwd, "bun.lock")).catch(() => null);
+  const hasPnpmLock = await fs3.stat(path4.join(cwd, "pnpm-lock.yaml")).catch(() => null);
+  const hasYarnLock = await fs3.stat(path4.join(cwd, "yarn.lock")).catch(() => null);
   if (hasDenoLock) return "deno";
   if (hasBunLockb || hasBunLock) return "bun";
   if (hasPnpmLock) return "pnpm";
@@ -1782,7 +1782,7 @@ function getDevCommand(pm, script) {
 async function detectBuildDirectory(cwd) {
   const commonDirs = [".next", ".output", ".svelte-kit", "dist", "build", "out"];
   for (const dir of commonDirs) {
-    const fullPath = path5.join(cwd, dir);
+    const fullPath = path4.join(cwd, dir);
     try {
       const stat2 = await fs3.stat(fullPath);
       if (stat2.isDirectory()) return dir;
@@ -2330,10 +2330,10 @@ function safeCallback(label, fn) {
     console.error(`[intellitester] ${label} callback threw:`, e);
   }
 }
-var defaultScreenshotDir = path5__default.join(process.cwd(), "artifacts", "screenshots");
+var defaultScreenshotDir = path4__default.join(process.cwd(), "artifacts", "screenshots");
 var resolveStorageStatePath = (value, baseDir) => {
   if (typeof value !== "string") return value;
-  return path5__default.isAbsolute(value) ? value : path5__default.resolve(baseDir, value);
+  return path4__default.isAbsolute(value) ? value : path4__default.resolve(baseDir, value);
 };
 var interpolateTrackMetadata = (value, variables) => {
   if (typeof value === "string") {
@@ -2531,7 +2531,7 @@ var runScreenshot = async (page, name, screenshotDir, stepIndex, browserName) =>
   const timing = getBrowserTimingConfig(browserName ?? "chromium");
   await waitForPageStable(page, timing.screenshotNetworkIdleTimeout);
   const filename = name ?? `step-${stepIndex + 1}.png`;
-  const filePath = path5__default.join(screenshotDir, filename);
+  const filePath = path4__default.join(screenshotDir, filename);
   await page.screenshot({ path: filePath, fullPage: true });
   return filePath;
 };
@@ -2551,7 +2551,7 @@ async function handleInteractiveError(page, action, error, screenshotDir, stepIn
   console.error(`   Error: ${error.message}
 `);
   await ensureScreenshotDir(screenshotDir);
-  const screenshotPath = path5__default.join(screenshotDir, `error-step-${stepIndex + 1}.png`);
+  const screenshotPath = path4__default.join(screenshotDir, `error-step-${stepIndex + 1}.png`);
   await page.screenshot({ path: screenshotPath, fullPage: true });
   const pageContent = await page.content();
   if (aiConfig) {
@@ -2600,7 +2600,7 @@ async function handleInteractiveError(page, action, error, screenshotDir, stepIn
   return response.action || "abort";
 }
 async function executeActionWithRetry(page, action, index, options) {
-  const { baseUrl, context, screenshotDir, debugMode, interactive, aiConfig, browserName, healing, testFilePath } = options;
+  const { baseUrl, context, screenshotDir, debugMode, interactive, aiConfig, browserName, healing, testFilePath, responseLog, stepStartTs } = options;
   const extras = {};
   const buildTrackPayload = (stepExtras) => {
     if (!("track" in action)) return null;
@@ -3053,15 +3053,7 @@ async function executeActionWithRetry(page, action, index, options) {
             if (debugMode) {
               console.log(`[DEBUG] Executing nested step ${nestedIdx + 1}: ${nestedAction.type}`);
             }
-            await executeActionWithRetry(page, nestedAction, index, {
-              baseUrl,
-              context,
-              screenshotDir,
-              debugMode,
-              interactive,
-              aiConfig,
-              browserName
-            });
+            await executeActionWithRetry(page, nestedAction, index, options);
           }
           break;
         }
@@ -3163,20 +3155,12 @@ async function executeActionWithRetry(page, action, index, options) {
               if (debugMode) {
                 console.log(`[DEBUG] Executing branch step ${nestedIdx + 1}: ${nestedAction.type}`);
               }
-              await executeActionWithRetry(page, nestedAction, index, {
-                baseUrl,
-                context,
-                screenshotDir,
-                debugMode,
-                interactive,
-                aiConfig,
-                browserName
-              });
+              await executeActionWithRetry(page, nestedAction, index, options);
             }
           } else {
             const { loadWorkflowDefinition, loadTestDefinition: loadTestDefinition2 } = await import('./loader-2CW6OEXJ.js');
-            const workflowPath = path5__default.resolve(process.cwd(), branchToExecute.workflow);
-            const workflowDir = path5__default.dirname(workflowPath);
+            const workflowPath = path4__default.resolve(process.cwd(), branchToExecute.workflow);
+            const workflowDir = path4__default.dirname(workflowPath);
             if (debugMode) {
               console.log(`[DEBUG] Executing workflow: ${workflowPath}`);
             }
@@ -3188,7 +3172,7 @@ async function executeActionWithRetry(page, action, index, options) {
               }
             }
             for (const testRef of workflow.tests) {
-              const testFilePath2 = path5__default.resolve(workflowDir, testRef.file);
+              const testFilePath2 = path4__default.resolve(workflowDir, testRef.file);
               if (debugMode) {
                 console.log(`[DEBUG] Loading test from workflow: ${testFilePath2}`);
               }
@@ -3200,18 +3184,148 @@ async function executeActionWithRetry(page, action, index, options) {
                 }
               }
               for (const [testStepIdx, testAction] of test.steps.entries()) {
-                await executeActionWithRetry(page, testAction, testStepIdx, {
-                  baseUrl,
-                  context,
-                  screenshotDir,
-                  debugMode,
-                  interactive,
-                  aiConfig,
-                  browserName
-                });
+                await executeActionWithRetry(page, testAction, testStepIdx, options);
+              }
+            }
+          }
+          break;
+        }
+        case "saveStorageState": {
+          const saveAction = action;
+          if (saveAction.path) {
+            const resolvedPath = interpolateVariables(saveAction.path, context.variables);
+            const baseDir = testFilePath ? path4__default.dirname(testFilePath) : process.cwd();
+            const absPath = path4__default.isAbsolute(resolvedPath) ? resolvedPath : path4__default.resolve(baseDir, resolvedPath);
+            await page.context().storageState({ path: absPath });
+            if (debugMode) {
+              console.log(`[DEBUG] Saved storage state to ${absPath}`);
+            }
+          } else if (saveAction.handler) {
+            const resolvedHandler = interpolateVariables(saveAction.handler, context.variables);
+            const baseDir = testFilePath ? path4__default.dirname(testFilePath) : process.cwd();
+            const absPath = path4__default.isAbsolute(resolvedHandler) ? resolvedHandler : path4__default.resolve(baseDir, resolvedHandler);
+            let loadPath = absPath;
+            if (absPath.endsWith(".ts")) {
+              const jsPath = absPath.replace(/\.ts$/, ".js");
+              try {
+                await fs3__default.access(jsPath);
+                loadPath = jsPath;
+              } catch {
+              }
+            }
+            const mod = await import(`${loadPath}?t=${Date.now()}`);
+            const fn = mod.default ?? mod;
+            if (typeof fn !== "function") {
+              throw new Error(`saveStorageState handler at ${resolvedHandler} did not export a default function`);
+            }
+            await fn({
+              page,
+              context: page.context(),
+              variables: context.variables
+            });
+            if (debugMode) {
+              console.log(`[DEBUG] Ran custom saveStorageState handler: ${resolvedHandler}`);
+            }
+          } else {
+            throw new Error("saveStorageState requires either `path` or `handler` (schema should have caught this)");
+          }
+          break;
+        }
+        case "assertCookies": {
+          const cookieAction = action;
+          const filterUrl = cookieAction.url ? interpolateVariables(cookieAction.url, context.variables) : void 0;
+          const jar = await page.context().cookies(filterUrl);
+          const names = new Set(jar.map((c) => c.name));
+          const problems = [];
+          if (cookieAction.has) {
+            for (const name of cookieAction.has) {
+              if (!names.has(name)) problems.push(`expected cookie "${name}" to be present`);
+            }
+          }
+          if (cookieAction.not) {
+            for (const name of cookieAction.not) {
+              if (names.has(name)) problems.push(`expected cookie "${name}" to be absent`);
+            }
+          }
+          if (cookieAction.match) {
+            for (const [name, pattern] of Object.entries(cookieAction.match)) {
+              const c = jar.find((entry) => entry.name === name);
+              if (!c) {
+                problems.push(`expected cookie "${name}" to be present (for value match)`);
+                continue;
+              }
+              const matcher = compileMatcher(interpolateVariables(pattern, context.variables), "substr");
+              if (!matcher(c.value)) {
+                problems.push(`cookie "${name}" value "${c.value}" did not match pattern "${pattern}"`);
               }
             }
           }
+          if (problems.length > 0) {
+            throw new Error(`assertCookies failed:
+  - ${problems.join("\n  - ")}
+  (cookies seen: ${[...names].join(", ") || "<none>"})`);
+          }
+          break;
+        }
+        case "expectResponse": {
+          if (!responseLog) {
+            throw new Error("expectResponse requires a responseLog to be attached (executor wiring issue)");
+          }
+          const respAction = action;
+          const urlPattern = interpolateVariables(respAction.url, context.variables);
+          const urlMatch = compileMatcher(urlPattern, "url");
+          const headerMatchers = respAction.headers ? Object.entries(respAction.headers).map(([name, pattern]) => ({
+            name: name.toLowerCase(),
+            test: compileMatcher(interpolateVariables(pattern, context.variables), "substr"),
+            pattern
+          })) : [];
+          const expectedStatus = respAction.status;
+          let sinceTs;
+          if (respAction.since === "testStart") {
+            sinceTs = 0;
+          } else if (typeof respAction.since === "number") {
+            sinceTs = respAction.since;
+          } else {
+            sinceTs = stepStartTs ?? 0;
+          }
+          const timeout = respAction.timeout ?? 5e3;
+          const deadline = Date.now() + timeout;
+          const findMatch = () => {
+            for (const entry of responseLog.snapshot()) {
+              if (entry.ts < sinceTs) continue;
+              if (!urlMatch(entry.url)) continue;
+              if (expectedStatus !== void 0 && entry.status !== expectedStatus) continue;
+              let headersOk = true;
+              for (const h of headerMatchers) {
+                const value = entry.headers[h.name];
+                if (value === void 0 || !h.test(value)) {
+                  headersOk = false;
+                  break;
+                }
+              }
+              if (headersOk) return entry;
+            }
+            return null;
+          };
+          let match = findMatch();
+          while (!match && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            match = findMatch();
+          }
+          if (!match) {
+            const recent = responseLog.snapshot().slice(-5).map((e) => `${e.status} ${e.url}`).join("\n  ");
+            throw new Error(
+              `expectResponse timed out after ${timeout}ms.
+  url pattern: ${urlPattern}
+` + (expectedStatus !== void 0 ? `  expected status: ${expectedStatus}
+` : "") + (headerMatchers.length > 0 ? `  expected headers: ${headerMatchers.map((h) => `${h.name}=${h.pattern}`).join(", ")}
+` : "") + `  recent responses:
+  ${recent || "<none>"}`
+            );
+          }
+          if (debugMode) {
+            console.log(`[DEBUG] expectResponse matched: ${match.status} ${match.url}`);
+          }
           break;
         }
         default:
@@ -3663,7 +3777,7 @@ var runWebTest = async (test, options = {}) => {
             const timing = getBrowserTimingConfig(browserName ?? "chromium");
             await waitForPageStable(page, timing.screenshotNetworkIdleTimeout);
             await ensureScreenshotDir(screenshotDir);
-            const evalScreenshotPath = path5__default.join(screenshotDir, `evaluate-step-${index + 1}.png`);
+            const evalScreenshotPath = path4__default.join(screenshotDir, `evaluate-step-${index + 1}.png`);
             const screenshotBuffer = await page.screenshot({
               path: evalScreenshotPath,
               fullPage: evalAction.fullPage ?? true
@@ -3699,172 +3813,7 @@ var runWebTest = async (test, options = {}) => {
             safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
             continue;
           }
-          if (action.type === "saveStorageState") {
-            const saveAction = action;
-            try {
-              if (saveAction.path) {
-                const resolvedPath = interpolateVariables(saveAction.path, executionContext.variables);
-                const baseDir = options.testFilePath ? path5__default.dirname(options.testFilePath) : process.cwd();
-                const absPath = path5__default.isAbsolute(resolvedPath) ? resolvedPath : path5__default.resolve(baseDir, resolvedPath);
-                await page.context().storageState({ path: absPath });
-                if (debugMode) {
-                  console.log(`[DEBUG] Saved storage state to ${absPath}`);
-                }
-              } else if (saveAction.handler) {
-                const resolvedHandler = interpolateVariables(saveAction.handler, executionContext.variables);
-                const baseDir = options.testFilePath ? path5__default.dirname(options.testFilePath) : process.cwd();
-                const absPath = path5__default.isAbsolute(resolvedHandler) ? resolvedHandler : path5__default.resolve(baseDir, resolvedHandler);
-                let loadPath = absPath;
-                if (absPath.endsWith(".ts")) {
-                  const jsPath = absPath.replace(/\.ts$/, ".js");
-                  try {
-                    await fs3__default.access(jsPath);
-                    loadPath = jsPath;
-                  } catch {
-                  }
-                }
-                const mod = await import(`${loadPath}?t=${Date.now()}`);
-                const fn = mod.default ?? mod;
-                if (typeof fn !== "function") {
-                  throw new Error(`saveStorageState handler at ${resolvedHandler} did not export a default function`);
-                }
-                await fn({
-                  page,
-                  context: page.context(),
-                  variables: executionContext.variables
-                });
-                if (debugMode) {
-                  console.log(`[DEBUG] Ran custom saveStorageState handler: ${resolvedHandler}`);
-                }
-              } else {
-                throw new Error("saveStorageState requires either `path` or `handler` (schema should have caught this)");
-              }
-              sizeResults.push({ action, status: "passed" });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-              const trackedPayload = buildTrackPayload(action, index);
-              if (trackedPayload) {
-                await track(trackedPayload);
-              }
-            } catch (e) {
-              const errMsg = e instanceof Error ? e.message : String(e);
-              sizeResults.push({ action, status: "failed", error: errMsg });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-              throw e;
-            }
-            continue;
-          }
-          if (action.type === "assertCookies") {
-            const cookieAction = action;
-            try {
-              const filterUrl = cookieAction.url ? interpolateVariables(cookieAction.url, executionContext.variables) : void 0;
-              const jar = await page.context().cookies(filterUrl);
-              const names = new Set(jar.map((c) => c.name));
-              const problems = [];
-              if (cookieAction.has) {
-                for (const name of cookieAction.has) {
-                  if (!names.has(name)) problems.push(`expected cookie "${name}" to be present`);
-                }
-              }
-              if (cookieAction.not) {
-                for (const name of cookieAction.not) {
-                  if (names.has(name)) problems.push(`expected cookie "${name}" to be absent`);
-                }
-              }
-              if (cookieAction.match) {
-                for (const [name, pattern] of Object.entries(cookieAction.match)) {
-                  const c = jar.find((entry) => entry.name === name);
-                  if (!c) {
-                    problems.push(`expected cookie "${name}" to be present (for value match)`);
-                    continue;
-                  }
-                  const matcher = compileMatcher(interpolateVariables(pattern, executionContext.variables), "substr");
-                  if (!matcher(c.value)) {
-                    problems.push(`cookie "${name}" value "${c.value}" did not match pattern "${pattern}"`);
-                  }
-                }
-              }
-              if (problems.length > 0) {
-                throw new Error(`assertCookies failed:
-  - ${problems.join("\n  - ")}
-  (cookies seen: ${[...names].join(", ") || "<none>"})`);
-              }
-              sizeResults.push({ action, status: "passed" });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-            } catch (e) {
-              const errMsg = e instanceof Error ? e.message : String(e);
-              sizeResults.push({ action, status: "failed", error: errMsg });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-              throw e;
-            }
-            continue;
-          }
-          if (action.type === "expectResponse") {
-            const respAction = action;
-            try {
-              const urlPattern = interpolateVariables(respAction.url, executionContext.variables);
-              const urlMatch = compileMatcher(urlPattern, "url");
-              const headerMatchers = respAction.headers ? Object.entries(respAction.headers).map(([name, pattern]) => ({
-                name: name.toLowerCase(),
-                test: compileMatcher(interpolateVariables(pattern, executionContext.variables), "substr"),
-                pattern
-              })) : [];
-              const expectedStatus = respAction.status;
-              let sinceTs;
-              if (respAction.since === "testStart") {
-                sinceTs = 0;
-              } else if (typeof respAction.since === "number") {
-                sinceTs = respAction.since;
-              } else {
-                sinceTs = lastStepEndTs;
-              }
-              const timeout = respAction.timeout ?? 5e3;
-              const deadline = Date.now() + timeout;
-              const findMatch = () => {
-                for (const entry of responseLog.snapshot()) {
-                  if (entry.ts < sinceTs) continue;
-                  if (!urlMatch(entry.url)) continue;
-                  if (expectedStatus !== void 0 && entry.status !== expectedStatus) continue;
-                  let headersOk = true;
-                  for (const h of headerMatchers) {
-                    const value = entry.headers[h.name];
-                    if (value === void 0 || !h.test(value)) {
-                      headersOk = false;
-                      break;
-                    }
-                  }
-                  if (headersOk) return entry;
-                }
-                return null;
-              };
-              let match = findMatch();
-              while (!match && Date.now() < deadline) {
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                match = findMatch();
-              }
-              if (!match) {
-                const recent = responseLog.snapshot().slice(-5).map((e) => `${e.status} ${e.url}`).join("\n  ");
-                throw new Error(
-                  `expectResponse timed out after ${timeout}ms.
-  url pattern: ${urlPattern}
-` + (expectedStatus !== void 0 ? `  expected status: ${expectedStatus}
-` : "") + (headerMatchers.length > 0 ? `  expected headers: ${headerMatchers.map((h) => `${h.name}=${h.pattern}`).join(", ")}
-` : "") + `  recent responses:
-  ${recent || "<none>"}`
-                );
-              }
-              if (debugMode) {
-                console.log(`[DEBUG] expectResponse matched: ${match.status} ${match.url}`);
-              }
-              sizeResults.push({ action, status: "passed" });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-            } catch (e) {
-              const errMsg = e instanceof Error ? e.message : String(e);
-              sizeResults.push({ action, status: "failed", error: errMsg });
-              safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
-              throw e;
-            }
-            continue;
-          }
+          const stepStartTs = lastStepEndTs;
           const actionExtras = await executeActionWithRetry(page, action, index, {
             baseUrl: options.baseUrl ?? test.config?.web?.baseUrl,
             context: executionContext,
@@ -3874,7 +3823,9 @@ var runWebTest = async (test, options = {}) => {
             aiConfig: options.aiConfig,
             browserName,
             healing: options.healing,
-            testFilePath: options.testFilePath
+            testFilePath: options.testFilePath,
+            responseLog,
+            stepStartTs
           });
           sizeResults.push({ action, status: "passed", logOutput: actionExtras.logOutput });
           safeCallback("onStepComplete", options.onStepComplete ? () => options.onStepComplete(sizeResults[sizeResults.length - 1], index, test.steps.length) : void 0);
@@ -3951,24 +3902,7 @@ var runWebTest = async (test, options = {}) => {
 
 // src/executors/web/workflowExecutor.ts
 init_esm_shims();
-var defaultScreenshotDir2 = path5__default.join(process.cwd(), "artifacts", "screenshots");
-var interpolateTrackMetadata2 = (value, variables) => {
-  if (typeof value === "string") {
-    return interpolateVariables(value, variables);
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => interpolateTrackMetadata2(entry, variables));
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [
-        key,
-        interpolateTrackMetadata2(entry, variables)
-      ])
-    );
-  }
-  return value;
-};
+var defaultScreenshotDir2 = path4__default.join(process.cwd(), "artifacts", "screenshots");
 var getBrowser2 = (browser) => {
   switch (browser) {
     case "firefox":
@@ -3991,761 +3925,34 @@ function interpolateWorkflowVariables(value, currentVariables, testResults) {
     return result;
   });
 }
-async function runTestInWorkflow(test, page, context, options, workflowDir, testFilePath, workflowBaseUrl) {
+async function runTestInWorkflow(test, page, context, options, _workflowDir, testFilePath, workflowBaseUrl) {
   const results = [];
   const debugMode = options.debug ?? false;
   const screenshotDir = defaultScreenshotDir2;
-  const resolveUrl2 = (value, baseUrl) => {
-    if (!baseUrl) return value;
-    try {
-      const url = new URL(value, baseUrl);
-      return url.toString();
-    } catch {
-      return value;
-    }
-  };
-  const interpolate = (value) => {
-    return interpolateVariables(value, context.variables);
-  };
+  const browserName = options.browser ?? "chromium";
+  const baseUrl = test.config?.web?.baseUrl || workflowBaseUrl;
   const responseLog = new ResponseLog();
   responseLog.attach(page);
-  let lastStepEndTs = Date.now();
-  const resolveLocator2 = (locator) => {
-    if (locator.testId) return page.getByTestId(locator.testId);
-    if (locator.text) return page.getByText(locator.text);
-    if (locator.css) return page.locator(locator.css);
-    if (locator.xpath) return page.locator(`xpath=${locator.xpath}`);
-    if (locator.role) {
-      const options2 = {};
-      if (locator.name) options2.name = locator.name;
-      return page.getByRole(locator.role, options2);
-    }
-    if (locator.description) return page.getByText(locator.description);
-    throw new Error("No usable selector found for locator");
-  };
-  const buildTrackPayload = (action, index, stepExtras) => {
-    if (!("track" in action)) return null;
-    const rawTrack = action.track;
-    if (!rawTrack || typeof rawTrack !== "object") return null;
-    const track2 = interpolateTrackMetadata2(rawTrack, context.variables);
-    if (typeof track2.type !== "string" || typeof track2.id !== "string") return null;
-    const { includeStepContext, ...rest } = track2;
-    const payload = {
-      type: track2.type,
-      id: track2.id,
-      ...rest
-    };
-    if (includeStepContext) {
-      payload.step = { index, ...action, ...stepExtras };
-    }
-    return payload;
-  };
   try {
     for (const [index, action] of test.steps.entries()) {
-      lastStepEndTs = Date.now();
+      const stepStartTs = Date.now();
       if (debugMode) {
         console.log(`  [DEBUG] Step ${index + 1}: ${action.type}`);
       }
       try {
-        switch (action.type) {
-          case "navigate": {
-            const interpolated = interpolate(action.value);
-            const baseUrl = test.config?.web?.baseUrl || workflowBaseUrl;
-            const target = resolveUrl2(interpolated, baseUrl);
-            if (debugMode) {
-              console.log(`  [DEBUG] Navigate step:`);
-              console.log(`  [DEBUG]   - action.value: ${action.value}`);
-              console.log(`  [DEBUG]   - interpolated: ${interpolated}`);
-              console.log(`  [DEBUG]   - test.config?.web?.baseUrl: ${test.config?.web?.baseUrl ?? "(undefined)"}`);
-              console.log(`  [DEBUG]   - workflowBaseUrl: ${workflowBaseUrl ?? "(undefined)"}`);
-              console.log(`  [DEBUG]   - effective baseUrl: ${baseUrl ?? "(undefined)"}`);
-              console.log(`  [DEBUG]   - target: ${target}`);
-            }
-            await page.goto(target);
-            break;
-          }
-          case "tap": {
-            if (debugMode) console.log(`  [DEBUG] Tapping element:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.click();
-            await page.waitForLoadState("domcontentloaded").catch(() => {
-            });
-            await page.waitForLoadState("networkidle", { timeout: 1e4 }).catch(() => {
-            });
-            break;
-          }
-          case "input": {
-            const interpolated = interpolate(action.value);
-            if (debugMode) console.log(`  [DEBUG] Input: ${interpolated}`);
-            const handle = resolveLocator2(action.target);
-            await handle.fill(interpolated);
-            break;
-          }
-          case "clear": {
-            if (debugMode) console.log(`  [DEBUG] Clearing element:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.clear();
-            break;
-          }
-          case "hover": {
-            if (debugMode) console.log(`  [DEBUG] Hovering element:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.hover();
-            break;
-          }
-          case "select": {
-            const interpolated = interpolate(action.value);
-            if (debugMode) console.log(`  [DEBUG] Selecting: ${interpolated}`);
-            const handle = resolveLocator2(action.target);
-            await handle.selectOption(interpolated);
-            break;
-          }
-          case "check": {
-            if (debugMode) console.log(`  [DEBUG] Checking:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.check();
-            break;
-          }
-          case "uncheck": {
-            if (debugMode) console.log(`  [DEBUG] Unchecking:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.uncheck();
-            break;
-          }
-          case "press": {
-            if (debugMode) console.log(`  [DEBUG] Pressing key: ${action.key}`);
-            if (action.target) {
-              const handle = resolveLocator2(action.target);
-              await handle.press(action.key);
-            } else {
-              await page.keyboard.press(action.key);
-            }
-            break;
-          }
-          case "focus": {
-            if (debugMode) console.log(`  [DEBUG] Focusing:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.focus();
-            break;
-          }
-          case "assert": {
-            if (debugMode) console.log(`  [DEBUG] Assert:`, action.target);
-            const handle = resolveLocator2(action.target);
-            await handle.waitFor({ state: "visible" });
-            if (action.value) {
-              const interpolated = interpolate(action.value);
-              const text = (await handle.textContent())?.trim() ?? "";
-              if (!text.includes(interpolated)) {
-                throw new Error(
-                  `Assertion failed: expected "${interpolated}", got "${text}"`
-                );
-              }
-            }
-            break;
-          }
-          case "wait": {
-            if (action.target) {
-              const handle = resolveLocator2(action.target);
-              await handle.waitFor({ state: "visible", timeout: action.timeout });
-            } else {
-              await page.waitForTimeout(action.timeout ?? 1e3);
-            }
-            break;
-          }
-          case "scroll": {
-            if (action.target) {
-              const handle = resolveLocator2(action.target);
-              await handle.scrollIntoViewIfNeeded();
-            } else {
-              const amount = action.amount ?? 500;
-              const direction = action.direction ?? "down";
-              const deltaY = direction === "up" ? -amount : amount;
-              await page.evaluate((value) => window.scrollBy(0, value), deltaY);
-            }
-            break;
-          }
-          case "screenshot": {
-            const ssAction = action;
-            await page.waitForLoadState("domcontentloaded").catch(() => {
-            });
-            await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
-            });
-            const waitBefore = ssAction.waitBefore ?? 500;
-            if (waitBefore > 0) {
-              await page.waitForTimeout(waitBefore);
-            }
-            const filename = ssAction.name ?? `step-${index + 1}.png`;
-            const filePath = path5__default.join(screenshotDir, filename);
-            await page.screenshot({ path: filePath, fullPage: true });
-            results.push({ action, status: "passed", screenshotPath: filePath });
-            const trackedPayload2 = buildTrackPayload(action, index, { screenshotPath: filePath });
-            if (trackedPayload2) {
-              await track(trackedPayload2);
-            }
-            continue;
-          }
-          case "saveStorageState": {
-            const saveAction = action;
-            if (saveAction.path) {
-              const resolvedPath = interpolate(saveAction.path);
-              const baseDir = path5__default.dirname(testFilePath);
-              const absPath = path5__default.isAbsolute(resolvedPath) ? resolvedPath : path5__default.resolve(baseDir, resolvedPath);
-              await page.context().storageState({ path: absPath });
-              if (debugMode) {
-                console.log(`  [DEBUG] Saved storage state to ${absPath}`);
-              }
-            } else if (saveAction.handler) {
-              const resolvedHandler = interpolate(saveAction.handler);
-              const baseDir = path5__default.dirname(testFilePath);
-              const absPath = path5__default.isAbsolute(resolvedHandler) ? resolvedHandler : path5__default.resolve(baseDir, resolvedHandler);
-              let loadPath = absPath;
-              if (absPath.endsWith(".ts")) {
-                const jsPath = absPath.replace(/\.ts$/, ".js");
-                try {
-                  await fs3__default.access(jsPath);
-                  loadPath = jsPath;
-                } catch {
-                }
-              }
-              const mod = await import(`${loadPath}?t=${Date.now()}`);
-              const fn = mod.default ?? mod;
-              if (typeof fn !== "function") {
-                throw new Error(`saveStorageState handler at ${resolvedHandler} did not export a default function`);
-              }
-              await fn({
-                page,
-                context: page.context(),
-                variables: context.variables
-              });
-              if (debugMode) {
-                console.log(`  [DEBUG] Ran custom saveStorageState handler: ${resolvedHandler}`);
-              }
-            } else {
-              throw new Error("saveStorageState requires either `path` or `handler` (schema should have caught this)");
-            }
-            results.push({ action, status: "passed" });
-            const trackedPayload2 = buildTrackPayload(action, index);
-            if (trackedPayload2) {
-              await track(trackedPayload2);
-            }
-            break;
-          }
-          case "assertCookies": {
-            const cookieAction = action;
-            const filterUrl = cookieAction.url ? interpolate(cookieAction.url) : void 0;
-            const jar = await page.context().cookies(filterUrl);
-            const names = new Set(jar.map((c) => c.name));
-            const problems = [];
-            if (cookieAction.has) {
-              for (const name of cookieAction.has) {
-                if (!names.has(name)) problems.push(`expected cookie "${name}" to be present`);
-              }
-            }
-            if (cookieAction.not) {
-              for (const name of cookieAction.not) {
-                if (names.has(name)) problems.push(`expected cookie "${name}" to be absent`);
-              }
-            }
-            if (cookieAction.match) {
-              for (const [name, pattern] of Object.entries(cookieAction.match)) {
-                const c = jar.find((entry) => entry.name === name);
-                if (!c) {
-                  problems.push(`expected cookie "${name}" to be present (for value match)`);
-                  continue;
-                }
-                const matcher = compileMatcher(interpolate(pattern), "substr");
-                if (!matcher(c.value)) {
-                  problems.push(`cookie "${name}" value "${c.value}" did not match pattern "${pattern}"`);
-                }
-              }
-            }
-            if (problems.length > 0) {
-              throw new Error(`assertCookies failed:
-  - ${problems.join("\n  - ")}
-  (cookies seen: ${[...names].join(", ") || "<none>"})`);
-            }
-            results.push({ action, status: "passed" });
-            break;
-          }
-          case "expectResponse": {
-            const respAction = action;
-            const urlPattern = interpolate(respAction.url);
-            const urlMatch = compileMatcher(urlPattern, "url");
-            const headerMatchers = respAction.headers ? Object.entries(respAction.headers).map(([name, pattern]) => ({
-              name: name.toLowerCase(),
-              test: compileMatcher(interpolate(pattern), "substr"),
-              pattern
-            })) : [];
-            const expectedStatus = respAction.status;
-            let sinceTs;
-            if (respAction.since === "testStart") {
-              sinceTs = 0;
-            } else if (typeof respAction.since === "number") {
-              sinceTs = respAction.since;
-            } else {
-              sinceTs = lastStepEndTs;
-            }
-            const timeout = respAction.timeout ?? 5e3;
-            const deadline = Date.now() + timeout;
-            const findMatch = () => {
-              for (const entry of responseLog.snapshot()) {
-                if (entry.ts < sinceTs) continue;
-                if (!urlMatch(entry.url)) continue;
-                if (expectedStatus !== void 0 && entry.status !== expectedStatus) continue;
-                let headersOk = true;
-                for (const h of headerMatchers) {
-                  const value = entry.headers[h.name];
-                  if (value === void 0 || !h.test(value)) {
-                    headersOk = false;
-                    break;
-                  }
-                }
-                if (headersOk) return entry;
-              }
-              return null;
-            };
-            let match = findMatch();
-            while (!match && Date.now() < deadline) {
-              await new Promise((resolve) => setTimeout(resolve, 50));
-              match = findMatch();
-            }
-            if (!match) {
-              const recent = responseLog.snapshot().slice(-5).map((e) => `${e.status} ${e.url}`).join("\n  ");
-              throw new Error(
-                `expectResponse timed out after ${timeout}ms.
-  url pattern: ${urlPattern}
-` + (expectedStatus !== void 0 ? `  expected status: ${expectedStatus}
-` : "") + (headerMatchers.length > 0 ? `  expected headers: ${headerMatchers.map((h) => `${h.name}=${h.pattern}`).join(", ")}
-` : "") + `  recent responses:
-  ${recent || "<none>"}`
-              );
-            }
-            if (debugMode) {
-              console.log(`  [DEBUG] expectResponse matched: ${match.status} ${match.url}`);
-            }
-            results.push({ action, status: "passed" });
-            break;
-          }
-          case "setVar": {
-            let value;
-            if (action.value) {
-              value = interpolate(action.value);
-            } else if (action.from === "response") {
-              throw new Error("setVar from response not yet implemented");
-            } else if (action.from === "element") {
-              throw new Error("setVar from element not yet implemented");
-            } else if (action.from === "email") {
-              throw new Error("Use email.extractCode or email.extractLink instead");
-            } else {
-              throw new Error("setVar requires value or from");
-            }
-            context.variables.set(action.name, value);
-            if (debugMode) console.log(`  [DEBUG] Set variable ${action.name} = ${value}`);
-            break;
-          }
-          case "email.waitFor": {
-            if (!context.emailClient) {
-              throw new Error("Email client not configured");
-            }
-            const mailbox = interpolate(action.mailbox);
-            context.lastEmail = await context.emailClient.waitForEmail(mailbox, {
-              timeout: action.timeout,
-              subjectContains: action.subjectContains
-            });
-            break;
-          }
-          case "email.extractCode": {
-            if (!context.emailClient) {
-              throw new Error("Email client not configured");
-            }
-            if (!context.lastEmail) {
-              throw new Error("No email loaded - call email.waitFor first");
-            }
-            const code = context.emailClient.extractCode(
-              context.lastEmail,
-              action.pattern ? new RegExp(action.pattern) : void 0
-            );
-            if (!code) {
-              throw new Error("No code found in email");
-            }
-            context.variables.set(action.saveTo, code);
-            break;
-          }
-          case "email.extractLink": {
-            if (!context.emailClient) {
-              throw new Error("Email client not configured");
-            }
-            if (!context.lastEmail) {
-              throw new Error("No email loaded - call email.waitFor first");
-            }
-            const link = context.emailClient.extractLink(
-              context.lastEmail,
-              action.pattern ? new RegExp(action.pattern) : void 0
-            );
-            if (!link) {
-              throw new Error("No link found in email");
-            }
-            context.variables.set(action.saveTo, link);
-            break;
-          }
-          case "email.clear": {
-            if (!context.emailClient) {
-              throw new Error("Email client not configured");
-            }
-            const mailbox = interpolate(action.mailbox);
-            await context.emailClient.clearMailbox(mailbox);
-            break;
-          }
-          case "appwrite.verifyEmail": {
-            if (!context.appwriteContext.userId) {
-              throw new Error("No user tracked. appwrite.verifyEmail requires a user signup first.");
-            }
-            if (!context.appwriteConfig?.apiKey) {
-              throw new Error("appwrite.verifyEmail requires appwrite.apiKey in config");
-            }
-            const { Client: Client2, Users: Users2 } = await import('node-appwrite');
-            const client = new Client2().setEndpoint(context.appwriteConfig.endpoint).setProject(context.appwriteConfig.projectId).setKey(context.appwriteConfig.apiKey);
-            const users = new Users2(client);
-            await users.updateEmailVerification(context.appwriteContext.userId, true);
-            if (debugMode) console.log(`  [DEBUG] Verified email for user ${context.appwriteContext.userId}`);
-            break;
-          }
-          case "debug": {
-            console.log("  [DEBUG] Pausing execution - Playwright Inspector will open");
-            await page.pause();
-            break;
-          }
-          case "waitForSelector": {
-            const handle = resolveLocator2(action.target);
-            const timeout = action.timeout ?? 3e4;
-            if (debugMode) {
-              console.log(`  [DEBUG] Waiting for element to be ${action.state}:`, action.target);
-            }
-            const waitForCondition2 = async (checkFn, timeoutMs, errorMessage) => {
-              const start = Date.now();
-              while (Date.now() - start < timeoutMs) {
-                if (await checkFn()) return;
-                await new Promise((r) => setTimeout(r, 100));
-              }
-              throw new Error(errorMessage);
-            };
-            switch (action.state) {
-              case "visible":
-              case "hidden":
-              case "attached":
-              case "detached":
-                await handle.waitFor({ state: action.state, timeout });
-                break;
-              case "enabled":
-                await waitForCondition2(
-                  () => handle.isEnabled(),
-                  timeout,
-                  `Element did not become enabled within ${timeout}ms`
-                );
-                break;
-              case "disabled":
-                await waitForCondition2(
-                  () => handle.isDisabled(),
-                  timeout,
-                  `Element did not become disabled within ${timeout}ms`
-                );
-                break;
-            }
-            break;
-          }
-          case "conditional": {
-            const handle = resolveLocator2(action.condition.target);
-            let conditionMet = false;
-            if (debugMode) {
-              console.log(`  [DEBUG] Checking condition ${action.condition.type}:`, action.condition.target);
-            }
-            try {
-              switch (action.condition.type) {
-                case "exists":
-                  await handle.waitFor({ state: "attached", timeout: 500 });
-                  conditionMet = true;
-                  break;
-                case "notExists":
-                  try {
-                    await handle.waitFor({ state: "detached", timeout: 500 });
-                    conditionMet = true;
-                  } catch {
-                    conditionMet = false;
-                  }
-                  break;
-                case "visible":
-                  conditionMet = await handle.isVisible();
-                  break;
-                case "hidden":
-                  conditionMet = !await handle.isVisible();
-                  break;
-              }
-            } catch {
-              conditionMet = action.condition.type === "notExists";
-            }
-            if (debugMode) {
-              console.log(`  [DEBUG] Condition result: ${conditionMet}`);
-            }
-            const stepsToRun = conditionMet ? action.then : action.else ?? [];
-            for (const nestedAction of stepsToRun) {
-              switch (nestedAction.type) {
-                case "screenshot": {
-                  await page.waitForLoadState("domcontentloaded").catch(() => {
-                  });
-                  await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
-                  });
-                  const filename = nestedAction.name ?? `conditional-step.png`;
-                  const filePath = path5__default.join(screenshotDir, filename);
-                  await page.screenshot({ path: filePath, fullPage: true });
-                  results.push({ action: nestedAction, status: "passed", screenshotPath: filePath });
-                  const trackedPayload2 = buildTrackPayload(nestedAction, index, { screenshotPath: filePath });
-                  if (trackedPayload2) {
-                    await track(trackedPayload2);
-                  }
-                  break;
-                }
-                case "evaluate":
-                  throw new Error("Evaluate action in nested context (conditional/waitForBranch) is not yet supported");
-                case "fail": {
-                  throw new Error(nestedAction.message);
-                }
-                default:
-                  throw new Error(`Nested action type ${nestedAction.type} in conditional not yet supported`);
-              }
-            }
-            break;
-          }
-          case "evaluate": {
-            const evalAction = action;
-            await page.waitForLoadState("domcontentloaded").catch(() => {
-            });
-            await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
-            });
-            const waitBefore = evalAction.waitBefore ?? 500;
-            if (waitBefore > 0) {
-              await page.waitForTimeout(waitBefore);
-            }
-            const evalScreenshotPath = path5__default.join(screenshotDir, `evaluate-step-${index + 1}.png`);
-            const screenshotBuffer = await page.screenshot({
-              path: evalScreenshotPath,
-              fullPage: evalAction.fullPage ?? true
-            });
-            const expectedRaw = evalAction.expected;
-            const expectedArray = Array.isArray(expectedRaw) ? expectedRaw.map((e) => interpolate(e)) : [interpolate(expectedRaw)];
-            const evalResult = await evaluate({
-              expected: expectedArray,
-              mode: evalAction.mode ?? "auto",
-              regex: evalAction.regex ?? false,
-              prompt: evalAction.prompt,
-              confidence: evalAction.confidence ?? 60,
-              screenshotBuffer,
-              screenshotPath: evalScreenshotPath,
-              aiConfig: options.aiConfig
-            });
-            if (debugMode) {
-              console.log(`  [DEBUG] Evaluate result: ${evalResult.passed ? "PASSED" : "FAILED"} (${evalResult.mode})`);
-              console.log(`  [DEBUG] Reason: ${evalResult.reason}`);
-            }
-            if (!evalResult.passed) {
-              throw new Error(`Evaluate failed (${evalResult.mode} mode): ${evalResult.reason}`);
-            }
-            results.push({
-              action,
-              status: "passed",
-              screenshotPath: evalScreenshotPath,
-              logOutput: `Evaluate passed (${evalResult.mode}): ${evalResult.reason}`
-            });
-            continue;
-          }
-          case "fail": {
-            throw new Error(action.message);
-          }
-          case "waitForBranch": {
-            const wfbAction = action;
-            const handle = resolveLocator2(wfbAction.target);
-            const timeout = wfbAction.timeout ?? 3e4;
-            const state = wfbAction.state ?? "visible";
-            const pollInterval = wfbAction.pollInterval ?? 100;
-            if (debugMode) {
-              console.log(`  [DEBUG] waitForBranch: waiting for element to be ${state}:`, wfbAction.target);
-            }
-            const startTime = Date.now();
-            let elementAppeared = false;
-            while (Date.now() - startTime < timeout) {
-              try {
-                let conditionMet = false;
-                switch (state) {
-                  case "visible":
-                    conditionMet = await handle.isVisible();
-                    break;
-                  case "attached":
-                    conditionMet = await handle.count() > 0;
-                    break;
-                  case "enabled":
-                    conditionMet = await handle.isEnabled().catch(() => false);
-                    break;
-                }
-                if (conditionMet) {
-                  elementAppeared = true;
-                  break;
-                }
-              } catch {
-              }
-              await new Promise((r) => setTimeout(r, pollInterval));
-            }
-            if (debugMode) {
-              console.log(`  [DEBUG] waitForBranch: element ${elementAppeared ? "appeared" : "timed out"}`);
-            }
-            const branch = elementAppeared ? wfbAction.onAppear : wfbAction.onTimeout;
-            if (branch) {
-              if (Array.isArray(branch)) {
-                for (const nestedAction of branch) {
-                  if (debugMode) {
-                    console.log(`  [DEBUG] waitForBranch: executing nested action ${nestedAction.type}`);
-                  }
-                  switch (nestedAction.type) {
-                    case "navigate": {
-                      const interpolated = interpolate(nestedAction.value);
-                      const baseUrl = test.config?.web?.baseUrl || workflowBaseUrl;
-                      const target = resolveUrl2(interpolated, baseUrl);
-                      await page.goto(target);
-                      break;
-                    }
-                    case "tap": {
-                      const nestedHandle = resolveLocator2(nestedAction.target);
-                      await nestedHandle.click();
-                      await page.waitForLoadState("domcontentloaded").catch(() => {
-                      });
-                      await page.waitForLoadState("networkidle", { timeout: 1e4 }).catch(() => {
-                      });
-                      break;
-                    }
-                    case "input": {
-                      const interpolated = interpolate(nestedAction.value);
-                      const nestedHandle = resolveLocator2(nestedAction.target);
-                      await nestedHandle.fill(interpolated);
-                      break;
-                    }
-                    case "screenshot": {
-                      await page.waitForLoadState("domcontentloaded").catch(() => {
-                      });
-                      await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
-                      });
-                      const nestedSsAction = nestedAction;
-                      const nestedWaitBefore = nestedSsAction.waitBefore ?? 500;
-                      if (nestedWaitBefore > 0) {
-                        await page.waitForTimeout(nestedWaitBefore);
-                      }
-                      const filename = nestedSsAction.name ?? `waitForBranch-step.png`;
-                      const filePath = path5__default.join(screenshotDir, filename);
-                      await page.screenshot({ path: filePath, fullPage: true });
-                      results.push({ action: nestedAction, status: "passed", screenshotPath: filePath });
-                      const trackedPayload2 = buildTrackPayload(nestedAction, index, { screenshotPath: filePath });
-                      if (trackedPayload2) {
-                        await track(trackedPayload2);
-                      }
-                      break;
-                    }
-                    case "wait": {
-                      if (nestedAction.target) {
-                        const nestedHandle = resolveLocator2(nestedAction.target);
-                        await nestedHandle.waitFor({ state: "visible", timeout: nestedAction.timeout });
-                      } else {
-                        await page.waitForTimeout(nestedAction.timeout ?? 1e3);
-                      }
-                      break;
-                    }
-                    case "evaluate":
-                      throw new Error("Evaluate action in nested context (conditional/waitForBranch) is not yet supported");
-                    case "fail": {
-                      throw new Error(nestedAction.message);
-                    }
-                    case "setVar": {
-                      let value;
-                      if (nestedAction.value) {
-                        value = interpolate(nestedAction.value);
-                      } else {
-                        throw new Error("setVar in waitForBranch requires value");
-                      }
-                      context.variables.set(nestedAction.name, value);
-                      if (debugMode) console.log(`  [DEBUG] Set variable ${nestedAction.name} = ${value}`);
-                      break;
-                    }
-                    case "assert": {
-                      const nestedHandle = resolveLocator2(nestedAction.target);
-                      await nestedHandle.waitFor({ state: "visible" });
-                      if (nestedAction.value) {
-                        const interpolated = interpolate(nestedAction.value);
-                        const text = (await nestedHandle.textContent())?.trim() ?? "";
-                        if (!text.includes(interpolated)) {
-                          throw new Error(
-                            `Assertion failed: expected "${interpolated}", got "${text}"`
-                          );
-                        }
-                      }
-                      break;
-                    }
-                    default:
-                      throw new Error(`Nested action type ${nestedAction.type} in waitForBranch not yet supported`);
-                  }
-                  if (nestedAction.type !== "screenshot") {
-                    const trackedPayload2 = buildTrackPayload(nestedAction, index);
-                    if (trackedPayload2) {
-                      await track(trackedPayload2);
-                    }
-                  }
-                  results.push({ action: nestedAction, status: "passed" });
-                }
-              } else if (typeof branch === "object" && "workflow" in branch) {
-                const workflowPath = path5__default.resolve(workflowDir, branch.workflow);
-                if (debugMode) {
-                  console.log(`  [DEBUG] waitForBranch: loading workflow from ${workflowPath}`);
-                }
-                const { loadWorkflowDefinition } = await import('./loader-2CW6OEXJ.js');
-                const nestedWorkflow = await loadWorkflowDefinition(workflowPath);
-                if (branch.variables) {
-                  for (const [key, value] of Object.entries(branch.variables)) {
-                    const interpolated = interpolate(value);
-                    context.variables.set(key, interpolated);
-                  }
-                }
-                for (const testRef of nestedWorkflow.tests) {
-                  const testFilePath2 = path5__default.resolve(path5__default.dirname(workflowPath), testRef.file);
-                  const nestedTest = await loadTestDefinition(testFilePath2);
-                  if (nestedTest.variables) {
-                    for (const [key, value] of Object.entries(nestedTest.variables)) {
-                      const interpolated = interpolateVariables(value, context.variables);
-                      context.variables.set(key, interpolated);
-                    }
-                  }
-                  const nestedResult = await runTestInWorkflow(
-                    nestedTest,
-                    page,
-                    context,
-                    options,
-                    path5__default.dirname(workflowPath),
-                    testFilePath2,
-                    nestedWorkflow.config?.web?.baseUrl ?? workflowBaseUrl
-                  );
-                  results.push(...nestedResult.steps);
-                  if (nestedResult.status === "failed") {
-                    throw new Error(`Nested workflow test failed in waitForBranch`);
-                  }
-                }
-              }
-            } else if (!elementAppeared && debugMode) {
-              console.log(`  [DEBUG] waitForBranch: timeout occurred but no onTimeout branch defined, continuing silently`);
-            }
-            break;
-          }
-          default:
-            throw new Error(`Unsupported action type: ${action.type}`);
-        }
-        const trackedPayload = buildTrackPayload(action, index);
-        if (trackedPayload) {
-          await track(trackedPayload);
-        }
-        results.push({ action, status: "passed" });
+        const actionExtras = await executeActionWithRetry(page, action, index, {
+          baseUrl,
+          context,
+          screenshotDir,
+          debugMode,
+          interactive: false,
+          aiConfig: options.aiConfig,
+          browserName,
+          testFilePath,
+          responseLog,
+          stepStartTs
+        });
+        results.push({ action, status: "passed", logOutput: actionExtras.logOutput });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         results.push({ action, status: "failed", error: message });
@@ -4948,20 +4155,21 @@ function inferCleanupConfig(config) {
 }
 async function runWorkflowWithContext(workflow, workflowFilePath, options) {
   const { page, executionContext, skipCleanup = false, sessionId: providedSessionId, testStartTime: providedTestStartTime } = options;
-  const workflowDir = path5__default.dirname(workflowFilePath);
+  const workflowDir = path4__default.dirname(workflowFilePath);
   const sessionId = providedSessionId ?? crypto4.randomUUID();
   const testStartTime = providedTestStartTime ?? (/* @__PURE__ */ new Date()).toISOString();
   console.log(`
 Starting workflow: ${workflow.name}`);
   console.log(`Session ID: ${sessionId}
 `);
-  if (workflow.config?.appwrite) {
+  const effectiveAppwriteConfig = workflow.config?.appwrite ? {
+    endpoint: workflow.config.appwrite.endpoint,
+    projectId: workflow.config.appwrite.projectId,
+    apiKey: workflow.config.appwrite.apiKey
+  } : options.appwriteConfig;
+  if (effectiveAppwriteConfig) {
     if (!executionContext.appwriteConfig) {
-      executionContext.appwriteConfig = {
-        endpoint: workflow.config.appwrite.endpoint,
-        projectId: workflow.config.appwrite.projectId,
-        apiKey: workflow.config.appwrite.apiKey
-      };
+      executionContext.appwriteConfig = effectiveAppwriteConfig;
     }
     setupAppwriteTracking(page, executionContext);
   }
@@ -4976,7 +4184,7 @@ Starting workflow: ${workflow.name}`);
   const testResults = [];
   let workflowFailed = false;
   for (const [index, testRef] of workflow.tests.entries()) {
-    const testFilePath = path5__default.resolve(workflowDir, testRef.file);
+    const testFilePath = path4__default.resolve(workflowDir, testRef.file);
     console.log(`
 [${index + 1}/${workflow.tests.length}] Running: ${testRef.file}`);
     if (testRef.id) {
@@ -5143,7 +4351,7 @@ ${"=".repeat(60)}`);
   };
 }
 async function runWorkflow(workflow, workflowFilePath, options = {}) {
-  const workflowDir = path5__default.dirname(workflowFilePath);
+  const workflowDir = path4__default.dirname(workflowFilePath);
   const sessionId = options.sessionId ?? crypto4.randomUUID();
   const testStartTime = (/* @__PURE__ */ new Date()).toISOString();
   const cleanupConfig = inferCleanupConfig(workflow.config);
@@ -5163,15 +4371,20 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
       process.env.INTELLITESTER_SESSION_ID = sessionId;
       process.env.INTELLITESTER_TRACK_URL = `http://localhost:${trackingServer.port}`;
     }
+    const trackingAppwrite = workflow.config?.appwrite ? {
+      endpoint: workflow.config.appwrite.endpoint,
+      projectId: workflow.config.appwrite.projectId,
+      apiKey: workflow.config.appwrite.apiKey
+    } : options.appwriteConfig;
     fileTracking = await initFileTracking({
       sessionId,
       cleanupConfig,
       trackDir: options.trackDir,
-      providerConfig: workflow.config?.appwrite ? {
+      providerConfig: trackingAppwrite ? {
         provider: "appwrite",
-        endpoint: workflow.config.appwrite.endpoint,
-        projectId: workflow.config.appwrite.projectId,
-        apiKey: workflow.config.appwrite.apiKey
+        endpoint: trackingAppwrite.endpoint,
+        projectId: trackingAppwrite.projectId,
+        apiKey: trackingAppwrite.apiKey
       } : void 0
     });
     process.env.INTELLITESTER_TRACK_FILE = fileTracking.trackFile;
@@ -5195,7 +4408,7 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
       }
       const normalized = wsEntries.map((entry) => ({
         ...entry,
-        workdir: path5__default.resolve(serverCwd, entry.workdir ?? entry.cwd ?? "."),
+        workdir: path4__default.resolve(serverCwd, entry.workdir ?? entry.cwd ?? "."),
         ...shouldForceNoReuse ? { reuseExistingServer: false } : {}
       }));
       await webServerManager.start(normalized.length === 1 ? normalized[0] : normalized);
@@ -5219,12 +4432,13 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
   };
   process.on("SIGINT", signalCleanup);
   process.on("SIGTERM", signalCleanup);
-  const browserName = options.browser ?? workflow.config?.web?.browser ?? "chromium";
+  const browserName = workflow.config?.web?.browser ?? options.browser ?? "chromium";
   const headless = options.headed === true ? false : workflow.config?.web?.headless ?? true;
   console.log(`Launching ${browserName}${headless ? " (headless)" : " (visible)"}...`);
   const browser = await getBrowser2(browserName).launch(getBrowserLaunchOptions({ headless, browser: browserName }));
   console.log(`Browser launched successfully`);
-  const testSizes = options.testSizes && options.testSizes.length > 0 ? options.testSizes : ["1920x1080"];
+  const workflowTestSizes = workflow.config?.web?.testSizes;
+  const testSizes = workflowTestSizes && workflowTestSizes.length > 0 ? workflowTestSizes : options.testSizes && options.testSizes.length > 0 ? options.testSizes : ["1920x1080"];
   const viewportSizes = [];
   for (const size of testSizes) {
     const viewport = parseViewportSize(size);
@@ -5237,11 +4451,12 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
   }
   const allTestResults = [];
   let anyFailed = false;
-  const cliStorageState = typeof options.storageState === "string" ? path5__default.isAbsolute(options.storageState) ? options.storageState : path5__default.resolve(process.cwd(), options.storageState) : options.storageState;
-  const storageState = cliStorageState ?? resolveStorageStatePath(
+  const optionsStorageState = typeof options.storageState === "string" ? path4__default.isAbsolute(options.storageState) ? options.storageState : path4__default.resolve(process.cwd(), options.storageState) : options.storageState;
+  const workflowStorageState = resolveStorageStatePath(
     workflow.config?.web?.storageState,
     workflowDir
   );
+  const storageState = workflowStorageState ?? optionsStorageState;
   let browserContext = await browser.newContext({
     viewport: viewportSizes[0].viewport,
     ...storageState ? { storageState } : {}
@@ -5257,7 +4472,7 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
       endpoint: workflow.config.appwrite.endpoint,
       projectId: workflow.config.appwrite.projectId,
       apiKey: workflow.config.appwrite.apiKey
-    } : void 0
+    } : options.appwriteConfig
   };
   if (workflow.variables) {
     for (const [key, value] of Object.entries(workflow.variables)) {
@@ -5430,6 +4645,6 @@ Collected ${serverResources.length} server-tracked resources`);
 // src/executors/web/index.ts
 init_esm_shims();
 
-export { buildCompletionOptions, buildModel, createTestContext, generateFillerText, generateRandomEmail, generateRandomPhone, generateRandomPhoto, generateRandomUsername, getBrowserLaunchOptions, initFileTracking, interpolateVariables, mergeFileTrackedResources, parseViewportSize, resolveStorageStatePath, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, webServerManager };
-//# sourceMappingURL=chunk-VWXGXFIM.js.map
-//# sourceMappingURL=chunk-VWXGXFIM.js.map
+export { buildCompletionOptions, buildModel, createTestContext, executeActionWithRetry, generateFillerText, generateRandomEmail, generateRandomPhone, generateRandomPhoto, generateRandomUsername, getBrowserLaunchOptions, initFileTracking, interpolateVariables, mergeFileTrackedResources, parseViewportSize, resolveStorageStatePath, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, webServerManager };
+//# sourceMappingURL=chunk-7UYD5Q7D.js.map
+//# sourceMappingURL=chunk-7UYD5Q7D.js.map