flowstride 1.0.21 → 1.0.22

package/dist/reporting/runtime_failure.d.ts

@@ -0,0 +1,10 @@
+export interface FailureContext {
+    file?: string;
+    line?: number;
+    profile?: string;
+    timeout?: number;
+    elapsed?: number;
+}
+/** Preserve the adapter's evidence and nested causes, without printing request bodies or typed values. */
+export declare function commandSecrets(command: string, payload: any): string[];
+export declare function runtimeFailure(command: string, payload: any, error: unknown, context: FailureContext): string;

package/dist/reporting/runtime_failure.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandSecrets = commandSecrets;
+exports.runtimeFailure = runtimeFailure;
+const redaction_1 = require("../security/redaction");
+const assertion_result_1 = require("./assertion_result");
+/** Preserve the adapter's evidence and nested causes, without printing request bodies or typed values. */
+function commandSecrets(command, payload) {
+    const secrets = [], seen = new Set();
+    const visit = (value, depth) => {
+        if (depth > 8 || value == null || seen.has(value))
+            return;
+        if (typeof value === 'string') {
+            if (/^\s*[\[{]/.test(value)) {
+                try {
+                    visit(JSON.parse(value), depth + 1);
+                }
+                catch { }
+            }
+            return;
+        }
+        if (typeof value !== 'object')
+            return;
+        seen.add(value);
+        for (const [key, item] of Object.entries(value).slice(0, 200)) {
+            if (/password|passcode|secret|token|authorization|cookie|api.?key|otp/i.test(key) && typeof item === 'string')
+                secrets.push(item);
+            else
+                visit(item, depth + 1);
+        }
+    };
+    visit(payload, 0);
+    if (/^(?:flow\.)?(?:type|forceType|passcode)$/i.test(command) && typeof payload?.text === 'string')
+        secrets.push(payload.text);
+    return secrets;
+}
+function runtimeFailure(command, payload, error, context) {
+    const label = command.includes('.') ? command : 'flow.' + command;
+    const lines = [`Failed command: ${(0, assertion_result_1.diagnosticValue)(label)}`];
+    if (context.file)
+        lines.push(`Location: ${(0, assertion_result_1.diagnosticValue)(context.file)}${context.line ? ':' + context.line : ''}`);
+    const input = payload?.data && typeof payload.data === 'object' ? payload.data : payload || {};
+    const fields = ['selector', 'role', 'name', 'text', 'url', 'path', 'file', 'filename', 'audioPath', 'sessionName', 'jsonPath', 'attribute', 'property', 'key', 'canvas', 'id', 'target'];
+    const targets = fields.filter(key => !(/^(?:flow\.)?(?:type|forceType|passcode)$/i.test(command) && key === 'text') && (['string', 'number'].includes(typeof input[key]) || key === 'selector' && input[key] && typeof input[key] === 'object')).map(key => `${key}: ${(0, assertion_result_1.diagnosticValue)(input[key])}`);
+    if (targets.length)
+        lines.push('Target / resource: ' + targets.join('; '));
+    if (context.profile)
+        lines.push('Profile: ' + (0, assertion_result_1.diagnosticValue)(context.profile));
+    if (context.timeout !== undefined)
+        lines.push(`Timeout: ${context.timeout} ms${context.elapsed !== undefined ? '; elapsed: ' + context.elapsed + ' ms' : ''}`);
+    const seen = new Set();
+    let current = error;
+    for (let depth = 0; current != null && depth < 5 && !seen.has(current); depth++) {
+        seen.add(current);
+        const message = typeof current === 'object' ? current.message || String(current) : String(current);
+        // Keep line breaks in Playwright call logs, but escape terminal control sequences.
+        const reason = String(message).slice(0, 12000).split('\n').map(line => (0, assertion_result_1.diagnosticValue)(line)).join('\n');
+        lines.push((depth ? 'Caused by: ' : 'Reason: ') + reason);
+        if (current.code)
+            lines.push('Error code: ' + (0, assertion_result_1.diagnosticValue)(current.code));
+        current = current.cause;
+    }
+    return (0, redaction_1.redactText)(lines.join('\n'), commandSecrets(command, payload));
+}

package/dist/reporting/step_status.d.ts

@@ -0,0 +1,10 @@
+/** Presentation shared by the interactive TestCase view and exported PDF. */
+export interface StepStatusPresentation {
+    status: string;
+    label: string;
+    actualResult: string;
+    color: string;
+    isPassed: boolean;
+    isFailed: boolean;
+}
+export declare function stepStatusPresentation(value: unknown): StepStatusPresentation;

package/dist/reporting/step_status.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepStatusPresentation = stepStatusPresentation;
+function stepStatusPresentation(value) {
+    const status = typeof value === "string"
+        ? value.trim().toLowerCase().replace(/[\s-]+/g, "_")
+        : value == null ? "pending" : "unknown";
+    const result = (state, label, actualResult, color = "#64748b") => ({
+        status: state, label, actualResult, color,
+        isPassed: state === "passed",
+        isFailed: state === "failed" || state === "error",
+    });
+    switch (status) {
+        case "pass":
+        case "passed":
+        case "success":
+            return result("passed", "PASSED", "Action verified successfully.", "#10b981");
+        case "fail":
+        case "failed":
+            return result("failed", "FAILED", "Validation failed.", "#ef4444");
+        case "error":
+            return result("error", "ERROR", "Step execution failed.", "#ef4444");
+        case "skip":
+        case "skipped":
+            return result("skipped", "SKIPPED", "Step skipped; not executed.");
+        case "not_tested":
+            return result("not_tested", "NOT TESTED", "Step not tested.");
+        case "":
+        case "pending":
+            return result("pending", "PENDING", "Awaiting execution.");
+        case "running":
+        case "in_progress":
+            return result("running", "RUNNING", "Execution in progress.");
+        case "cancelled":
+        case "canceled":
+            return result("cancelled", "CANCELLED", "Execution cancelled.");
+        case "interrupted":
+            return result("interrupted", "INTERRUPTED", "Execution interrupted.");
+        case "blocked":
+            return result("blocked", "BLOCKED", "Execution blocked.");
+        default:
+            return result("unknown", "UNKNOWN", "Result unavailable.");
+    }
+}

package/dist/runner/flow_orchestrator.d.ts

@@ -5,6 +5,7 @@ export declare class FlowOrchestrator {
     private workerCount;
     private config?;
     static readonly nativeBrowserProtocol = 2;
+    static readonly nativeAssertionProtocol = 1;
     static readonly nativeCIProtocol = 1;
     readonly nativeEventProtocol = 1;
     private wss;

package/dist/runner/flow_orchestrator.js

@@ -53,6 +53,7 @@ class FlowOrchestrator {
     workerCount;
     config;
     static nativeBrowserProtocol = 2;
+    static nativeAssertionProtocol = 1;
     static nativeCIProtocol = 1;
     nativeEventProtocol = 1;
     wss = null;
@@ -108,9 +109,13 @@ class FlowOrchestrator {
             }
         };
         this.worker.on("worker_event", listener);
-        await this.worker.runBatch(filesToProcess);
-        this.worker.off("worker_event", listener);
-        const passed = ![...this.stepStatusRegistry.values()].some(status => ['failed', 'running', 'not_tested'].includes(status));
+        let passed = false;
+        try {
+            passed = await this.worker.runBatch(filesToProcess);
+        }
+        finally {
+            this.worker.off("worker_event", listener);
+        }
         this.forwardToDashboard("RUN_COMPLETE", { status: passed ? 'success' : 'failed' });
         return passed;
     }

package/dist/runner/flow_worker.d.ts

@@ -20,11 +20,15 @@ export declare class FlowWorker extends EventEmitter {
     private sessions;
     private pluginManager?;
     static readonly nativeBrowserProtocol = 2;
+    static readonly nativeAssertionProtocol = 1;
     private isSilent;
     private isAborted;
     private bailTriggered;
     private isDebugHalted;
     private native;
+    private currentAssertion?;
+    private commandSecretValues;
+    private batchPassed;
     private attempt;
     private maxAttempts;
     private fallbackStream?;
@@ -41,6 +45,9 @@ export declare class FlowWorker extends EventEmitter {
     private lastApiUrl;
     constructor(config: FlowstrideConfig, web: WebAdapter, api: ApiAdapter, store: any, sessions: SessionManager, pluginManager?: PluginManager | undefined);
     private broadcast;
+    private secretValues;
+    private assertionForStep;
+    private printAssertion;
     private emitLog;
     private translateError;
     private captureStepContext;
@@ -51,7 +58,7 @@ export declare class FlowWorker extends EventEmitter {
     private emitApiTelemetry;
     handleReplayRequest(payload: any): Promise<void>;
     abort(): void;
-    runBatch(filesToProcess: string[]): Promise<void>;
+    runBatch(filesToProcess: string[]): Promise<boolean>;
     private runScenarioWithRetries;
     private runScenario;
     private waitForPipeline;

package/dist/runner/flow_worker.js

@@ -37,8 +37,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowWorker = void 0;
+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_1 = require("../ci/deadline");
+const deadline_2 = require("../ci/deadline");
 const replayRequest_1 = require("../utils/replayRequest");
 const projectPaths_1 = require("../utils/projectPaths");
 const redaction_1 = require("../security/redaction");
@@ -59,11 +63,15 @@ class FlowWorker extends events_1.EventEmitter {
     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;
@@ -92,8 +100,20 @@ class FlowWorker extends events_1.EventEmitter {
     broadcast(type, payload) {
         if (["STEP_ADD", "STEP_UPDATE", "LOG_EVENT"].includes(type))
             payload = { ...payload, attempt: this.attempt, profile: this.web.activeProfile || "default" };
-        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) });
+        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);
@@ -110,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 });
@@ -350,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;
@@ -376,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 {
@@ -470,7 +483,8 @@ class FlowWorker extends events_1.EventEmitter {
                                 scenarioName: s.name,
                                 fileName: this.currentFileName,
                             });
-                            await this.runScenarioWithRetries(s, f.declarations);
+                            if (!await this.runScenarioWithRetries(s, f.declarations))
+                                this.batchPassed = false;
                             if (this.isDebugHalted || this.bailTriggered)
                                 break;
                             await this.web
@@ -511,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");
@@ -532,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 }),
                     });
                 }
             }
@@ -541,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."));
                 }
             }
         }
@@ -559,6 +574,7 @@ 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;
@@ -567,6 +583,7 @@ class FlowWorker extends events_1.EventEmitter {
         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;
@@ -593,7 +610,15 @@ class FlowWorker extends events_1.EventEmitter {
             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)
@@ -601,26 +626,38 @@ class FlowWorker extends events_1.EventEmitter {
         }
         this.attempt = 1;
         this.maxAttempts = 1;
+        return finalPassed;
     }
     async runScenario(scenario, globalDeclarations = []) {
         let hasScenarioFailed = false;
         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() {
@@ -647,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", {
@@ -654,17 +693,27 @@ 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,
@@ -680,6 +729,7 @@ 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 = "";
@@ -696,12 +746,14 @@ 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,
@@ -739,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,
@@ -750,6 +809,8 @@ 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,
@@ -807,9 +868,25 @@ 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 result = await (0, deadline_1.withDeadline)(this.native.execute(payload.pluginMethod, payload.data), this.config.timeout);
+                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;
@@ -1049,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 {
@@ -1073,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;
@@ -1183,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;
@@ -1237,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 });

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;