@testspectra/cli 1.1.7 → 1.1.8-rc.2

package/dist/refactor/refactor-engine.d.ts

@@ -5,6 +5,7 @@ export interface RenameOptions {
     oldName: string;
     newName: string;
     dryRun?: boolean;
+    skipPathRename?: boolean;
 }
 export interface RefactorResult {
     status: 'success' | 'failed';
@@ -19,7 +20,31 @@ export interface RefactorResult {
     }>;
     error?: string;
 }
+export declare const ENTITY_NAMING_RULES: Record<RefactorType, {
+    regex: RegExp;
+    convention: string;
+}>;
+export declare const SUPPORTED_FIXTURE_EXTENSIONS: string[];
 export declare class RefactorEngine {
+    /**
+     * Deterministically parses testing entity type and symbol name from a filesystem path.
+     * Supports directory paths, file paths, and paths with trailing slashes.
+     */
+    static parseEntityFromPath(filePath: string): {
+        type: RefactorType;
+        symbol: string;
+    } | null;
+    /**
+     * Deterministically parses source and target paths, validates entity types,
+     * and executes symbol refactoring across the workspace.
+     */
+    static renameFromPaths(options: {
+        workspaceRoot: string;
+        fromPath: string;
+        toPath: string;
+        dryRun?: boolean;
+        skipPathRename?: boolean;
+    }): Promise<RefactorResult>;
     private static findFiles;
     static renameSymbol(options: RenameOptions): Promise<RefactorResult>;
 }

package/dist/refactor/refactor-engine.js

@@ -1,7 +1,130 @@
 import fs from 'fs';
 import path from 'path';
 import { TypeGenerator } from '../generator/type-generator.js';
+export const ENTITY_NAMING_RULES = {
+    'page-object': {
+        regex: /^[A-Z][a-zA-Z0-9]*$/,
+        convention: 'PascalCase (e.g. "LoginPage", "AuthPage")',
+    },
+    step: {
+        regex: /^[a-z][a-zA-Z0-9]*$/,
+        convention: 'camelCase (e.g. "loginUser", "loginAsAdmin")',
+    },
+    action: {
+        regex: /^[a-z][a-zA-Z0-9]*$/,
+        convention: 'camelCase (e.g. "customSwipe", "swipeTop")',
+    },
+    fixture: {
+        regex: /^[a-z][a-zA-Z0-9_]*$/,
+        convention: 'camelCase or snake_case starting with lowercase (e.g. "users", "apiPayloads", "user_accounts")',
+    },
+};
+export const SUPPORTED_FIXTURE_EXTENSIONS = ['.json', '.csv', '.yaml', '.yml', '.ts', '.js'];
 export class RefactorEngine {
+    /**
+     * Deterministically parses testing entity type and symbol name from a filesystem path.
+     * Supports directory paths, file paths, and paths with trailing slashes.
+     */
+    static parseEntityFromPath(filePath) {
+        if (!filePath || typeof filePath !== 'string')
+            return null;
+        const normalized = filePath.replace(/\\/g, '/').replace(/\/+$/, '');
+        const parts = normalized.split('/').filter(Boolean);
+        // 1. Page Objects: page-objects/<name> or page-objects/<name>/web.ts or page-objects/<name>.ts
+        const poIdx = parts.findIndex((p) => p === 'page-objects');
+        if (poIdx !== -1 && poIdx + 1 < parts.length) {
+            const rawSymbol = parts[poIdx + 1];
+            const symbol = path.parse(rawSymbol).name;
+            if (symbol)
+                return { type: 'page-object', symbol };
+        }
+        // 2. Steps: support/steps/<name> or steps/<name> or steps/<name>/step.md or steps/<name>.ts
+        const stepIdx = parts.findIndex((p) => p === 'steps');
+        if (stepIdx !== -1 && stepIdx + 1 < parts.length) {
+            const rawSymbol = parts[stepIdx + 1];
+            const symbol = path.parse(rawSymbol).name;
+            if (symbol)
+                return { type: 'step', symbol };
+        }
+        // 3. Actions: support/actions/<name> or actions/<name> or actions/<name>/action.ts or actions/<name>.ts
+        const actionIdx = parts.findIndex((p) => p === 'actions');
+        if (actionIdx !== -1 && actionIdx + 1 < parts.length) {
+            const rawSymbol = parts[actionIdx + 1];
+            const symbol = path.parse(rawSymbol).name;
+            if (symbol)
+                return { type: 'action', symbol };
+        }
+        // 4. Fixtures: fixtures/<name>.<ext> or fixtures/nested/<name>.<ext> or fixtures/<name>
+        const fixIdx = parts.findIndex((p) => p === 'fixtures');
+        if (fixIdx !== -1 && fixIdx + 1 < parts.length) {
+            const lastPart = parts[parts.length - 1];
+            const symbol = path.parse(lastPart).name;
+            if (symbol)
+                return { type: 'fixture', symbol };
+        }
+        return null;
+    }
+    /**
+     * Deterministically parses source and target paths, validates entity types,
+     * and executes symbol refactoring across the workspace.
+     */
+    static async renameFromPaths(options) {
+        const { workspaceRoot, fromPath, toPath, dryRun, skipPathRename } = options;
+        if (!fromPath || !toPath) {
+            return {
+                status: 'failed',
+                entityType: 'page-object',
+                oldSymbol: fromPath || '',
+                newSymbol: toPath || '',
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: 'Both source and target paths must be specified for path-based refactoring.',
+            };
+        }
+        const fromParsed = RefactorEngine.parseEntityFromPath(fromPath);
+        if (!fromParsed) {
+            return {
+                status: 'failed',
+                entityType: 'page-object',
+                oldSymbol: fromPath,
+                newSymbol: toPath,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Unable to determine entity type from source path: "${fromPath}". Path must be within page-objects/, support/steps/, support/actions/, or fixtures/.`,
+            };
+        }
+        const toParsed = RefactorEngine.parseEntityFromPath(toPath);
+        if (!toParsed) {
+            return {
+                status: 'failed',
+                entityType: fromParsed.type,
+                oldSymbol: fromParsed.symbol,
+                newSymbol: toPath,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Unable to determine entity type from target path: "${toPath}". Path must be within page-objects/, support/steps/, support/actions/, or fixtures/.`,
+            };
+        }
+        if (fromParsed.type !== toParsed.type) {
+            return {
+                status: 'failed',
+                entityType: fromParsed.type,
+                oldSymbol: fromParsed.symbol,
+                newSymbol: toParsed.symbol,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Entity type mismatch: source is "${fromParsed.type}" but target is "${toParsed.type}". Cross-entity refactoring is not supported.`,
+            };
+        }
+        return RefactorEngine.renameSymbol({
+            workspaceRoot,
+            type: fromParsed.type,
+            oldName: fromParsed.symbol,
+            newName: toParsed.symbol,
+            dryRun,
+            skipPathRename,
+        });
+    }
     static findFiles(dir, extensions) {
         const results = [];
         if (!fs.existsSync(dir))
@@ -30,7 +153,7 @@ export class RefactorEngine {
         return results;
     }
     static async renameSymbol(options) {
-        const { workspaceRoot, type, oldName, newName, dryRun = false } = options;
+        const { workspaceRoot, type, oldName, newName, dryRun = false, skipPathRename = false } = options;
         if (!oldName || !newName || oldName === newName) {
             return {
                 status: 'failed',
@@ -42,60 +165,133 @@ export class RefactorEngine {
                 error: 'Invalid or identical old/new symbol names',
             };
         }
+        let targetOldName = oldName;
+        let targetNewName = newName;
+        if (type === 'fixture') {
+            const parsedOld = path.parse(oldName);
+            if (parsedOld.ext && SUPPORTED_FIXTURE_EXTENSIONS.includes(parsedOld.ext.toLowerCase())) {
+                targetOldName = parsedOld.name;
+            }
+            const parsedNew = path.parse(newName);
+            if (parsedNew.ext && SUPPORTED_FIXTURE_EXTENSIONS.includes(parsedNew.ext.toLowerCase())) {
+                targetNewName = parsedNew.name;
+            }
+        }
+        const rule = ENTITY_NAMING_RULES[type];
+        if (rule && !rule.regex.test(targetNewName)) {
+            return {
+                status: 'failed',
+                entityType: type,
+                oldSymbol: oldName,
+                newSymbol: newName,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Invalid new symbol name "${targetNewName}". Symbol name for ${type} must follow ${rule.convention}.`,
+            };
+        }
         // Phase 1: Determine file operations and replacement patterns
         const plannedRenames = [];
         const plannedEdits = [];
-        let oldSymbol = oldName;
-        let newSymbol = newName;
-        // 1. Target Directory / File Discovery
+        let oldSymbol = targetOldName;
+        let newSymbol = targetNewName;
+        const fixtureDirs = [
+            path.join(workspaceRoot, 'fixtures'),
+            path.join(workspaceRoot, 'support', 'fixtures'),
+            path.join(workspaceRoot, 'shared', 'fixtures'),
+        ];
+        function findFixtureFiles(dir) {
+            const files = [];
+            if (!fs.existsSync(dir))
+                return files;
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name !== 'node_modules' && entry.name !== '.git') {
+                        files.push(...findFixtureFiles(fullPath));
+                    }
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name).toLowerCase();
+                    if (SUPPORTED_FIXTURE_EXTENSIONS.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+            return files;
+        }
+        // 1. Target Directory / File Discovery for Source Entity
         if (type === 'page-object') {
-            oldSymbol = oldName;
-            newSymbol = newName;
-            const poDir = path.join(workspaceRoot, 'page-objects', oldName);
+            oldSymbol = targetOldName;
+            newSymbol = targetNewName;
+            const targetPoDir = path.join(workspaceRoot, 'page-objects', targetNewName);
+            const poDir = path.join(workspaceRoot, 'page-objects', targetOldName);
             if (fs.existsSync(poDir)) {
-                plannedRenames.push({ from: poDir, to: path.join(workspaceRoot, 'page-objects', newName) });
+                plannedRenames.push({ from: poDir, to: targetPoDir });
+            }
+            else if (skipPathRename && fs.existsSync(targetPoDir)) {
+                plannedRenames.push({ from: poDir, to: targetPoDir });
             }
         }
         else if (type === 'step') {
-            oldSymbol = `Step.${oldName}`;
-            newSymbol = `Step.${newName}`;
+            oldSymbol = `Step.${targetOldName}`;
+            newSymbol = `Step.${targetNewName}`;
             const stepCandidates = [
-                path.join(workspaceRoot, 'support', 'steps', oldName),
-                path.join(workspaceRoot, 'steps', oldName),
+                path.join(workspaceRoot, 'support', 'steps', targetOldName),
+                path.join(workspaceRoot, 'steps', targetOldName),
             ];
             for (const cand of stepCandidates) {
                 if (fs.existsSync(cand)) {
                     const parent = path.dirname(cand);
-                    plannedRenames.push({ from: cand, to: path.join(parent, newName) });
+                    plannedRenames.push({ from: cand, to: path.join(parent, targetNewName) });
+                }
+                else if (skipPathRename) {
+                    const parent = path.dirname(cand);
+                    const targetCand = path.join(parent, targetNewName);
+                    if (fs.existsSync(targetCand)) {
+                        plannedRenames.push({ from: cand, to: targetCand });
+                    }
                 }
             }
         }
         else if (type === 'action') {
-            oldSymbol = `Spectra.${oldName}`;
-            newSymbol = `Spectra.${newName}`;
+            oldSymbol = `Spectra.${targetOldName}`;
+            newSymbol = `Spectra.${targetNewName}`;
             const actionCandidates = [
-                path.join(workspaceRoot, 'support', 'actions', oldName),
-                path.join(workspaceRoot, 'actions', oldName),
+                path.join(workspaceRoot, 'support', 'actions', targetOldName),
+                path.join(workspaceRoot, 'actions', targetOldName),
             ];
             for (const cand of actionCandidates) {
                 if (fs.existsSync(cand)) {
                     const parent = path.dirname(cand);
-                    plannedRenames.push({ from: cand, to: path.join(parent, newName) });
+                    plannedRenames.push({ from: cand, to: path.join(parent, targetNewName) });
+                }
+                else if (skipPathRename) {
+                    const parent = path.dirname(cand);
+                    const targetCand = path.join(parent, targetNewName);
+                    if (fs.existsSync(targetCand)) {
+                        plannedRenames.push({ from: cand, to: targetCand });
+                    }
                 }
             }
         }
         else if (type === 'fixture') {
-            oldSymbol = `Fixture.${oldName}`;
-            newSymbol = `Fixture.${newName}`;
-            const fixturesDir = path.join(workspaceRoot, 'fixtures');
-            if (fs.existsSync(fixturesDir)) {
-                const entries = fs.readdirSync(fixturesDir);
-                for (const entry of entries) {
-                    const parsed = path.parse(entry);
-                    if (parsed.name === oldName) {
+            oldSymbol = `Fixture.${targetOldName}`;
+            newSymbol = `Fixture.${targetNewName}`;
+            for (const dir of fixtureDirs) {
+                const fixtureFiles = findFixtureFiles(dir);
+                for (const file of fixtureFiles) {
+                    const parsed = path.parse(file);
+                    if (parsed.name === targetOldName) {
+                        plannedRenames.push({
+                            from: file,
+                            to: path.join(parsed.dir, `${targetNewName}${parsed.ext}`),
+                        });
+                    }
+                    else if (skipPathRename && parsed.name === targetNewName) {
                         plannedRenames.push({
-                            from: path.join(fixturesDir, entry),
-                            to: path.join(fixturesDir, `${newName}${parsed.ext}`),
+                            from: path.join(parsed.dir, `${targetOldName}${parsed.ext}`),
+                            to: file,
                         });
                     }
                 }
@@ -110,6 +306,9 @@ export class RefactorEngine {
             path.join(workspaceRoot, 'steps'),
             path.join(workspaceRoot, 'actions'),
             path.join(workspaceRoot, 'global-hooks'),
+            path.join(workspaceRoot, 'packages'),
+            path.join(workspaceRoot, 'apps'),
+            path.join(workspaceRoot, 'shared'),
         ];
         const allCodeFiles = searchDirs.flatMap((dir) => this.findFiles(dir, ['.ts', '.js', '.md']));
         const uniqueFiles = Array.from(new Set(allCodeFiles));
@@ -126,6 +325,20 @@ export class RefactorEngine {
                     modified = modified.replace(classReg, `class ${newName}`);
                     count += classMatches;
                 }
+                // Replace `new OldName` -> `new NewName` (e.g. `export default new OldName()`, `new OldName(...)`)
+                const newReg = new RegExp(`\\bnew\\s+${oldName}\\b`, 'g');
+                const newMatches = (modified.match(newReg) || []).length;
+                if (newMatches > 0) {
+                    modified = modified.replace(newReg, `new ${newName}`);
+                    count += newMatches;
+                }
+                // Replace `export default OldName` -> `export default NewName`
+                const exportDefaultReg = new RegExp(`\\bexport\\s+default\\s+${oldName}\\b`, 'g');
+                const exportDefaultMatches = (modified.match(exportDefaultReg) || []).length;
+                if (exportDefaultMatches > 0) {
+                    modified = modified.replace(exportDefaultReg, `export default ${newName}`);
+                    count += exportDefaultMatches;
+                }
                 // Replace `OldName.` -> `NewName.`
                 const refReg = new RegExp(`\\b${oldName}\\.`, 'g');
                 const refMatches = (modified.match(refReg) || []).length;
@@ -161,12 +374,20 @@ export class RefactorEngine {
             }
             else if (type === 'fixture') {
                 // Replace `Fixture.oldFixture` -> `Fixture.newFixture`
-                const fixReg = new RegExp(`\\bFixture\\.${oldName}\\b`, 'g');
+                const fixReg = new RegExp(`\\bFixture\\.${targetOldName}\\b`, 'g');
                 const fixMatches = (modified.match(fixReg) || []).length;
                 if (fixMatches > 0) {
-                    modified = modified.replace(fixReg, `Fixture.${newName}`);
+                    modified = modified.replace(fixReg, `Fixture.${targetNewName}`);
                     count += fixMatches;
                 }
+                // Also replace file references with supported extensions (e.g. 'users.csv', 'users.yaml', etc.)
+                const extPattern = SUPPORTED_FIXTURE_EXTENSIONS.map((e) => e.replace('.', '')).join('|');
+                const fixFileReg = new RegExp(`(?<!Fixture\\.)\\b${targetOldName}\\.(${extPattern})\\b`, 'g');
+                const fixFileMatches = (modified.match(fixFileReg) || []).length;
+                if (fixFileMatches > 0) {
+                    modified = modified.replace(fixFileReg, `${targetNewName}.$1`);
+                    count += fixFileMatches;
+                }
             }
             if (count > 0) {
                 totalOccurrences += count;
@@ -178,6 +399,108 @@ export class RefactorEngine {
                 });
             }
         }
+        // Source Existence Guard:
+        // If no filesystem files/directories match the source symbol AND no code occurrences were found,
+        // the source symbol does not exist anywhere in the workspace.
+        if (plannedRenames.length === 0 && totalOccurrences === 0) {
+            return {
+                status: 'failed',
+                entityType: type,
+                oldSymbol,
+                newSymbol,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Source ${type} "${oldName}" was not found in the workspace (no matching files or symbol occurrences).`,
+            };
+        }
+        // Target Collision Guards (Priority 2 - checked only if source entity exists and skipPathRename is false)
+        if (!skipPathRename) {
+            if (type === 'page-object') {
+                const targetPoDir = path.join(workspaceRoot, 'page-objects', targetNewName);
+                if (fs.existsSync(targetPoDir)) {
+                    return {
+                        status: 'failed',
+                        entityType: type,
+                        oldSymbol,
+                        newSymbol,
+                        modifiedFiles: [],
+                        occurrencesReplaced: 0,
+                        error: `Target page-object "${targetNewName}" already exists at "${path.relative(workspaceRoot, targetPoDir)}"`,
+                    };
+                }
+            }
+            else if (type === 'step') {
+                const targetStepCandidates = [
+                    path.join(workspaceRoot, 'support', 'steps', targetNewName),
+                    path.join(workspaceRoot, 'steps', targetNewName),
+                ];
+                for (const cand of targetStepCandidates) {
+                    if (fs.existsSync(cand)) {
+                        return {
+                            status: 'failed',
+                            entityType: type,
+                            oldSymbol,
+                            newSymbol,
+                            modifiedFiles: [],
+                            occurrencesReplaced: 0,
+                            error: `Target step "${targetNewName}" already exists at "${path.relative(workspaceRoot, cand)}"`,
+                        };
+                    }
+                }
+            }
+            else if (type === 'action') {
+                const targetActionCandidates = [
+                    path.join(workspaceRoot, 'support', 'actions', targetNewName),
+                    path.join(workspaceRoot, 'actions', targetNewName),
+                ];
+                for (const cand of targetActionCandidates) {
+                    if (fs.existsSync(cand)) {
+                        return {
+                            status: 'failed',
+                            entityType: type,
+                            oldSymbol,
+                            newSymbol,
+                            modifiedFiles: [],
+                            occurrencesReplaced: 0,
+                            error: `Target action "${targetNewName}" already exists at "${path.relative(workspaceRoot, cand)}"`,
+                        };
+                    }
+                }
+            }
+            else if (type === 'fixture') {
+                for (const dir of fixtureDirs) {
+                    const fixtureFiles = findFixtureFiles(dir);
+                    for (const file of fixtureFiles) {
+                        const parsed = path.parse(file);
+                        if (parsed.name === targetNewName) {
+                            return {
+                                status: 'failed',
+                                entityType: type,
+                                oldSymbol,
+                                newSymbol,
+                                modifiedFiles: [],
+                                occurrencesReplaced: 0,
+                                error: `Target fixture "${targetNewName}" already exists at "${path.relative(workspaceRoot, file)}"`,
+                            };
+                        }
+                    }
+                }
+            }
+            // Universal pre-commit collision guard
+            for (const rn of plannedRenames) {
+                if (fs.existsSync(rn.to)) {
+                    return {
+                        status: 'failed',
+                        entityType: type,
+                        oldSymbol,
+                        newSymbol,
+                        modifiedFiles: [],
+                        occurrencesReplaced: 0,
+                        error: `Target destination already exists on disk: "${path.relative(workspaceRoot, rn.to)}"`,
+                    };
+                }
+            }
+        }
         if (dryRun) {
             return {
                 status: 'success',
@@ -200,19 +523,26 @@ export class RefactorEngine {
                 modifiedFilesWritten.push(edit.filePath);
             }
             // 2. Perform path renames (directories and files)
-            for (const rn of plannedRenames) {
-                if (fs.existsSync(rn.from)) {
-                    const parent = path.dirname(rn.to);
-                    if (!fs.existsSync(parent))
-                        fs.mkdirSync(parent, { recursive: true });
-                    fs.renameSync(rn.from, rn.to);
+            if (!skipPathRename) {
+                for (const rn of plannedRenames) {
+                    if (fs.existsSync(rn.from)) {
+                        const parent = path.dirname(rn.to);
+                        if (!fs.existsSync(parent))
+                            fs.mkdirSync(parent, { recursive: true });
+                        fs.renameSync(rn.from, rn.to);
+                    }
                 }
             }
             // 3. Automatically regenerate ambient declarations post-refactor
             TypeGenerator.generateAll(workspaceRoot);
             const typesDir = path.join(workspaceRoot, '.testspectra', 'types');
             if (fs.existsSync(typesDir)) {
-                modifiedFilesWritten.push(path.join(typesDir, 'web.d.ts'));
+                if (fs.existsSync(path.join(typesDir, 'web.d.ts'))) {
+                    modifiedFilesWritten.push(path.join(typesDir, 'web.d.ts'));
+                }
+                if (fs.existsSync(path.join(typesDir, 'fixtures.d.ts'))) {
+                    modifiedFilesWritten.push(path.join(typesDir, 'fixtures.d.ts'));
+                }
             }
             return {
                 status: 'success',
@@ -233,12 +563,14 @@ export class RefactorEngine {
                 catch { }
             }
             // Reverse path renames
-            for (const rn of plannedRenames) {
-                if (fs.existsSync(rn.to)) {
-                    try {
-                        fs.renameSync(rn.to, rn.from);
+            if (!skipPathRename) {
+                for (const rn of plannedRenames) {
+                    if (fs.existsSync(rn.to)) {
+                        try {
+                            fs.renameSync(rn.to, rn.from);
+                        }
+                        catch { }
                     }
-                    catch { }
                 }
             }
             return {

package/dist/reporter/semantic-formatter.js

@@ -13,6 +13,17 @@ function extractTargetString(target) {
     }
     return String(target);
 }
+/** Renders a `ScopedSelector`'s `.parent` chain (produced by `element.get()`/`.getAll()`
+ * chaining) as `"parent" within "grandparent"`, nearest ancestor first — or null when the
+ * target isn't scoped. */
+function extractWithinChain(target) {
+    if (!target || typeof target !== 'object' || !target.parent)
+        return null;
+    const chain = [];
+    for (let p = target.parent; p; p = p.parent)
+        chain.push(p.selector);
+    return chain.join('" within "');
+}
 function formatElementTarget(target) {
     const sel = extractTargetString(target);
     if (!sel)
@@ -20,7 +31,8 @@ function formatElementTarget(target) {
     if (sel.startsWith('element "') || sel.startsWith('collection "')) {
         return sel;
     }
-    return `element "${sel}"`;
+    const within = extractWithinChain(target);
+    return within ? `element "${sel}" within "${within}"` : `element "${sel}"`;
 }
 function formatCollectionTarget(target) {
     const sel = extractTargetString(target);
@@ -29,7 +41,8 @@ function formatCollectionTarget(target) {
     if (sel.startsWith('collection "')) {
         return sel;
     }
-    return `collection "${sel}"`;
+    const within = extractWithinChain(target);
+    return within ? `collection "${sel}" within "${within}"` : `collection "${sel}"`;
 }
 /**
  * Transforms raw matcher assertions and element commands into grammatically correct English sentences.
@@ -37,6 +50,11 @@ function formatCollectionTarget(target) {
 export function formatAction(actionKey, target, args = {}) {
     const el = formatElementTarget(target);
     switch (actionKey) {
+        // Component testing only (@testspectra/react's Spectra.mount()) — target is a component name,
+        // not a DOM selector, so it's rendered plainly rather than through formatElementTarget's
+        // `element "..."` wrapping.
+        case 'mount':
+            return `Mount component "${extractTargetString(target) || '{component}'}"`;
         case 'click':
             return `Click on ${el}`;
         case 'doubleClick':
@@ -83,6 +101,8 @@ export function formatAction(actionKey, target, args = {}) {
             return `Intercept ${args.method ?? '{method}'} "${args.url ?? '{url}'}" mock rule registered`;
         case 'clearCookies':
             return `Clear all browser cookies`;
+        case 'setCookies':
+            return `Set cookies for "${args.url ?? '{url}'}"`;
         case 'clearLocalStorage':
             return `Clear browser localStorage`;
         default:

package/dist/reporter/types.d.ts

@@ -1,2 +1,2 @@
-export type ActionKey = 'click' | 'doubleClick' | 'rightClick' | 'type' | 'clear' | 'select' | 'hover' | 'dragDrop' | 'scrollIntoView' | 'longPress' | 'waitForElement' | 'navigate' | 'back' | 'forward' | 'refresh' | 'setViewport' | 'wait' | 'pressKey' | 'scroll' | 'swipe' | 'intercept' | 'clearCookies' | 'clearLocalStorage';
+export type ActionKey = 'click' | 'doubleClick' | 'rightClick' | 'type' | 'clear' | 'select' | 'hover' | 'dragDrop' | 'scrollIntoView' | 'longPress' | 'waitForElement' | 'navigate' | 'back' | 'forward' | 'refresh' | 'setViewport' | 'wait' | 'pressKey' | 'scroll' | 'swipe' | 'intercept' | 'clearCookies' | 'setCookies' | 'clearLocalStorage';
 export type AssertionKey = 'be.visible' | 'not.be.visible' | 'exist' | 'not.exist' | 'be.clickable' | 'not.be.clickable' | 'be.enabled' | 'be.disabled' | 'be.checked' | 'not.be.checked' | 'be.selected' | 'not.be.selected' | 'be.focused' | 'not.be.focused' | 'have.text' | 'not.have.text' | 'contain.text' | 'not.contain.text' | 'have.value' | 'not.have.value' | 'contain.value' | 'not.contain.value' | 'have.attr' | 'not.have.attr' | 'have.class' | 'not.have.class' | 'have.css' | 'not.have.css' | 'have.length' | 'not.have.length' | 'have.length.greaterThan' | 'have.length.lessThan' | 'be.empty' | 'not.be.empty' | 'shouldHaveUrl' | 'shouldContainUrl' | 'shouldHaveTitle' | 'shouldContainTitle' | 'shouldBeLoaded' | 'shouldBePageLoaded' | 'shouldHaveNoConsoleErrors' | 'have.url' | 'contain.url' | 'have.title' | 'contain.title' | 'be.loaded' | 'be.pageLoaded' | 'have.noConsoleErrors';

package/dist/runner/bridge.d.ts

@@ -14,7 +14,7 @@ export interface RunOptions {
     targetDevice?: string;
     licenseKey?: string;
     outputJsonPath?: string;
-    spec?: string;
+    specs?: string[];
     concurrency?: number;
     failedOnly?: boolean;
     failedTarget?: string;