flowstride 1.0.20 → 1.0.22

package/dist/runner/flow_worker.js

@@ -37,7 +37,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowWorker = void 0;
-const deadline_1 = require("../ci/deadline");
+const runtime_failure_1 = require("../reporting/runtime_failure");
+const assertion_result_1 = require("../reporting/assertion_result");
+const assertion_contract_1 = require("../parser/assertion_contract");
+const deadline_1 = require("../native/deadline");
+const runtime_1 = require("../native/runtime");
+const deadline_2 = require("../ci/deadline");
 const replayRequest_1 = require("../utils/replayRequest");
 const projectPaths_1 = require("../utils/projectPaths");
 const redaction_1 = require("../security/redaction");
@@ -57,10 +62,20 @@ class FlowWorker extends events_1.EventEmitter {
     store;
     sessions;
     pluginManager;
+    static nativeBrowserProtocol = 2;
+    static nativeAssertionProtocol = 1;
     isSilent = process.env.FLOWSTRIDE_PARALLEL === "true";
     isAborted = false;
     bailTriggered = false;
     isDebugHalted = false;
+    native;
+    currentAssertion;
+    commandSecretValues = [];
+    batchPassed = true;
+    attempt = 1;
+    maxAttempts = 1;
+    fallbackStream;
+    interceptedContexts = new WeakSet();
     currentStepContext = "Initializing...";
     currentFileName = "System";
     activeAudioPath = undefined;
@@ -79,10 +94,26 @@ class FlowWorker extends events_1.EventEmitter {
         this.store = store;
         this.sessions = sessions;
         this.pluginManager = pluginManager;
+        this.native = new runtime_1.NativeRuntime(web, config);
+        this.web.onPageChanged = async () => { await this.startStreaming(); await this.setupNetworkInterception(); };
     }
     broadcast(type, payload) {
-        const secrets = [this.config.machineToken || '', ...(this.dataGen?.sensitiveValues?.() || []), ...Object.entries(process.env).filter(([key]) => /password|token|secret|api.?key/i.test(key)).map(([, value]) => String(value)), ...Object.entries(this.localVariables).filter(([key]) => /password|passcode|token|secret|otp|api.?key/i.test(key)).map(([, value]) => String(value))];
-        this.emit('worker_event', { type, payload: (0, redaction_1.redactWorkerPayload)(type, payload, secrets, this.config.ci === false) });
+        if (["STEP_ADD", "STEP_UPDATE", "LOG_EVENT"].includes(type))
+            payload = { ...payload, attempt: this.attempt, profile: this.web.activeProfile || "default" };
+        this.emit('worker_event', { type, payload: (0, redaction_1.redactWorkerPayload)(type, payload, this.secretValues(), this.config.ci === false) });
+    }
+    secretValues() {
+        return [...this.commandSecretValues, this.config.machineToken || '', ...(this.dataGen?.sensitiveValues?.() || []), ...Object.entries(process.env).filter(([key]) => /password|token|secret|api.?key/i.test(key)).map(([, value]) => String(value)), ...Object.entries(this.localVariables).filter(([key]) => /password|passcode|token|secret|otp|api.?key/i.test(key)).map(([, value]) => String(value))];
+    }
+    assertionForStep(step) {
+        if (!this.currentAssertion)
+            return;
+        const value = { ...this.currentAssertion, sourceFile: this.currentFileName, sourceLine: step.line, profile: this.web.activeProfile || 'default' };
+        return (0, redaction_1.redactWorkerPayload)('STEP_UPDATE', { assertion: value }, this.secretValues()).assertion;
+    }
+    printAssertion(value) {
+        if (!this.isSilent && value)
+            console.log((0, assertion_result_1.assertionText)(value).split('\n').map(line => '        ' + line).join('\n'));
     }
     emitLog(type, status, summary, details, customId, overrideFileName) {
         const id = customId || Math.random().toString(36).substr(2, 9);
@@ -99,24 +130,16 @@ class FlowWorker extends events_1.EventEmitter {
         return id;
     }
     translateError(error, action, payload) {
-        const msg = error.message || String(error);
-        if (msg.includes("API Assertion Failed") ||
-            msg.includes("Network Execution Error") ||
-            msg.includes("Extraction Failed") ||
-            msg.includes("Plugin Execution Failed") ||
-            msg.includes("Scoping Error"))
-            return msg;
-        const target = payload.selector || payload.text || payload.url || "the element";
-        if (msg.includes("Timeout"))
-            return `I waited for "${target}" to appear, but it never did.`;
-        if (msg.includes("intercepted"))
-            return `I found "${target}", but another element is blocking it.`;
-        if (msg.includes("Framework rejected"))
-            return msg;
-        return `An error occurred while trying to ${action}: ${msg.split("\n")[0]}`;
+        return (0, runtime_failure_1.runtimeFailure)(action, payload, error, { file: this.currentFileName, profile: this.web.activeProfile || 'default', timeout: this.config.timeout });
     }
     async captureStepContext(payload) {
-        const page = this.web.getPage();
+        let page;
+        try {
+            page = this.web.getPage();
+        }
+        catch {
+            return {};
+        }
         const context = {};
         try {
             const buffer = await page.screenshot({ type: "jpeg", quality: 50 });
@@ -339,6 +362,7 @@ class FlowWorker extends events_1.EventEmitter {
         this.isAborted = true;
     }
     async runBatch(filesToProcess) {
+        this.batchPassed = filesToProcess.length > 0;
         const isCliHeadless = process.argv.includes("--headless");
         if (isCliHeadless) {
             this.config.headless = true;
@@ -365,7 +389,7 @@ class FlowWorker extends events_1.EventEmitter {
             }
             catch (e) { }
             if (!this.config.ci)
-                process.exit(0);
+                process.exit(this.isAborted ? 130 : process.exitCode || 0);
         };
         process.once("SIGINT", sigintHandler);
         try {
@@ -394,7 +418,13 @@ class FlowWorker extends events_1.EventEmitter {
                     this.localBrowserSessions = {};
                     this.api.resetState();
                     this.dataGen = new data_generators_1.DataGenerators();
+                    await this.native.dispose();
                     await this.web.initialise(this.activeAudioPath);
+                    if (typeof this.web.getBrowserInfo === 'function') {
+                        const browser = this.web.getBrowserInfo();
+                        console.log(`[Browser]: ${browser.engine} ${browser.version}; ${browser.headless ? 'headless' : 'headed'}; ${fileName}`);
+                        this.broadcast('BROWSER_INFO', { ...browser, fileName });
+                    }
                     await this.startStreaming();
                     await this.setupNetworkInterception();
                     const content = fs.readFileSync(filePath, "utf8");
@@ -453,7 +483,8 @@ class FlowWorker extends events_1.EventEmitter {
                                 scenarioName: s.name,
                                 fileName: this.currentFileName,
                             });
-                            await this.runScenario(s, f.declarations);
+                            if (!await this.runScenarioWithRetries(s, f.declarations))
+                                this.batchPassed = false;
                             if (this.isDebugHalted || this.bailTriggered)
                                 break;
                             await this.web
@@ -482,6 +513,7 @@ class FlowWorker extends events_1.EventEmitter {
                         const targetVideoPath = path.join(mockCloudDir, `${baseName}.webm`);
                         for (const message of this.web.pageErrors || [])
                             this.broadcast('BROWSER_ERROR', { message, fileName: this.currentFileName });
+                        await this.native.dispose();
                         await this.web.shutdown(targetVideoPath);
                         if (!this.isSilent)
                             console.log(chalk_1.default.gray(`      [Cloud Sync]: Video safely encoded and preserved for ${this.currentFileName}`));
@@ -493,10 +525,11 @@ class FlowWorker extends events_1.EventEmitter {
                     });
                 }
                 catch (e) {
+                    this.batchPassed = false;
                     if (this.isAborted)
                         break;
                     if (!this.isSilent)
-                        console.error(chalk_1.default.red(`\n[Execution]: Failed processing ${this.currentFileName}: ${e.message}`));
+                        console.error(chalk_1.default.red(`\n[Execution]: Failed processing ${this.currentFileName}: ${(0, redaction_1.redactText)((0, runtime_failure_1.runtimeFailure)("file.setup", { file: this.currentFileName }, e, { file: this.currentFileName }), this.secretValues())}`));
                     try {
                         const baseName = (0, projectPaths_1.videoFileName)(this.currentFileName).replace(/\.webm$/, '');
                         const mockCloudDir = path.join(process.cwd(), ".flowstride", "mock-cloud");
@@ -505,6 +538,7 @@ class FlowWorker extends events_1.EventEmitter {
                         const targetVideoPath = path.join(mockCloudDir, `${baseName}.webm`);
                         for (const message of this.web.pageErrors || [])
                             this.broadcast('BROWSER_ERROR', { message, fileName: this.currentFileName });
+                        await this.native.dispose();
                         await this.web.shutdown(targetVideoPath);
                         if (!this.isSilent)
                             console.log(chalk_1.default.gray(`      [Cloud Sync]: Video safely encoded and preserved for ${this.currentFileName}`));
@@ -513,7 +547,7 @@ class FlowWorker extends events_1.EventEmitter {
                     this.broadcast("FILE_FAILED", {
                         fileName: this.currentFileName,
                         duration: Date.now() - fileStartTime,
-                        error: e.message,
+                        error: (0, runtime_failure_1.runtimeFailure)("file.setup", { file: this.currentFileName }, e, { file: this.currentFileName }),
                     });
                 }
             }
@@ -522,7 +556,7 @@ class FlowWorker extends events_1.EventEmitter {
                     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."));
+                    console.log(this.batchPassed ? chalk_1.default.green("\n[Execution]: All suites completed successfully.") : chalk_1.default.red("\n[Execution]: Test suite failed. Review the diagnostics above."));
                 }
             }
         }
@@ -531,6 +565,7 @@ class FlowWorker extends events_1.EventEmitter {
                 try {
                     const directory = path.join(process.cwd(), '.flowstride', 'artifacts');
                     fs.mkdirSync(directory, { recursive: true });
+                    await this.native.dispose();
                     await this.web.shutdown(path.join(directory, (0, projectPaths_1.videoFileName)(this.currentFileName)));
                 }
                 catch (error) {
@@ -539,25 +574,90 @@ class FlowWorker extends events_1.EventEmitter {
             }
             process.removeListener("SIGINT", sigintHandler);
         }
+        return this.batchPassed && !this.isAborted && !this.isDebugHalted;
+    }
+    async runScenarioWithRetries(scenario, declarations) {
+        this.maxAttempts = (this.config.retries || 0) + 1;
+        const baseline = this.maxAttempts > 1 ? await this.web.checkpointProfiles() : undefined;
+        const variables = this.maxAttempts > 1 ? structuredClone(this.localVariables) : {}, sessions = this.maxAttempts > 1 ? structuredClone(this.localBrowserSessions) : {};
+        const globals = this.maxAttempts > 1 ? structuredClone(FlowWorker.globalVariables) : {}, globalSessions = this.maxAttempts > 1 ? structuredClone(FlowWorker.globalBrowserSessions) : {};
+        const storeState = this.maxAttempts > 1 ? structuredClone(this.store.getAll?.()) : undefined;
+        const apiState = this.maxAttempts > 1 ? this.api.checkpointState?.() : undefined;
+        let finalPassed = false;
+        for (this.attempt = 1; this.attempt <= this.maxAttempts; this.attempt++) {
+            if (this.isAborted || this.isDebugHalted)
+                break;
+            if (this.attempt > 1) {
+                await this.native.dispose();
+                if (apiState)
+                    this.api.restoreState(apiState);
+                else
+                    this.api.resetState();
+                this.localVariables = structuredClone(variables);
+                this.localBrowserSessions = structuredClone(sessions);
+                FlowWorker.globalVariables = structuredClone(globals);
+                FlowWorker.globalBrowserSessions = structuredClone(globalSessions);
+                if (storeState) {
+                    this.store.clear();
+                    for (const [key, value] of Object.entries(structuredClone(storeState)))
+                        this.store.set(key, value);
+                }
+                await this.web.restoreProfiles(baseline);
+            }
+            const started = Date.now();
+            this.broadcast('SCENARIO_ATTEMPT', { fileName: this.currentFileName, scenario: scenario.name, attempt: this.attempt });
+            const errorIndex = this.web.pageErrors?.length || 0;
+            const completed = await this.runScenario(structuredClone(scenario), declarations);
+            const browserErrors = this.web.pageErrors?.slice(errorIndex) || [];
+            const passed = completed && (this.config.browserErrors === 'record' || !browserErrors.length);
+            if (this.config.browserErrors !== 'record')
+                for (const message of browserErrors) {
+                    const error = (0, runtime_failure_1.runtimeFailure)('browser.pageError', {}, new Error(message), { file: this.currentFileName, profile: this.web.activeProfile || 'default' });
+                    this.emitLog('ERROR', 'error', error, { rawError: error, command: 'browser.pageError' }, undefined, this.currentFileName);
+                    if (!this.isSilent)
+                        console.error((0, redaction_1.redactText)(error, this.secretValues()));
+                }
+            this.broadcast('SCENARIO_RESULT', { fileName: this.currentFileName, scenario: scenario.name, attempt: this.attempt, status: this.isAborted ? 'interrupted' : passed ? 'passed' : 'failed', flaky: passed && this.attempt > 1, browserErrors, duration: Date.now() - started });
+            finalPassed = passed && !(this.config.failOnFlaky && this.attempt > 1);
+            if (passed || this.isAborted || this.isDebugHalted)
+                break;
+            if (this.attempt < this.maxAttempts)
+                this.web.pageErrors?.splice(errorIndex);
+        }
+        this.attempt = 1;
+        this.maxAttempts = 1;
+        return finalPassed;
     }
     async runScenario(scenario, globalDeclarations = []) {
         let hasScenarioFailed = false;
-        for (const step of scenario.steps) {
+        for (const originalStep of scenario.steps) {
+            const step = structuredClone(originalStep);
+            this.currentAssertion = undefined;
+            this.commandSecretValues = [];
             if (this.isAborted)
                 break;
             const blockName = step.blockDescription.split(" ")[0];
             let blockDesc = step.blockDescription.substring(blockName.length).trim();
-            blockDesc = this.resolveTextVariables(blockDesc);
-            if (this.dataGen)
-                blockDesc = this.dataGen.resolve(blockDesc);
-            step.payload = this.resolveTemplateData(step.payload);
-            this.currentStepContext = `${blockName} ${blockDesc}`;
-            const isOpt = step.payload?.optional;
+            const stepLabel = (0, assertion_result_1.commandLabel)(step.action, step.payload);
             if (hasScenarioFailed) {
-                this.broadcast('STEP_ADD', { id: step.id, type: blockName, description: blockDesc, command: step.action, status: 'not_tested', fileName: this.currentFileName });
-                this.broadcast('STEP_UPDATE', { id: step.id, status: 'not_tested', fileName: this.currentFileName });
+                const assertion = (0, assertion_result_1.unexecutedAssertion)(step.action, step.payload);
+                this.broadcast('STEP_ADD', { id: step.id, type: blockName, description: blockDesc, command: step.action, commandLabel: stepLabel, sourceLine: step.line, status: 'not_tested', fileName: this.currentFileName });
+                this.broadcast('STEP_UPDATE', { id: step.id, status: 'not_tested', assertion, error: null, commandLabel: stepLabel, sourceLine: step.line, fileName: this.currentFileName });
                 continue;
             }
+            let resolutionError;
+            try {
+                blockDesc = this.resolveTextVariables(blockDesc);
+                if (this.dataGen)
+                    blockDesc = this.dataGen.resolve(blockDesc);
+                step.payload = this.resolveTemplateData(step.payload);
+            }
+            catch (error) {
+                resolutionError = error;
+            }
+            this.commandSecretValues = (0, runtime_failure_1.commandSecrets)(step.action, step.payload);
+            this.currentStepContext = `${blockName} ${blockDesc}`;
+            const isOpt = step.payload?.optional;
             const mockSpinner = {
                 text: "",
                 start() {
@@ -584,6 +684,8 @@ class FlowWorker extends events_1.EventEmitter {
                 }).start();
             this.emitLog("ACTION", "info", `${blockName}: ${blockDesc}`, {
                 command: step.action,
+                commandLabel: stepLabel,
+                sourceLine: step.line,
                 payload: step.payload,
             }, undefined, this.currentFileName);
             this.broadcast("STEP_ADD", {
@@ -591,17 +693,29 @@ class FlowWorker extends events_1.EventEmitter {
                 type: blockName,
                 description: blockDesc,
                 command: step.action,
+                commandLabel: stepLabel,
+                sourceLine: step.line,
                 status: "running",
+                error: null, assertion: null,
                 fileName: this.currentFileName,
             });
+            const stepStarted = Date.now();
             try {
+                if (resolutionError)
+                    throw resolutionError;
                 await this.executeStep(step.action, step.payload, scenario.declarations, globalDeclarations);
                 const stepContext = await this.captureStepContext(step.payload);
+                const domSnapshot = await this.native.captureDOM(step.id).catch(() => undefined);
                 spinner.succeed();
+                const assertion = this.assertionForStep(step);
+                this.printAssertion(assertion);
                 this.broadcast("STEP_UPDATE", {
                     id: step.id,
                     status: "passed",
+                    error: null,
+                    assertion,
                     screenshot: stepContext.screenshot,
+                    domSnapshot,
                     fileName: this.currentFileName,
                 });
                 if (step.isStop) {
@@ -615,7 +729,9 @@ class FlowWorker extends events_1.EventEmitter {
             catch (e) {
                 if (this.isAborted)
                     break;
+                const assertion = this.assertionForStep(step);
                 const stepContext = await this.captureStepContext(step.payload);
+                const domSnapshot = await this.native.captureDOM(step.id).catch(() => undefined);
                 let strippedDom = "";
                 try {
                     const page = this.web.getPage();
@@ -630,13 +746,16 @@ class FlowWorker extends events_1.EventEmitter {
                 if (isOpt) {
                     spinner.warn(chalk_1.default.yellow(`[Skipped]: ${blockDesc}`));
                     this.emitLog("ACTION", "info", `Skipped Optional Step: ${blockDesc}`, {
-                        reason: "Element not present after full timeout.",
+                        reason: (0, runtime_failure_1.runtimeFailure)(stepLabel, step.payload, e, { file: this.currentFileName, line: step.line }),
                         strippedDom,
                     }, undefined, this.currentFileName);
                     this.broadcast("STEP_UPDATE", {
                         id: step.id,
                         status: "skipped",
+                        error: (0, runtime_failure_1.runtimeFailure)(stepLabel, step.payload, e, { file: this.currentFileName, line: step.line }),
+                        assertion,
                         screenshot: stepContext.screenshot,
+                        domSnapshot,
                         fileName: this.currentFileName,
                     });
                     continue;
@@ -672,10 +791,17 @@ class FlowWorker extends events_1.EventEmitter {
                 else {
                     spinner.fail();
                 }
-                const humanReadableError = this.translateError(e, step.action, step.payload);
+                const humanReadableError = assertion ? (0, assertion_result_1.assertionText)(assertion) : (0, runtime_failure_1.runtimeFailure)(stepLabel, step.payload, e, { file: this.currentFileName, line: step.line, profile: this.web.activeProfile || "default", timeout: this.config.timeout, elapsed: Date.now() - stepStarted });
+                this.printAssertion(assertion);
+                if (!this.isSilent && !assertion)
+                    console.error('      ' + (0, redaction_1.redactText)(String(humanReadableError), this.secretValues()).replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ''));
                 this.emitLog("ERROR", "error", humanReadableError, {
-                    rawError: e.message,
+                    rawError: humanReadableError,
+                    stepId: step.id,
+                    assertion,
                     command: step.action,
+                    commandLabel: stepLabel,
+                    sourceLine: step.line,
                     screenshot: stepContext.screenshot,
                     boundingBox: stepContext.boundingBox,
                     strippedDom,
@@ -683,16 +809,20 @@ class FlowWorker extends events_1.EventEmitter {
                 this.broadcast("STEP_UPDATE", {
                     id: step.id,
                     status: "failed",
+                    error: humanReadableError,
+                    assertion,
                     screenshot: stepContext.screenshot,
+                    domSnapshot,
                     fileName: this.currentFileName,
                 });
                 hasScenarioFailed = true;
-                if (this.config.bail && !this.bailTriggered) {
+                if (this.config.bail && this.attempt >= this.maxAttempts && !this.bailTriggered) {
                     this.bailTriggered = true;
                     this.broadcast('BAIL', { fileName: this.currentFileName, id: step.id });
                 }
             }
         }
+        return !hasScenarioFailed;
     }
     async waitForPipeline() {
         if (!this.activeAudioPath || !fs.existsSync(this.activeAudioPath)) {
@@ -738,7 +868,29 @@ class FlowWorker extends events_1.EventEmitter {
                 '[id*="burger" i]',
             ].join(", ");
         }
+        if (action === 'expect')
+            (0, assertion_contract_1.validateExpectationType)(payload?.type);
         switch (action) {
+            case 'native': {
+                const timeout = (0, deadline_1.nativeStepTimeout)(payload.pluginMethod, payload.data, this.config.timeout);
+                let result;
+                try {
+                    result = await (0, deadline_2.withDeadline)(this.native.execute(payload.pluginMethod, payload.data), timeout);
+                    this.currentAssertion = this.native.lastAssertion;
+                }
+                catch (error) {
+                    const fallback = (0, assertion_result_1.unexecutedAssertion)('native', payload, 'The assertion could not execute.');
+                    if (fallback) {
+                        fallback.status = 'failed';
+                        fallback.checks.push({ key: 'execution', label: 'Assertion execution', status: 'failed', reason: String(error.message || error) });
+                    }
+                    this.currentAssertion = (0, assertion_result_1.failedAssertion)(error.assertion || this.native.lastAssertion || fallback, String(error.message || error));
+                    throw error;
+                }
+                if (payload.saveAs)
+                    this.localVariables[payload.saveAs] = result;
+                break;
+            }
             case "extract":
                 if (["resBody", "resHeader", "cookie"].includes(payload.target)) {
                     this.processExtractions([
@@ -974,8 +1126,8 @@ class FlowWorker extends events_1.EventEmitter {
                             throw new Error(`API Assertion Failed: Expected HTTP status ${expectedStatus}, but got ${apiState.status}`);
                     }
                     else if (expectType === "responseTime") {
-                        const threshold = payload.threshold || payload.value;
-                        if (apiState.responseTime > parseInt(threshold, 10))
+                        const threshold = (0, assertion_contract_1.validateResponseTimeThreshold)(payload.threshold ?? payload.value);
+                        if (apiState.responseTime > threshold)
                             throw new Error(`API Assertion Failed: Expected response time to be less than ${threshold}ms, but got ${apiState.responseTime}ms`);
                     }
                     else {
@@ -998,6 +1150,7 @@ class FlowWorker extends events_1.EventEmitter {
                             : payload.condition
                                 ? [{ condition: payload.condition, value: payload.value }]
                                 : [];
+                        (0, assertion_contract_1.validateApiAssertions)(assertionsArray);
                         for (const assertion of assertionsArray) {
                             const condition = assertion.condition;
                             const rawExpected = assertion.value;
@@ -1108,10 +1261,10 @@ class FlowWorker extends events_1.EventEmitter {
                                     "undefined",
                                 ];
                                 if (["equals", "contains"].includes(condition) ||
-                                    (isToBe && !knownTypes.includes(expectedLower))) {
+                                    ((isToBe || isNegated) && !knownTypes.includes(expectedLower))) {
                                     const strActual = String(actualValue);
                                     const isEquals = condition === "equals" ||
-                                        (isToBe && !knownTypes.includes(expectedLower));
+                                        ((isToBe || isNegated) && !knownTypes.includes(expectedLower));
                                     if (isEquals) {
                                         const match = strActual === rawExpected;
                                         const passed = isNegated ? !match : match;
@@ -1162,7 +1315,7 @@ class FlowWorker extends events_1.EventEmitter {
                         if (remaining <= 0)
                             throw new Error(failure());
                         try {
-                            actual = await (0, deadline_1.withDeadline)(this.web.getAttribute(payload.selector, payload.attribute, payload.elementType), remaining);
+                            actual = await (0, deadline_2.withDeadline)(this.web.getAttribute(payload.selector, payload.attribute, payload.elementType), remaining);
                         }
                         catch (error) {
                             throw new Error(`${failure()}\n${error instanceof Error ? error.message : String(error)}`, { cause: error });
@@ -1181,6 +1334,9 @@ class FlowWorker extends events_1.EventEmitter {
     }
     async setupNetworkInterception() {
         const context = this.web.getPage().context();
+        if (this.interceptedContexts.has(context))
+            return;
+        this.interceptedContexts.add(context);
         context.on("response", async (response) => {
             const lockedFileName = this.currentFileName;
             const request = response.request();
@@ -1239,8 +1395,27 @@ class FlowWorker extends events_1.EventEmitter {
         });
     }
     async startStreaming() {
+        clearInterval(this.fallbackStream);
         if (this.config.ci)
             return;
+        if (this.config.browser && this.config.browser !== 'chromium') {
+            const page = this.web.getPage();
+            let busy = false;
+            this.fallbackStream = setInterval(async () => {
+                if (busy || page.isClosed())
+                    return;
+                busy = true;
+                try {
+                    this.broadcast('BROWSER_FRAME', { base64: (await page.screenshot({ type: 'jpeg', quality: 60 })).toString('base64'), fileName: this.currentFileName });
+                }
+                catch { }
+                finally {
+                    busy = false;
+                }
+            }, 250);
+            this.fallbackStream.unref();
+            return;
+        }
         const page = this.web.getPage();
         if (this.currentCdpSession) {
             await this.currentCdpSession.detach().catch(() => { });
@@ -1261,6 +1436,8 @@ class FlowWorker extends events_1.EventEmitter {
         });
     }
     async shutdown() {
+        clearInterval(this.fallbackStream);
+        await this.native.dispose();
         try {
             await this.web.shutdown();
         }

package/dist/runner/plugin_manager.js

@@ -121,6 +121,7 @@ class PluginManager {
                     get: (url, headers) => this.apiProxy.get(url, headers),
                     post: (url, body, headers) => this.apiProxy.post(url, body, headers),
                     put: (url, body, headers) => this.apiProxy.put(url, body, headers),
+                    patch: (url, body, headers) => this.apiProxy.patch(url, body, headers),
                     delete: (url, headers) => this.apiProxy.delete(url, headers),
                 },
                 ui: {
@@ -144,6 +145,8 @@ class PluginManager {
                 state: {
                     get: (k) => this.store.get(k),
                     set: (k, v) => this.store.set(k, v),
+                    delete: (k) => { this.store.delete(k); },
+                    clear: () => this.store.clear(),
                 },
                 env: {
                     get: (k) => process.env[k],

package/dist/runner/temporary_store.d.ts

@@ -3,6 +3,7 @@ export declare class TemporaryStore {
     set(key: string, value: any): void;
     get(key: string): any;
     has(key: string): boolean;
+    delete(key: string): boolean;
     clear(): void;
     getAll(): Record<string, any>;
 }

package/dist/runner/temporary_store.js

@@ -12,6 +12,9 @@ class TemporaryStore {
     has(key) {
         return this.store.has(key);
     }
+    delete(key) {
+        return this.store.delete(key);
+    }
     clear() {
         this.store.clear();
     }

package/dist/sdk/api_proxy.d.ts

@@ -5,4 +5,7 @@ export declare class ApiProxy {
     private formatHeaders;
     get(url: string, headers?: Record<string, string>): Promise<any>;
     post(url: string, body: any, headers?: Record<string, string>): Promise<any>;
+    put(url: string, body: any, headers?: Record<string, string>): Promise<any>;
+    patch(url: string, body: any, headers?: Record<string, string>): Promise<any>;
+    delete(url: string, headers?: Record<string, string>): Promise<any>;
 }

package/dist/sdk/api_proxy.js

@@ -24,5 +24,21 @@ class ApiProxy {
         const state = this.adapter.getState();
         return state.body;
     }
+    async put(url, body, headers) {
+        const formattedHeaders = this.formatHeaders(headers);
+        const stringifiedBody = typeof body === "string" ? body : JSON.stringify(body);
+        await this.adapter.put(url, formattedHeaders, stringifiedBody);
+        return this.adapter.getState().body;
+    }
+    async patch(url, body, headers) {
+        const formattedHeaders = this.formatHeaders(headers);
+        const stringifiedBody = typeof body === "string" ? body : JSON.stringify(body);
+        await this.adapter.patch(url, formattedHeaders, stringifiedBody);
+        return this.adapter.getState().body;
+    }
+    async delete(url, headers) {
+        await this.adapter.delete(url, this.formatHeaders(headers));
+        return this.adapter.getState().body;
+    }
 }
 exports.ApiProxy = ApiProxy;

package/dist/security/localWorkspace.d.ts

@@ -0,0 +1,2 @@
+/** Bind the manual workspace browser boundary to the actual loopback listener. */
+export declare function isLocalWorkspaceRequest(host: string | undefined, origin: string | undefined, localPort: number | undefined, fetchSite?: string): boolean;

package/dist/security/localWorkspace.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalWorkspaceRequest = isLocalWorkspaceRequest;
+const localDashboard_1 = require("./localDashboard");
+/** Bind the manual workspace browser boundary to the actual loopback listener. */
+function isLocalWorkspaceRequest(host, origin, localPort, fetchSite) {
+    if (!Number.isInteger(localPort) || !localPort || localPort < 1 || localPort > 65535)
+        return false;
+    if (!(0, localDashboard_1.isLocalDashboardRequest)(host, origin) || fetchSite === 'cross-site')
+        return false;
+    try {
+        return Number(new URL(`http://${host}`).port) === localPort;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/security/redaction.js

@@ -33,7 +33,7 @@ function redactPayload(value, secrets = [], depth = 0) {
         return value.map(item => redactPayload(item, secrets, depth + 1));
     if (!value || typeof value !== 'object')
         return value;
-    if (Buffer.isBuffer(value))
+    if (globalThis.Buffer?.isBuffer(value))
         return '[binary]';
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sensitive.test(key) ? '[REDACTED]' : redactPayload(item, secrets, depth + 1)]));
 }

package/dist/types/index.d.ts

@@ -1,4 +1,14 @@
 export interface FlowstrideConfig {
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    browserOptions?: import('playwright').BrowserContextOptions;
+    retries?: number;
+    failOnFlaky?: boolean;
+    trace?: boolean;
+    har?: boolean;
+    domSnapshots?: boolean;
+    shard?: string;
+    shardHistory?: string;
+    updateBaselines?: boolean;
     ci?: boolean;
     flowRoot?: string;
     projectRoot?: string;
@@ -95,6 +105,7 @@ export interface FlowstrideSDK {
         get: (url: string, headers?: Record<string, string>) => Promise<any>;
         post: (url: string, body: any, headers?: Record<string, string>) => Promise<any>;
         put: (url: string, body: any, headers?: Record<string, string>) => Promise<any>;
+        patch: (url: string, body: any, headers?: Record<string, string>) => Promise<any>;
         delete: (url: string, headers?: Record<string, string>) => Promise<any>;
     };
     ui: {
@@ -106,6 +117,8 @@ export interface FlowstrideSDK {
     state: {
         get: (key: string) => any;
         set: (key: string, value: any) => void;
+        delete: (key: string) => void;
+        clear: () => void;
     };
     env: {
         get: (key: string) => string | undefined;