@testspectra/cli 1.1.8-rc.8 → 1.1.10

package/dist/commands/run.js

@@ -6,6 +6,7 @@ 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';
+import { DevServerManager } from '../utils/dev-server-manager.js';
 function renderSummaryCard(options) {
     const width = 64;
     const borderColor = options.isPassed ? '\x1b[38;2;52;211;153m' : '\x1b[38;2;248;113;113m';
@@ -157,9 +158,29 @@ export async function runCommand(specPaths, options = {}) {
         }
     }
     const config = await ConfigLoader.loadConfig(cwd);
+    if (options.baseUrl) {
+        config.webConfig.baseUrl = options.baseUrl;
+    }
+    else if (options.host) {
+        if (config.webConfig.hosts && config.webConfig.hosts[options.host]) {
+            config.webConfig.baseUrl = config.webConfig.hosts[options.host];
+            console.log(`\x1b[36m[TestSpectra]\x1b[0m 🎯 Active Host target: \x1b[33m${options.host}\x1b[0m (\x1b[32m${config.webConfig.baseUrl}\x1b[0m)`);
+        }
+        else {
+            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`);
+        }
+    }
     let demoServer = null;
     let apiServer = null;
+    const devServerManager = new DevServerManager();
     try {
+        const configuredDevServers = [
+            ...(config.webConfig.devServers || []),
+            ...(config.webConfig.devServer ? [config.webConfig.devServer] : []),
+        ];
+        if (configuredDevServers.length > 0 && !options.demo) {
+            await devServerManager.startAll(configuredDevServers, options.host, cwd);
+        }
         if (options.demo) {
             demoServer = new DemoServer(5173);
             try {
@@ -343,6 +364,7 @@ export async function runCommand(specPaths, options = {}) {
         process.exit(1);
     }
     finally {
+        await devServerManager.stopAll();
         if (demoServer) {
             await demoServer.stop();
         }

package/dist/commands/test.d.ts

@@ -1,5 +1,6 @@
 export interface TestCommandOptions {
     cwd?: string;
+    runner?: 'spectra' | 'vitest';
     headed?: boolean;
     headless?: boolean;
     stepDelay?: string | number;
@@ -8,6 +9,18 @@ export interface TestCommandOptions {
     output?: string;
     concurrency?: string | number;
 }
+/**
+ * Guarantees the `.testspectra` solution-tsconfig scaffolding exists before Vitest 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
+ * 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.
+ */
+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

package/dist/commands/test.js

@@ -1,9 +1,30 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import * as p from '@clack/prompts';
+import { ConfigLoader } from '../config/loader.js';
 import { renderSummaryView } from '../reporter/summary-view.js';
 import { Reporter } from '../runner/reporter.js';
+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.
+ *
+ * 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
+ * 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.
+ */
+export function ensureTestSpectraScaffolding(cwd) {
+    const masterConfigPath = path.join(cwd, '.testspectra', 'tsconfig.json');
+    if (fs.existsSync(masterConfigPath))
+        return;
+    TypeGenerator.generateAll(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
@@ -14,8 +35,10 @@ import { runSystemChecks } from './doctor.js';
  */
 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')));
+        // `--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'));
         return chrome?.installed && chrome.location ? chrome.location : null;
     }
     catch {
@@ -30,6 +53,11 @@ async function resolveBrowserExecutable(cwd) {
  */
 export async function testCommand(options = {}) {
     const cwd = options.cwd ?? process.cwd();
+    // User-facing phase log. Deliberately describes TestSpectra's own stages only — never the
+    // bundled runtime/toolchain underneath — so the CLI surface stays implementation-agnostic.
+    const logPhase = (message) => p.log.step(chalk.dim(message));
+    logPhase('Preparing component test workspace…');
+    ensureTestSpectraScaffolding(cwd);
     let reactPkg;
     try {
         reactPkg = await import('@testspectra/react');
@@ -41,6 +69,7 @@ export async function testCommand(options = {}) {
         process.exit(1);
         return;
     }
+    logPhase('Resolving managed test browser…');
     const browserExecutablePath = await resolveBrowserExecutable(cwd);
     if (!browserExecutablePath) {
         p.log.error(chalk.red('✖ TestSpectra-managed Chrome for Testing was not found.'));
@@ -64,6 +93,21 @@ export async function testCommand(options = {}) {
     else if (options.headless !== undefined) {
         headless = options.headless;
     }
+    // Fallback to spectra.config.ts if options were not explicitly provided on CLI
+    try {
+        const config = await ConfigLoader.loadConfig(cwd);
+        if (stepDelayMs === undefined && config?.webConfig?.stepDelay !== undefined) {
+            const parsed = parseInt(String(config.webConfig.stepDelay), 10);
+            if (!isNaN(parsed) && parsed >= 0)
+                stepDelayMs = parsed;
+        }
+        if (!options.headed && options.headless === undefined && config?.webConfig?.headless !== undefined) {
+            headless = String(config.webConfig.headless) !== 'false' && Boolean(config.webConfig.headless);
+        }
+    }
+    catch {
+        /* ignore config load failures */
+    }
     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
@@ -72,31 +116,81 @@ 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();
-    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);
-            }
-        },
-    });
+    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));
+                }
+            },
+        });
+    }
+    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();
+        }
+    }
     const durationMs = Date.now() - runStartedAt;
     const result = reporter.generateResult(ok ? 'passed' : 'failed', `${(durationMs / 1000).toFixed(1)}s`);
-    const totalTests = result.passedCount + result.failedCount;
+    const failedCount = !ok && result.failedCount === 0 ? 1 : result.failedCount;
+    const totalTests = result.passedCount + failedCount;
     renderSummaryView({
         totalSuites: totalTests,
         totalTests,
         passedCount: result.passedCount,
-        failedCount: result.failedCount,
+        failedCount,
         durationMs,
         reportLocation: outputFile ? path.relative(cwd, outputFile) : '(use -o/--output to save a report)',
     });

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,12 @@
+export interface PackageUpdate {
+    pkg: string;
+    current: string | null;
+    latest: string | null;
+    needsUpdate: boolean;
+}
+export declare function upgradeCommand(requestedPackages?: string[], options?: {
+    check?: boolean;
+    packagesOnly?: boolean;
+    driversOnly?: boolean;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/upgrade.js

@@ -0,0 +1,197 @@
+import { execSync, execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { RustCoreBridge } from '../runner/bridge.js';
+import { checkDriverUpdates } from '../utils/dependency-updates.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGES = ['@testspectra/cli', '@testspectra/matchers', '@testspectra/react'];
+/** Filters requested package names against the known catalog; empty means "all". */
+function selectPackages(requested) {
+    if (requested.length === 0)
+        return [...PACKAGES];
+    const known = new Set(PACKAGES);
+    const unknown = requested.filter((p) => !known.has(p));
+    if (unknown.length > 0) {
+        console.warn(`\x1b[33mIgnoring unknown TestSpectra package(s): ${unknown.join(', ')}\x1b[0m`);
+    }
+    return requested.filter((p) => known.has(p));
+}
+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) {
+    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 collectPackageUpdates(cwd, packages) {
+    return packages.map((pkg) => {
+        const current = getCurrentVersion(pkg, cwd);
+        const latest = getLatestVersion(pkg);
+        return { pkg, current, latest, needsUpdate: !!latest && latest !== current };
+    });
+}
+function printUpdateRow(label, 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[90m(unknown)\x1b[0m';
+    const arrow = needsUpdate ? ` → ${latestStr}` : '';
+    const status = needsUpdate ? '\x1b[33m↑\x1b[0m' : '\x1b[32m✓\x1b[0m';
+    console.log(`\x1b[36m│\x1b[0m   ${status} ${label.padEnd(28)} ${currentStr}${arrow}`);
+}
+function buildInstallCmd(pm, pkgSpecs, cwd) {
+    const list = pkgSpecs.join(' ');
+    switch (pm) {
+        case 'pnpm': {
+            const isWorkspaceRoot = fs.existsSync(path.join(cwd, 'pnpm-workspace.yaml'));
+            return isWorkspaceRoot ? `pnpm add -D -w ${list}` : `pnpm add -D ${list}`;
+        }
+        case 'bun':
+            return `bun add -d ${list}`;
+        case 'npm':
+        default:
+            return `npm install -D ${list}`;
+    }
+}
+export async function upgradeCommand(requestedPackages = [], options = {}) {
+    const cwd = process.cwd();
+    const pm = detectPackageManager(cwd);
+    const selected = selectPackages(requestedPackages);
+    const targeted = requestedPackages.length > 0;
+    if (targeted && selected.length === 0) {
+        console.error(`\x1b[31mNo known TestSpectra package matched: ${requestedPackages.join(', ')}. Known packages: ${PACKAGES.join(', ')}\x1b[0m`);
+        process.exitCode = 1;
+        return;
+    }
+    // Machine-readable mode for the VS Code Preflight panel: implies `--check`, never mutates.
+    if (options.json) {
+        const packages = collectPackageUpdates(cwd, selected);
+        const drivers = targeted ? [] : await checkDriverUpdates();
+        const updatesAvailable = [...packages, ...drivers].filter((u) => u.needsUpdate).length;
+        console.log(JSON.stringify({ packages, drivers, updatesAvailable }, null, 2));
+        return;
+    }
+    console.log('\x1b[36m┌  🚀 TestSpectra Self-Upgrade Mechanism\x1b[0m');
+    console.log('\x1b[36m│\x1b[0m');
+    const updates = [];
+    let packagesUpdated = false;
+    // Phase 1: NPM Packages
+    if (!options.driversOnly) {
+        console.log(`\x1b[36m│\x1b[0m  \x1b[1mPhase 1: Workspace Packages\x1b[0m (Manager: \x1b[33m${pm}\x1b[0m)`);
+        console.log('\x1b[36m│\x1b[0m  Fetching latest versions from npm registry...');
+        updates.push(...collectPackageUpdates(cwd, selected));
+        for (const { pkg, current, latest, needsUpdate } of updates) {
+            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 (options.check) {
+            console.log(`\x1b[36m│\x1b[0m  \x1b[33m${toUpdate.length} package update(s) available. Run \x1b[36mspectra upgrade\x1b[33m to install.\x1b[0m`);
+        }
+        else if (toUpdate.length > 0) {
+            const pkgSpecs = toUpdate.map((u) => `${u.pkg}@${u.latest}`);
+            const installCmd = buildInstallCmd(pm, pkgSpecs, cwd);
+            console.log(`\x1b[36m│\x1b[0m  Running: \x1b[90m${installCmd}\x1b[0m`);
+            try {
+                execSync(installCmd, { cwd, stdio: 'inherit' });
+                packagesUpdated = true;
+            }
+            catch (err) {
+                console.error(`\x1b[31m│  ✗ Package upgrade failed: ${err.message}\x1b[0m`);
+                process.exit(1);
+            }
+        }
+        else {
+            console.log('\x1b[36m│\x1b[0m  \x1b[32m✓ All TestSpectra packages are already up-to-date!\x1b[0m');
+        }
+        console.log('\x1b[36m│\x1b[0m');
+    }
+    if (options.check) {
+        if (!targeted) {
+            const drivers = await checkDriverUpdates();
+            if (drivers.length > 0) {
+                console.log('\x1b[36m│\x1b[0m  \x1b[1mDriver & Agent Status\x1b[0m');
+                for (const dep of drivers) {
+                    printUpdateRow(dep.name, dep.current, dep.latest, dep.needsUpdate);
+                }
+                console.log('\x1b[36m│\x1b[0m');
+            }
+        }
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m\n');
+        return;
+    }
+    // Phase 2: Drivers and Binaries
+    if (!options.packagesOnly && !targeted) {
+        console.log(`\x1b[36m│\x1b[0m  \x1b[1mPhase 2: System Binaries & Drivers\x1b[0m`);
+        try {
+            const binPath = RustCoreBridge.resolveBinaryPath();
+            // Using doctor --fix as the underlying mechanism for pulling drivers
+            // In the future, this could be passed a specific --force-latest flag
+            console.log(`\x1b[36m│\x1b[0m  Forcing update for ADB and Spectra Android Agent...`);
+            const home = process.env.HOME || process.env.USERPROFILE || '';
+            const globalDriversDir = path.join(home, '.testspectra', 'drivers');
+            execSync(`"${binPath}" doctor --fix`, {
+                cwd,
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    TEST_SPECTRA_DRIVER_CACHE: globalDriversDir,
+                    TEST_SPECTRA_FORCE_LATEST: '1',
+                },
+            });
+            console.log('\x1b[36m│\x1b[0m  \x1b[32m✓ Drivers updated successfully.\x1b[0m');
+        }
+        catch (err) {
+            console.error(`\x1b[31m│  ✗ Driver upgrade failed: ${err.message}\x1b[0m`);
+            // We don't exit 1 here so we can still print the post-upgrade report
+        }
+        console.log('\x1b[36m│\x1b[0m');
+    }
+    // Phase 3: Post-Upgrade Report
+    console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+    console.log('\x1b[32m🎉 TestSpectra upgrade complete!\x1b[0m');
+    if (!options.driversOnly && packagesUpdated) {
+        const toUpdate = updates.filter((u) => u.needsUpdate && u.latest);
+        for (const u of toUpdate) {
+            console.log(`   \x1b[32m✓\x1b[0m ${u.pkg}: v${u.current ?? '?'} → v${u.latest}`);
+        }
+    }
+    if (!options.packagesOnly) {
+        console.log(`   \x1b[32m✓\x1b[0m System drivers and agents synchronized to latest versions`);
+    }
+    console.log('');
+}

package/dist/config/schema.d.ts

@@ -1,3 +1,42 @@
+/**
+ * Configuration for an individual local development server lifecycle.
+ */
+export interface DevServerConfig {
+    /**
+     * Unique name or alias identifying this server (e.g. "sso", "adminConsole", "globalSettings").
+     */
+    name?: string;
+    /**
+     * Shell command to launch the development server (e.g. "pnpm --filter sso dev" or "nx serve sso").
+     */
+    command: string;
+    /**
+     * Target URL or healthcheck endpoint (e.g. "https://sso.tagsamurai.local:5174").
+     */
+    url: string;
+    /**
+     * Optional port number (inferred from `url` if omitted).
+     */
+    port?: number;
+    /**
+     * Maximum wait timeout in milliseconds for the server to become interactive and accept HTTP connections.
+     * @default 60000
+     */
+    timeout?: number;
+    /**
+     * Whether to reuse an already running development server if its port/URL is actively responding.
+     * @default true
+     */
+    reuseExistingServer?: boolean;
+    /**
+     * Working directory from which to launch `command`. Defaults to workspace root.
+     */
+    cwd?: string;
+    /**
+     * Custom environment variables passed to the spawned development server process.
+     */
+    env?: Record<string, string>;
+}
 /**
  * Configuration for web automation and browser test runners.
  */
@@ -7,6 +46,20 @@ export interface WebConfig {
      * @default "http://localhost:3000"
      */
     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" }`).
+     * Allows tests to navigate using `Spectra.navigate('sso:/login')` or CLI `--host sso`.
+     */
+    hosts?: Record<string, string>;
+    /**
+     * Array of development servers to auto-start and healthcheck before running tests.
+     */
+    devServers?: DevServerConfig[];
+    /**
+     * Convenience single development server configuration.
+     */
+    devServer?: DevServerConfig;
     /**
      * Maximum number of parallel browser sessions/workers spawned during test execution.
      * Can be an explicit number, numeric string, or `"auto"`.

package/dist/config/schema.js

@@ -22,6 +22,8 @@ export function defineConfig(config) {
 export const DEFAULT_CONFIG_DATA = {
     webConfig: {
         baseUrl: 'http://localhost:3000',
+        hosts: {},
+        devServers: [],
         maxConcurrentSessions: '1',
         headless: true,
         implicitWait: '5000',

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

@@ -41,7 +41,8 @@ describe('Platform TSConfigs & Type Isolation (docs/v2/cli/tsconfig-platform-iso
         expect(rootConfig.references).toEqual([{ path: './.testspectra/tsconfig.json' }]);
         // Verify dynamic master solution references all 5 platform solution tsconfigs in .testspectra/tsconfig/
         const solutionConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig.json'), 'utf-8'));
-        expect(solutionConfig.compilerOptions.noEmit).toBe(true);
+        expect(solutionConfig.compilerOptions.composite).toBe(true);
+        expect(solutionConfig.compilerOptions.noEmit).toBeUndefined();
         expect(solutionConfig.references).toEqual([
             { path: './tsconfig/web.json' },
             { path: './tsconfig/mobile.json' },

package/dist/generator/__tests__/type-generator.test.js

@@ -383,4 +383,42 @@ async function verifyZeroImport() {
         expect(fs.existsSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'))).toBe(false);
         expect(fs.existsSync(path.join(tmpDir, '.testspectra', 'types', 'common.d.ts'))).toBe(false);
     });
+    it('nx monorepo: does NOT treat feature library as shared library and discovers nested e2e subproject', () => {
+        // 1. Shared library with testspectra:shared
+        const sharedDir = path.join(tmpDir, 'shared', 'testing');
+        fs.mkdirSync(path.join(sharedDir, 'page-objects', 'SharedNav'), { recursive: true });
+        fs.writeFileSync(path.join(sharedDir, 'project.json'), JSON.stringify({ name: 'shared-testing', projectType: 'library', tags: ['testspectra:shared'] }));
+        fs.writeFileSync(path.join(sharedDir, 'page-objects', 'SharedNav', 'common.ts'), 'export default class SharedNav {}');
+        // 2. Nx Feature library (projectType: "library", standard Nx tags, NO testspectra tags)
+        const featureLibDir = path.join(tmpDir, 'packages', 'features', 'auth');
+        fs.mkdirSync(featureLibDir, { recursive: true });
+        fs.writeFileSync(path.join(featureLibDir, 'project.json'), JSON.stringify({
+            name: '@tagsamurai/feature-auth',
+            projectType: 'library',
+            sourceRoot: 'packages/features/auth',
+            targets: {},
+            tags: ['type:feature', 'scope:feature-auth'],
+        }));
+        // 3. Nested E2E subproject inside feature library
+        const featureE2eDir = path.join(featureLibDir, 'e2e');
+        fs.mkdirSync(path.join(featureE2eDir, 'specs', 'AuthSuite', 'TC-001'), { recursive: true });
+        fs.writeFileSync(path.join(featureE2eDir, 'project.json'), JSON.stringify({
+            name: 'feature-auth-e2e',
+            projectType: 'application',
+            tags: ['testspectra:e2e', 'testspectra:scope:feature-auth'],
+        }));
+        fs.writeFileSync(path.join(featureE2eDir, 'specs', 'AuthSuite', 'TC-001', 'web.test.ts'), 'it("auth test", async () => {});');
+        const scopes = TypeGenerator.getEntityScopes(tmpDir);
+        expect(scopes).toHaveLength(2);
+        const sharedScope = scopes.find((s) => s.isShared);
+        expect(sharedScope).toBeDefined();
+        expect(sharedScope?.name).toBe('shared');
+        expect(sharedScope?.dir).toBe(path.resolve(sharedDir));
+        const featureScope = scopes.find((s) => !s.isShared);
+        expect(featureScope).toBeDefined();
+        expect(featureScope?.name).toBe('feature-auth');
+        expect(featureScope?.dir).toBe(path.resolve(featureE2eDir));
+        // Verify packages/features/auth is NOT in scopes
+        expect(scopes.some((s) => s.dir === path.resolve(featureLibDir))).toBe(false);
+    });
 });

package/dist/generator/architecture-doc-generator.d.ts

@@ -0,0 +1,14 @@
+export interface ArchitectureDocResult {
+    mode: 'nx' | 'default';
+    path: string;
+    sharedTestingRelPath?: string;
+    featureCount?: number;
+}
+export declare function buildFeatureModulesSection(cwd: string, featureE2eDirs: string[]): string;
+/**
+ * (Re)generates `ARCHITECTURE.md` from the current on-disk workspace state — no prompts, no other
+ * scaffolding side effects. Nx/monorepo mode is auto-detected via `TsConfigGenerator.getEntityScopes`
+ * (the same shared/feature discovery `sync-types` already relies on), so this stays accurate after
+ * features are added/removed/renamed without needing to re-run `spectra init`.
+ */
+export declare function generateArchitectureDoc(cwd: string): ArchitectureDocResult;