flowstride 1.0.20 → 1.0.21

package/dist/ci/runtime.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runNativeCI = runNativeCI;
+const distribution_1 = require("./distribution");
 const node_crypto_1 = require("node:crypto");
 const projectPaths_1 = require("../utils/projectPaths");
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -20,6 +21,11 @@ async function runNativeCI(worker, orchestrator, target, config, engine) {
     node_fs_1.default.mkdirSync(artifactRoot, { recursive: true });
     const directory = node_fs_1.default.mkdtempSync(node_path_1.default.join(artifactRoot, 'run-'));
     config.artifactsDir = directory;
+    const plan = (0, distribution_1.executionPlan)(target, config);
+    const browsers = new Map();
+    const attempts = [];
+    const attemptSteps = new Map();
+    const timings = {};
     const steps = new Map();
     const completed = new Set();
     const errors = [];
@@ -34,8 +40,18 @@ async function runNativeCI(worker, orchestrator, target, config, engine) {
         if (!data?.payload)
             return;
         const p = data.payload;
+        if (data.type === 'BROWSER_INFO')
+            browsers.set(p.fileName, { ...p });
         if (data.type === 'BAIL')
             bailed = true;
+        if (data.type === 'SCENARIO_ATTEMPT')
+            attemptSteps.set(p.fileName, []);
+        if (data.type === 'SCENARIO_RESULT')
+            attempts.push({ ...p, steps: [...(attemptSteps.get(p.fileName) || [])] });
+        if (data.type === 'FILE_COMPLETE' || data.type === 'FILE_FAILED')
+            timings[p.fileName] = p.duration;
+        if (data.type === 'STEP_UPDATE')
+            attemptSteps.get(p.fileName)?.push({ ...p, screenshot: undefined });
         if (data.type === 'LOG_EVENT' && p.status === 'error') {
             const active = [...steps.values()].reverse().find(step => step.fileName === p.fileName && step.status === 'running');
             if (active)
@@ -69,9 +85,9 @@ async function runNativeCI(worker, orchestrator, target, config, engine) {
     process.on('SIGINT', interrupt);
     process.on('SIGTERM', interrupt);
     try {
-        files = (0, projectPaths_1.discoverFlows)(target, config.projectRoot || process.cwd());
+        files = plan.files;
         config.flowRoot = node_fs_1.default.statSync(target).isDirectory() ? target : node_path_1.default.dirname(target);
-        if (!files.length)
+        if (!plan.allFiles.length)
             throw new Error('No .flow tests found.');
         for (const file of files) {
             const features = (0, projectPaths_1.selectedFeatures)(new parser_1.Parser(new lexer_1.Lexer(node_fs_1.default.readFileSync(file, 'utf8')).tokenise()).parse());
@@ -83,7 +99,7 @@ async function runNativeCI(worker, orchestrator, target, config, engine) {
                     }
             expected += features.reduce((n, feature) => n + feature.scenarios.reduce((m, scenario) => m + scenario.steps.length, 0), 0);
         }
-        if (!expected)
+        if (files.length && !expected)
             throw new Error('No executable test steps found.');
         if (config.webServer) {
             const settings = config.webServer;
@@ -175,8 +191,10 @@ async function runNativeCI(worker, orchestrator, target, config, engine) {
         errors.push('Engine produced an unexpected step count.');
     const metrics = { total: expected, passed: results.filter(s => s.status === 'passed').length,
         failed: results.filter(s => s.status === 'failed').length, skipped: results.filter(s => ['skipped', 'not_tested'].includes(s.status)).length, incomplete };
-    const result = { cloudSync: config.cloudSyncResult, protocol: 1, engine, status: interrupted ? 'interrupted' : errors.length || metrics.failed || incomplete ? 'failed' : 'passed',
-        duration: Date.now() - started, artifactsDir: directory, files: files.map(file => (0, projectPaths_1.flowIdentity)(file, config.flowRoot)), steps: results, errors, metrics };
+    if (config.failOnFlaky && attempts.some(attempt => attempt.flaky))
+        errors.push('Flaky scenarios are configured to fail CI.');
+    const result = { cloudSync: config.cloudSyncResult, browser: config.browser || 'chromium', browsers: [...browsers.values()], protocol: 1, engine, status: interrupted ? 'interrupted' : errors.length || metrics.failed || incomplete ? 'failed' : 'passed',
+        duration: Date.now() - started, artifactsDir: directory, files: files.map(file => (0, projectPaths_1.flowIdentity)(file, config.flowRoot)), steps: results, errors, metrics, attempts, timings, distribution: { ...plan, files: undefined, flowRoot: undefined } };
     // Existing workers finalize videos into these locations. Copy only run files,
     // never the project directory or credentials.
     if (config.recordVideo !== false)
@@ -190,6 +208,7 @@ async function runNativeCI(worker, orchestrator, target, config, engine) {
             }
         }
     config.artifactsDir = artifactRoot;
+    node_fs_1.default.writeFileSync(node_path_1.default.join(artifactRoot, 'timings.json'), JSON.stringify(timings, null, 2));
     node_fs_1.default.writeFileSync(node_path_1.default.join(artifactRoot, 'summary.json'), JSON.stringify(result, null, 2));
     const cases = results.map(step => `<testcase classname="${xml(step.fileName)}" name="${xml(step.description || step.id)}">${step.status === 'failed' ? `<failure message="${xml(step.error || 'Test step failed')}"/>` : ['skipped', 'not_tested'].includes(step.status) ? '<skipped/>' : ''}</testcase>`);
     for (const error of errors)

package/dist/cli/commands/run.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runAction = runAction;
+const compatibility_1 = require("../../native/compatibility");
 const projectPaths_1 = require("../../utils/projectPaths");
 const config_1 = require("../../ci/config");
 const runtime_1 = require("../../ci/runtime");
@@ -121,6 +122,8 @@ async function runAction(targetPath, options) {
             const proOrchModule = await import((0, url_1.pathToFileURL)(proOrchPath).href);
             if (config.ci && proOrchModule.FlowOrchestrator.nativeCIProtocol !== 1)
                 throw new Error('Installed Pro engine does not support native CI protocol 1; install the matching Pro candidate.');
+            if ((0, compatibility_1.needsNativeBrowserProtocol)(resolvedPath, config) && (proWorkerModule.FlowWorker.nativeBrowserProtocol !== 2 || proOrchModule.FlowOrchestrator.nativeBrowserProtocol !== 2))
+                throw new Error('Installed Cloud engine does not support these native browser capabilities. Install the matching Cloud archive; this run will use OS fallback.');
             ActiveFlowWorker = proWorkerModule.FlowWorker;
             ActiveFlowOrchestrator = proOrchModule.FlowOrchestrator;
             engineMode = "Enterprise (Pro)";

package/dist/cli/index.js

@@ -37,6 +37,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const distribution_1 = require("../ci/distribution");
+const projectPaths_1 = require("../utils/projectPaths");
 const cloud_1 = require("../utils/cloud");
 const cloudSession_1 = require("./utils/cloudSession");
 const config_1 = require("../ci/config");
@@ -63,7 +65,7 @@ let API_BASE = (0, cloud_1.cloudApiBase)(process.env);
 program
     .name("flowstride")
     .description("Flowstride: The Enterprise Flow-First Automation CLI")
-    .version("1.0.20");
+    .version(require("../../package.json").version);
 program
     .command("init")
     .description("Initialise a new Flowstride workspace in the current directory")
@@ -258,6 +260,10 @@ program
     .option("--workers <number>", "Number of parallel workers to spawn (Pro feature)")
     .option('--ci', 'Run without a dashboard and write CI reports')
     .option('--device <profile>', 'desktop, phone, or landscape')
+    .option('--browser <engine>', 'chromium, firefox, or webkit')
+    .option('--shard <index/total>', 'Run one deterministic CI shard, e.g. 1/4')
+    .option('--shard-history <file>', 'Use merged timing history for shard balancing')
+    .option('--update-baselines', 'Explicitly update ARIA baselines locally')
     .option('--config <file>', 'Path to the Flowstride configuration')
     .option('--env <name>', 'Environment profile')
     .action(async (targetPath, options) => {
@@ -394,15 +400,28 @@ program
     await (0, open_1.openAction)();
 });
 program.command('install')
-    .description('Install Chromium matching this Flowstride engine')
+    .description('Install browsers matching this Flowstride engine')
+    .argument('[browsers...]', 'chromium, firefox, or webkit')
     .option('--with-deps', 'Install operating-system browser dependencies')
-    .action((options) => {
+    .action((browsers, options) => {
+    if (browsers.some(browser => !['chromium', 'firefox', 'webkit'].includes(browser)))
+        throw new Error('Unknown browser.');
     const { execFileSync } = require('node:child_process');
-    execFileSync(process.execPath, [path.join(path.dirname(require.resolve('playwright/package.json')), 'cli.js'), 'install', ...(options.withDeps ? ['--with-deps'] : []), 'chromium'], { stdio: 'inherit', env: { ...process.env, PLAYWRIGHT_SKIP_BROWSER_GC: '1' } });
+    execFileSync(process.execPath, [path.join(path.dirname(require.resolve('playwright/package.json')), 'cli.js'), 'install', ...(options.withDeps ? ['--with-deps'] : []), ...(browsers.length ? browsers : ['chromium'])], { stdio: 'inherit', env: { ...process.env, PLAYWRIGHT_SKIP_BROWSER_GC: '1' } });
+    console.log(`[Browsers]: Matching binaries installed: ${(browsers.length ? browsers : ['chromium']).join(', ')}. Use run --browser <engine> to select one.`);
 });
 program.command('ci')
     .description('Set up native Flowstride CI')
     .command('init <provider>')
     .description('Generate a GitHub Actions workflow without overwriting existing files')
-    .action((provider) => (0, init_1.initCI)(provider));
+    .option('--browsers <names>', 'Comma-separated browser matrix', 'chromium')
+    .option('--shards <total>', 'Number of CI machines per browser', '1')
+    .action((provider, options) => (0, init_1.initCI)(provider, options));
+program.command('merge <summaries...>')
+    .description('Merge complete native shard results and evidence')
+    .option('--output <directory>', 'New project directory for merged results', 'flowstride-merged')
+    .action((summaries, options) => { const result = (0, distribution_1.mergeResults)(summaries, options.output); console.log(`Merged Flowstride result: ${result.status}`); process.exitCode = result.status === 'passed' ? 0 : 1; });
+program.command('trace <file>')
+    .description('Open a local Playwright trace without uploading it')
+    .action((file) => { const { execFileSync } = require('node:child_process'); const local = (0, projectPaths_1.projectPath)(process.cwd(), file); execFileSync(process.execPath, [path.join(path.dirname(require.resolve('playwright/package.json')), 'cli.js'), 'show-trace', local], { stdio: 'inherit' }); });
 program.parse(process.argv);

package/dist/manual/security.d.ts

@@ -61,6 +61,7 @@ export declare const manualRunSchema: z.ZodObject<{
                 failed: "failed";
                 skipped: "skipped";
                 success: "success";
+                pending: "pending";
                 Pending: "Pending";
                 Current: "Current";
                 Passed: "Passed";
@@ -71,7 +72,6 @@ export declare const manualRunSchema: z.ZodObject<{
                 Fail: "Fail";
                 Success: "Success";
                 pass: "pass";
-                pending: "pending";
                 blocked: "blocked";
             }>;
             group_title: z.ZodOptional<z.ZodString>;
@@ -143,6 +143,7 @@ export declare const manualCanvasSchema: z.ZodObject<{
             failed: "failed";
             skipped: "skipped";
             success: "success";
+            pending: "pending";
             Pending: "Pending";
             Current: "Current";
             Passed: "Passed";
@@ -153,7 +154,6 @@ export declare const manualCanvasSchema: z.ZodObject<{
             Fail: "Fail";
             Success: "Success";
             pass: "pass";
-            pending: "pending";
             blocked: "blocked";
         }>;
         group_title: z.ZodOptional<z.ZodString>;

package/dist/native/accessibility.d.ts

@@ -0,0 +1,3 @@
+import type { Page } from 'playwright';
+import type { FlowstrideConfig } from '../types';
+export declare function accessibility(page: Page, config: FlowstrideConfig, action: string, input: unknown): Promise<string | undefined>;

package/dist/native/accessibility.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accessibility = accessibility;
+const zod_1 = require("zod");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const playwright_1 = __importDefault(require("@axe-core/playwright"));
+const validation_1 = require("./validation");
+const projectPaths_1 = require("../utils/projectPaths");
+async function accessibility(page, config, action, input) {
+    if (action === 'scan') {
+        const data = zod_1.z.object({ name: validation_1.name.default('accessibility'), include: zod_1.z.array(zod_1.z.string()).optional(), exclude: zod_1.z.array(zod_1.z.string()).optional(), tags: zod_1.z.array(zod_1.z.string()).optional(), rules: zod_1.z.array(zod_1.z.string()).optional(), disableRules: zod_1.z.array(zod_1.z.string()).optional(), impacts: zod_1.z.array(zod_1.z.enum(['minor', 'moderate', 'serious', 'critical'])).optional(), maxViolations: zod_1.z.number().int().nonnegative().default(0) }).strict().parse(input);
+        let builder = new playwright_1.default({ page });
+        for (const selector of data.include || [])
+            builder = builder.include(selector);
+        for (const selector of data.exclude || [])
+            builder = builder.exclude(selector);
+        if (data.tags)
+            builder = builder.withTags(data.tags);
+        if (data.rules)
+            builder = builder.withRules(data.rules);
+        if (data.disableRules)
+            builder = builder.disableRules(data.disableRules);
+        const result = await builder.analyze();
+        const violations = result.violations.filter(item => !data.impacts || item.impact && data.impacts.includes(item.impact));
+        const file = (0, validation_1.evidencePath)(config, `${data.name}-${Date.now()}.json`);
+        // Reports may contain application content. They remain in local evidence.
+        node_fs_1.default.writeFileSync(file, JSON.stringify({ ...result, violations }, null, 2), { mode: 0o600 });
+        if (violations.length > data.maxViolations)
+            throw new Error(`Accessibility assertion failed: ${violations.length} violations (${violations.map(item => item.id).join(', ')}). Report: ${file}`);
+        return file;
+    }
+    if (action === 'snapshot') {
+        const data = zod_1.z.object({ name: validation_1.name, selector: zod_1.z.string().default('body'), baseline: zod_1.z.string().optional(), update: zod_1.z.boolean().default(false), timeout: validation_1.positive.optional() }).strict().parse(input);
+        const snapshot = await page.locator(data.selector).ariaSnapshot({ timeout: data.timeout ?? config.timeout });
+        const file = (0, validation_1.evidencePath)(config, `${data.name}-${Date.now()}.aria.yml`);
+        node_fs_1.default.writeFileSync(file, snapshot, { mode: 0o600 });
+        if (!data.baseline) {
+            if (data.update)
+                throw new Error('Choose a baseline path.');
+            return file;
+        }
+        const baseline = (0, projectPaths_1.projectPath)(config.projectRoot || process.cwd(), data.baseline);
+        if (data.update || config.updateBaselines) {
+            if (config.ci || process.env.CI && process.env.CI !== 'false')
+                throw new Error('Baseline updates are not allowed in CI.');
+            if (!config.updateBaselines)
+                throw new Error('Baseline writing requires --update-baselines.');
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(baseline), { recursive: true });
+            node_fs_1.default.writeFileSync(baseline, snapshot, { mode: 0o600 });
+        }
+        else {
+            const expected = (0, validation_1.readProjectFile)(config, baseline).toString('utf8').replace(/\r\n/g, '\n').trim();
+            if (expected !== snapshot.trim())
+                throw new Error(`ARIA baseline differs. Review the captured snapshot before updating: ${file}`);
+        }
+        return file;
+    }
+    if (action === 'match') {
+        const data = zod_1.z.object({ selector: zod_1.z.string().default('body'), yaml: zod_1.z.string().min(1), timeout: validation_1.positive.optional() }).strict().parse(input);
+        await (0, validation_1.poll)(async () => (await page.locator(data.selector).ariaSnapshot()).trim() === data.yaml.replace(/\r\n/g, '\n').trim(), data.timeout ?? config.timeout, 'ARIA snapshot differs');
+        return;
+    }
+    throw new Error(`Unknown accessibility action: ${action}`);
+}

package/dist/native/assertions.d.ts

@@ -0,0 +1,2 @@
+import type { Page } from 'playwright';
+export declare function assertBrowser(page: Page, input: unknown, defaultTimeout: number): Promise<void>;

package/dist/native/assertions.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertBrowser = assertBrowser;
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const validation_1 = require("./validation");
+const node_util_1 = require("node:util");
+let accessibilityBundle;
+async function installAccessibilityNames(page) {
+    if (await page.evaluate(() => !!window.__FLOWSTRIDE_ACCESSIBILITY_NAMES__))
+        return;
+    accessibilityBundle ||= (async () => {
+        const { build } = await import('vite');
+        const result = await build({ configFile: false, root: node_path_1.default.dirname(require.resolve('dom-accessibility-api')), envDir: false, logLevel: 'silent', build: { write: false, minify: true, emptyOutDir: false,
+                lib: { entry: require.resolve('dom-accessibility-api'), formats: ['iife'], name: '__FLOWSTRIDE_ACCESSIBILITY_NAMES__' } } });
+        const code = (Array.isArray(result) ? result : [result]).flatMap(bundle => bundle.output).find((file) => file.type === 'chunk').code;
+        return code + '\nwindow.__FLOWSTRIDE_ACCESSIBILITY_NAMES__=__FLOWSTRIDE_ACCESSIBILITY_NAMES__;';
+    })();
+    const source = await accessibilityBundle;
+    for (const frame of page.frames())
+        await frame.evaluate(source);
+}
+const schema = zod_1.z.object({ selector: zod_1.z.string().optional(), role: zod_1.z.string().optional(), name: zod_1.z.string().optional(), frame: zod_1.z.string().optional(),
+    condition: zod_1.z.enum(['visible', 'hidden', 'attached', 'enabled', 'disabled', 'editable', 'checked', 'empty', 'focused', 'text', 'containsText', 'value', 'values', 'count', 'attribute', 'css', 'id', 'property', 'accessibleName', 'accessibleDescription', 'inViewport', 'url', 'title', 'localStorage', 'sessionStorage']),
+    value: zod_1.z.unknown().optional(), attribute: zod_1.z.string().optional(), property: zod_1.z.string().optional(), key: zod_1.z.string().optional(),
+    matches: zod_1.z.string().optional(), flags: zod_1.z.string().regex(/^[imsu]*$/).optional(), not: zod_1.z.boolean().default(false), timeout: validation_1.positive.optional(),
+}).strict();
+async function assertBrowser(page, input, defaultTimeout) {
+    const data = schema.parse(input), timeout = data.timeout ?? defaultTimeout;
+    const expected = data.matches !== undefined ? new RegExp(data.matches, data.flags) : data.value;
+    const equals = (actual) => expected instanceof RegExp ? typeof actual === 'string' && expected.test(actual) : (0, node_util_1.isDeepStrictEqual)(actual, expected);
+    const scope = data.frame ? page.frameLocator(data.frame) : page;
+    const elementCondition = !['url', 'title', 'localStorage', 'sessionStorage'].includes(data.condition);
+    if (elementCondition && !!data.selector === !!data.role)
+        throw new Error('Choose one selector or role.');
+    const locator = data.role ? scope.getByRole(data.role, { name: data.name, exact: true }) : scope.locator(data.selector || 'body');
+    const booleanConditions = ['visible', 'hidden', 'attached', 'enabled', 'disabled', 'editable', 'checked', 'empty', 'focused', 'inViewport'];
+    if (!booleanConditions.includes(data.condition) && data.condition !== 'attribute' && expected === undefined)
+        throw new Error('This assertion requires value or matches.');
+    if (data.condition === 'attribute' && !data.attribute || ['css', 'property'].includes(data.condition) && !data.property || ['localStorage', 'sessionStorage'].includes(data.condition) && !data.key)
+        throw new Error('Assertion requires an attribute, property, or storage key.');
+    if (data.condition === 'count' && (!Number.isSafeInteger(expected) || expected < 0))
+        throw new Error('Count requires a nonnegative integer.');
+    await (0, validation_1.poll)(async () => {
+        if (['accessibleName', 'accessibleDescription'].includes(data.condition))
+            await installAccessibilityNames(page);
+        let matched;
+        switch (data.condition) {
+            case 'url':
+                matched = equals(page.url());
+                break;
+            case 'title':
+                matched = equals(await page.title());
+                break;
+            case 'localStorage':
+            case 'sessionStorage':
+                matched = equals(await page.evaluate(({ kind, key }) => window[kind].getItem(key), { kind: data.condition, key: data.key }));
+                break;
+            case 'count':
+                matched = equals(await locator.count());
+                break;
+            case 'attached':
+                matched = await locator.count() > 0;
+                break;
+            case 'hidden':
+                matched = await locator.count() === 0 || await locator.isHidden();
+                break;
+            case 'visible':
+                matched = await locator.isVisible();
+                break;
+            default: {
+                if (await locator.count() !== 1)
+                    return false;
+                switch (data.condition) {
+                    case 'enabled':
+                        matched = await locator.isEnabled();
+                        break;
+                    case 'disabled':
+                        matched = await locator.isDisabled();
+                        break;
+                    case 'editable':
+                        matched = await locator.isEditable();
+                        break;
+                    case 'checked':
+                        matched = await locator.isChecked();
+                        break;
+                    case 'focused':
+                        matched = await locator.evaluate(element => element === element.ownerDocument.activeElement);
+                        break;
+                    case 'empty':
+                        matched = await locator.evaluate(element => (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement ? element.value : element.textContent || '').length === 0);
+                        break;
+                    case 'text':
+                        matched = equals((await locator.textContent())?.replace(/\s+/g, ' ').trim());
+                        break;
+                    case 'containsText': {
+                        const text = (await locator.textContent() || '').replace(/\s+/g, ' ').trim();
+                        matched = expected instanceof RegExp ? expected.test(text) : text.includes(String(expected));
+                        break;
+                    }
+                    case 'value':
+                        matched = equals(await locator.inputValue());
+                        break;
+                    case 'values':
+                        matched = equals(await locator.evaluate(element => Array.from(element.selectedOptions).map(option => option.value)));
+                        break;
+                    case 'attribute': {
+                        const value = await locator.getAttribute(data.attribute);
+                        matched = expected === undefined ? value !== null : equals(value);
+                        break;
+                    }
+                    case 'id':
+                        matched = equals(await locator.getAttribute('id'));
+                        break;
+                    case 'css':
+                        matched = equals(await locator.evaluate((element, key) => getComputedStyle(element).getPropertyValue(key), data.property));
+                        break;
+                    case 'property':
+                        matched = equals(await locator.evaluate((element, key) => element[key], data.property));
+                        break;
+                    case 'accessibleName':
+                    case 'accessibleDescription':
+                        matched = equals(await locator.evaluate((element, condition) => {
+                            const api = element.ownerDocument.defaultView.__FLOWSTRIDE_ACCESSIBILITY_NAMES__;
+                            return condition === 'accessibleName' ? api.computeAccessibleName(element) : api.computeAccessibleDescription(element);
+                        }, data.condition));
+                        break;
+                    case 'inViewport':
+                        matched = await locator.evaluate(element => { const box = element.getBoundingClientRect(); return box.width > 0 && box.height > 0 && box.bottom > 0 && box.right > 0 && box.top < innerHeight && box.left < innerWidth; });
+                        break;
+                    default: throw new Error('Unknown assertion condition.');
+                }
+            }
+        }
+        return data.not ? !matched : matched;
+    }, timeout, `${data.condition} ${data.selector || data.role || data.key || ''}`);
+}

package/dist/native/compatibility.d.ts

@@ -0,0 +1,3 @@
+import type { FlowstrideConfig } from '../types';
+/** Old Cloud engines remain usable for their existing commands. */
+export declare function needsNativeBrowserProtocol(target: string, config: FlowstrideConfig): boolean;

package/dist/native/compatibility.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsNativeBrowserProtocol = needsNativeBrowserProtocol;
+const node_fs_1 = __importDefault(require("node:fs"));
+const lexer_1 = require("../parser/lexer");
+const projectPaths_1 = require("../utils/projectPaths");
+/** Old Cloud engines remain usable for their existing commands. */
+function needsNativeBrowserProtocol(target, config) {
+    if (config.browser && config.browser !== 'chromium' || Object.keys(config.browserOptions || {}).length ||
+        config.retries || config.failOnFlaky || config.trace || config.har || config.domSnapshots || config.shard)
+        return true;
+    return (0, projectPaths_1.discoverFlows)(target, config.projectRoot || process.cwd()).some(file => new lexer_1.Lexer(node_fs_1.default.readFileSync(file, 'utf8')).tokenise().some(token => token.type === lexer_1.TokenType.ALIAS_COMMAND && /^flow\.(browser|assert|network|download|clock|stub|trace|har|a11y|component)\./i.test(token.value)));
+}

package/dist/native/components.d.ts

@@ -0,0 +1,12 @@
+import type { Page } from 'playwright';
+import type { FlowstrideConfig } from '../types';
+export declare class NativeComponents {
+    private config;
+    private server?;
+    private page?;
+    private mounted;
+    private framework?;
+    constructor(config: FlowstrideConfig);
+    execute(page: Page, action: string, input: unknown): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/native/components.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeComponents = void 0;
+const zod_1 = require("zod");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const projectPaths_1 = require("../utils/projectPaths");
+const node_crypto_1 = require("node:crypto");
+const schema = zod_1.z.object({ module: zod_1.z.string().min(1), framework: zod_1.z.enum(['vanilla', 'react', 'vue']), export: zod_1.z.string().regex(/^[a-zA-Z_$][\w$]*$/).default('default'), props: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).default({}), css: zod_1.z.array(zod_1.z.string()).default([]) }).strict();
+class NativeComponents {
+    config;
+    server;
+    page;
+    mounted = false;
+    framework;
+    constructor(config) {
+        this.config = config;
+    }
+    async execute(page, action, input) {
+        if (action === 'mount') {
+            const data = schema.parse(input);
+            await this.dispose();
+            const root = this.config.projectRoot || process.cwd(), module = (0, projectPaths_1.projectPath)(root, data.module);
+            const css = data.css.map(file => '/' + node_path_1.default.relative(root, (0, projectPaths_1.projectPath)(root, file)).split(node_path_1.default.sep).join('/'));
+            const projectRequire = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+            // Resolve project framework runtimes before starting any server.
+            if (data.framework === 'react') {
+                projectRequire.resolve('react');
+                projectRequire.resolve('react-dom/client');
+            }
+            if (data.framework === 'vue')
+                projectRequire.resolve('vue');
+            const { createServer } = await import('vite');
+            const plugins = [];
+            if (data.framework === 'react') {
+                const { default: react } = await import('@vitejs/plugin-react');
+                plugins.push(react({ jsxRuntime: 'automatic' }));
+            }
+            if (data.framework === 'vue') {
+                const { default: vue } = await import('@vitejs/plugin-vue');
+                plugins.push(vue());
+            }
+            const entry = `/__flowstride_component_${(0, node_crypto_1.randomUUID)()}`;
+            const moduleURL = '/' + node_path_1.default.relative(root, module).split(node_path_1.default.sep).join('/');
+            const importComponent = `import { ${data.export} as component } from ${JSON.stringify(moduleURL)};`;
+            const styles = css.map(file => `import ${JSON.stringify(file)};`).join('\n');
+            let kernel;
+            if (data.framework === 'react')
+                kernel = `import React from 'react'; import {createRoot} from 'react-dom/client'; const root = createRoot(target); export function update(props){root.render(React.createElement(component,props));} export function unmount(){root.unmount();}`;
+            else if (data.framework === 'vue')
+                kernel = `import {createApp,h,reactive} from 'vue'; const props=reactive({}); const app=createApp({render:()=>h(component,props)}); app.mount(target); export function update(next){for(const key of Object.keys(props))delete props[key];Object.assign(props,next);} export function unmount(){app.unmount();}`;
+            else
+                kernel = `let current; export function update(props){current?.unmount?.();target.replaceChildren();current=component(target,props);if(current instanceof Node)target.appendChild(current);} export function unmount(){current?.unmount?.();target.replaceChildren();}`;
+            const source = `${importComponent}\n${styles}\nconst target=document.getElementById('flowstride-component-root');\n${kernel}`;
+            plugins.push({ name: 'flowstride-component-module', resolveId(id) { if (id === entry + '.js')
+                    return '\0' + entry; }, load(id) { if (id === '\0' + entry)
+                    return source; } });
+            plugins.push({ name: 'flowstride-component-entry', configureServer(server) {
+                    server.middlewares.use((req, res, next) => {
+                        const host = `127.0.0.1:${server.httpServer.address()?.port}`;
+                        if (req.headers.host !== host || req.headers.origin && req.headers.origin !== `http://${host}`) {
+                            res.statusCode = 403;
+                            res.end('Forbidden');
+                            return;
+                        }
+                        if (req.url?.split('?')[0] !== entry)
+                            return next();
+                        res.setHeader('Content-Type', 'text/html');
+                        res.setHeader('Cache-Control', 'no-store');
+                        res.end('<!doctype html><html><head><title>Flowstride component test</title></head><body><div id="flowstride-component-root"></div></body></html>');
+                    });
+                } });
+            this.server = await createServer({ configFile: false, root, plugins, logLevel: 'error', cacheDir: (0, projectPaths_1.projectPath)(root, '.flowstride/component-cache'),
+                server: { host: '127.0.0.1', port: 0, cors: false, hmr: false, watch: null, fs: { strict: true, allow: [root], deny: ['.env', '.env.*', '**/.flowstride/**', '**/.git/**', '*.{crt,pem,key}'] } },
+                optimizeDeps: { noDiscovery: true, include: data.framework === 'react' ? ['react', 'react-dom/client'] : data.framework === 'vue' ? ['vue'] : [] }, appType: 'custom' });
+            try {
+                await this.server.listen();
+                const address = this.server.httpServer.address();
+                await page.goto(`http://127.0.0.1:${address.port}${entry}`);
+                await page.evaluate(async ({ entry, props }) => {
+                    const mod = await import(entry + '.js');
+                    window.__FLOWSTRIDE_COMPONENT__ = mod;
+                    mod.update(props);
+                }, { entry, props: data.props });
+                this.page = page;
+                this.mounted = true;
+                this.framework = data.framework;
+            }
+            catch (error) {
+                await this.dispose();
+                throw error;
+            }
+            return;
+        }
+        if (!this.mounted || page !== this.page)
+            throw new Error('Mount a component on this page first.');
+        if (action === 'update') {
+            const data = zod_1.z.object({ props: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()) }).strict().parse(input);
+            await page.evaluate(props => window.__FLOWSTRIDE_COMPONENT__.update(props), data.props);
+            return;
+        }
+        if (action === 'unmount') {
+            zod_1.z.object({}).strict().parse(input);
+            await page.evaluate(() => window.__FLOWSTRIDE_COMPONENT__.unmount());
+            this.mounted = false;
+            return;
+        }
+        throw new Error(`Unknown component action: ${action}`);
+    }
+    async dispose() {
+        if (this.mounted && this.page && !this.page.isClosed())
+            await this.page.evaluate(() => window.__FLOWSTRIDE_COMPONENT__?.unmount()).catch(() => { });
+        this.mounted = false;
+        this.page = undefined;
+        await this.server?.close();
+        this.server = undefined;
+    }
+}
+exports.NativeComponents = NativeComponents;

package/dist/native/dashboard.d.ts

@@ -0,0 +1,7 @@
+import type { FlowstrideConfig } from '../types';
+/** The dashboard has its own browser; it never shares test cookies or hooks. */
+export declare class DashboardBrowser {
+    private browser?;
+    open(url: string, engine?: FlowstrideConfig['browser']): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/native/dashboard.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardBrowser = void 0;
+const playwright_1 = require("playwright");
+/** The dashboard has its own browser; it never shares test cookies or hooks. */
+class DashboardBrowser {
+    browser;
+    async open(url, engine = 'chromium') {
+        if (engine === 'chromium') {
+            const { default: open } = await import('open');
+            await open(url);
+            return;
+        }
+        if (engine !== 'firefox' && engine !== 'webkit')
+            throw new Error('Unknown dashboard browser.');
+        try {
+            this.browser = await (engine === 'firefox' ? playwright_1.firefox : playwright_1.webkit).launch({ headless: false });
+            const page = await this.browser.newPage();
+            await page.goto(url);
+        }
+        catch (error) {
+            await this.close();
+            throw error;
+        }
+    }
+    async close() {
+        const browser = this.browser;
+        this.browser = undefined;
+        await browser?.close();
+    }
+}
+exports.DashboardBrowser = DashboardBrowser;