@testspectra/cli 1.1.11-rc.3 → 1.1.12

package/dist/commands/run.js

@@ -4,9 +4,10 @@ import { ConfigLoader } from '../config/loader.js';
 import { RustCoreBridge } from '../runner/bridge.js';
 import { Reporter } from '../runner/reporter.js';
 import { TypeGenerator } from '../types/generator.js';
-import { DemoServer } from '../utils/demo-server.js';
+import { DemoServer, DEFAULT_DEMO_PORT } from '../utils/demo-server.js';
 import { DemoApiServer } from '../utils/api-server.js';
 import { DevServerManager } from '../utils/dev-server-manager.js';
+import { DemoStateManager } from '../utils/demo-state.js';
 function renderSummaryCard(options) {
     const width = 64;
     const borderColor = options.isPassed ? '\x1b[38;2;52;211;153m' : '\x1b[38;2;248;113;113m';
@@ -69,6 +70,15 @@ function renderSummaryCard(options) {
     if (options.networkReportPath) {
         console.log(row(`${dim}Network${reset}`, `${dim}${options.networkReportPath}${reset}`));
     }
+    if (options.videoPaths && options.videoPaths.length > 0) {
+        const reportsDir = path.dirname(options.reportPath);
+        const videoDir = (reportsDir !== '.'
+            ? path.join(reportsDir, 'videos')
+            : path.dirname(options.videoPaths[0]) !== '.'
+                ? path.dirname(options.videoPaths[0])
+                : 'videos').replace(/\\/g, '/');
+        console.log(row(`${dim}Videos${reset}`, `${yellow}${options.videoPaths.length} failed recorded${reset} ${dim}(${videoDir})${reset}`));
+    }
     console.log(`${bot}\n`);
 }
 const TIMING_PHASE_LABELS = {
@@ -170,6 +180,13 @@ export async function runCommand(specPaths, options = {}) {
             console.warn(`\x1b[33m[TestSpectra] Warning: Target host "${options.host}" is not defined in spectra.config.ts (webConfig.hosts). Falling back to ${config.webConfig.baseUrl}\x1b[0m`);
         }
     }
+    else if (!options.demo) {
+        const activeDemo = await DemoStateManager.getActiveDemoServer(cwd);
+        if (activeDemo) {
+            config.webConfig.baseUrl = activeDemo.url;
+            console.log(`\x1b[36m[TestSpectra]\x1b[0m 🌐 Connected to active demo server at: \x1b[33m${activeDemo.url}\x1b[0m`);
+        }
+    }
     let demoServer = null;
     let apiServer = null;
     const devServerManager = new DevServerManager();
@@ -178,11 +195,21 @@ export async function runCommand(specPaths, options = {}) {
             ...(config.webConfig.devServers || []),
             ...(config.webConfig.devServer ? [config.webConfig.devServer] : []),
         ];
-        if (configuredDevServers.length > 0 && !options.demo) {
+        const shouldStartDevServers = options.devServer !== false &&
+            options.devServers !== false &&
+            !options.skipDevServers &&
+            process.env.SPECTRA_SKIP_DEV_SERVERS !== '1' &&
+            process.env.SPECTRA_SKIP_DEV_SERVERS !== 'true' &&
+            process.env.SPECTRA_SKIP_DEV_SERVER !== '1' &&
+            process.env.SPECTRA_SKIP_DEV_SERVER !== 'true' &&
+            process.env.TESTSPECTRA_SKIP_DEV_SERVERS !== '1' &&
+            process.env.TESTSPECTRA_SKIP_DEV_SERVERS !== 'true';
+        if (shouldStartDevServers && configuredDevServers.length > 0 && !options.demo) {
             await devServerManager.startAll(configuredDevServers, options.host, cwd);
         }
         if (options.demo) {
-            demoServer = new DemoServer(5173);
+            // Try preferred static port first (DEFAULT_DEMO_PORT); if occupied, DemoServer automatically falls back to an ephemeral port
+            demoServer = new DemoServer(DEFAULT_DEMO_PORT);
             try {
                 const { url } = await demoServer.start();
                 config.webConfig.baseUrl = url;
@@ -200,7 +227,7 @@ export async function runCommand(specPaths, options = {}) {
                 console.warn(`\x1b[33m[TestSpectra] Warning: Could not start built-in demo API server: ${err.message}\x1b[0m`);
             }
         }
-        if (options.headed) {
+        if (options.debug || options.headed) {
             config.webConfig.headless = false;
         }
         else if (options.headless !== undefined) {
@@ -215,6 +242,13 @@ export async function runCommand(specPaths, options = {}) {
                 config.iosConfig.stepDelay = delayNum;
             }
         }
+        if (options.video !== undefined) {
+            config.webConfig.video = options.video;
+            if (config.androidConfig)
+                config.androidConfig.video = options.video;
+            if (config.iosConfig)
+                config.iosConfig.video = options.video;
+        }
         const platform = options.target || 'web';
         const userConcurrency = options.concurrency ? parseInt(String(options.concurrency), 10) : undefined;
         console.log(`\x1b[36m[TestSpectra]\x1b[0m Starting execution on target \x1b[1m${platform}\x1b[0m...`);
@@ -258,9 +292,11 @@ export async function runCommand(specPaths, options = {}) {
             licenseKey: options.licenseKey,
             outputJsonPath,
             specs: effectiveSpecPaths,
-            concurrency: userConcurrency,
+            concurrency: options.debug ? 1 : userConcurrency,
             failedOnly: isFailedMode,
             failedTarget,
+            debug: options.debug,
+            inspectPort: options.inspectPort ? Number(options.inspectPort) : undefined,
         }, reporter);
         const isPassed = result.status.toLowerCase() === 'passed';
         const relReport = path.relative(cwd, outputJsonPath);
@@ -296,6 +332,7 @@ export async function runCommand(specPaths, options = {}) {
             finalDuration = totalMs < 1000 ? `${Math.round(totalMs)}ms` : `${(totalMs / 1000).toFixed(1)}s`;
         }
         const overallPassed = isPassed && totalFailed === 0;
+        const videoPaths = [];
         if (fs.existsSync(outputJsonPath)) {
             try {
                 const fullReport = JSON.parse(fs.readFileSync(outputJsonPath, 'utf8'));
@@ -307,6 +344,13 @@ export async function runCommand(specPaths, options = {}) {
                         s.status === 'failed' ||
                         s.tests?.some((t) => t.passed === false || t.status === 'failed')).length;
                     passedSuites = fullReport.suites.length - failedSuites;
+                    for (const s of fullReport.suites) {
+                        for (const t of s.tests || []) {
+                            if (t.videoPath) {
+                                videoPaths.push(t.videoPath);
+                            }
+                        }
+                    }
                 }
                 if (fullReport.performance) {
                     renderSummaryCard({
@@ -323,6 +367,7 @@ export async function runCommand(specPaths, options = {}) {
                         carriedPassed,
                         reportPath: relReport,
                         networkReportPath: relNetworkReport,
+                        videoPaths,
                     });
                     renderTimingBreakdown({
                         ...fullReport.performance,
@@ -354,6 +399,7 @@ export async function runCommand(specPaths, options = {}) {
             carriedPassed,
             reportPath: relReport,
             networkReportPath: relNetworkReport,
+            videoPaths,
         });
         if (!overallPassed || totalFailed > 0) {
             process.exitCode = 1;

package/dist/commands/test.d.ts

@@ -1,6 +1,5 @@
 export interface TestCommandOptions {
     cwd?: string;
-    runner?: 'spectra' | 'vitest';
     headed?: boolean;
     headless?: boolean;
     stepDelay?: string | number;
@@ -10,20 +9,21 @@ export interface TestCommandOptions {
     concurrency?: string | number;
 }
 /**
- * Guarantees the `.testspectra` solution-tsconfig scaffolding exists before Vitest starts.
+ * Guarantees the `.testspectra` solution-tsconfig scaffolding exists before the component
+ * runner starts.
  *
- * The bundled Vitest browser runner transpiles raw TypeScript specs/page-objects Just-In-Time.
- * When it does, `vite:esbuild` walks the nearest `tsconfig.json` and tries to read every entry in
+ * The bundled component runner transpiles raw TypeScript specs/page-objects Just-In-Time.
+ * When it does, esbuild walks the nearest `tsconfig.json` and tries to read every entry in
  * its `references` — including `./.testspectra/tsconfig.json`. That directory is gitignored, so on
  * a clean clone / fresh CI checkout the reference points at a file that does not exist, esbuild
- * throws `ENOENT`, Vite answers HTTP 500, and every suite dies with "Failed to fetch dynamically
- * imported module" before a single assertion runs. Regenerating the scaffolding up front (same
- * output as `spectra sync-types`) keeps the reference resolvable.
+ * throws `ENOENT`, and every suite dies before a single assertion runs. Regenerating the
+ * scaffolding up front (same output as `spectra sync-types`) keeps the reference resolvable.
  */
 export declare function ensureTestSpectraScaffolding(cwd: string): void;
 /**
- * `spectra test` — delegates to `@testspectra/react`'s bundled Vitest browser-mode runner for
- * component testing. Deliberately separate from `spectra run` (E2E via core/orchestrator): see
+ * `spectra test` — runs React component tests via the native CDP engine
+ * (`@testspectra/react` bundle server + Rust `core/orchestrator::component_runner`).
+ * Deliberately separate from `spectra run` (E2E via core/orchestrator): see
  * docs/v2/features/component-testing/react/README.md §2 for why these are two independent
  * runners rather than one extended pipeline.
  */

package/dist/commands/test.js

@@ -9,15 +9,15 @@ import { RustCoreBridge } from '../runner/bridge.js';
 import { TypeGenerator } from '../generator/type-generator.js';
 import { runSystemChecks } from './doctor.js';
 /**
- * Guarantees the `.testspectra` solution-tsconfig scaffolding exists before Vitest starts.
+ * Guarantees the `.testspectra` solution-tsconfig scaffolding exists before the component
+ * runner starts.
  *
- * The bundled Vitest browser runner transpiles raw TypeScript specs/page-objects Just-In-Time.
- * When it does, `vite:esbuild` walks the nearest `tsconfig.json` and tries to read every entry in
+ * The bundled component runner transpiles raw TypeScript specs/page-objects Just-In-Time.
+ * When it does, esbuild walks the nearest `tsconfig.json` and tries to read every entry in
  * its `references` — including `./.testspectra/tsconfig.json`. That directory is gitignored, so on
  * a clean clone / fresh CI checkout the reference points at a file that does not exist, esbuild
- * throws `ENOENT`, Vite answers HTTP 500, and every suite dies with "Failed to fetch dynamically
- * imported module" before a single assertion runs. Regenerating the scaffolding up front (same
- * output as `spectra sync-types`) keeps the reference resolvable.
+ * throws `ENOENT`, and every suite dies before a single assertion runs. Regenerating the
+ * scaffolding up front (same output as `spectra sync-types`) keeps the reference resolvable.
  */
 export function ensureTestSpectraScaffolding(cwd) {
     const masterConfigPath = path.join(cwd, '.testspectra', 'tsconfig.json');
@@ -28,17 +28,16 @@ export function ensureTestSpectraScaffolding(cwd) {
 /**
  * Finds the Chrome-for-Testing binary that `spectra doctor` already installs/manages for the
  * E2E CDP driver (`core/driver-cdp`) — same install, same binary. `@testspectra/react` must not
- * contain any browser-discovery logic of its own (see the package-level comment in
- * tools/react/vitest.config.ts): this is the one place that resolves the path, passed down to
- * the bundled Vitest/Playwright runner as a plain argument (env var), so component testing never
- * requires a separate `playwright install` download alongside TestSpectra's own browser.
+ * contain any browser-discovery logic of its own: this is the one place that resolves the path,
+ * passed down to the native CDP component runner as a plain argument, so component testing never
+ * requires a separate browser download alongside TestSpectra's own browser.
  */
 async function resolveBrowserExecutable(cwd) {
     try {
         // `--only chrome` runs exactly one check — no adb/bun/git spawns, no Matchers lookup — since
         // this call exists solely to locate the managed browser binary.
         const { dependencies } = await runSystemChecks(cwd, { only: 'chrome' });
-        const chrome = dependencies.find((d) => d.category === 'web' && d.name.includes('Chrome'));
+        const chrome = dependencies.find((d) => d.category === 'web' && (d.name.includes('Chrome') || d.name.includes('Chromium')));
         return chrome?.installed && chrome.location ? chrome.location : null;
     }
     catch {
@@ -46,8 +45,9 @@ async function resolveBrowserExecutable(cwd) {
     }
 }
 /**
- * `spectra test` — delegates to `@testspectra/react`'s bundled Vitest browser-mode runner for
- * component testing. Deliberately separate from `spectra run` (E2E via core/orchestrator): see
+ * `spectra test` — runs React component tests via the native CDP engine
+ * (`@testspectra/react` bundle server + Rust `core/orchestrator::component_runner`).
+ * Deliberately separate from `spectra run` (E2E via core/orchestrator): see
  * docs/v2/features/component-testing/react/README.md §2 for why these are two independent
  * runners rather than one extended pipeline.
  */
@@ -116,71 +116,36 @@ export async function testCommand(options = {}) {
     // / setup.ts), so the same Reporter class parses them with zero changes on either side.
     const reporter = new Reporter();
     const runStartedAt = Date.now();
+    logPhase('Starting component test runner (Spectra Native CDP Engine)…');
+    const bundleServer = await reactPkg.startBundleServer({
+        testRoot: cwd,
+        stepDelayMs: stepDelayMs ?? 0,
+    });
     let ok = false;
-    if (options.runner === 'vitest') {
-        logPhase('Starting component test runner (Vitest Browser Mode)…');
-        ok = await reactPkg.runComponentTests({
-            runner: 'vitest',
-            cwd,
-            headless,
-            stepDelayMs,
-            spec: options.spec,
-            outputFile,
-            concurrency: concurrency !== undefined && !isNaN(concurrency) ? concurrency : undefined,
-            browserExecutablePath,
-            onLine: (line) => {
-                const cleanLine = line.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '').trim();
-                if (!cleanLine)
-                    return;
-                if (cleanLine.startsWith('[TESTSPECTRA_')) {
-                    reporter.addLog({ timestamp: new Date().toLocaleTimeString(), level: 'INFO', message: cleanLine });
-                    if (!reporter.isInteractiveMode()) {
-                        console.log(cleanLine);
-                    }
-                    return;
-                }
-                if (reactPkg.isVitestNoise?.(cleanLine)) {
-                    return;
-                }
-                const sanitized = reactPkg.sanitizeErrorMessage?.(cleanLine) ?? cleanLine;
-                reporter.addLog({ timestamp: new Date().toLocaleTimeString(), level: 'ERROR', message: sanitized });
-                if (!reporter.isInteractiveMode()) {
-                    console.error(chalk.red(sanitized));
-                }
+    try {
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const globalAppDataPath = path.join(home, '.testspectra');
+        const appDataPath = globalAppDataPath;
+        const runResult = await RustCoreBridge.run({
+            baseDir: cwd,
+            appDataPath,
+            platform: 'component',
+            config: {
+                bundleServerUrl: bundleServer.url,
+                webConfig: {
+                    headless,
+                    stepDelay: stepDelayMs,
+                    browserExecutablePath,
+                },
             },
-        });
+            specs: options.spec ? [options.spec] : undefined,
+            concurrency: concurrency !== undefined && !isNaN(concurrency) ? concurrency : undefined,
+            outputJsonPath: outputFile,
+        }, reporter);
+        ok = runResult.status.toLowerCase() === 'passed';
     }
-    else {
-        logPhase('Starting component test runner (Spectra Native CDP Engine)…');
-        const bundleServer = await reactPkg.startBundleServer({
-            testRoot: cwd,
-            stepDelayMs: stepDelayMs ?? 0,
-        });
-        try {
-            const home = process.env.HOME || process.env.USERPROFILE || '';
-            const globalAppDataPath = path.join(home, '.testspectra');
-            const appDataPath = globalAppDataPath;
-            const runResult = await RustCoreBridge.run({
-                baseDir: cwd,
-                appDataPath,
-                platform: 'component',
-                config: {
-                    bundleServerUrl: bundleServer.url,
-                    webConfig: {
-                        headless,
-                        stepDelay: stepDelayMs,
-                        browserExecutablePath,
-                    },
-                },
-                specs: options.spec ? [options.spec] : undefined,
-                concurrency: concurrency !== undefined && !isNaN(concurrency) ? concurrency : undefined,
-                outputJsonPath: outputFile,
-            }, reporter);
-            ok = runResult.status.toLowerCase() === 'passed';
-        }
-        finally {
-            bundleServer.stop();
-        }
+    finally {
+        bundleServer.stop();
     }
     const durationMs = Date.now() - runStartedAt;
     const result = reporter.generateResult(ok ? 'passed' : 'failed', `${(durationMs / 1000).toFixed(1)}s`);

package/dist/commands/update.d.ts

@@ -0,0 +1,3 @@
+export declare function updateCommand(options?: {
+    check?: boolean;
+}): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,109 @@
+import { execSync, execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGES = ['@testspectra/cli', '@testspectra/matchers'];
+function getLatestVersion(pkg) {
+    try {
+        const out = execFileSync('npm', ['view', pkg, 'version', '--json'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 10000,
+        })
+            .toString()
+            .trim()
+            .replace(/"/g, '');
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+function getCurrentVersion(pkg, cwd) {
+    // Walk up to find the installed version
+    let cur = path.resolve(cwd);
+    while (cur && cur !== path.dirname(cur)) {
+        const pkgJson = path.join(cur, 'node_modules', pkg, 'package.json');
+        if (fs.existsSync(pkgJson)) {
+            try {
+                const p = JSON.parse(fs.readFileSync(pkgJson, 'utf-8'));
+                return p.version ?? null;
+            }
+            catch { }
+        }
+        cur = path.dirname(cur);
+    }
+    return null;
+}
+function detectPackageManager(cwd) {
+    if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(cwd, 'bun.lockb')) || fs.existsSync(path.join(cwd, 'bun.lock')))
+        return 'bun';
+    return 'npm';
+}
+function buildInstallCmd(pm, pkgSpecs) {
+    const list = pkgSpecs.join(' ');
+    switch (pm) {
+        case 'pnpm':
+            return `pnpm add -D ${list}`;
+        case 'bun':
+            return `bun add -d ${list}`;
+        case 'npm':
+        default:
+            return `npm install -D ${list}`;
+    }
+}
+export async function updateCommand(options = {}) {
+    const cwd = process.cwd();
+    const pm = detectPackageManager(cwd);
+    console.log('\x1b[36m┌  🔄 TestSpectra Self-Update\x1b[0m');
+    console.log('\x1b[36m│\x1b[0m');
+    console.log(`\x1b[36m│\x1b[0m  Package Manager: \x1b[33m${pm}\x1b[0m`);
+    console.log('\x1b[36m│\x1b[0m');
+    console.log('\x1b[36m│\x1b[0m  Fetching latest versions from npm registry...');
+    const updates = [];
+    for (const pkg of PACKAGES) {
+        const current = getCurrentVersion(pkg, cwd);
+        const latest = getLatestVersion(pkg);
+        const needsUpdate = !!latest && latest !== current;
+        updates.push({ pkg, current, latest, needsUpdate });
+        const currentStr = current ? `\x1b[33mv${current}\x1b[0m` : '\x1b[90m(not installed)\x1b[0m';
+        const latestStr = latest ? `\x1b[32mv${latest}\x1b[0m` : '\x1b[31m(unavailable)\x1b[0m';
+        const arrow = needsUpdate ? ` → ${latestStr}` : '';
+        const status = !latest ? '\x1b[31m✗\x1b[0m' : needsUpdate ? '\x1b[33m↑\x1b[0m' : '\x1b[32m✓\x1b[0m';
+        console.log(`\x1b[36m│\x1b[0m   ${status} ${pkg.padEnd(28)} ${currentStr}${arrow}`);
+    }
+    const toUpdate = updates.filter((u) => u.needsUpdate && u.latest);
+    console.log('\x1b[36m│\x1b[0m');
+    if (toUpdate.length === 0) {
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+        console.log('\x1b[32m✓ All TestSpectra packages are already up-to-date!\x1b[0m\n');
+        return;
+    }
+    if (options.check) {
+        console.log(`\x1b[36m│\x1b[0m  \x1b[33m${toUpdate.length} update(s) available. Run \x1b[36mspectra update\x1b[33m to install.\x1b[0m`);
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m\n');
+        return;
+    }
+    const pkgSpecs = toUpdate.map((u) => `${u.pkg}@${u.latest}`);
+    const installCmd = buildInstallCmd(pm, pkgSpecs);
+    console.log(`\x1b[36m│\x1b[0m  Running: \x1b[90m${installCmd}\x1b[0m`);
+    console.log('\x1b[36m│\x1b[0m');
+    try {
+        execSync(installCmd, { cwd, stdio: 'inherit' });
+        console.log('\x1b[36m│\x1b[0m');
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+        console.log('\x1b[32m🎉 TestSpectra updated successfully!\x1b[0m');
+        for (const u of toUpdate) {
+            console.log(`   \x1b[32m✓\x1b[0m ${u.pkg}: v${u.current ?? '?'} → v${u.latest}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+        console.error(`\x1b[31m✗ Update failed: ${err.message}\x1b[0m\n`);
+        process.exit(1);
+    }
+}

package/dist/config/loader.js

@@ -41,12 +41,39 @@ export class ConfigLoader {
             }
             else if (configPath.endsWith('.ts') || configPath.endsWith('.js')) {
                 try {
-                    const fileUrl = new URL(`file://${path.resolve(configPath)}`).href;
-                    const mod = await import(fileUrl);
-                    loaded = mod.default || mod.config || mod;
+                    const raw = fs.readFileSync(configPath, 'utf-8');
+                    const ts = (await import('typescript')).default || (await import('typescript'));
+                    const transpiled = ts.transpileModule(raw, {
+                        compilerOptions: {
+                            module: ts.ModuleKind.CommonJS,
+                            target: ts.ScriptTarget.ES2022,
+                        },
+                    });
+                    const mod = { exports: {} };
+                    const mockRequire = (id) => {
+                        if (id === '@testspectra/cli' || id.endsWith('defineConfig')) {
+                            return { defineConfig: (c) => c };
+                        }
+                        try {
+                            return require(id);
+                        }
+                        catch {
+                            return {};
+                        }
+                    };
+                    const fn = new Function('exports', 'require', 'module', '__filename', '__dirname', transpiled.outputText);
+                    fn(mod.exports, mockRequire, mod, configPath, path.dirname(configPath));
+                    loaded = mod.exports.default || mod.exports.config || mod.exports;
                 }
                 catch (e) {
-                    console.warn(`[TestSpectra] Warning: Failed to import ${configPath}:`, e);
+                    try {
+                        const fileUrl = new URL(`file://${path.resolve(configPath)}`).href;
+                        const mod = await import(fileUrl);
+                        loaded = mod.default || mod.config || mod;
+                    }
+                    catch {
+                        console.warn(`[TestSpectra] Warning: Failed to import ${configPath}:`, e);
+                    }
                 }
             }
         }

package/dist/config/schema.d.ts

@@ -11,7 +11,7 @@ export interface DevServerConfig {
      */
     command: string;
     /**
-     * Target URL or healthcheck endpoint (e.g. "https://sso.tagsamurai.local:5174").
+     * Target URL or healthcheck endpoint (e.g. "https://sso.example.local:5174").
      */
     url: string;
     /**
@@ -37,6 +37,46 @@ export interface DevServerConfig {
      */
     env?: Record<string, string>;
 }
+/**
+ * Configuration options for failure-only video recording.
+ */
+export interface VideoConfig {
+    /**
+     * Video container format ('webm' | 'mp4').
+     * @default "webm"
+     */
+    format?: 'webm' | 'mp4';
+    /**
+     * Target frame rate in frames per second (15 | 30 | 60).
+     * @default 30
+     */
+    fps?: 15 | 30 | 60 | number;
+    /**
+     * Compression quality (1 - 100).
+     * @default 80
+     */
+    quality?: number;
+    /**
+     * Maximum video width in pixels.
+     * @default 1280
+     */
+    maxWidth?: number;
+    /**
+     * Maximum video height in pixels.
+     * @default 720
+     */
+    maxHeight?: number;
+    /**
+     * Bitrate in Mbps (Android screen recording).
+     * @default 4
+     */
+    bitRateMbps?: number;
+    /**
+     * Maximum recording time limit per test case in seconds (Android screen recording).
+     * @default 180
+     */
+    timeLimitSeconds?: number;
+}
 /**
  * Configuration for web automation and browser test runners.
  */
@@ -48,7 +88,7 @@ export interface WebConfig {
     baseUrl: string;
     /**
      * Multi-host / multi-app mapping dictionary for micro-frontends and multi-entrypoint monorepos.
-     * Maps named aliases to full base URLs (e.g. `{ sso: "https://sso.tagsamurai.local:5174", fam: "https://fam.tagsamurai.local:5175" }`).
+     * Maps named aliases to full base URLs (e.g. `{ sso: "https://sso.example.local:5174", fam: "https://fam.example.local:5175" }`).
      * Allows tests to navigate using `Spectra.navigate('sso:/login')` or CLI `--host sso`.
      */
     hosts?: Record<string, string>;
@@ -90,6 +130,14 @@ export interface WebConfig {
      * @default "testcase"
      */
     parallelizationMode: 'testcase' | 'suite';
+    /**
+     * Failure-only video recording configuration.
+     * - `true`: Records screencast and persists video only when a test case fails (default).
+     * - `false`: Disables video recording completely for maximum execution speed.
+     * - `VideoConfig`: Detailed video format and quality settings.
+     * @default true
+     */
+    video?: boolean | VideoConfig;
 }
 /**
  * Target Android device specification for multi-device parallel execution.
@@ -203,6 +251,11 @@ export interface AndroidConfig {
      * @default 0
      */
     stepDelay?: number;
+    /**
+     * Failure-only video recording configuration.
+     * @default true
+     */
+    video?: boolean | VideoConfig;
 }
 /**
  * Configuration for iOS mobile test automation with Appium & XCUITest.
@@ -273,6 +326,11 @@ export interface IosConfig {
      * @default "suite"
      */
     parallelizationMode: 'testcase' | 'suite';
+    /**
+     * Failure-only video recording configuration.
+     * @default true
+     */
+    video?: boolean | VideoConfig;
 }
 /**
  * Specific domain filter for real-time network interception and recording.

package/dist/config/schema.js

@@ -28,6 +28,7 @@ export const DEFAULT_CONFIG_DATA = {
         headless: true,
         implicitWait: '5000',
         parallelizationMode: 'testcase',
+        video: true,
     },
     androidConfig: {
         driverServer: 'http://127.0.0.1:4800',
@@ -36,6 +37,7 @@ export const DEFAULT_CONFIG_DATA = {
         noReset: false,
         implicitWait: 10000,
         parallelizationMode: 'suite',
+        video: true,
         devices: [
             {
                 id: 'emulator-5554',
@@ -53,6 +55,7 @@ export const DEFAULT_CONFIG_DATA = {
         noReset: false,
         implicitWait: 10000,
         parallelizationMode: 'suite',
+        video: true,
         devices: [
             {
                 id: 'iphone-15-pro',
@@ -68,6 +71,6 @@ export const DEFAULT_CONFIG_DATA = {
         fastResponseTime: '200',
         normalResponseTime: '1000',
         monitoredDomains: [],
-        environmentVariables: {},
+        environmentVariables: { DEMO_API_MODE: 'sandbox' },
     },
 };

package/dist/generator/__tests__/tsconfig-isolation.test.js

@@ -262,6 +262,27 @@ describe('Platform TSConfigs & Type Isolation (docs/v2/cli/tsconfig-platform-iso
         expect(threw).toBe(true);
         expect(errorMessage).toContain("Cannot find name 'AuthLoginPage'");
     });
+    it('feature-scoped configs enable JSX so .tsx component tests type-check (regression: getScopedConfig omitted jsx)', () => {
+        const featureDir = path.join(tmpDir, 'packages', 'catalog', 'e2e');
+        fs.mkdirSync(path.join(featureDir, 'page-objects', 'RowComponent'), { recursive: true });
+        fs.writeFileSync(path.join(featureDir, 'page-objects', 'RowComponent', 'web.ts'), 'export default class RowComponent { static title = "row"; }');
+        fs.mkdirSync(path.join(featureDir, 'specs'), { recursive: true });
+        TypeGenerator.generateAll(tmpDir);
+        const scopedWebConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig', 'features', 'catalog', 'web.json'), 'utf-8'));
+        expect(scopedWebConfig.compilerOptions.jsx).toBe('react-jsx');
+    });
+    it('E2E: compiles a .tsx component test inside a feature scope via tsc -b with 0 errors', () => {
+        linkNodeModules(tmpDir);
+        const featureDir = path.join(tmpDir, 'packages', 'catalog', 'e2e');
+        fs.mkdirSync(path.join(featureDir, 'page-objects', 'RowComponent'), { recursive: true });
+        fs.writeFileSync(path.join(featureDir, 'page-objects', 'RowComponent', 'web.ts'), 'export default class RowComponent { static title = "row"; }');
+        fs.mkdirSync(path.join(featureDir, 'specs', 'Row', 'TC-0001'), { recursive: true });
+        fs.writeFileSync(path.join(featureDir, 'specs', 'Row', 'TC-0001', 'web.test.tsx'), 'const el = <div>{RowComponent.title}</div>;\n');
+        TypeGenerator.generateAll(tmpDir);
+        expect(() => {
+            execSync(`npx tsc -b ${tmpDir}`, { stdio: 'pipe' });
+        }).not.toThrow();
+    });
     it('E2E: compiles the full Nx monorepo template via tsc -b with 0 errors', async () => {
         let root = process.cwd();
         while (root && root !== path.dirname(root)) {