flowstride 1.0.20 → 1.0.22

package/dist/manual/security.d.ts

@@ -61,6 +61,9 @@ export declare const manualRunSchema: z.ZodObject<{
                 failed: "failed";
                 skipped: "skipped";
                 success: "success";
+                pending: "pending";
+                pass: "pass";
+                blocked: "blocked";
                 Pending: "Pending";
                 Current: "Current";
                 Passed: "Passed";
@@ -70,9 +73,6 @@ export declare const manualRunSchema: z.ZodObject<{
                 Pass: "Pass";
                 Fail: "Fail";
                 Success: "Success";
-                pass: "pass";
-                pending: "pending";
-                blocked: "blocked";
             }>;
             group_title: z.ZodOptional<z.ZodString>;
             id: z.ZodNumber;
@@ -143,6 +143,9 @@ export declare const manualCanvasSchema: z.ZodObject<{
             failed: "failed";
             skipped: "skipped";
             success: "success";
+            pending: "pending";
+            pass: "pass";
+            blocked: "blocked";
             Pending: "Pending";
             Current: "Current";
             Passed: "Passed";
@@ -152,9 +155,6 @@ export declare const manualCanvasSchema: z.ZodObject<{
             Pass: "Pass";
             Fail: "Fail";
             Success: "Success";
-            pass: "pass";
-            pending: "pending";
-            blocked: "blocked";
         }>;
         group_title: z.ZodOptional<z.ZodString>;
         id: z.ZodNumber;

package/dist/native/accessibility.d.ts

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

package/dist/native/accessibility.js

@@ -0,0 +1,84 @@
+"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 assertion_result_1 = require("../reporting/assertion_result");
+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, reporter) {
+    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 });
+        (0, assertion_result_1.requireAssertion)('a11y.scan', 'accessibility scan ' + data.name, [(0, assertion_result_1.assertionCheck)('violations', 'Violation count within the allowed maximum', violations.length <= data.maxViolations, `at most ${data.maxViolations}`, violations.length)], reporter, { reason: violations.length > data.maxViolations ? `Accessibility assertion failed: ${violations.length} violations (${violations.map(item => item.id).slice(0, 30).join(', ')}). Report: ${file}` : undefined });
+        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();
+            (0, assertion_result_1.requireAssertion)('a11y.snapshot', 'ARIA baseline ' + data.baseline, [(0, assertion_result_1.assertionCheck)('baseline', 'ARIA baseline matches', expected === snapshot.trim(), expected, snapshot.trim())], reporter, { reason: expected !== snapshot.trim() ? `ARIA baseline differs. Review the captured snapshot before updating: ${file}` : undefined });
+        }
+        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);
+        const started = Date.now(), timeout = data.timeout ?? config.timeout;
+        let latest = (0, assertion_result_1.reportAssertion)('a11y.match', 'ARIA snapshot ' + data.selector, [{ key: 'snapshot', label: 'ARIA snapshot matches', status: 'running' }], reporter, { status: 'running', timeout, elapsed: 0 });
+        let closed = false;
+        try {
+            await (0, validation_1.poll)(async () => { const actual = (await page.locator(data.selector).ariaSnapshot()).trim(), expected = data.yaml.replace(/\r\n/g, '\n').trim(); const check = (0, assertion_result_1.assertionCheck)('snapshot', 'ARIA snapshot matches', actual === expected, expected, actual); if (!closed)
+                latest = (0, assertion_result_1.reportAssertion)('a11y.match', 'ARIA snapshot ' + data.selector, [check], reporter, { status: 'running', timeout, elapsed: Date.now() - started }); return check.status === 'passed'; }, timeout, 'ARIA snapshot differs');
+            closed = true;
+            reporter?.({ ...latest, status: 'passed', elapsed: Date.now() - started });
+        }
+        catch (error) {
+            closed = true;
+            const result = { ...latest, status: 'failed', elapsed: Date.now() - started, reason: (0, assertion_result_1.diagnosticValue)(error instanceof Error ? error.message : String(error)) };
+            for (const check of result.checks)
+                if (check.status === 'running')
+                    check.status = 'failed';
+            reporter?.(result);
+            throw new assertion_result_1.AssertionFailure(result);
+        }
+        return;
+    }
+    throw new Error(`Unknown accessibility action: ${action}`);
+}

package/dist/native/assertions.d.ts

@@ -0,0 +1,3 @@
+import type { Page } from 'playwright';
+import { type AssertionReporter } from '../reporting/assertion_result';
+export declare function assertBrowser(page: Page, input: unknown, defaultTimeout: number, reporter?: AssertionReporter): Promise<void>;

package/dist/native/assertions.js

@@ -0,0 +1,223 @@
+"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");
+const assertion_result_1 = require("../reporting/assertion_result");
+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, reporter) {
+    const data = schema.parse(input), timeout = data.timeout ?? defaultTimeout, started = Date.now();
+    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.');
+    const target = elementCondition ? (data.role ? `${data.role}${data.name === undefined ? '' : ' named ' + JSON.stringify(data.name)}` : data.selector) + (data.frame ? ` inside frame ${data.frame}` : '') : data.key ? `${data.condition} key ${JSON.stringify(data.key)}` : `page ${data.condition}`;
+    const needsSingle = elementCondition && !['count', 'attached'].includes(data.condition);
+    let latest = (0, assertion_result_1.reportAssertion)('assert.that', target, [{ key: 'target', label: 'Target lookup: ' + target, status: 'running' }, { key: 'condition', label: 'condition: ' + data.condition, status: 'not_evaluated' }], reporter, { status: 'running', timeout, elapsed: 0 });
+    let closed = false, lastReadError;
+    const progress = (checks) => {
+        if (closed)
+            return;
+        latest = (0, assertion_result_1.reportAssertion)('assert.that', target, checks, reporter, { status: 'running', timeout, elapsed: Date.now() - started });
+    };
+    try {
+        await (0, validation_1.poll)(async () => {
+            let count, roleCount, actual, matched = false, evaluated = false;
+            let sensitive = !!data.key && /password|passcode|token|secret|authorization|cookie|api.?key|otp/i.test(data.key);
+            lastReadError = undefined;
+            try {
+                if (elementCondition) {
+                    count = await locator.count();
+                    roleCount = data.role && data.name !== undefined && count === 0 ? await scope.getByRole(data.role).count() : count;
+                    if (count === 1 && (['value', 'values'].includes(data.condition) || data.attribute === 'value' || data.property === 'value')) {
+                        sensitive ||= await locator.evaluate(element => {
+                            const hints = ['type', 'name', 'id', 'autocomplete'].map(key => element.getAttribute(key) || '').join(' ');
+                            return /password|passcode|token|secret|authorization|cookie|api.?key|one-time-code|otp/i.test(hints);
+                        });
+                    }
+                }
+                if (!needsSingle || count === 1 || count === 0 && ['visible', 'hidden'].includes(data.condition)) {
+                    evaluated = true;
+                    if (['accessibleName', 'accessibleDescription'].includes(data.condition))
+                        await installAccessibilityNames(page);
+                    switch (data.condition) {
+                        case 'url':
+                            actual = page.url();
+                            matched = equals(actual);
+                            break;
+                        case 'title':
+                            actual = await page.title();
+                            matched = equals(actual);
+                            break;
+                        case 'localStorage':
+                        case 'sessionStorage':
+                            actual = await page.evaluate(({ kind, key }) => window[kind].getItem(key), { kind: data.condition, key: data.key });
+                            matched = equals(actual);
+                            break;
+                        case 'count':
+                            actual = count;
+                            matched = equals(actual);
+                            break;
+                        case 'attached':
+                            actual = count > 0;
+                            matched = actual === true;
+                            break;
+                        case 'hidden':
+                            actual = count === 0 || await locator.isHidden();
+                            matched = actual === true;
+                            break;
+                        case 'visible':
+                            actual = await locator.isVisible();
+                            matched = actual === true;
+                            break;
+                        case 'enabled':
+                            actual = await locator.isEnabled();
+                            matched = actual === true;
+                            break;
+                        case 'disabled':
+                            actual = await locator.isDisabled();
+                            matched = actual === true;
+                            break;
+                        case 'editable':
+                            actual = await locator.isEditable();
+                            matched = actual === true;
+                            break;
+                        case 'checked':
+                            actual = await locator.isChecked();
+                            matched = actual === true;
+                            break;
+                        case 'focused':
+                            actual = await locator.evaluate(element => element === element.ownerDocument.activeElement);
+                            matched = actual === true;
+                            break;
+                        case 'empty':
+                            actual = await locator.evaluate(element => (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement ? element.value : element.textContent || '').length === 0);
+                            matched = actual === true;
+                            break;
+                        case 'text':
+                            actual = (await locator.textContent())?.replace(/\s+/g, ' ').trim();
+                            matched = equals(actual);
+                            break;
+                        case 'containsText':
+                            actual = (await locator.textContent() || '').replace(/\s+/g, ' ').trim();
+                            matched = expected instanceof RegExp ? expected.test(String(actual)) : String(actual).includes(String(expected));
+                            break;
+                        case 'value':
+                            actual = await locator.inputValue();
+                            matched = equals(actual);
+                            break;
+                        case 'values':
+                            actual = await locator.evaluate(element => Array.from(element.selectedOptions).map(option => option.value));
+                            matched = equals(actual);
+                            break;
+                        case 'attribute':
+                            actual = await locator.getAttribute(data.attribute);
+                            matched = expected === undefined ? actual !== null : equals(actual);
+                            break;
+                        case 'id':
+                            actual = await locator.getAttribute('id');
+                            matched = equals(actual);
+                            break;
+                        case 'css':
+                            actual = await locator.evaluate((element, key) => getComputedStyle(element).getPropertyValue(key), data.property);
+                            matched = equals(actual);
+                            break;
+                        case 'property':
+                            actual = await locator.evaluate((element, key) => element[key], data.property);
+                            matched = equals(actual);
+                            break;
+                        case 'accessibleName':
+                        case 'accessibleDescription':
+                            actual = await locator.evaluate((element, condition) => { const api = element.ownerDocument.defaultView.__FLOWSTRIDE_ACCESSIBILITY_NAMES__; return condition === 'accessibleName' ? api.computeAccessibleName(element) : api.computeAccessibleDescription(element); }, data.condition);
+                            matched = equals(actual);
+                            break;
+                        case 'inViewport':
+                            actual = 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; });
+                            matched = actual === true;
+                            break;
+                    }
+                    if (data.not)
+                        matched = !matched;
+                }
+            }
+            catch (error) {
+                lastReadError = (0, assertion_result_1.diagnosticValue)(error instanceof Error ? error.message : String(error));
+                evaluated = false;
+                matched = false;
+            }
+            const checks = [];
+            if (elementCondition) {
+                const absenceAllowed = count === 0 && matched;
+                const lookup = { key: 'target', label: count === 0 && absenceAllowed ? 'Target absent as expected' : 'Target found: ' + target, status: count === undefined ? 'failed' : count > 0 || absenceAllowed ? 'passed' : data.condition === 'count' ? 'not_evaluated' : 'failed', actual: count === undefined ? 'Could not resolve the target' : `${count} matching target(s)` };
+                if (lastReadError && count === undefined)
+                    lookup.reason = lastReadError;
+                const part = (key, label, found) => ({ key, label, status: found === true ? 'passed' : absenceAllowed || count === undefined || data.condition === 'count' ? 'not_evaluated' : found === false ? 'failed' : 'not_evaluated' });
+                lookup.children = [];
+                if (data.role)
+                    lookup.children.push(part('role', 'role: ' + data.role, roleCount === undefined ? undefined : roleCount > 0));
+                if (data.name !== undefined)
+                    lookup.children.push(part('name', 'name: ' + data.name, count === undefined || !roleCount ? undefined : count > 0));
+                if (data.selector)
+                    lookup.children.push(part('selector', 'selector: ' + data.selector, count === undefined ? undefined : count > 0));
+                checks.push(lookup);
+                if (needsSingle && count !== 0)
+                    checks.push(count === undefined ? { key: 'unique', label: 'Exactly one matching target', status: 'not_evaluated' } : (0, assertion_result_1.assertionCheck)('unique', 'Exactly one matching target', count === 1, 1, count));
+                else if (needsSingle)
+                    checks.push({ key: 'unique', label: 'Exactly one matching target', status: 'not_evaluated', reason: absenceAllowed ? 'A matching element is not required for this condition.' : 'Target lookup did not find an element.' });
+            }
+            const opposites = { visible: 'not visible', hidden: 'visible', attached: 'absent', enabled: 'disabled', disabled: 'enabled', editable: 'not editable', checked: 'unchecked', empty: 'not empty', focused: 'not focused', inViewport: 'outside the viewport' };
+            const positiveLabel = { inViewport: 'inside the viewport' };
+            const wanted = sensitive ? '[REDACTED]' : booleanConditions.includes(data.condition) ? (data.not ? opposites[data.condition] : positiveLabel[data.condition] || data.condition) : data.condition === 'attribute' && expected === undefined ? 'present' : `${data.not ? 'not ' : ''}${expected instanceof RegExp ? expected.toString() : (0, assertion_result_1.diagnosticValue)(expected)}`;
+            const observed = sensitive ? '[REDACTED]' : booleanConditions.includes(data.condition) && typeof actual === 'boolean' ? (actual ? positiveLabel[data.condition] || data.condition : opposites[data.condition]) : (0, assertion_result_1.diagnosticValue)(actual);
+            checks.push(evaluated ? (0, assertion_result_1.assertionCheck)('condition', 'condition: ' + data.condition + (data.attribute ? ' ' + data.attribute : data.property ? ' ' + data.property : ''), matched, wanted, observed) : { key: 'condition', label: 'condition: ' + data.condition, status: 'not_evaluated', expected: wanted, reason: lastReadError || 'The target could not be resolved uniquely.' });
+            if (lastReadError && checks.at(-1))
+                checks.at(-1).reason = lastReadError;
+            progress(checks);
+            return evaluated && matched;
+        }, timeout, `${data.condition} ${target}`);
+        closed = true;
+        reporter?.({ ...latest, status: 'passed', elapsed: Date.now() - started });
+    }
+    catch (error) {
+        closed = true;
+        const result = { ...latest, status: 'failed', elapsed: Date.now() - started, reason: (0, assertion_result_1.diagnosticValue)(error instanceof Error ? error.message : String(error)) };
+        if (!result.checks.some(check => check.status === 'failed'))
+            result.checks.push({ key: 'read', label: 'Assertion could be evaluated', status: 'failed', reason: lastReadError || result.reason });
+        reporter?.(result);
+        throw new assertion_result_1.AssertionFailure(result);
+    }
+}

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;

package/dist/native/deadline.d.ts

@@ -0,0 +1,2 @@
+/** Only commands whose validated contract accepts a timeout may override it. */
+export declare function nativeStepTimeout(command: string, input: unknown, fallback: number): number;

package/dist/native/deadline.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeStepTimeout = nativeStepTimeout;
+const validation_1 = require("./validation");
+/** Only commands whose validated contract accepts a timeout may override it. */
+function nativeStepTimeout(command, input, fallback) {
+    if (['assert.that', 'a11y.match', 'a11y.snapshot', 'stub.expect'].includes(command) &&
+        input !== null && typeof input === 'object' && !Array.isArray(input) &&
+        Object.hasOwn(input, 'timeout')) {
+        return validation_1.positive.parse(input.timeout);
+    }
+    return fallback;
+}

package/dist/native/events.d.ts

@@ -0,0 +1,35 @@
+import { type AssertionReporter } from '../reporting/assertion_result';
+import type { FlowstrideConfig } from '../types';
+import { WebAdapter } from '../adapters/web/playwright';
+export declare class ArmedEvent<T> {
+    private detach;
+    private settled;
+    private timer;
+    private resolve;
+    readonly promise: Promise<{
+        value?: T;
+        error?: Error;
+    }>;
+    constructor(timeout: number, detach: () => void);
+    capture(value: T): void;
+    fail(error: Error): void;
+    take(): Promise<T>;
+}
+export declare function matchesURL(pattern: string, url: string): boolean;
+export declare class NativeEvents {
+    private web;
+    private config;
+    private routes;
+    private events;
+    private captured;
+    private routeErrors;
+    private generation;
+    private downloads;
+    private savedDownloads;
+    constructor(web: WebAdapter, config: FlowstrideConfig);
+    private key;
+    network(action: string, input: unknown, reporter?: AssertionReporter): Promise<any>;
+    download(action: string, input: unknown, reporter?: AssertionReporter): Promise<any>;
+    disposeProfile(profile: string): Promise<void>;
+    dispose(): Promise<void>;
+}