flowstride 1.0.11 → 1.0.12

package/dist/adapters/web/playwright.d.ts

@@ -26,6 +26,7 @@ export declare class WebAdapter {
     private checkAmbiguity;
     close(targetText: string): Promise<void>;
     click(selector: string, elementType?: string): Promise<void>;
+    hover(selector: string, elementType?: string): Promise<void>;
     type(selector: string, value: string, elementType?: string): Promise<void>;
     passcode(selector: string, value: string, elementType?: string): Promise<void>;
     check(selector: string, elementType?: string): Promise<void>;

package/dist/adapters/web/playwright.js

@@ -397,6 +397,66 @@ class WebAdapter {
         await targetLoc.scrollIntoViewIfNeeded();
         await targetLoc.click();
     }
+    async hover(selector, elementType) {
+        const loc = await this.getLocator(selector, elementType, false, false);
+        const targetLoc = await this.checkAmbiguity(loc, selector);
+        await targetLoc.waitFor({ state: "visible" });
+        await targetLoc.scrollIntoViewIfNeeded();
+        // 1. Accessibility WAI-ARIA Hack (Focus)
+        await targetLoc.focus({ timeout: 3000 }).catch(() => { });
+        await targetLoc
+            .evaluate((node) => {
+            if (typeof node.focus === "function")
+                node.focus();
+        })
+            .catch(() => { });
+        // 2. Get Exact Center Coordinates for Physical Move
+        let box = null;
+        try {
+            box = await targetLoc.boundingBox({ timeout: 3000 });
+        }
+        catch (e) { } // Catch in case it mutated instantly during focus
+        if (box) {
+            const centerX = box.x + box.width / 2;
+            const centerY = box.y + box.height / 2;
+            // Physically drag the mouse to the element to satisfy Hover Intent APIs
+            await this.page.mouse.move(centerX, centerY, { steps: 5 });
+        }
+        // 3. Playwright Native Hover Backup (Caught to prevent mutation crashes)
+        await targetLoc.hover({ force: true, timeout: 3000 }).catch(() => { });
+        // 4. The Ultimate Wakeup Call: Synthesize Full Coordinate-Loaded Events
+        await targetLoc
+            .evaluate((node) => {
+            const rect = node.getBoundingClientRect();
+            const x = rect.left + rect.width / 2;
+            const y = rect.top + rect.height / 2;
+            const events = [
+                "pointerover",
+                "pointerenter",
+                "mouseover",
+                "mouseenter",
+                "mousemove",
+            ];
+            events.forEach((type) => {
+                node.dispatchEvent(new MouseEvent(type, {
+                    view: window,
+                    bubbles: true,
+                    cancelable: true,
+                    clientX: x,
+                    clientY: y,
+                    screenX: x,
+                    screenY: y,
+                }));
+            });
+        })
+            .catch(() => { });
+        // 5. We perform a programmatic click that won't trigger W3C navigation if handled by React toggles
+        await targetLoc
+            .click({ delay: 50, force: true, timeout: 3000 })
+            .catch(() => { });
+        // 6. The Paint Buffer
+        await this.page.waitForTimeout(600);
+    }
     async type(selector, value, elementType) {
         const loc = await this.getLocator(selector, elementType, false, false);
         const targetLoc = await this.checkAmbiguity(loc, selector);

package/dist/cli/index.js

@@ -54,7 +54,7 @@ const API_BASE = process.env.FLOWSTRIDE_API_URL || "https://cloud.flowstride.io"
 program
     .name("flowstride")
     .description("Flowstride: The Enterprise Flow-First Automation CLI")
-    .version("1.0.11");
+    .version("1.0.12");
 program
     .command("init")
     .description("Initialise a new Flowstride workspace in the current directory")

package/dist/parser/lexer.js

@@ -129,7 +129,9 @@ class Lexer {
                     tokens.push({ type: TokenType.LET, value: ident, line: this.line });
                     continue;
                 }
-                if (lowerIdent === "feature" || lowerIdent === "scenario") {
+                if (lowerIdent === "feature" ||
+                    lowerIdent === "scenario" ||
+                    lowerIdent === "only.scenario") {
                     let tempPos = this.position;
                     while (tempPos < this.input.length &&
                         (this.input[tempPos] === " " || this.input[tempPos] === "\t"))
@@ -205,6 +207,7 @@ class Lexer {
                         "autoheal",
                         "mail.getotp",
                         "extract",
+                        "hover",
                     ];
                     if (validNakedCommands.map((c) => c.toLowerCase()).includes(lowerIdent)) {
                         tokens.push({
@@ -226,7 +229,16 @@ class Lexer {
                         throw new SyntaxError(`Syntax Error on line ${this.line}: Expected an action command after 'flow.try', but found "${ident}".`);
                     }
                 }
-                if (["given", "when", "then", "and"].includes(lowerIdent)) {
+                if ([
+                    "given",
+                    "when",
+                    "then",
+                    "and",
+                    "stop.given",
+                    "stop.when",
+                    "stop.then",
+                    "stop.and",
+                ].includes(lowerIdent)) {
                     let tempPos = this.position;
                     while (tempPos < this.input.length &&
                         (this.input[tempPos] === " " || this.input[tempPos] === "\t"))
@@ -268,6 +280,7 @@ class Lexer {
                     "flow.autoheal",
                     "flow.mail.getotp",
                     "flow.extract",
+                    "flow.hover",
                 ]
                     .map((c) => c.toLowerCase())
                     .includes(lowerIdent)) {
@@ -290,14 +303,16 @@ class Lexer {
                     "contains",
                     "placeholder",
                     "status",
-                    "responsetime",
-                    "reqbody",
-                    "resbody",
-                    "reqheader",
-                    "resheader",
+                    "responseTime",
+                    "reqBody",
+                    "resBody",
+                    "reqHeader",
+                    "resHeader",
                     "cookie",
                     "global",
-                ].includes(lowerIdent)) {
+                ]
+                    .map((c) => c.toLowerCase())
+                    .includes(lowerIdent)) {
                     tokens.push({
                         type: TokenType.MODIFIER,
                         value: ident,
@@ -314,6 +329,8 @@ class Lexer {
                     "span",
                     "image",
                     "img",
+                    "burger",
+                    "hamburger",
                 ].includes(lowerIdent)) {
                     tokens.push({
                         type: TokenType.ELEMENT,

package/dist/parser/parser.d.ts

@@ -10,11 +10,13 @@ export interface StepNode {
     action: string;
     payload: any;
     line: number;
+    isStop?: boolean;
 }
 export interface ScenarioNode {
     name: string;
     declarations: DeclarationNode[];
     steps: StepNode[];
+    isOnly?: boolean;
 }
 export interface FeatureNode {
     name: string;
@@ -26,6 +28,10 @@ export declare class Parser {
     private position;
     private currentBlockDescription;
     private stepCounter;
+    private scenarioCounter;
+    private hasOnlyScenario;
+    private hasStopInCurrentScenario;
+    private currentBlockIsStop;
     constructor(tokens: Token[]);
     parse(): FeatureNode[];
     private parseDeclaration;

package/dist/parser/parser.js

@@ -7,6 +7,10 @@ class Parser {
     position = 0;
     currentBlockDescription = "";
     stepCounter = 1;
+    scenarioCounter = 0;
+    hasOnlyScenario = false;
+    hasStopInCurrentScenario = false;
+    currentBlockIsStop = false;
     constructor(tokens) {
         this.tokens = tokens;
     }
@@ -68,15 +72,25 @@ class Parser {
         };
     }
     parseScenario() {
-        this.advance();
+        const scenarioToken = this.advance();
+        const isOnly = scenarioToken.value.toLowerCase() === "only.scenario";
+        if (isOnly) {
+            if (this.hasOnlyScenario) {
+                throw new Error(`Line ${scenarioToken.line}: You cannot have more than one 'only.Scenario' in a single file.`);
+            }
+            this.hasOnlyScenario = true;
+        }
+        this.hasStopInCurrentScenario = false;
         const nameToken = this.consume(lexer_1.TokenType.STRING, "Scenario must have a description");
         const steps = [];
         const declarations = [];
+        this.scenarioCounter++;
         this.stepCounter = 1;
         let state = "START";
         let hasGiven = false, hasWhen = false, hasAnd = false, hasThen = false;
         let isLocked = false;
         let currentBlockType = "";
+        this.currentBlockIsStop = false;
         while (!this.isAtEnd() &&
             this.peek().type !== lexer_1.TokenType.SCENARIO &&
             this.peek().type !== lexer_1.TokenType.FEATURE) {
@@ -88,7 +102,19 @@ class Parser {
                 if (isLocked)
                     throw new Error(`Line ${token.line}: Terminal Lock Violation. No steps allowed after Then.`);
                 const blockToken = this.advance();
-                const blockType = blockToken.value.toLowerCase();
+                let rawBlockType = blockToken.value.toLowerCase();
+                if (rawBlockType.startsWith("stop.")) {
+                    if (this.hasStopInCurrentScenario) {
+                        throw new Error(`Line ${blockToken.line}: You cannot have more than one 'stop.' block in a single scenario.`);
+                    }
+                    this.hasStopInCurrentScenario = true;
+                    this.currentBlockIsStop = true;
+                    rawBlockType = rawBlockType.replace("stop.", "");
+                }
+                else {
+                    this.currentBlockIsStop = false;
+                }
+                const blockType = rawBlockType;
                 let description = this.peek().type === lexer_1.TokenType.STRING ? this.advance().value : "";
                 if (blockType === "given") {
                     if (state !== "START")
@@ -116,9 +142,10 @@ class Parser {
                     hasAnd = true;
                 }
                 currentBlockType = blockType;
+                const displayBlockName = blockType.charAt(0).toUpperCase() + blockType.slice(1);
                 this.currentBlockDescription = description
-                    ? `${blockToken.value} "${description}"`
-                    : blockToken.value;
+                    ? `${displayBlockName} "${description}"`
+                    : displayBlockName;
             }
             else if (token.type === lexer_1.TokenType.COMMAND ||
                 token.type === lexer_1.TokenType.ALIAS_COMMAND) {
@@ -126,6 +153,9 @@ class Parser {
                     throw new Error(`Line ${token.line}: Terminal Lock Violation.`);
                 }
                 const step = this.parseCommand();
+                if (this.currentBlockIsStop) {
+                    step.isStop = true;
+                }
                 if (currentBlockType === "and" &&
                     step.action !== "expect" &&
                     step.action !== "plugin") {
@@ -140,7 +170,15 @@ class Parser {
         if (!hasGiven || !hasWhen || !hasThen) {
             throw new Error(`Scenario "${nameToken.value}" is missing mandatory blocks.`);
         }
-        return { name: nameToken.value, declarations, steps };
+        const scenarioNode = {
+            name: nameToken.value,
+            declarations,
+            steps,
+        };
+        if (isOnly) {
+            scenarioNode.isOnly = true;
+        }
+        return scenarioNode;
     }
     parseSmartSelectorPayload() {
         let selector = "";
@@ -202,7 +240,7 @@ class Parser {
                 dataPayload = this.advance().value;
             }
             return {
-                id: `S${this.stepCounter++}`,
+                id: `scenario_${this.scenarioCounter}_S${this.stepCounter++}`,
                 blockDescription: this.currentBlockDescription,
                 action: "plugin",
                 payload: {
@@ -259,26 +297,32 @@ class Parser {
             autoheal: "autoHeal",
             "mail.getotp": "getOtp",
             extract: "extract",
+            hover: "hover",
         };
         const action = actionMap[actionBase] || actionBase;
         let payload = { optional: isOptional };
         switch (action) {
             case "extract":
                 const extTargetToken = this.consume(lexer_1.TokenType.MODIFIER, "Expected target after extract");
-                const extTarget = extTargetToken.value.toLowerCase();
-                let normalizedTarget = extTarget;
-                if (extTarget === "resbody")
-                    normalizedTarget = "resBody";
-                else if (extTarget === "reqbody")
-                    normalizedTarget = "reqBody";
-                else if (extTarget === "resheader")
-                    normalizedTarget = "resHeader";
-                else if (extTarget === "reqheader")
-                    normalizedTarget = "reqHeader";
-                if (!["resBody", "resHeader", "cookie"].includes(normalizedTarget)) {
+                const extTarget = extTargetToken.value;
+                if (extTarget.toLowerCase() === "resbody" && extTarget !== "resBody") {
+                    throw new Error(`Syntax Error on line ${extTargetToken.line}: Invalid keyword '${extTarget}'. Flowstride uses strict camelCase. Did you mean 'resBody'?`);
+                }
+                if (extTarget.toLowerCase() === "reqbody" && extTarget !== "reqBody") {
+                    throw new Error(`Syntax Error on line ${extTargetToken.line}: Invalid keyword '${extTarget}'. Flowstride uses strict camelCase. Did you mean 'reqBody'?`);
+                }
+                if (extTarget.toLowerCase() === "resheader" &&
+                    extTarget !== "resHeader") {
+                    throw new Error(`Syntax Error on line ${extTargetToken.line}: Invalid keyword '${extTarget}'. Flowstride uses strict camelCase. Did you mean 'resHeader'?`);
+                }
+                if (extTarget.toLowerCase() === "reqheader" &&
+                    extTarget !== "reqHeader") {
+                    throw new Error(`Syntax Error on line ${extTargetToken.line}: Invalid keyword '${extTarget}'. Flowstride uses strict camelCase. Did you mean 'reqHeader'?`);
+                }
+                if (!["resBody", "resHeader", "cookie"].includes(extTarget)) {
                     throw new Error(`Line ${extTargetToken.line}: Expected 'resBody', 'resHeader', or 'cookie' after extract`);
                 }
-                payload.target = normalizedTarget;
+                payload.target = extTarget;
                 payload.jsonPath = this.consume(lexer_1.TokenType.STRING, "JSONPath or Key expected").value;
                 const asToken = this.advance();
                 if (asToken.value.toLowerCase() !== "as") {
@@ -333,8 +377,19 @@ class Parser {
             case "forceClick":
             case "check":
             case "uncheck":
+            case "hover":
                 this.consumeOptionalElement(payload);
-                payload.selector = this.parseSmartSelectorPayload();
+                if (["burger", "hamburger"].includes(payload.elementType)) {
+                    if (!this.isAtEnd() && this.peek().type === lexer_1.TokenType.STRING) {
+                        payload.selector = this.parseSmartSelectorPayload();
+                    }
+                    else {
+                        payload.selector = "smart-burger-fallback";
+                    }
+                }
+                else {
+                    payload.selector = this.parseSmartSelectorPayload();
+                }
                 break;
             case "type":
             case "forceType":
@@ -426,16 +481,21 @@ class Parser {
                 break;
             case "expect":
                 const modToken = this.consume(lexer_1.TokenType.MODIFIER, "Modifier expected");
-                let mod = modToken.value.toLowerCase();
-                if (mod === "resbody")
-                    mod = "resBody";
-                if (mod === "resheader")
-                    mod = "resHeader";
+                const mod = modToken.value;
+                if (mod.toLowerCase() === "resbody" && mod !== "resBody") {
+                    throw new Error(`Syntax Error on line ${modToken.line}: Invalid keyword '${mod}'. Flowstride uses strict camelCase. Did you mean 'resBody'?`);
+                }
+                if (mod.toLowerCase() === "resheader" && mod !== "resHeader") {
+                    throw new Error(`Syntax Error on line ${modToken.line}: Invalid keyword '${mod}'. Flowstride uses strict camelCase. Did you mean 'resHeader'?`);
+                }
+                if (mod.toLowerCase() === "responsetime" && mod !== "responseTime") {
+                    throw new Error(`Syntax Error on line ${modToken.line}: Invalid keyword '${mod}'. Flowstride uses strict camelCase. Did you mean 'responseTime'?`);
+                }
                 payload.type = mod;
                 if (mod === "status") {
                     payload.statusCode = this.consume(lexer_1.TokenType.STRING, 'Status code expected (e.g., "200")').value;
                 }
-                else if (mod === "responsetime") {
+                else if (mod === "responseTime") {
                     const conditionToken = this.advance();
                     if (conditionToken.value.toLowerCase() !== "lessthan") {
                         throw new Error(`Line ${modToken.line}: Expected 'lessThan' after responseTime`);
@@ -502,7 +562,17 @@ class Parser {
                         payload.fuzzy = true;
                     }
                     this.consumeOptionalElement(payload);
-                    payload.selector = this.parseSmartSelectorPayload();
+                    if (["burger", "hamburger"].includes(payload.elementType)) {
+                        if (!this.isAtEnd() && this.peek().type === lexer_1.TokenType.STRING) {
+                            payload.selector = this.parseSmartSelectorPayload();
+                        }
+                        else {
+                            payload.selector = "smart-burger-fallback";
+                        }
+                    }
+                    else {
+                        payload.selector = this.parseSmartSelectorPayload();
+                    }
                 }
                 else if (mod === "value" || mod === "attribute") {
                     this.consumeOptionalElement(payload);
@@ -523,7 +593,7 @@ class Parser {
                 throw new Error(`Unknown command: ${action}`);
         }
         return {
-            id: `S${this.stepCounter++}`,
+            id: `scenario_${this.scenarioCounter}_S${this.stepCounter++}`,
             blockDescription: this.currentBlockDescription,
             action,
             payload,
@@ -537,13 +607,19 @@ class Parser {
             if (nextToken.type === lexer_1.TokenType.PREPOSITION && nextVal === "with") {
                 this.advance();
                 const targetToken = this.advance();
-                const target = targetToken.value.toLowerCase();
-                if (target === "reqheader") {
+                const target = targetToken.value;
+                if (target.toLowerCase() === "reqbody" && target !== "reqBody") {
+                    throw new Error(`Syntax Error on line ${targetToken.line}: Invalid keyword '${target}'. Flowstride uses strict camelCase. Did you mean 'reqBody'?`);
+                }
+                if (target.toLowerCase() === "reqheader" && target !== "reqHeader") {
+                    throw new Error(`Syntax Error on line ${targetToken.line}: Invalid keyword '${target}'. Flowstride uses strict camelCase. Did you mean 'reqHeader'?`);
+                }
+                if (target === "reqHeader") {
                     const hKey = this.consume(lexer_1.TokenType.STRING, "Header key expected").value;
                     const hVal = this.consume(lexer_1.TokenType.STRING, "Header value expected").value;
                     payload.headers.push({ key: hKey, value: hVal });
                 }
-                else if (target === "reqbody") {
+                else if (target === "reqBody") {
                     payload.body = this.consume(lexer_1.TokenType.STRING, "Body content expected").value;
                 }
                 else {

package/dist/runner/flow_orchestrator.d.ts

@@ -9,6 +9,7 @@ export declare class FlowOrchestrator {
     private globalTestScenarios;
     private stepStatusRegistry;
     private pdfGenerator;
+    private disconnectTimer;
     constructor(worker: FlowWorker, workerCount?: number, config?: FlowstrideConfig | undefined);
     private forwardToDashboard;
     private executeTestRun;

package/dist/runner/flow_orchestrator.js

@@ -53,6 +53,7 @@ class FlowOrchestrator {
     globalTestScenarios = [];
     stepStatusRegistry = new Map();
     pdfGenerator;
+    disconnectTimer = null;
     constructor(worker, workerCount = 1, config) {
         this.worker = worker;
         this.workerCount = workerCount;
@@ -222,6 +223,10 @@ class FlowOrchestrator {
             });
             this.wss = new ws_1.WebSocketServer({ server: this.httpServer });
             this.wss.on("connection", (ws) => {
+                if (this.disconnectTimer) {
+                    clearTimeout(this.disconnectTimer);
+                    this.disconnectTimer = null;
+                }
                 ws.on("message", async (message) => {
                     const data = JSON.parse(message.toString());
                     if (data.type === "EXPORT_PDF_REQ") {
@@ -255,6 +260,21 @@ class FlowOrchestrator {
                         this.forwardToDashboard("RUN_COMPLETE", { status: "aborted" });
                     }
                 });
+                ws.on("close", () => {
+                    if (this.wss && this.wss.clients.size === 0) {
+                        this.disconnectTimer = setTimeout(async () => {
+                            console.log(chalk_1.default.yellow("\n[Flowstride]: Dashboard disconnected. Shutting down framework..."));
+                            this.worker.abort();
+                            try {
+                                await this.worker.shutdown();
+                            }
+                            catch (e) { }
+                            this.wss?.close();
+                            this.httpServer?.close();
+                            process.exit(0);
+                        }, 3000);
+                    }
+                });
             });
             this.httpServer.listen(0, async () => {
                 const address = this.httpServer?.address();
@@ -273,11 +293,6 @@ class FlowOrchestrator {
                 console.log(chalk_1.default.green("[Dashboard]: Connected to UI!"));
                 await this.executeTestRun(targetPath);
             });
-            process.on("SIGINT", () => {
-                this.wss?.close();
-                this.httpServer?.close();
-                process.exit();
-            });
         }
         catch (e) {
             throw e;

package/dist/runner/flow_worker.d.ts

@@ -21,6 +21,7 @@ export declare class FlowWorker extends EventEmitter {
     private pluginManager?;
     private isSilent;
     private isAborted;
+    private isDebugHalted;
     private currentStepContext;
     private currentFileName;
     private activeAudioPath;

package/dist/runner/flow_worker.js

@@ -55,6 +55,7 @@ class FlowWorker extends events_1.EventEmitter {
     pluginManager;
     isSilent = process.env.FLOWSTRIDE_PARALLEL === "true";
     isAborted = false;
+    isDebugHalted = false;
     currentStepContext = "Initializing...";
     currentFileName = "System";
     activeAudioPath = undefined;
@@ -171,6 +172,8 @@ class FlowWorker extends events_1.EventEmitter {
     extractFromJsonPath(obj, path) {
         if (!obj)
             return undefined;
+        if (!path)
+            return obj;
         const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
         let current = obj;
         for (const part of parts) {
@@ -186,11 +189,11 @@ class FlowWorker extends events_1.EventEmitter {
         const state = this.api.getState();
         for (const ext of extracts) {
             let val;
-            if (ext.target === "resbody") {
+            if (ext.target === "resBody") {
                 val = this.extractFromJsonPath(state.body, ext.jsonPath);
             }
-            else if (ext.target === "resheader") {
-                val = state.headers?.[ext.jsonPath.toLowerCase()];
+            else if (ext.target === "resHeader") {
+                val = state.headers?.[(ext.jsonPath || "").toLowerCase()];
             }
             else if (ext.target === "cookie") {
                 const cookies = state.headers?.["set-cookie"];
@@ -340,136 +343,174 @@ class FlowWorker extends events_1.EventEmitter {
         this.config.headless = true;
         this.activeAudioPath = undefined;
         this.isAborted = false;
-        for (const filePath of filesToProcess) {
-            const content = fs.readFileSync(filePath, "utf8");
-            const audioMatch = content.match(/(?:flow\.)?injectAudio\s+["']([^"']+)["']/i);
-            if (audioMatch && audioMatch[1]) {
-                const rawPath = audioMatch[1];
-                const absolutePath = path.resolve(process.cwd(), rawPath);
-                if (!fs.existsSync(absolutePath)) {
-                    throw new Error(`Pre-launch initialization failed: Audio file not found at ${absolutePath}`);
-                }
-                this.activeAudioPath = absolutePath;
-                break;
+        this.isDebugHalted = false;
+        const sigintHandler = async () => {
+            if (!this.isSilent) {
+                console.log(chalk_1.default.yellow("\n[Flowstride]: Process interrupted. Gracefully shutting down..."));
             }
-        }
-        for (const filePath of filesToProcess) {
-            if (this.isAborted)
-                break;
-            const fileStartTime = Date.now();
+            this.abort();
+            this.broadcast("SERVER_SHUTDOWN", { message: "Terminal closed." });
             try {
-                const fileName = path.basename(filePath);
-                this.currentFileName = fileName;
-                this.localVariables = {};
-                this.localBrowserSessions = {};
-                this.api.resetState();
-                this.dataGen = new data_generators_1.DataGenerators();
-                await this.web.initialise(this.activeAudioPath);
-                await this.startStreaming();
-                await this.setupNetworkInterception();
+                await this.web.shutdown();
+            }
+            catch (e) { }
+            process.exit(0);
+        };
+        process.once("SIGINT", sigintHandler);
+        try {
+            for (const filePath of filesToProcess) {
                 const content = fs.readFileSync(filePath, "utf8");
-                const hasSessionIntent = content.includes("use session") ||
-                    content.includes("use global session");
-                if (!hasSessionIntent) {
-                    try {
-                        const page = this.web.getPage();
-                        if (page) {
-                            await page
-                                .context()
-                                .clearCookies()
+                const audioMatch = content.match(/(?:flow\.)?injectAudio\s+["']([^"']+)["']/i);
+                if (audioMatch && audioMatch[1]) {
+                    const rawPath = audioMatch[1];
+                    const absolutePath = path.resolve(process.cwd(), rawPath);
+                    if (!fs.existsSync(absolutePath)) {
+                        throw new Error(`Pre-launch initialization failed: Audio file not found at ${absolutePath}`);
+                    }
+                    this.activeAudioPath = absolutePath;
+                    break;
+                }
+            }
+            for (const filePath of filesToProcess) {
+                if (this.isAborted || this.isDebugHalted)
+                    break;
+                const fileStartTime = Date.now();
+                try {
+                    const fileName = path.basename(filePath);
+                    this.currentFileName = fileName;
+                    this.localVariables = {};
+                    this.localBrowserSessions = {};
+                    this.api.resetState();
+                    this.dataGen = new data_generators_1.DataGenerators();
+                    await this.web.initialise(this.activeAudioPath);
+                    await this.startStreaming();
+                    await this.setupNetworkInterception();
+                    const content = fs.readFileSync(filePath, "utf8");
+                    const hasSessionIntent = content.includes("use session") ||
+                        content.includes("use global session");
+                    if (!hasSessionIntent) {
+                        try {
+                            const page = this.web.getPage();
+                            if (page) {
+                                await page
+                                    .context()
+                                    .clearCookies()
+                                    .catch(() => { });
+                                await page
+                                    .evaluate(() => {
+                                    try {
+                                        localStorage.clear();
+                                    }
+                                    catch (e) { }
+                                    try {
+                                        sessionStorage.clear();
+                                    }
+                                    catch (e) { }
+                                })
+                                    .catch(() => { });
+                            }
+                        }
+                        catch (e) { }
+                    }
+                    if (!this.isSilent)
+                        console.log(chalk_1.default.blue.bold(`\n[Execution]: Processing file: ${fileName}`));
+                    this.emitLog("FILE_HEADER", "info", fileName, { filePath });
+                    const features = new parser_1.Parser(new lexer_1.Lexer(content).tokenise()).parse();
+                    const hasOnlyMode = features.some((f) => f.scenarios.some((s) => s.isOnly));
+                    if (hasOnlyMode) {
+                        if (!this.isSilent) {
+                            console.log(chalk_1.default.yellow(`      > [Debug Mode]: 'only.Scenario' detected. Operating in Ghost Mode.`));
+                        }
+                        features.forEach((f) => {
+                            f.scenarios = f.scenarios.filter((s) => s.isOnly);
+                        });
+                    }
+                    for (const f of features) {
+                        if (this.isAborted || this.isDebugHalted)
+                            break;
+                        if (f.scenarios.length === 0)
+                            continue;
+                        if (!this.isSilent)
+                            console.log(chalk_1.default.magenta.bold(`  Feature: ${f.name}`));
+                        for (const s of f.scenarios) {
+                            if (this.isAborted || this.isDebugHalted)
+                                break;
+                            if (!this.isSilent)
+                                console.log(chalk_1.default.cyan(`    Scenario: ${s.name}`));
+                            this.broadcast("RUN_START", {
+                                scenarioName: s.name,
+                                fileName: this.currentFileName,
+                            });
+                            await this.runScenario(s, f.declarations);
+                            if (this.isDebugHalted)
+                                break;
+                            await this.web
+                                .getPage()
+                                .waitForLoadState("load", { timeout: 4000 })
                                 .catch(() => { });
-                            await page
-                                .evaluate(() => {
-                                try {
-                                    localStorage.clear();
-                                }
-                                catch (e) { }
-                                try {
-                                    sessionStorage.clear();
-                                }
-                                catch (e) { }
-                            })
+                            await this.web
+                                .getPage()
+                                .waitForLoadState("networkidle", { timeout: 4000 })
                                 .catch(() => { });
+                            await new Promise((resolve) => setTimeout(resolve, 2000));
                         }
                     }
-                    catch (e) { }
-                }
-                if (!this.isSilent)
-                    console.log(chalk_1.default.blue.bold(`\n[Execution]: Processing file: ${fileName}`));
-                this.emitLog("FILE_HEADER", "info", fileName, { filePath });
-                const features = new parser_1.Parser(new lexer_1.Lexer(content).tokenise()).parse();
-                for (const f of features) {
                     if (this.isAborted)
                         break;
                     if (!this.isSilent)
-                        console.log(chalk_1.default.magenta.bold(`  Feature: ${f.name}`));
-                    for (const s of f.scenarios) {
-                        if (this.isAborted)
-                            break;
+                        console.log(chalk_1.default.gray("\n[Execution]: Finalizing browser actions..."));
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                    try {
+                        const baseName = this.currentFileName.replace(".flow", "");
+                        const mockCloudDir = path.join(process.cwd(), ".flowstride", "mock-cloud");
+                        if (!fs.existsSync(mockCloudDir))
+                            fs.mkdirSync(mockCloudDir, { recursive: true });
+                        const targetVideoPath = path.join(mockCloudDir, `${baseName}.webm`);
+                        await this.web.shutdown(targetVideoPath);
                         if (!this.isSilent)
-                            console.log(chalk_1.default.cyan(`    Scenario: ${s.name}`));
-                        this.broadcast("RUN_START", {
-                            scenarioName: s.name,
-                            fileName: this.currentFileName,
-                        });
-                        await this.runScenario(s, f.declarations);
-                        await this.web
-                            .getPage()
-                            .waitForLoadState("load", { timeout: 4000 })
-                            .catch(() => { });
-                        await this.web
-                            .getPage()
-                            .waitForLoadState("networkidle", { timeout: 4000 })
-                            .catch(() => { });
-                        await new Promise((resolve) => setTimeout(resolve, 2000));
+                            console.log(chalk_1.default.gray(`      [Cloud Sync]: Video safely encoded and preserved for ${this.currentFileName}`));
                     }
+                    catch (err) { }
+                    this.broadcast("FILE_COMPLETE", {
+                        fileName: this.currentFileName,
+                        duration: Date.now() - fileStartTime,
+                    });
                 }
-                if (this.isAborted)
-                    break;
-                if (!this.isSilent)
-                    console.log(chalk_1.default.gray("\n[Execution]: Finalizing browser actions..."));
-                await new Promise((resolve) => setTimeout(resolve, 2000));
-                try {
-                    const baseName = this.currentFileName.replace(".flow", "");
-                    const mockCloudDir = path.join(process.cwd(), ".flowstride", "mock-cloud");
-                    if (!fs.existsSync(mockCloudDir))
-                        fs.mkdirSync(mockCloudDir, { recursive: true });
-                    const targetVideoPath = path.join(mockCloudDir, `${baseName}.webm`);
-                    await this.web.shutdown(targetVideoPath);
+                catch (e) {
+                    if (this.isAborted)
+                        break;
                     if (!this.isSilent)
-                        console.log(chalk_1.default.gray(`      [Cloud Sync]: Video safely encoded and preserved for ${this.currentFileName}`));
+                        console.error(chalk_1.default.red(`\n[Execution]: Failed processing ${this.currentFileName}: ${e.message}`));
+                    try {
+                        const baseName = this.currentFileName.replace(".flow", "");
+                        const mockCloudDir = path.join(process.cwd(), ".flowstride", "mock-cloud");
+                        if (!fs.existsSync(mockCloudDir))
+                            fs.mkdirSync(mockCloudDir, { recursive: true });
+                        const targetVideoPath = path.join(mockCloudDir, `${baseName}.webm`);
+                        await this.web.shutdown(targetVideoPath);
+                        if (!this.isSilent)
+                            console.log(chalk_1.default.gray(`      [Cloud Sync]: Video safely encoded and preserved for ${this.currentFileName}`));
+                    }
+                    catch (err) { }
+                    this.broadcast("FILE_FAILED", {
+                        fileName: this.currentFileName,
+                        duration: Date.now() - fileStartTime,
+                        error: e.message,
+                    });
                 }
-                catch (err) { }
-                this.broadcast("FILE_COMPLETE", {
-                    fileName: this.currentFileName,
-                    duration: Date.now() - fileStartTime,
-                });
             }
-            catch (e) {
-                if (this.isAborted)
-                    break;
-                if (!this.isSilent)
-                    console.error(chalk_1.default.red(`\n[Execution]: Failed processing ${this.currentFileName}: ${e.message}`));
-                try {
-                    const baseName = this.currentFileName.replace(".flow", "");
-                    const mockCloudDir = path.join(process.cwd(), ".flowstride", "mock-cloud");
-                    if (!fs.existsSync(mockCloudDir))
-                        fs.mkdirSync(mockCloudDir, { recursive: true });
-                    const targetVideoPath = path.join(mockCloudDir, `${baseName}.webm`);
-                    await this.web.shutdown(targetVideoPath);
-                    if (!this.isSilent)
-                        console.log(chalk_1.default.gray(`      [Cloud Sync]: Video safely encoded and preserved for ${this.currentFileName}`));
+            if (!this.isSilent && !this.isAborted) {
+                if (this.isDebugHalted) {
+                    console.log(chalk_1.default.cyan("\n[Execution]: Test suite halted by debug flag."));
+                }
+                else {
+                    console.log(chalk_1.default.green("\n[Execution]: All suites completed successfully."));
                 }
-                catch (err) { }
-                this.broadcast("FILE_FAILED", {
-                    fileName: this.currentFileName,
-                    duration: Date.now() - fileStartTime,
-                    error: e.message,
-                });
             }
         }
-        if (!this.isSilent && !this.isAborted)
-            console.log(chalk_1.default.green("[Execution]: All suites completed successfully."));
+        finally {
+            process.removeListener("SIGINT", sigintHandler);
+        }
     }
     async runScenario(scenario, globalDeclarations = []) {
         for (const step of scenario.steps) {
@@ -529,6 +570,13 @@ class FlowWorker extends events_1.EventEmitter {
                     screenshot: stepContext.screenshot,
                     fileName: this.currentFileName,
                 });
+                if (step.isStop) {
+                    if (!this.isSilent) {
+                        console.log(chalk_1.default.cyan(`      > [Execution]: Debug stop triggered. Halting global execution.`));
+                    }
+                    this.isDebugHalted = true;
+                    break;
+                }
             }
             catch (e) {
                 if (this.isAborted)
@@ -561,6 +609,7 @@ class FlowWorker extends events_1.EventEmitter {
                 }
                 const isUIAction = [
                     "click",
+                    "hover",
                     "type",
                     "forceClick",
                     "forceType",
@@ -639,11 +688,23 @@ class FlowWorker extends events_1.EventEmitter {
         }
     }
     async executeStep(action, payload, localDeclarations = [], globalDeclarations = []) {
+        if (payload && payload.selector === "smart-burger-fallback") {
+            payload.selector = [
+                'button[aria-label*="menu" i]',
+                '[aria-label*="menu" i]',
+                '[title*="menu" i]',
+                ".bm-burger-button",
+                '[class*="hamburger" i]',
+                '[class*="burger" i]',
+                '[id*="hamburger" i]',
+                '[id*="burger" i]',
+            ].join(", ");
+        }
         switch (action) {
             case "extract":
                 this.processExtractions([
                     {
-                        target: payload.target.toLowerCase(),
+                        target: payload.target,
                         jsonPath: payload.jsonPath,
                         variableName: payload.variableName,
                         isGlobal: payload.isGlobal,
@@ -791,6 +852,9 @@ class FlowWorker extends events_1.EventEmitter {
             case "click":
                 await this.web.click(payload.selector, payload.elementType);
                 break;
+            case "hover":
+                await this.web.hover(payload.selector, payload.elementType);
+                break;
             case "forceClick":
                 await this.web.forceClick(payload.selector, payload.elementType);
                 break;
@@ -841,23 +905,27 @@ class FlowWorker extends events_1.EventEmitter {
                 await this.waitForPipeline();
                 break;
             case "expect":
-                if (["status", "responsetime", "resbody", "resheader", "cookie"].includes(payload.type)) {
+                const expectType = payload.type;
+                if (["status", "responseTime", "resBody", "resHeader", "cookie"].includes(expectType)) {
                     const apiState = this.api.getState();
-                    if (payload.type === "status") {
-                        if (String(apiState.status) !== String(payload.statusCode))
-                            throw new Error(`API Assertion Failed: Expected HTTP status ${payload.statusCode}, but got ${apiState.status}`);
+                    if (expectType === "status") {
+                        const expectedStatus = payload.statusCode || payload.value;
+                        if (String(apiState.status) !== String(expectedStatus))
+                            throw new Error(`API Assertion Failed: Expected HTTP status ${expectedStatus}, but got ${apiState.status}`);
                     }
-                    else if (payload.type === "responsetime") {
-                        if (apiState.responseTime > parseInt(payload.threshold, 10))
-                            throw new Error(`API Assertion Failed: Expected response time to be less than ${payload.threshold}ms, but got ${apiState.responseTime}ms`);
+                    else if (expectType === "responseTime") {
+                        const threshold = payload.threshold || payload.value;
+                        if (apiState.responseTime > parseInt(threshold, 10))
+                            throw new Error(`API Assertion Failed: Expected response time to be less than ${threshold}ms, but got ${apiState.responseTime}ms`);
                     }
                     else {
                         let actualValue;
-                        if (payload.type === "resbody")
+                        if (expectType === "resBody")
                             actualValue = this.extractFromJsonPath(apiState.body, payload.jsonPath);
-                        else if (payload.type === "resheader")
-                            actualValue = apiState.headers?.[payload.jsonPath.toLowerCase()];
-                        else if (payload.type === "cookie") {
+                        else if (expectType === "resHeader")
+                            actualValue =
+                                apiState.headers?.[(payload.jsonPath || "").toLowerCase()];
+                        else if (expectType === "cookie") {
                             const cookies = apiState.headers?.["set-cookie"];
                             if (Array.isArray(cookies)) {
                                 const match = cookies.find((c) => c.startsWith(`${payload.jsonPath}=`));
@@ -865,7 +933,12 @@ class FlowWorker extends events_1.EventEmitter {
                                     actualValue = match.split("=")[1].split(";")[0];
                             }
                         }
-                        for (const assertion of payload.assertions) {
+                        const assertionsArray = Array.isArray(payload.assertions)
+                            ? payload.assertions
+                            : payload.condition
+                                ? [{ condition: payload.condition, value: payload.value }]
+                                : [];
+                        for (const assertion of assertionsArray) {
                             const condition = assertion.condition;
                             const rawExpected = assertion.value;
                             const expectedLower = String(rawExpected || "").toLowerCase();
@@ -1014,13 +1087,13 @@ class FlowWorker extends events_1.EventEmitter {
                         }
                     }
                 }
-                else if (payload.type === "visible")
+                else if (expectType === "visible")
                     await this.web.expectVisible(payload.selector, payload.elementType);
-                else if (payload.type === "text")
+                else if (expectType === "text")
                     await this.web.expectText(payload.selector, payload.fuzzy, payload.elementType);
-                else if (payload.type === "value")
+                else if (expectType === "value")
                     await this.web.expectValue(payload.selector, payload.text, payload.elementType);
-                else if (payload.type === "transcript")
+                else if (expectType === "transcript")
                     await this.web.expectTranscript(payload.text);
                 break;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowstride",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "An opensource flowfirst test automation framework",
   "workspaces": [
     "packages/flowstride_report"