@testspectra/cli 1.0.70 → 1.1.0-rc.1

package/dist/runner/reporter.js

@@ -1,26 +1,433 @@
+import chalk from 'chalk';
+import { formatAction, formatAssertion } from '../reporter/semantic-formatter.js';
+function stripAnsi(str) {
+    return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+}
+function mapActionArgs(key, arr) {
+    if (!Array.isArray(arr)) {
+        return typeof arr === 'object' && arr !== null ? arr : {};
+    }
+    switch (key) {
+        case 'type':
+            return { text: arr[0] };
+        case 'select':
+        case 'selectOption':
+            return { option: arr[0] };
+        case 'dragDrop':
+            return { dest: arr[0] };
+        case 'longPress':
+            return { durationMs: arr[0] };
+        case 'navigate':
+            return { url: arr[0] };
+        case 'setCookies':
+            return { url: arr[0] };
+        case 'setViewport':
+            return { width: arr[0], height: arr[1] };
+        case 'wait':
+            return { ms: arr[0] };
+        case 'pressKey':
+            return { key: arr[0] };
+        case 'scroll':
+            return { direction: arr[0], pixels: arr[1] };
+        case 'swipe':
+            return { direction: arr[0], distance: arr[1] };
+        case 'intercept':
+            return { method: arr[0], url: arr[1] };
+        default:
+            return {};
+    }
+}
+function mapAssertionArgs(key, arr) {
+    if (!Array.isArray(arr)) {
+        return typeof arr === 'object' && arr !== null ? arr : { expected: arr };
+    }
+    if (key === 'have.attr' || key === 'not.have.attr') {
+        return arr.length >= 2 ? { name: arr[0], value: arr[1], expected: arr[0] } : { name: arr[0], expected: arr[0] };
+    }
+    if (key === 'have.css' || key === 'not.have.css') {
+        return { name: arr[0], property: arr[0], value: arr[1], expected: arr[0] };
+    }
+    if (arr.length >= 2) {
+        return { name: arr[0], value: arr[1], expected: arr[0] };
+    }
+    return {
+        expected: arr[0],
+        name: arr[0],
+        text: arr[0],
+        value: arr[0],
+        title: arr[0],
+        url: arr[0],
+        length: arr[0],
+        min: arr[0],
+        max: arr[0],
+    };
+}
+function parseAndFormat(cmdText) {
+    try {
+        const payload = JSON.parse(cmdText);
+        // Passed through as-is (not pre-flattened to a bare string here) — `formatAction`/
+        // `formatAssertion` already do the same `.selector`/`.name`/`.target` fallback lookup
+        // themselves, and only the raw object retains `.parent` for a scoped (`element.get()`/
+        // `.getAll()`-chained) target, which they need to render the "within" phrasing.
+        const target = payload.target;
+        if (payload.type === 'action') {
+            return formatAction(payload.key, target, mapActionArgs(payload.key, payload.args || []));
+        }
+        else if (payload.type === 'assertion' || payload.type === 'browser') {
+            return formatAssertion(payload.key, target, mapAssertionArgs(payload.key, payload.args || []));
+        }
+        // Native Orchestrator payload format ({ test, action, selector, target, ... })
+        if (payload.action) {
+            const action = payload.action;
+            const t = payload.selector || payload.target;
+            switch (action) {
+                case 'navigate':
+                    return formatAction('navigate', undefined, {
+                        url: t || payload.url || payload.value || 'http://localhost:5173',
+                    });
+                case 'click':
+                    return formatAction('click', t);
+                case 'double_click':
+                case 'doubleClick':
+                    return formatAction('doubleClick', t);
+                case 'right_click':
+                case 'rightClick':
+                    return formatAction('rightClick', t);
+                case 'type':
+                case 'type_text':
+                case 'set_value':
+                    return formatAction('type', t, { text: payload.text || payload.value });
+                case 'clear':
+                    return formatAction('clear', t);
+                case 'hover':
+                    return formatAction('hover', t);
+                case 'scroll_into_view':
+                case 'scrollIntoView':
+                    return formatAction('scrollIntoView', t);
+                case 'should_be_visible':
+                    return formatAssertion('be.visible', t);
+                case 'should_not_be_visible':
+                    return formatAssertion('not.be.visible', t);
+                case 'should_exist':
+                    return formatAssertion('exist', t);
+                case 'should_not_exist':
+                    return formatAssertion('not.exist', t);
+                case 'should_be_enabled':
+                    return formatAssertion('be.enabled', t);
+                case 'should_be_disabled':
+                    return formatAssertion('be.disabled', t);
+                case 'should_be_clickable':
+                    return formatAssertion('be.clickable', t);
+                case 'should_have_text':
+                    return formatAssertion('have.text', t, { expected: payload.expected || payload.text || payload.value });
+                case 'should_contain_text':
+                    return formatAssertion('contain.text', t, {
+                        expected: payload.expected || payload.text || payload.value,
+                    });
+                case 'should_have_value':
+                    return formatAssertion('have.value', t, { expected: payload.expected || payload.value });
+                case 'should_contain_value':
+                    return formatAssertion('contain.value', t, { expected: payload.expected || payload.value });
+                case 'should_have_length':
+                    return formatAssertion('have.length', t, {
+                        expected: payload.expected || payload.length || payload.value,
+                    });
+                case 'should_have_title':
+                    return formatAssertion('have.title', undefined, {
+                        expected: payload.expected || payload.value || t || 'TestSpectra',
+                    });
+                case 'should_be_empty':
+                    return formatAssertion('be.empty', t);
+                case 'should_not_be_empty':
+                    return formatAssertion('not.be.empty', t);
+                default:
+                    return `Execute step "${action}" on ${t || 'target'}`;
+            }
+        }
+        return cmdText;
+    }
+    catch {
+        return cmdText;
+    }
+}
 export class Reporter {
     logs = [];
     networkEvents = [];
+    pendingTests = new Map();
+    workerToTest = new Map();
+    passedCount = 0;
+    failedCount = 0;
+    isInteractive;
+    lastRenderedLines = 0;
+    spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    spinnerIndex = 0;
+    spinnerTimer = null;
+    constructor() {
+        this.isInteractive = Boolean(process.stdout.isTTY && !process.env.CI && process.env.NODE_ENV !== 'test' && !process.env.VITEST);
+        if (this.isInteractive) {
+            this.spinnerTimer = setInterval(() => {
+                this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+                this.renderActiveSlots();
+            }, 80);
+        }
+    }
+    /** Whether this reporter is drawing the live-updating interactive terminal UI (real TTY, not CI/VS Code/test). */
+    isInteractiveMode() {
+        return this.isInteractive;
+    }
+    clearActiveSlots() {
+        if (!this.isInteractive || this.lastRenderedLines === 0)
+            return;
+        try {
+            process.stdout.write(`\x1b[${this.lastRenderedLines}A\x1b[0J`);
+        }
+        catch { }
+        this.lastRenderedLines = 0;
+    }
+    renderActiveSlots() {
+        if (!this.isInteractive)
+            return;
+        const active = Array.from(this.pendingTests.values());
+        if (active.length === 0) {
+            this.clearActiveSlots();
+            return;
+        }
+        this.clearActiveSlots();
+        const frame = chalk.cyan(this.spinnerFrames[this.spinnerIndex]);
+        let linesCount = 0;
+        for (const tc of active) {
+            const workerBadge = tc.workerId ? chalk.gray(`[Worker ${tc.workerId}] `) : '';
+            const titleShort = tc.title.length > 55 ? tc.title.slice(0, 52) + '...' : tc.title;
+            const elapsed = Date.now() - tc.startTime;
+            const line1 = `  ${frame} ${workerBadge}${chalk.white.bold(titleShort)} ${chalk.gray(`(${elapsed}ms)`)}`;
+            const stepText = tc.currentStep ? chalk.dim(`     ↳ ${tc.currentStep}`) : '';
+            process.stdout.write(line1 + '\n');
+            linesCount++;
+            if (stepText) {
+                process.stdout.write(stepText + '\n');
+                linesCount++;
+            }
+        }
+        this.lastRenderedLines = linesCount;
+    }
+    resolveTestCase(testTitle, workerId) {
+        if (testTitle && this.pendingTests.has(testTitle)) {
+            return this.pendingTests.get(testTitle);
+        }
+        if (workerId !== undefined && this.workerToTest.has(workerId)) {
+            const title = this.workerToTest.get(workerId);
+            if (title && this.pendingTests.has(title)) {
+                return this.pendingTests.get(title);
+            }
+        }
+        if (this.pendingTests.size === 1) {
+            return this.pendingTests.values().next().value;
+        }
+        return Array.from(this.pendingTests.values()).pop();
+    }
     addLog(log) {
         this.logs.push(log);
-        const time = `\x1b[90m${log.timestamp}\x1b[0m`;
-        let prefix = `[${log.level}]`;
-        if (log.level === "SUCCESS" || log.level === "PASSED") {
-            prefix = `\x1b[32m${prefix}\x1b[0m`;
+        const raw = stripAnsi(log.message || '').trim();
+        if (!raw)
+            return;
+        // Filter out WDIO framework internal noise
+        if (raw.includes('RUNNING in chrome') ||
+            raw.includes('PASSED in chrome') ||
+            raw.includes('FAILED in chrome') ||
+            raw.includes('[NetworkRecorder]') ||
+            raw.includes('"spec" Reporter:') ||
+            raw.includes('"DotReporter" Reporter:') ||
+            raw.includes('SilentReporter') ||
+            raw.startsWith('---') ||
+            raw === '.' ||
+            raw.includes('Session ID:') ||
+            raw.includes('Running: chrome') ||
+            raw.includes('[chrome') ||
+            raw.includes('[firefox') ||
+            raw.includes('[safari') ||
+            raw.includes('[edge') ||
+            raw.includes('(root)') ||
+            raw.includes('passing (') ||
+            raw.includes('failing (') ||
+            raw.includes('Spec Files:') ||
+            (raw.includes('Execution of') && raw.includes('workers started')) ||
+            raw.includes('Spawning WDIO execution') ||
+            raw.includes('WARN webdriver:') ||
+            raw.includes('WebDriverError: unknown error: net::ERR_CONNECTION_REFUSED') ||
+            raw.includes('when running "url" with method "POST"') ||
+            raw.includes('Session info: chrome=')) {
+            return;
+        }
+        // 1. Test started -> initialize test buffer & worker slot
+        if (raw.startsWith('[TESTSPECTRA_TEST_START]')) {
+            const content = raw.replace('[TESTSPECTRA_TEST_START]', '').trim();
+            let title = content;
+            let workerId;
+            try {
+                const parsed = JSON.parse(content);
+                if (parsed.title) {
+                    title = parsed.title;
+                    workerId = parsed.workerId;
+                }
+            }
+            catch { }
+            const pending = {
+                title,
+                workerId,
+                steps: [],
+                currentStep: 'Running suite...',
+                startTime: Date.now(),
+            };
+            this.pendingTests.set(title, pending);
+            if (workerId !== undefined) {
+                this.workerToTest.set(workerId, title);
+            }
+            this.renderActiveSlots();
+            return;
+        }
+        // 2. Step in-progress / start
+        if (raw.startsWith('[TESTSPECTRA_STEP_START]')) {
+            const fullText = raw.replace('[TESTSPECTRA_STEP_START]', '').trim();
+            let testTitle = '';
+            let workerId;
+            try {
+                const payload = JSON.parse(fullText);
+                testTitle = payload.test || payload.title || '';
+                workerId = payload.workerId;
+            }
+            catch { }
+            const formatted = parseAndFormat(fullText);
+            const testCase = this.resolveTestCase(testTitle, workerId);
+            if (testCase) {
+                testCase.currentStep = formatted;
+                this.renderActiveSlots();
+            }
+            return;
         }
-        else if (log.level === "ERROR" || log.level === "FAILED") {
-            prefix = `\x1b[31m${prefix}\x1b[0m`;
+        // 3. Step passed -> record step to matching test case
+        if (raw.startsWith('[TESTSPECTRA_STEP_PASS]')) {
+            const fullText = raw.replace('[TESTSPECTRA_STEP_PASS]', '').trim();
+            const match = fullText.match(/\(([^)]+)ms\)$/);
+            const duration = match ? parseInt(match[1], 10) : 0;
+            const cmdText = fullText.replace(/\s*\([^)]+\)$/, '').trim();
+            const formatted = parseAndFormat(cmdText);
+            let testTitle = '';
+            let workerId;
+            try {
+                const payload = JSON.parse(cmdText);
+                testTitle = payload.test || payload.title || '';
+                workerId = payload.workerId;
+            }
+            catch { }
+            const testCase = this.resolveTestCase(testTitle, workerId);
+            if (testCase) {
+                testCase.steps.push({ text: formatted, duration, passed: true });
+                testCase.currentStep = formatted;
+                this.renderActiveSlots();
+            }
+            return;
         }
-        else if (log.level === "WARN" || log.level === "WARNING") {
-            prefix = `\x1b[33m${prefix}\x1b[0m`;
+        // 4. Step failed -> record failed step to matching test case
+        if (raw.startsWith('[TESTSPECTRA_STEP_FAIL]')) {
+            const fullText = raw.replace('[TESTSPECTRA_STEP_FAIL]', '').trim();
+            const match = fullText.match(/\(([^)]+)ms\)$/);
+            const duration = match ? parseInt(match[1], 10) : 0;
+            const cmdText = fullText.replace(/\s*\([^)]+\)$/, '').trim();
+            const formatted = parseAndFormat(cmdText);
+            let testTitle = '';
+            let workerId;
+            try {
+                const payload = JSON.parse(cmdText);
+                testTitle = payload.test || payload.title || '';
+                workerId = payload.workerId;
+            }
+            catch { }
+            const testCase = this.resolveTestCase(testTitle, workerId);
+            if (testCase) {
+                testCase.steps.push({ text: formatted, duration, passed: false });
+                testCase.currentStep = formatted;
+                this.renderActiveSlots();
+            }
+            return;
         }
-        else if (log.level === "INFO") {
-            prefix = `\x1b[36m${prefix}\x1b[0m`;
+        // 5. Test error detail
+        if (raw.startsWith('[TESTSPECTRA_TEST_ERROR]')) {
+            const err = raw.replace('[TESTSPECTRA_TEST_ERROR]', '').trim();
+            const latest = Array.from(this.pendingTests.values()).pop();
+            if (latest) {
+                latest.errorMsg = err;
+            }
+            else {
+                console.log(`    \x1b[38;2;251;191;36m↳ Error:\x1b[0m \x1b[38;2;248;113;113m${err}\x1b[0m`);
+            }
+            return;
         }
-        else {
-            prefix = `\x1b[90m${prefix}\x1b[0m`;
+        // 6. Test passed completely -> flush atomic test block to permanent history
+        if (raw.startsWith('[TESTSPECTRA_TEST_PASS]')) {
+            const fullText = raw.replace('[TESTSPECTRA_TEST_PASS]', '').trim();
+            const match = fullText.match(/\(([^)]+)ms\)$/);
+            const duration = match ? parseInt(match[1], 10) : 0;
+            const title = fullText.replace(/\s*\([^)]+\)$/, '').trim();
+            this.passedCount++;
+            const testCase = this.pendingTests.get(title) || this.resolveTestCase(title);
+            const steps = testCase?.steps || [];
+            const workerId = testCase?.workerId;
+            this.pendingTests.delete(title);
+            if (workerId !== undefined) {
+                this.workerToTest.delete(workerId);
+            }
+            this.clearActiveSlots();
+            console.log(`${chalk.hex('#34d399')('✓')} ${chalk.white.bold(title)} ${chalk.gray(`(${duration}ms)`)}`);
+            for (const step of steps) {
+                console.log(`  ${chalk.green('✔')} ${step.text} ${chalk.gray(`(${step.duration}ms)`)}`);
+            }
+            console.log('');
+            this.renderActiveSlots();
+            return;
+        }
+        // 7. Test failed completely -> flush atomic failed test block to permanent history
+        if (raw.startsWith('[TESTSPECTRA_TEST_FAIL]')) {
+            const fullText = raw.replace('[TESTSPECTRA_TEST_FAIL]', '').trim();
+            const match = fullText.match(/\(([^)]+)ms\)$/);
+            const duration = match ? parseInt(match[1], 10) : 0;
+            const title = fullText.replace(/\s*\([^)]+\)$/, '').trim();
+            this.failedCount++;
+            const testCase = this.pendingTests.get(title) || this.resolveTestCase(title);
+            const steps = testCase?.steps || [];
+            const errorMsg = testCase?.errorMsg;
+            const workerId = testCase?.workerId;
+            this.pendingTests.delete(title);
+            if (workerId !== undefined) {
+                this.workerToTest.delete(workerId);
+            }
+            this.clearActiveSlots();
+            if (errorMsg) {
+                console.log(`    \x1b[38;2;251;191;36m↳ Error:\x1b[0m \x1b[38;2;248;113;113m${errorMsg}\x1b[0m`);
+            }
+            console.log(`${chalk.hex('#f87171')('✗')} ${chalk.white.bold(title)} ${chalk.gray(`(${duration}ms)`)}`);
+            for (const step of steps) {
+                if (step.passed) {
+                    console.log(`  ${chalk.green('✔')} ${step.text} ${chalk.gray(`(${step.duration}ms)`)}`);
+                }
+                else {
+                    console.log(`  ${chalk.red('✖')} ${chalk.red(step.text)} ${chalk.gray(`(${step.duration}ms)`)}`);
+                }
+            }
+            console.log('');
+            this.renderActiveSlots();
+            return;
+        }
+        // Generic errors & warnings
+        if (log.level === 'ERROR' || log.level === 'FAILED') {
+            this.clearActiveSlots();
+            console.log(`  \x1b[38;2;248;113;113m${log.message}\x1b[0m`);
+            this.renderActiveSlots();
+        }
+        else if (log.level === 'WARN' || log.level === 'WARNING') {
+            this.clearActiveSlots();
+            console.log(`  \x1b[38;2;251;191;36m${log.message}\x1b[0m`);
+            this.renderActiveSlots();
         }
-        console.log(`${time} ${prefix} ${log.message}`);
     }
     addNetwork(res) {
         this.networkEvents.push(res);
@@ -32,9 +439,16 @@ export class Reporter {
         return this.networkEvents;
     }
     generateResult(status, duration) {
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = null;
+        }
+        this.clearActiveSlots();
         return {
             status,
             duration,
+            passedCount: this.passedCount,
+            failedCount: this.failedCount,
             logs: this.logs,
             networkResources: this.networkEvents,
         };

package/dist/server/demo.js

@@ -1,28 +1,28 @@
-import http from "http";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { execSync } from "child_process";
-import chalk from "chalk";
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class DemoAppServer {
     server = null;
     port = 0;
-    url = "";
+    url = '';
     static findDemoAppDir(cwd) {
         // 1. Check upward from cwd
         let cur = cwd;
         while (cur !== path.dirname(cur)) {
-            const cand = path.join(cur, "apps", "demo-web-app");
-            if (fs.existsSync(cand) && fs.existsSync(path.join(cand, "package.json"))) {
+            const cand = path.join(cur, 'apps', 'demo-web-app');
+            if (fs.existsSync(cand) && fs.existsSync(path.join(cand, 'package.json'))) {
                 return cand;
             }
             cur = path.dirname(cur);
         }
         // 2. Check relative to CLI package location
-        const relCand = path.resolve(__dirname, "../../../apps/demo-web-app");
-        if (fs.existsSync(relCand) && fs.existsSync(path.join(relCand, "package.json"))) {
+        const relCand = path.resolve(__dirname, '../../../apps/demo-web-app');
+        if (fs.existsSync(relCand) && fs.existsSync(path.join(relCand, 'package.json'))) {
             return relCand;
         }
         return null;
@@ -32,67 +32,66 @@ export class DemoAppServer {
         if (!demoDir) {
             throw new Error("Could not locate 'apps/demo-web-app'. Ensure you are running within the TestSpectra workspace.");
         }
-        const distDir = path.join(demoDir, "dist");
-        if (!fs.existsSync(distDir) || !fs.existsSync(path.join(distDir, "index.html"))) {
-            console.log(chalk.cyan("[TestSpectra] ") +
-                chalk.dim("Building demo web app bundle (apps/demo-web-app)..."));
-            execSync("pnpm --filter @testspectra/demo-web-app build", {
-                cwd: path.resolve(demoDir, "../.."),
-                stdio: "inherit",
+        const distDir = path.join(demoDir, 'dist');
+        if (!fs.existsSync(distDir) || !fs.existsSync(path.join(distDir, 'index.html'))) {
+            console.log(chalk.cyan('[TestSpectra] ') + chalk.dim('Building demo web app bundle (apps/demo-web-app)...'));
+            execSync('pnpm --filter @testspectra/demo-web-app build', {
+                cwd: path.resolve(demoDir, '../..'),
+                stdio: 'inherit',
             });
         }
         const mimeTypes = {
-            ".html": "text/html; charset=utf-8",
-            ".js": "text/javascript; charset=utf-8",
-            ".css": "text/css; charset=utf-8",
-            ".json": "application/json",
-            ".svg": "image/svg+xml",
-            ".png": "image/png",
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-            ".ico": "image/x-icon",
-            ".woff": "font/woff",
-            ".woff2": "font/woff2",
-            ".ttf": "font/ttf",
+            '.html': 'text/html; charset=utf-8',
+            '.js': 'text/javascript; charset=utf-8',
+            '.css': 'text/css; charset=utf-8',
+            '.json': 'application/json',
+            '.svg': 'image/svg+xml',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.ico': 'image/x-icon',
+            '.woff': 'font/woff',
+            '.woff2': 'font/woff2',
+            '.ttf': 'font/ttf',
         };
         return new Promise((resolve, reject) => {
             this.server = http.createServer((req, res) => {
-                const rawUrl = req.url || "/";
-                const cleanPath = rawUrl.split("?")[0].split("#")[0];
-                let filePath = path.join(distDir, cleanPath === "/" ? "index.html" : cleanPath);
+                const rawUrl = req.url || '/';
+                const cleanPath = rawUrl.split('?')[0].split('#')[0];
+                let filePath = path.join(distDir, cleanPath === '/' ? 'index.html' : cleanPath);
                 // Fallback to index.html for SPA client-side routing
                 if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
-                    filePath = path.join(distDir, "index.html");
+                    filePath = path.join(distDir, 'index.html');
                 }
                 const ext = path.extname(filePath).toLowerCase();
-                const contentType = mimeTypes[ext] || "application/octet-stream";
+                const contentType = mimeTypes[ext] || 'application/octet-stream';
                 fs.readFile(filePath, (err, content) => {
                     if (err) {
-                        res.writeHead(500, { "Content-Type": "text/plain" });
-                        res.end("Internal Server Error");
+                        res.writeHead(500, { 'Content-Type': 'text/plain' });
+                        res.end('Internal Server Error');
                     }
                     else {
                         res.writeHead(200, {
-                            "Content-Type": contentType,
-                            "Cache-Control": "no-cache",
-                            "Access-Control-Allow-Origin": "*",
+                            'Content-Type': contentType,
+                            'Cache-Control': 'no-cache',
+                            'Access-Control-Allow-Origin': '*',
                         });
                         res.end(content);
                     }
                 });
             });
-            this.server.listen(0, "127.0.0.1", () => {
+            this.server.listen(0, '127.0.0.1', () => {
                 const addr = this.server?.address();
-                if (addr && typeof addr === "object") {
+                if (addr && typeof addr === 'object') {
                     this.port = addr.port;
                     this.url = `http://127.0.0.1:${this.port}`;
                     resolve(this.url);
                 }
                 else {
-                    reject(new Error("Failed to bind demo preview server address"));
+                    reject(new Error('Failed to bind demo preview server address'));
                 }
             });
-            this.server.on("error", reject);
+            this.server.on('error', reject);
         });
     }
     stop() {

package/dist/types/generator.d.ts

@@ -1,17 +1 @@
-export type PlatformTarget = "web" | "android" | "ios" | "mobile" | "common";
-export declare class TypeGenerator {
-    /**
-     * Discovers all feature directories and shared library directories.
-     * Returns a map of scope -> base directory (e.g. { "shared": ".../shared/testing", "auth": ".../packages/features/auth/e2e" })
-     */
-    static getEntityScopes(cwd: string): {
-        name: string;
-        dir: string;
-        isShared: boolean;
-    }[];
-    static getPageObjectsDirsForScope(scopeDir: string, sharedDir?: string): string[];
-    static getEntityDirsForScope(entityType: "actions" | "steps" | "fixtures", scopeDir: string, sharedDir?: string): string[];
-    static generateDeclarationsForScope(cwd: string, outputTypesDir: string, scopeDir: string, sharedDir?: string): Record<string, string>;
-    static generateFixturesDeclarationForScope(cwd: string, outputTypesDir: string, scopeDir: string, sharedDir?: string): string;
-    static writeDeclarationFiles(cwd: string): void;
-}
+export * from '../generator/type-generator.js';