flowstride 1.0.0

package/dist/parser/variable_resolver.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableResolver = void 0;
+class VariableResolver {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    resolve(input) {
+        if (typeof input === "string") {
+            return this.interpolateString(input);
+        }
+        if (typeof input === "object" && input !== null) {
+            const resolvedObj = Array.isArray(input) ? [] : {};
+            for (const key in input) {
+                resolvedObj[key] = this.resolve(input[key]);
+            }
+            return resolvedObj;
+        }
+        return input;
+    }
+    interpolateString(text) {
+        return text.replace(/\{\{(.+?)\}\}/g, (match, varName) => {
+            const value = this.store.get(varName.trim());
+            if (value === undefined) {
+                console.warn(`⚠️  Warning: Variable "{{${varName}}}" not found in store.`);
+                return match;
+            }
+            return String(value);
+        });
+    }
+}
+exports.VariableResolver = VariableResolver;

package/dist/runner/data_generators.d.ts

@@ -0,0 +1,55 @@
+export declare class DataGenerators {
+    private memoryBank;
+    private runIdContext;
+    private workerIdContext;
+    constructor(runId?: string, workerId?: string);
+    resolve(template: string): string;
+    private pickRandom;
+    uuid: () => `${string}-${string}-${string}-${string}-${string}`;
+    timestamp: () => string;
+    isoTimestamp: () => string;
+    randomIntStr: () => string;
+    randomNumber: () => string;
+    randomString: () => string;
+    randomAlpha: () => string;
+    randomAlphaNumeric: () => string;
+    randomFirstName: () => string;
+    randomLastName: () => string;
+    randomFullName: () => string;
+    randomUsername: () => string;
+    randomDisplayName: () => string;
+    randomJobTitle: () => string;
+    randomEmail: () => string;
+    randomDomain: () => string;
+    private generateLocalizedPhone;
+    randomPhone: () => string;
+    randomPhoneNG: () => string;
+    randomPassword: () => string;
+    randomOtp: () => string;
+    randomPin: () => string;
+    randomToken: () => string;
+    randomCountry: () => string;
+    randomState: () => string;
+    randomCity: () => string;
+    randomStreet: () => string;
+    randomAddress: () => string;
+    randomZipCode: () => string;
+    private generatePair;
+    private retrievePair;
+    today: () => string;
+    tomorrow: () => string;
+    yesterday: () => string;
+    currentYear: () => string;
+    currentMonth: () => string;
+    randomCompany: () => string;
+    randomCurrency: () => string;
+    randomAmount: () => string;
+    randomTransactionId: () => string;
+    maliciousString: () => string;
+    invalidEmail: () => string;
+    overflowString: () => string;
+    specialChars: () => string;
+    runId: () => string;
+    workerId: () => string;
+    getMap(): Record<string, () => string>;
+}

package/dist/runner/data_generators.js

@@ -0,0 +1,233 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGenerators = void 0;
+const node_crypto_1 = require("node:crypto");
+const identities_json_1 = __importDefault(require("../test_data/identities.json"));
+const geography_json_1 = __importDefault(require("../test_data/geography.json"));
+const commerce_json_1 = __importDefault(require("../test_data/commerce.json"));
+const utility_json_1 = __importDefault(require("../test_data/utility.json"));
+const phone_data_json_1 = __importDefault(require("../test_data/phone_data.json"));
+class DataGenerators {
+    memoryBank;
+    runIdContext;
+    workerIdContext;
+    constructor(runId = `RUN-${(0, node_crypto_1.randomBytes)(3).toString("hex")}`, workerId = "worker-1") {
+        this.memoryBank = new Map();
+        this.runIdContext = runId;
+        this.workerIdContext = workerId;
+    }
+    resolve(template) {
+        if (!template || typeof template !== "string")
+            return template;
+        let resolvedString = template;
+        const emailOverrideRegex = /([$@])randomEmail@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/g;
+        resolvedString = resolvedString.replace(emailOverrideRegex, (match, mode, customDomain) => {
+            if (mode === "$") {
+                const freshEmail = this.randomEmail();
+                this.memoryBank.set("randomEmail", freshEmail);
+                const prefix = freshEmail.split("@")[0];
+                return `${prefix}@${customDomain}`;
+            }
+            else {
+                if (!this.memoryBank.has("randomEmail")) {
+                    throw new Error(`Framework Error: You tried to retrieve @randomEmail@${customDomain}, but no email was previously generated in this test.`);
+                }
+                const lockedEmail = this.memoryBank.get("randomEmail");
+                const prefix = lockedEmail.split("@")[0];
+                return `${prefix}@${customDomain}`;
+            }
+        });
+        const map = this.getMap();
+        const variableRegex = /([$@])([a-zA-Z0-9_]+(?:\[[a-zA-Z]+\])?)/g;
+        resolvedString = resolvedString.replace(variableRegex, (match, mode, varName) => {
+            if (varName.startsWith("randomPair[")) {
+                const typeMatch = varName.match(/\[([a-zA-Z]+)\]/);
+                const type = typeMatch ? typeMatch[1] : null;
+                if (!type)
+                    return match;
+                if (mode === "$") {
+                    return this.generatePair(type);
+                }
+                else {
+                    return this.retrievePair(type, varName);
+                }
+            }
+            const generator = map[varName];
+            if (generator) {
+                if (mode === "$") {
+                    const freshValue = generator();
+                    this.memoryBank.set(varName, freshValue);
+                    return freshValue;
+                }
+                else {
+                    if (!this.memoryBank.has(varName)) {
+                        throw new Error(`Framework Error: You tried to retrieve @${varName}, but no value was previously generated for it in this test.`);
+                    }
+                    return this.memoryBank.get(varName);
+                }
+            }
+            return match;
+        });
+        return resolvedString;
+    }
+    pickRandom(array) {
+        if (!array || array.length === 0)
+            return "";
+        return array[(0, node_crypto_1.randomInt)(0, array.length)];
+    }
+    uuid = () => (0, node_crypto_1.randomUUID)();
+    timestamp = () => Math.floor(Date.now() / 1000).toString();
+    isoTimestamp = () => new Date().toISOString();
+    randomIntStr = () => (0, node_crypto_1.randomInt)(1000, 99999).toString();
+    randomNumber = () => Math.floor(Math.random() * 1000000).toString();
+    randomString = () => (0, node_crypto_1.randomBytes)(4).toString("hex");
+    randomAlpha = () => Math.random()
+        .toString(36)
+        .replace(/[^a-z]+/g, "")
+        .substring(0, 6);
+    randomAlphaNumeric = () => Math.random().toString(36).substring(2, 10);
+    randomFirstName = () => this.pickRandom(identities_json_1.default.firstNames);
+    randomLastName = () => this.pickRandom(identities_json_1.default.lastNames);
+    randomFullName = () => `${this.randomFirstName()} ${this.randomLastName()}`;
+    randomUsername = () => `${this.randomFirstName().toLowerCase()}_flow_${this.randomIntStr()}`;
+    randomDisplayName = () => `${this.randomFirstName()} ${this.randomLastName().charAt(0)}.`;
+    randomJobTitle = () => this.pickRandom(identities_json_1.default.jobTitles);
+    randomEmail = () => {
+        const defaultDomain = identities_json_1.default.emailDomains[0];
+        return `flow_${this.randomIntStr()}@${defaultDomain}`;
+    };
+    randomDomain = () => identities_json_1.default.emailDomains[0];
+    generateLocalizedPhone(prefix, length) {
+        const firstDigit = (0, node_crypto_1.randomInt)(1, 9).toString();
+        let remainingDigits = "";
+        for (let i = 1; i < length; i++) {
+            remainingDigits += (0, node_crypto_1.randomInt)(0, 9).toString();
+        }
+        return `${prefix}${firstDigit}${remainingDigits}`;
+    }
+    randomPhone = () => {
+        const countryObj = this.pickRandom(geography_json_1.default.locations);
+        const isoCode = countryObj.iso;
+        const rules = phone_data_json_1.default[isoCode];
+        if (!rules)
+            return `+1${this.generateLocalizedPhone("", 10)}`;
+        return this.generateLocalizedPhone(rules.prefix, rules.length);
+    };
+    randomPhoneNG = () => `0${(0, node_crypto_1.randomInt)(7000000000, 9099999999)}`;
+    randomPassword = () => `P@ss${this.randomAlphaNumeric()}!`;
+    randomOtp = () => (0, node_crypto_1.randomInt)(100000, 999999).toString();
+    randomPin = () => (0, node_crypto_1.randomInt)(1000, 9999).toString();
+    randomToken = () => (0, node_crypto_1.randomBytes)(32).toString("base64").substring(0, 24);
+    randomCountry = () => {
+        const countryObj = this.pickRandom(geography_json_1.default.locations);
+        return countryObj.country;
+    };
+    randomState = () => {
+        const countryObj = this.pickRandom(geography_json_1.default.locations);
+        const stateObj = this.pickRandom(countryObj.states);
+        return stateObj.name;
+    };
+    randomCity = () => {
+        const countryObj = this.pickRandom(geography_json_1.default.locations);
+        const stateObj = this.pickRandom(countryObj.states);
+        return this.pickRandom(stateObj.cities);
+    };
+    randomStreet = () => `${(0, node_crypto_1.randomInt)(1, 99)} Admiralty Way`;
+    randomAddress = () => `${this.randomStreet()}, ${this.randomCity()}`;
+    randomZipCode = () => (0, node_crypto_1.randomInt)(10000, 99999).toString();
+    generatePair(type) {
+        const countryObj = this.pickRandom(geography_json_1.default.locations);
+        const stateObj = this.pickRandom(countryObj.states);
+        const city = this.pickRandom(stateObj.cities);
+        const triplet = {
+            Country: countryObj.country,
+            State: stateObj.name,
+            City: city,
+        };
+        this.memoryBank.set("lockedLocationPair", JSON.stringify(triplet));
+        return triplet[type] || "";
+    }
+    retrievePair(type, originalMatch) {
+        if (!this.memoryBank.has("lockedLocationPair")) {
+            throw new Error(`Framework Error: You tried to retrieve @${originalMatch}, but no location pair was previously generated in this test.`);
+        }
+        const lockedData = JSON.parse(this.memoryBank.get("lockedLocationPair"));
+        return lockedData[type] || "";
+    }
+    today = () => new Date().toISOString().split("T")[0];
+    tomorrow = () => {
+        const d = new Date();
+        d.setDate(d.getDate() + 1);
+        return d.toISOString().split("T")[0];
+    };
+    yesterday = () => {
+        const d = new Date();
+        d.setDate(d.getDate() - 1);
+        return d.toISOString().split("T")[0];
+    };
+    currentYear = () => new Date().getFullYear().toString();
+    currentMonth = () => (new Date().getMonth() + 1).toString().padStart(2, "0");
+    randomCompany = () => this.pickRandom(commerce_json_1.default.companies);
+    randomCurrency = () => this.pickRandom(commerce_json_1.default.currencies);
+    randomAmount = () => {
+        return (Math.random() * 10000).toFixed(2);
+    };
+    randomTransactionId = () => `TXN-${this.randomAlphaNumeric().toUpperCase()}`;
+    maliciousString = () => this.pickRandom(utility_json_1.default.maliciousStrings);
+    invalidEmail = () => this.pickRandom(utility_json_1.default.invalidEmails);
+    overflowString = () => this.pickRandom(utility_json_1.default.overflowStrings);
+    specialChars = () => this.pickRandom(utility_json_1.default.specialChars);
+    runId = () => this.runIdContext;
+    workerId = () => this.workerIdContext;
+    getMap() {
+        return {
+            uuid: this.uuid.bind(this),
+            timestamp: this.timestamp.bind(this),
+            isoTimestamp: this.isoTimestamp.bind(this),
+            randomInt: this.randomIntStr.bind(this),
+            randomNumber: this.randomNumber.bind(this),
+            randomString: this.randomString.bind(this),
+            randomAlpha: this.randomAlpha.bind(this),
+            randomAlphaNumeric: this.randomAlphaNumeric.bind(this),
+            randomFirstName: this.randomFirstName.bind(this),
+            randomLastName: this.randomLastName.bind(this),
+            randomFullName: this.randomFullName.bind(this),
+            randomUsername: this.randomUsername.bind(this),
+            randomDisplayName: this.randomDisplayName.bind(this),
+            randomJobTitle: this.randomJobTitle.bind(this),
+            randomEmail: this.randomEmail.bind(this),
+            randomPhone: this.randomPhone.bind(this),
+            randomPhoneNG: this.randomPhoneNG.bind(this),
+            randomDomain: this.randomDomain.bind(this),
+            randomPassword: this.randomPassword.bind(this),
+            randomOtp: this.randomOtp.bind(this),
+            randomPin: this.randomPin.bind(this),
+            randomToken: this.randomToken.bind(this),
+            randomCountry: this.randomCountry.bind(this),
+            randomState: this.randomState.bind(this),
+            randomCity: this.randomCity.bind(this),
+            randomStreet: this.randomStreet.bind(this),
+            randomAddress: this.randomAddress.bind(this),
+            randomZipCode: this.randomZipCode.bind(this),
+            today: this.today.bind(this),
+            tomorrow: this.tomorrow.bind(this),
+            yesterday: this.yesterday.bind(this),
+            currentYear: this.currentYear.bind(this),
+            currentMonth: this.currentMonth.bind(this),
+            randomCompany: this.randomCompany.bind(this),
+            randomAmount: this.randomAmount.bind(this),
+            randomCurrency: this.randomCurrency.bind(this),
+            randomTransactionId: this.randomTransactionId.bind(this),
+            maliciousString: this.maliciousString.bind(this),
+            invalidEmail: this.invalidEmail.bind(this),
+            overflowString: this.overflowString.bind(this),
+            specialChars: this.specialChars.bind(this),
+            runId: this.runId.bind(this),
+            workerId: this.workerId.bind(this),
+        };
+    }
+}
+exports.DataGenerators = DataGenerators;

package/dist/runner/dom_stripper.d.ts

@@ -0,0 +1,4 @@
+import { Page } from "playwright";
+export declare class DOMStripper {
+    static getStrippedHTML(page: Page): Promise<string>;
+}

package/dist/runner/dom_stripper.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMStripper = void 0;
+class DOMStripper {
+    static async getStrippedHTML(page) {
+        try {
+            const strippedHtml = await page.evaluate(() => {
+                const clone = document.documentElement.cloneNode(true);
+                const junkTags = [
+                    "script",
+                    "style",
+                    "svg",
+                    "path",
+                    "noscript",
+                    "meta",
+                    "link",
+                    "iframe",
+                    "canvas",
+                    "video",
+                    "audio",
+                    "picture",
+                ];
+                junkTags.forEach((tag) => {
+                    const elements = clone.querySelectorAll(tag);
+                    elements.forEach((el) => el.remove());
+                });
+                const hiddenElements = clone.querySelectorAll('[hidden], [aria-hidden="true"], [style*="display: none"], [style*="visibility: hidden"]');
+                hiddenElements.forEach((el) => el.remove());
+                const removeComments = (node) => {
+                    for (let i = node.childNodes.length - 1; i >= 0; i--) {
+                        const child = node.childNodes[i];
+                        if (child.nodeType === Node.COMMENT_NODE) {
+                            child.remove();
+                        }
+                        else if (child.nodeType === Node.ELEMENT_NODE) {
+                            removeComments(child);
+                        }
+                    }
+                };
+                removeComments(clone);
+                const allElements = clone.querySelectorAll("*");
+                allElements.forEach((el) => {
+                    if (el.tagName.toLowerCase() === "img") {
+                        el.removeAttribute("src");
+                    }
+                });
+                let rawHtml = clone.outerHTML;
+                rawHtml = rawHtml.replace(/[\n\r\t]+/g, " ");
+                rawHtml = rawHtml.replace(/\s{2,}/g, " ");
+                rawHtml = rawHtml.replace(/>\s+</g, "><");
+                return rawHtml.trim();
+            });
+            return strippedHtml;
+        }
+        catch (error) {
+            console.warn("[DOM Stripper] Failed to extract minified DOM:", error);
+            return "<html><body>[Error: Could not extract DOM state]</body></html>";
+        }
+    }
+}
+exports.DOMStripper = DOMStripper;

package/dist/runner/events.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from "events";
+export declare enum FlowstrideEvents {
+    RUN_START = "run:start",
+    RUN_END = "run:end",
+    FILE_START = "file:start",
+    FILE_END = "file:end",
+    SCENARIO_START = "scenario:start",
+    SCENARIO_END = "scenario:end",
+    STEP_START = "step:start",
+    STEP_PASS = "step:pass",
+    STEP_FAIL = "step:fail",
+    STEP_NOT_TESTED = "step:not_tested"
+}
+export declare class FlowstrideEmitter extends EventEmitter {
+}

package/dist/runner/events.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowstrideEmitter = exports.FlowstrideEvents = void 0;
+const events_1 = require("events");
+var FlowstrideEvents;
+(function (FlowstrideEvents) {
+    FlowstrideEvents["RUN_START"] = "run:start";
+    FlowstrideEvents["RUN_END"] = "run:end";
+    FlowstrideEvents["FILE_START"] = "file:start";
+    FlowstrideEvents["FILE_END"] = "file:end";
+    FlowstrideEvents["SCENARIO_START"] = "scenario:start";
+    FlowstrideEvents["SCENARIO_END"] = "scenario:end";
+    FlowstrideEvents["STEP_START"] = "step:start";
+    FlowstrideEvents["STEP_PASS"] = "step:pass";
+    FlowstrideEvents["STEP_FAIL"] = "step:fail";
+    FlowstrideEvents["STEP_NOT_TESTED"] = "step:not_tested";
+})(FlowstrideEvents || (exports.FlowstrideEvents = FlowstrideEvents = {}));
+class FlowstrideEmitter extends events_1.EventEmitter {
+}
+exports.FlowstrideEmitter = FlowstrideEmitter;

package/dist/runner/flow_orchestrator.d.ts

@@ -0,0 +1,15 @@
+import { FlowWorker } from "./flow_worker";
+import { FlowstrideConfig } from "../types";
+export declare class FlowOrchestrator {
+    private worker;
+    private workerCount;
+    private config?;
+    private wss;
+    private httpServer;
+    private globalTestScenarios;
+    private stepStatusRegistry;
+    constructor(worker: FlowWorker, workerCount?: number, config?: FlowstrideConfig | undefined);
+    private forwardToDashboard;
+    private executeTestRun;
+    start(targetPath: string): Promise<void>;
+}

package/dist/runner/flow_orchestrator.js

@@ -0,0 +1,216 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowOrchestrator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const http = __importStar(require("http"));
+const chalk_1 = __importDefault(require("chalk"));
+const ws_1 = require("ws");
+class FlowOrchestrator {
+    worker;
+    workerCount;
+    config;
+    wss = null;
+    httpServer = null;
+    globalTestScenarios = [];
+    stepStatusRegistry = new Map();
+    constructor(worker, workerCount = 1, config) {
+        this.worker = worker;
+        this.workerCount = workerCount;
+        this.config = config;
+        this.worker.on("worker_event", (data) => {
+            this.forwardToDashboard(data.type, data.payload);
+        });
+    }
+    forwardToDashboard(type, payload) {
+        if (this.wss) {
+            this.wss.clients.forEach((client) => {
+                if (client.readyState === 1)
+                    client.send(JSON.stringify({ type, payload }));
+            });
+        }
+    }
+    async executeTestRun(targetPath) {
+        this.forwardToDashboard("SUITE_START", {});
+        let filesToProcess = [];
+        const stats = fs.statSync(targetPath);
+        if (stats.isDirectory()) {
+            filesToProcess = fs
+                .readdirSync(targetPath)
+                .filter((f) => f.endsWith(".flow"))
+                .map((f) => path.join(targetPath, f));
+        }
+        else {
+            filesToProcess = [targetPath];
+        }
+        this.globalTestScenarios = [];
+        this.stepStatusRegistry.clear();
+        if (this.workerCount > 1) {
+            console.log(chalk_1.default.magenta(`\n[Notice]: You requested ${this.workerCount} parallel workers, but distributed parallel execution is a Flowstride Enterprise feature.`));
+            console.log(chalk_1.default.magenta(`[Notice]: Visit flowstride.io to upgrade. Falling back to sequential execution...\n`));
+        }
+        console.log(chalk_1.default.gray(`\n[Orchestrator]: Executing in standard sequential mode...`));
+        const listener = (data) => {
+            if (data.type === "STEP_UPDATE") {
+                if (data.payload && data.payload.id && data.payload.fileName) {
+                    const compositeKey = `${data.payload.fileName}_${data.payload.id}`;
+                    this.stepStatusRegistry.set(compositeKey, data.payload.status);
+                }
+                this.globalTestScenarios.push(data.payload);
+            }
+        };
+        this.worker.on("worker_event", listener);
+        await this.worker.runBatch(filesToProcess);
+        this.worker.off("worker_event", listener);
+        this.forwardToDashboard("RUN_COMPLETE", { status: "success" });
+    }
+    async start(targetPath) {
+        try {
+            this.httpServer = http.createServer((req, res) => {
+                res.setHeader("Access-Control-Allow-Origin", "http://localhost:5173");
+                if (req.url && req.url.startsWith("/videos/")) {
+                    let urlObj;
+                    try {
+                        urlObj = new URL(req.url, `http://${req.headers.host}`);
+                    }
+                    catch (err) {
+                        res.writeHead(400);
+                        return res.end("Bad Request");
+                    }
+                    const rawVideoName = decodeURIComponent(urlObj.pathname.replace("/videos/", ""));
+                    const videoName = path.basename(rawVideoName);
+                    if (!videoName || videoName === "/" || videoName === ".") {
+                        res.writeHead(400);
+                        return res.end("Invalid video requested");
+                    }
+                    const videoPath = path.join(process.cwd(), ".flowstride", "mock-cloud", videoName);
+                    if (fs.existsSync(videoPath)) {
+                        const stat = fs.statSync(videoPath);
+                        const fileSize = stat.size;
+                        if (fileSize === 0) {
+                            res.writeHead(200, {
+                                "Content-Length": 0,
+                                "Content-Type": "video/webm",
+                            });
+                            return res.end();
+                        }
+                        const range = req.headers.range;
+                        if (range) {
+                            const parts = range.replace(/bytes=/, "").split("-");
+                            const start = parseInt(parts[0], 10);
+                            const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
+                            const chunksize = end - start + 1;
+                            const file = fs.createReadStream(videoPath, { start, end });
+                            const head = {
+                                "Content-Range": `bytes ${start}-${end}/${fileSize}`,
+                                "Accept-Ranges": "bytes",
+                                "Content-Length": chunksize,
+                                "Content-Type": "video/webm",
+                            };
+                            res.writeHead(206, head);
+                            file.pipe(res);
+                        }
+                        else {
+                            const head = {
+                                "Content-Length": fileSize,
+                                "Content-Type": "video/webm",
+                            };
+                            res.writeHead(200, head);
+                            fs.createReadStream(videoPath).pipe(res);
+                        }
+                    }
+                    else {
+                        res.writeHead(404);
+                        res.end("Video not found");
+                    }
+                }
+                else {
+                    res.writeHead(404);
+                    res.end();
+                }
+            });
+            this.httpServer.on("error", (e) => {
+                if (e.code === "EADDRINUSE") {
+                    console.error(chalk_1.default.red(`\n[Error]: Port 4321 is in use. Close the other terminal.`));
+                    process.exit(1);
+                }
+            });
+            this.wss = new ws_1.WebSocketServer({ server: this.httpServer });
+            this.wss.on("connection", (ws) => {
+                ws.on("message", async (message) => {
+                    const data = JSON.parse(message.toString());
+                    if (data.type === "EXPORT_PDF_REQ") {
+                        console.log(chalk_1.default.magenta(`\n[Notice]: Exporting high-fidelity PDF reports is a Flowstride Enterprise feature.`));
+                        console.log(chalk_1.default.magenta(`[Notice]: Visit flowstride.io to upgrade and unlock advanced reporting.\n`));
+                    }
+                    else if (data.type === "REPLAY_REQ") {
+                        await this.worker.handleReplayRequest(data.payload);
+                    }
+                    else if (data.type === "RERUN_REQ") {
+                        await this.executeTestRun(targetPath);
+                    }
+                    else if (data.type === "STOP_REQ") {
+                        console.log(chalk_1.default.yellow("\nReceived STOP signal from Dashboard. Halting execution..."));
+                        this.worker.abort();
+                        await this.worker.shutdown();
+                        this.forwardToDashboard("RUN_COMPLETE", { status: "aborted" });
+                    }
+                });
+            });
+            this.httpServer.listen(4321, async () => {
+                const { default: open } = await import("open");
+                await open("http://localhost:5173");
+                console.log(chalk_1.default.yellow("[Dashboard]: Waiting for connection..."));
+                while (this.wss.clients.size === 0)
+                    await new Promise((r) => setTimeout(r, 250));
+                console.log(chalk_1.default.green("[Dashboard]: Connected!"));
+                await this.executeTestRun(targetPath);
+            });
+            process.on("SIGINT", () => {
+                this.wss?.close();
+                this.httpServer?.close();
+                process.exit();
+            });
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+}
+exports.FlowOrchestrator = FlowOrchestrator;