@testspectra/cli 1.1.7 → 1.1.8-rc.2

package/dist/commands/run.d.ts

@@ -12,7 +12,6 @@ export interface RunCommandOptions {
     workdir?: string;
     output?: string;
     demo?: boolean;
-    baseUrl?: string;
     failed?: boolean | string;
     concurrency?: string | number;
     licenseKey?: string;
@@ -28,5 +27,5 @@ export declare function renderTimingBreakdown(performance: {
     wallClockDurationMs?: number;
     totalTests?: number;
     duration?: string;
-}): void;
-export declare function runCommand(specPath?: string, options?: RunCommandOptions): Promise<void>;
+}, platform?: string): void;
+export declare function runCommand(specPaths?: string[], options?: RunCommandOptions): Promise<void>;

package/dist/commands/run.js

@@ -5,6 +5,7 @@ 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 { DemoApiServer } from '../utils/api-server.js';
 function renderSummaryCard(options) {
     const width = 64;
     const borderColor = options.isPassed ? '\x1b[38;2;52;211;153m' : '\x1b[38;2;248;113;113m';
@@ -46,6 +47,11 @@ function renderSummaryCard(options) {
     const statusBadge = options.isPassed ? `${green}✓ PASSED${reset}` : `${red}✗ FAILED${reset}`;
     const passedSuites = options.passedSuites ?? (options.isPassed ? options.suiteCount : 0);
     const failedSuites = options.failedSuites ?? (options.isPassed ? 0 : options.suiteCount);
+    const testsPassedText = options.carriedPassed
+        ? `${options.passedCount > 0 ? `${green}${options.passedCount} passed${reset}` : `${options.passedCount} passed`} ${dim}(${options.carriedPassed} carried over)${reset}`
+        : options.passedCount > 0
+            ? `${green}${options.passedCount} passed${reset}`
+            : `${options.passedCount} passed`;
     console.log(`\n${top}`);
     console.log(headerRow(`${boldWhite}✨  TESTSPECTRA EXECUTION SUMMARY${reset}`));
     console.log(mid);
@@ -53,7 +59,7 @@ function renderSummaryCard(options) {
     console.log(row(`${dim}Suites${reset}`, `${passedSuites > 0 ? `${green}${passedSuites} passed${reset}` : `${passedSuites} passed`}, ` +
         `${failedSuites > 0 ? `${red}${failedSuites} failed${reset}` : `${failedSuites} failed`} ` +
         `${dim}(${options.suiteCount} total)${reset}`));
-    console.log(row(`${dim}Tests${reset}`, `${options.passedCount > 0 ? `${green}${options.passedCount} passed${reset}` : `${options.passedCount} passed`}, ` +
+    console.log(row(`${dim}Tests${reset}`, `${testsPassedText}, ` +
         `${options.failedCount > 0 ? `${red}${options.failedCount} failed${reset}` : `${options.failedCount} failed`} ` +
         `${dim}(${options.testCount} total)${reset}`));
     console.log(row(`${dim}Platform${reset}`, `${cyan}${options.platform}${reset}`));
@@ -64,7 +70,13 @@ function renderSummaryCard(options) {
     }
     console.log(`${bot}\n`);
 }
-export function renderTimingBreakdown(performance) {
+const TIMING_PHASE_LABELS = {
+    web: { boot: '1. Master Chromium Process Boot', handshake: '3. Incognito Context & CDP Handshake' },
+    android: { boot: '1. Android Driver Bootstrap (ADB + Agent)', handshake: '3. Device Session Handshake' },
+    ios: { boot: '1. iOS Driver Bootstrap (Appium)', handshake: '3. WDA Session Handshake' },
+};
+export function renderTimingBreakdown(performance, platform = 'web') {
+    const phaseLabels = TIMING_PHASE_LABELS[platform] ?? TIMING_PHASE_LABELS.web;
     const yellowBold = '\x1b[1;38;2;251;191;36m';
     const reset = '\x1b[0m';
     const borderColor = '\x1b[38;2;75;85;99m';
@@ -89,20 +101,31 @@ export function renderTimingBreakdown(performance) {
     console.log(`${borderColor}┌──────────────────────────────────────────┬───────────────────┐${reset}`);
     console.log(`${borderColor}│${reset} Execution Phase                          ${borderColor}│${reset} Duration / Detail ${borderColor}│${reset}`);
     console.log(`${borderColor}├──────────────────────────────────────────┼───────────────────┤${reset}`);
-    console.log(`${borderColor}│${reset} 1. Master Chromium Process Boot          ${borderColor}│${reset} ${pad(performance.masterBootLatencyMs ?? 0, 13)} ms ${borderColor}│${reset}`);
-    console.log(`${borderColor}│${reset} 2. Worker Spawning & Runtime Overhead    ${borderColor}│${reset} ${pad(performance.runnerOverheadMs ?? 0, 13)} ms ${borderColor}│${reset}`);
-    console.log(`${borderColor}│${reset} 3. Incognito Context & CDP Handshake     ${borderColor}│${reset} ${pad(contextHandshakeMs, 10)} ms (avg)${borderColor}│${reset}`);
+    console.log(`${borderColor}│${reset} ${padRight(phaseLabels.boot, 40)} ${borderColor}│${reset} ${pad(performance.masterBootLatencyMs ?? 0, 13)} ms ${borderColor}│${reset}`);
+    console.log(`${borderColor}│${reset} ${padRight('2. Worker Spawning & Runtime Overhead', 40)} ${borderColor}│${reset} ${pad(performance.runnerOverheadMs ?? 0, 13)} ms ${borderColor}│${reset}`);
+    console.log(`${borderColor}│${reset} ${padRight(phaseLabels.handshake, 40)} ${borderColor}│${reset} ${pad(contextHandshakeMs, 10)} ms (avg)${borderColor}│${reset}`);
     console.log(`${borderColor}│${reset} ${padRight(testLabel, 40)} ${borderColor}│${reset} ${pad(testDetail, 17)} ${borderColor}│${reset}`);
-    console.log(`${borderColor}│${reset} 5. Context Teardown / Cleanup            ${borderColor}│${reset} ${pad(performance.avgTeardownMs ?? 0, 10)} ms (avg)${borderColor}│${reset}`);
+    console.log(`${borderColor}│${reset} ${padRight('5. Context Teardown / Cleanup', 40)} ${borderColor}│${reset} ${pad(performance.avgTeardownMs ?? 0, 10)} ms (avg)${borderColor}│${reset}`);
     console.log(`${borderColor}├──────────────────────────────────────────┼───────────────────┤${reset}`);
     console.log(`${borderColor}│${reset} Total Wall-Clock Execution Time          ${borderColor}│${reset} ${pad(wallClock, 15)} ${borderColor}│${reset}`);
     console.log(`${borderColor}└──────────────────────────────────────────┴───────────────────┘${reset}\n`);
 }
-export async function runCommand(specPath, options = {}) {
+export async function runCommand(specPaths, options = {}) {
     const cwd = process.cwd();
-    const effectiveSpecPath = specPath || options.spec;
+    // Opt-in duration logging (TESTSPECTRA_DURATION_LOG): resolve to one absolute JSONL path that
+    // both this host process (Rust orchestrator) and every spawned Bun worker append to, and stamp a
+    // run id so repeated runs can be told apart. Off by default; toggled purely via the env var.
+    if (process.env.TESTSPECTRA_DURATION_LOG) {
+        const v = process.env.TESTSPECTRA_DURATION_LOG;
+        const abs = v === '1' || v === 'true' ? path.join(cwd, '.testspectra', 'logs', 'duration.jsonl') : path.resolve(cwd, v);
+        process.env.TESTSPECTRA_DURATION_LOG = abs;
+        if (!process.env.TESTSPECTRA_RUN_ID)
+            process.env.TESTSPECTRA_RUN_ID = String(Date.now());
+    }
+    const effectiveSpecPaths = specPaths && specPaths.length > 0 ? specPaths : options.spec ? [options.spec] : undefined;
     // Ensure latest ambient types are up-to-date
     TypeGenerator.writeDeclarationFiles(cwd);
+    await TypeGenerator.syncEnvDeclaration(cwd);
     const home = process.env.HOME || process.env.USERPROFILE || '';
     const globalAppDataPath = path.join(home, '.testspectra');
     const appDataPath = options.workdir ? path.resolve(options.workdir) : globalAppDataPath;
@@ -135,6 +158,7 @@ export async function runCommand(specPath, options = {}) {
     }
     const config = await ConfigLoader.loadConfig(cwd);
     let demoServer = null;
+    let apiServer = null;
     try {
         if (options.demo) {
             demoServer = new DemoServer(5173);
@@ -146,9 +170,14 @@ export async function runCommand(specPath, options = {}) {
             catch (err) {
                 console.warn(`\x1b[33m[TestSpectra] Warning: Could not start built-in demo server: ${err.message}\x1b[0m`);
             }
-        }
-        if (options.baseUrl) {
-            config.webConfig.baseUrl = options.baseUrl;
+            apiServer = new DemoApiServer();
+            try {
+                const { url, port } = await apiServer.start();
+                console.log(`\x1b[36m[TestSpectra]\x1b[0m 🌐 Demo API server automatically started at: \x1b[33m${url}\x1b[0m (port ${port}, self-hosted /api/*)`);
+            }
+            catch (err) {
+                console.warn(`\x1b[33m[TestSpectra] Warning: Could not start built-in demo API server: ${err.message}\x1b[0m`);
+            }
         }
         if (options.headed) {
             config.webConfig.headless = false;
@@ -207,7 +236,7 @@ export async function runCommand(specPath, options = {}) {
             targetDevice,
             licenseKey: options.licenseKey,
             outputJsonPath,
-            spec: effectiveSpecPath,
+            specs: effectiveSpecPaths,
             concurrency: userConcurrency,
             failedOnly: isFailedMode,
             failedTarget,
@@ -216,16 +245,41 @@ export async function runCommand(specPath, options = {}) {
         const relReport = path.relative(cwd, outputJsonPath);
         const networkReportFile = path.join(path.dirname(outputJsonPath), 'network-resources.json');
         const relNetworkReport = fs.existsSync(networkReportFile) ? path.relative(cwd, networkReportFile) : undefined;
+        let carriedOver;
+        if (process.env.TESTSPECTRA_CARRIED_OVER) {
+            try {
+                carriedOver = JSON.parse(process.env.TESTSPECTRA_CARRIED_OVER);
+            }
+            catch { }
+        }
+        const carriedPassed = carriedOver?.passed || 0;
+        const carriedDurationMs = carriedOver?.durationMs || 0;
         let suiteCount = 1;
         let passedSuites = isPassed ? 1 : 0;
         let failedSuites = isPassed ? 0 : 1;
-        let testCount = (result.passedCount ?? 0) + (result.failedCount ?? 0);
+        let basePassed = result.passedCount ?? (isPassed ? 1 : 0);
+        let baseFailed = result.failedCount ?? (isPassed ? 0 : 1);
+        const totalPassed = basePassed + carriedPassed;
+        const totalFailed = baseFailed;
+        const totalTests = basePassed + baseFailed + carriedPassed;
+        let finalDuration = result.duration;
+        if (carriedDurationMs > 0) {
+            const match = result.duration.match(/([\d.]+)\s*(ms|s|m)/);
+            let runMs = 0;
+            if (match) {
+                const val = parseFloat(match[1]);
+                const unit = match[2];
+                runMs = unit === 's' ? val * 1000 : unit === 'm' ? val * 60000 : val;
+            }
+            const totalMs = runMs + carriedDurationMs;
+            finalDuration = totalMs < 1000 ? `${Math.round(totalMs)}ms` : `${(totalMs / 1000).toFixed(1)}s`;
+        }
+        const overallPassed = isPassed && totalFailed === 0;
         if (fs.existsSync(outputJsonPath)) {
             try {
                 const fullReport = JSON.parse(fs.readFileSync(outputJsonPath, 'utf8'));
                 if (fullReport.summary) {
                     suiteCount = fullReport.summary.totalSuites ?? 1;
-                    testCount = fullReport.summary.totalTests ?? testCount;
                 }
                 if (fullReport.suites && Array.isArray(fullReport.suites)) {
                     failedSuites = fullReport.suites.filter((s) => (typeof s.failed === 'number' && s.failed > 0) ||
@@ -235,16 +289,17 @@ export async function runCommand(specPath, options = {}) {
                 }
                 if (fullReport.performance) {
                     renderSummaryCard({
-                        isPassed,
-                        statusText: isPassed ? 'PASSED' : 'FAILED',
-                        duration: result.duration,
+                        isPassed: overallPassed,
+                        statusText: overallPassed ? 'PASSED' : 'FAILED',
+                        duration: finalDuration,
                         platform,
                         suiteCount,
                         passedSuites,
                         failedSuites,
-                        testCount,
-                        passedCount: result.passedCount ?? (isPassed ? testCount : 0),
-                        failedCount: result.failedCount ?? (isPassed ? 0 : testCount),
+                        testCount: totalTests,
+                        passedCount: totalPassed,
+                        failedCount: totalFailed,
+                        carriedPassed,
                         reportPath: relReport,
                         networkReportPath: relNetworkReport,
                     });
@@ -252,8 +307,11 @@ export async function runCommand(specPath, options = {}) {
                         ...fullReport.performance,
                         wallClockDurationMs: fullReport.wallClockDurationMs,
                         duration: fullReport.duration,
-                        totalTests: fullReport.summary?.totalTests ?? testCount,
-                    });
+                        totalTests: fullReport.summary?.totalTests ?? totalTests,
+                    }, platform);
+                    if (!overallPassed || totalFailed > 0) {
+                        process.exitCode = 1;
+                    }
                     return;
                 }
             }
@@ -262,19 +320,23 @@ export async function runCommand(specPath, options = {}) {
             }
         }
         renderSummaryCard({
-            isPassed,
-            statusText: isPassed ? 'PASSED' : 'FAILED',
-            duration: result.duration,
+            isPassed: overallPassed,
+            statusText: overallPassed ? 'PASSED' : 'FAILED',
+            duration: finalDuration,
             platform,
             suiteCount,
             passedSuites,
             failedSuites,
-            testCount,
-            passedCount: result.passedCount ?? (isPassed ? testCount : 0),
-            failedCount: result.failedCount ?? (isPassed ? 0 : testCount),
+            testCount: totalTests,
+            passedCount: totalPassed,
+            failedCount: totalFailed,
+            carriedPassed,
             reportPath: relReport,
             networkReportPath: relNetworkReport,
         });
+        if (!overallPassed || totalFailed > 0) {
+            process.exitCode = 1;
+        }
     }
     catch (e) {
         console.error(`\x1b[31m[TestSpectra] Execution error:\x1b[0m`, e);
@@ -284,5 +346,8 @@ export async function runCommand(specPath, options = {}) {
         if (demoServer) {
             await demoServer.stop();
         }
+        if (apiServer) {
+            await apiServer.stop();
+        }
     }
 }

package/dist/commands/skills.d.ts

@@ -0,0 +1,9 @@
+export interface SkillsCommandOptions {
+    cwd?: string;
+    agent?: string;
+}
+export declare function skillsInitCommand(options?: SkillsCommandOptions): Promise<void>;
+export declare function skillsListCommand(options?: SkillsCommandOptions): void;
+export declare function skillsAddCommand(ids?: string[], options?: SkillsCommandOptions): Promise<void>;
+export declare function skillsUpdateCommand(ids?: string[], options?: SkillsCommandOptions): void;
+export declare function skillsRemoveCommand(ids?: string[], options?: SkillsCommandOptions): void;

package/dist/commands/skills.js

@@ -0,0 +1,28 @@
+import path from 'path';
+import chalk from 'chalk';
+import { initSkills, listSkills, addSkills, updateSkills, removeSkills, getKnownAgentIds, resolveAgentSelection, } from '@testspectra/skills';
+function resolveBaseDir(options = {}) {
+    return options.cwd ? path.resolve(options.cwd) : process.cwd();
+}
+function resolveAgentIds(options = {}) {
+    const { ids, unknown } = resolveAgentSelection(options.agent);
+    if (unknown.length > 0) {
+        console.log(chalk.yellow(`⚠️  Unknown --agent value(s): ${unknown.join(', ')}. Known ids: ${getKnownAgentIds().join(', ')}`));
+    }
+    return ids.length > 0 ? ids : undefined;
+}
+export async function skillsInitCommand(options = {}) {
+    await initSkills(resolveBaseDir(options));
+}
+export function skillsListCommand(options = {}) {
+    listSkills(resolveBaseDir(options), resolveAgentIds(options));
+}
+export async function skillsAddCommand(ids = [], options = {}) {
+    await addSkills(ids, resolveBaseDir(options), resolveAgentIds(options));
+}
+export function skillsUpdateCommand(ids = [], options = {}) {
+    updateSkills(ids, resolveBaseDir(options), resolveAgentIds(options));
+}
+export function skillsRemoveCommand(ids = [], options = {}) {
+    removeSkills(ids, resolveBaseDir(options), resolveAgentIds(options));
+}

package/dist/commands/sync-types.js

@@ -5,6 +5,7 @@ export async function syncTypesCommand(options = {}) {
     const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
     try {
         TypeGenerator.generateAll(cwd);
+        await TypeGenerator.syncEnvDeclaration(cwd);
         console.log(chalk.green('✔ Successfully synchronized TestSpectra ambient type declarations in .testspectra/types/'));
     }
     catch (err) {

package/dist/commands/test.d.ts

@@ -0,0 +1,17 @@
+export interface TestCommandOptions {
+    cwd?: string;
+    headed?: boolean;
+    headless?: boolean;
+    stepDelay?: string | number;
+    delay?: string | number;
+    spec?: string;
+    output?: string;
+    concurrency?: string | number;
+}
+/**
+ * `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
+ * docs/v2/features/component-testing/react/README.md §2 for why these are two independent
+ * runners rather than one extended pipeline.
+ */
+export declare function testCommand(options?: TestCommandOptions): Promise<void>;

package/dist/commands/test.js

@@ -0,0 +1,104 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+import { renderSummaryView } from '../reporter/summary-view.js';
+import { Reporter } from '../runner/reporter.js';
+import { runSystemChecks } from './doctor.js';
+/**
+ * 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.
+ */
+async function resolveBrowserExecutable(cwd) {
+    try {
+        const { dependencies } = await runSystemChecks(cwd);
+        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 {
+        return null;
+    }
+}
+/**
+ * `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
+ * docs/v2/features/component-testing/react/README.md §2 for why these are two independent
+ * runners rather than one extended pipeline.
+ */
+export async function testCommand(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    let reactPkg;
+    try {
+        reactPkg = await import('@testspectra/react');
+    }
+    catch {
+        p.log.error(chalk.red('✖ @testspectra/react is not installed in this workspace.'));
+        p.log.info(chalk.dim('Component testing requires the @testspectra/react package.'));
+        p.log.info(chalk.dim('  👉 Install it:  pnpm add -D @testspectra/react'));
+        process.exit(1);
+        return;
+    }
+    const browserExecutablePath = await resolveBrowserExecutable(cwd);
+    if (!browserExecutablePath) {
+        p.log.error(chalk.red('✖ TestSpectra-managed Chrome for Testing was not found.'));
+        p.log.info(chalk.dim('Component testing reuses the same browser install as `spectra run` (web).'));
+        p.log.info(chalk.dim('  👉 Install it:  spectra doctor --fix'));
+        process.exit(1);
+        return;
+    }
+    let stepDelayMs;
+    const rawDelay = options.stepDelay ?? options.delay;
+    if (rawDelay !== undefined) {
+        const delayNum = parseInt(String(rawDelay), 10);
+        if (!isNaN(delayNum) && delayNum >= 0) {
+            stepDelayMs = delayNum;
+        }
+    }
+    let headless = true;
+    if (options.headed) {
+        headless = false;
+    }
+    else if (options.headless !== undefined) {
+        headless = options.headless;
+    }
+    const concurrency = options.concurrency !== undefined ? parseInt(String(options.concurrency), 10) : undefined;
+    const outputFile = options.output ? path.resolve(cwd, options.output) : undefined;
+    // Reuses the exact same semantic terminal reporter `spectra run` drives (see
+    // docs/v2/cli/matchers-semantic-reporter.md) — @testspectra/react emits the identical
+    // [TESTSPECTRA_*] protocol lines the E2E Rust orchestrator does (see tools/react/src/prelude.ts
+    // / setup.ts), so the same Reporter class parses them with zero changes on either side.
+    const reporter = new Reporter();
+    const runStartedAt = Date.now();
+    const ok = await reactPkg.runComponentTests({
+        cwd,
+        headless,
+        stepDelayMs,
+        spec: options.spec,
+        outputFile,
+        concurrency: concurrency !== undefined && !isNaN(concurrency) ? concurrency : undefined,
+        browserExecutablePath,
+        onLine: (line) => {
+            if (!line.startsWith('[TESTSPECTRA_'))
+                return;
+            reporter.addLog({ timestamp: new Date().toLocaleTimeString(), level: 'INFO', message: line });
+            if (!reporter.isInteractiveMode()) {
+                console.log(line);
+            }
+        },
+    });
+    const durationMs = Date.now() - runStartedAt;
+    const result = reporter.generateResult(ok ? 'passed' : 'failed', `${(durationMs / 1000).toFixed(1)}s`);
+    const totalTests = result.passedCount + result.failedCount;
+    renderSummaryView({
+        totalSuites: totalTests,
+        totalTests,
+        passedCount: result.passedCount,
+        failedCount: result.failedCount,
+        durationMs,
+        reportLocation: outputFile ? path.relative(cwd, outputFile) : '(use -o/--output to save a report)',
+    });
+    process.exit(ok ? 0 : 1);
+}

package/dist/commands/watch.js

@@ -3,15 +3,22 @@ import path from 'path';
 import chalk from 'chalk';
 import { TypeGenerator } from '../types/generator.js';
 export function startWatcher(cwd, debounceMs = 60) {
-    // Initial generation
+    // Initial generation. TypeGenerator.generateAll itself stays synchronous (reading
+    // spectra.config.ts is unavoidably async, so that part is handled by the separate
+    // syncEnvDeclaration call below); startWatcher stays sync so it can return the watcher handle
+    // immediately, with the async env sync fired-and-forgotten.
     TypeGenerator.generateAll(cwd);
+    TypeGenerator.syncEnvDeclaration(cwd).catch((err) => {
+        console.error(chalk.red(`✖ Error generating initial env.d.ts: ${err?.message}`));
+    });
     let debounceTimer = null;
     const triggerRegen = (filePath, eventType) => {
         if (debounceTimer)
             clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
+        debounceTimer = setTimeout(async () => {
             try {
                 TypeGenerator.generateAll(cwd);
+                await TypeGenerator.syncEnvDeclaration(cwd);
                 const time = new Date().toLocaleTimeString();
                 const rel = path.relative(cwd, filePath) || filePath;
                 console.log(chalk.gray(`[${time}] `) + chalk.cyan(`✨ Updated ambient types `) + chalk.gray(`(${eventType}: ${rel})`));
@@ -34,7 +41,6 @@ export function startWatcher(cwd, debounceMs = 60) {
         }
         if (fn.includes('fixtures') ||
             fn.includes('page-objects') ||
-            fn.includes('pageobjects') ||
             fn.includes('actions') ||
             fn.includes('steps') ||
             fn.includes('hooks') ||

package/dist/config/loader.js

@@ -89,7 +89,7 @@ export class ConfigLoader {
                 environmentVariables: overrides?.executionConfig?.environmentVariables ??
                     loaded.executionConfig?.environmentVariables ??
                     DEFAULT_CONFIG_DATA.executionConfig?.environmentVariables ??
-                    [],
+                    {},
             },
         };
     }

package/dist/config/schema.d.ts

@@ -20,19 +20,11 @@ export interface WebConfig {
     headless: boolean | 'new';
     /**
      * Implicit wait timeout (in milliseconds) for finding elements before throwing an error.
+     * Also the ceiling auto-waiting element assertions/actions poll against (capped at 2000ms for
+     * assertions — see `getAssertionTimeoutMs()`).
      * @default "5000"
      */
     implicitWait: string;
-    /**
-     * Maximum time (in milliseconds) allowed for a webpage to complete navigation and initial load.
-     * @default "30000"
-     */
-    pageLoadTimeout: string;
-    /**
-     * Maximum time (in milliseconds) allowed for asynchronous scripts to finish executing.
-     * @default "30000"
-     */
-    scriptTimeout: string;
     /**
      * Delay between consecutive actions and commands in milliseconds (slow motion).
      * @default 0
@@ -46,37 +38,6 @@ export interface WebConfig {
      */
     parallelizationMode: 'testcase' | 'suite';
 }
-/**
- * Browser target definition for web test execution.
- */
-export interface Browser {
-    /**
-     * Unique identifier for this browser configuration.
-     */
-    id: string;
-    /**
-     * Browser type/engine: `"chrome"`, `"firefox"`, `"safari"`, `"edge"`.
-     * @default "chrome"
-     */
-    type: string;
-    /**
-     * Whether to simulate mobile viewport and touch metrics.
-     * @default false
-     */
-    mobileEmulation: boolean;
-    /**
-     * Emulated device name when `mobileEmulation` is true (e.g. `"iPhone 14"`, `"Pixel 7"`).
-     */
-    deviceName?: string;
-    /**
-     * Custom browser window width in pixels.
-     */
-    width?: string;
-    /**
-     * Custom browser window height in pixels.
-     */
-    height?: string;
-}
 /**
  * Target Android device specification for multi-device parallel execution.
  */
@@ -156,11 +117,6 @@ export interface AndroidConfig {
      * Main activity name launched when starting the app.
      */
     appActivity: string;
-    /**
-     * Whether to automatically grant Android runtime permissions upon installation.
-     * @default true
-     */
-    autoGrantPermissions: boolean;
     /**
      * Whether to preserve app state and prevent clearing app data/cache between sessions.
      * @default false
@@ -265,40 +221,6 @@ export interface IosConfig {
      */
     parallelizationMode: 'testcase' | 'suite';
 }
-/**
- * Load testing stage ramp-up profile.
- */
-export interface LoadStage {
-    /**
-     * Stage identifier.
-     */
-    id: string;
-    /**
-     * Duration for this load stage (e.g. `"30s"`, `"2m"`).
-     */
-    duration: string;
-    /**
-     * Target virtual users (VUs) to scale to during this stage.
-     */
-    targetVUs: string;
-}
-/**
- * Performance and pass/fail metric threshold definition.
- */
-export interface SuccessThreshold {
-    /**
-     * Unique threshold identifier.
-     */
-    id: string;
-    /**
-     * Performance metric type (e.g. `"http_req_duration"`, `"http_req_failed"`).
-     */
-    metricType: string;
-    /**
-     * Maximum acceptable value (e.g. `"500ms"`, `"0.01"`).
-     */
-    maxValue: string;
-}
 /**
  * Specific domain filter for real-time network interception and recording.
  */
@@ -312,19 +234,6 @@ export interface MonitoredDomain {
      */
     enabled: boolean;
 }
-/**
- * Custom environment variable key-value pair injected into the test execution sandbox.
- */
-export interface EnvironmentVariable {
-    /**
-     * Environment variable name (e.g. `"API_SECRET_KEY"`).
-     */
-    key: string;
-    /**
-     * Environment variable value.
-     */
-    value: string;
-}
 /**
  * Test execution, CDP network monitoring, and sandbox environment configuration.
  */
@@ -349,9 +258,10 @@ export interface ExecutionConfig {
      */
     monitoredDomains?: MonitoredDomain[];
     /**
-     * Custom environment variables injected into the test process runtime.
+     * Custom environment variables injected into the test process runtime
+     * (e.g. `{ API_SECRET_KEY: "..." }`).
      */
-    environmentVariables?: EnvironmentVariable[];
+    environmentVariables?: Record<string, string>;
 }
 /**
  * Root configuration data structure matching TestSpectra project schema.
@@ -361,10 +271,6 @@ export interface ConfigData {
      * Web browser execution settings.
      */
     webConfig: WebConfig;
-    /**
-     * List of target browsers for web automation runs.
-     */
-    browsers: Browser[];
     /**
      * Android Appium driver and device options.
      */
@@ -373,21 +279,6 @@ export interface ConfigData {
      * iOS Appium driver and device options.
      */
     iosConfig: IosConfig;
-    /**
-     * Load testing parameters.
-     */
-    loadConfig: {
-        virtualUsers: string;
-        duration: string;
-    };
-    /**
-     * Load testing stages.
-     */
-    loadStages: LoadStage[];
-    /**
-     * Pass/fail metric thresholds.
-     */
-    thresholds: SuccessThreshold[];
     /**
      * Advanced execution and network recording settings.
      */