@testspectra/cli 1.1.0-rc.0 → 1.1.0-rc.1

package/dist/generator/tsconfig-generator.js

@@ -41,20 +41,28 @@ export class TsConfigGenerator {
                 target: 'ES2022',
                 module: 'NodeNext',
                 moduleResolution: 'NodeNext',
+                jsx: 'react-jsx',
                 composite: true,
                 noEmit: true,
                 skipLibCheck: true,
                 strict: true,
-                types: ['node', '@wdio/globals/types', '@wdio/mocha-framework'],
+                types: ['node'],
             },
             include: [
                 '../types/web.d.ts',
                 '../types/fixtures.d.ts',
                 '../../**/specs/**/*.ts',
+                '../../**/specs/**/*.tsx',
                 '../../**/page-objects/**/*.ts',
+                '../../**/page-objects/**/*.tsx',
                 '../../**/support/**/*.ts',
+                '../../**/support/**/*.tsx',
                 '../../**/global-hooks/**/*.ts',
+                '../../**/global-hooks/**/*.tsx',
                 '../../**/fixtures/**/*.ts',
+                '../../**/fixtures/**/*.json',
+                '../../**/src/**/*.ts',
+                '../../**/src/**/*.tsx',
                 '../../spectra.config.ts',
             ],
             exclude: [
@@ -73,20 +81,28 @@ export class TsConfigGenerator {
                 target: 'ES2022',
                 module: 'NodeNext',
                 moduleResolution: 'NodeNext',
+                jsx: 'react-jsx',
                 composite: true,
                 noEmit: true,
                 skipLibCheck: true,
                 strict: true,
-                types: ['node', '@wdio/globals/types', '@wdio/mocha-framework'],
+                types: ['node'],
             },
             include: [
                 '../types/mobile.d.ts',
                 '../types/fixtures.d.ts',
                 '../../**/specs/**/*.ts',
+                '../../**/specs/**/*.tsx',
                 '../../**/page-objects/**/*.ts',
+                '../../**/page-objects/**/*.tsx',
                 '../../**/support/**/*.ts',
+                '../../**/support/**/*.tsx',
                 '../../**/global-hooks/**/*.ts',
+                '../../**/global-hooks/**/*.tsx',
                 '../../**/fixtures/**/*.ts',
+                '../../**/fixtures/**/*.json',
+                '../../**/src/**/*.ts',
+                '../../**/src/**/*.tsx',
                 '../../spectra.config.ts',
             ],
             exclude: [
@@ -105,20 +121,28 @@ export class TsConfigGenerator {
                 target: 'ES2022',
                 module: 'NodeNext',
                 moduleResolution: 'NodeNext',
+                jsx: 'react-jsx',
                 composite: true,
                 noEmit: true,
                 skipLibCheck: true,
                 strict: true,
-                types: ['node', '@wdio/globals/types', '@wdio/mocha-framework'],
+                types: ['node'],
             },
             include: [
                 '../types/android.d.ts',
                 '../types/fixtures.d.ts',
                 '../../**/specs/**/*.ts',
+                '../../**/specs/**/*.tsx',
                 '../../**/page-objects/**/*.ts',
+                '../../**/page-objects/**/*.tsx',
                 '../../**/support/**/*.ts',
+                '../../**/support/**/*.tsx',
                 '../../**/global-hooks/**/*.ts',
+                '../../**/global-hooks/**/*.tsx',
                 '../../**/fixtures/**/*.ts',
+                '../../**/fixtures/**/*.json',
+                '../../**/src/**/*.ts',
+                '../../**/src/**/*.tsx',
                 '../../spectra.config.ts',
             ],
             exclude: [
@@ -137,20 +161,28 @@ export class TsConfigGenerator {
                 target: 'ES2022',
                 module: 'NodeNext',
                 moduleResolution: 'NodeNext',
+                jsx: 'react-jsx',
                 composite: true,
                 noEmit: true,
                 skipLibCheck: true,
                 strict: true,
-                types: ['node', '@wdio/globals/types', '@wdio/mocha-framework'],
+                types: ['node'],
             },
             include: [
                 '../types/ios.d.ts',
                 '../types/fixtures.d.ts',
                 '../../**/specs/**/*.ts',
+                '../../**/specs/**/*.tsx',
                 '../../**/page-objects/**/*.ts',
+                '../../**/page-objects/**/*.tsx',
                 '../../**/support/**/*.ts',
+                '../../**/support/**/*.tsx',
                 '../../**/global-hooks/**/*.ts',
+                '../../**/global-hooks/**/*.tsx',
                 '../../**/fixtures/**/*.ts',
+                '../../**/fixtures/**/*.json',
+                '../../**/src/**/*.ts',
+                '../../**/src/**/*.tsx',
                 '../../spectra.config.ts',
             ],
             exclude: [
@@ -169,20 +201,23 @@ export class TsConfigGenerator {
                 target: 'ES2022',
                 module: 'NodeNext',
                 moduleResolution: 'NodeNext',
+                jsx: 'react-jsx',
                 composite: true,
                 noEmit: true,
                 skipLibCheck: true,
                 strict: true,
-                types: ['node', '@wdio/globals/types', '@wdio/mocha-framework'],
+                types: ['node'],
             },
             include: [
                 '../types/common.d.ts',
                 '../types/fixtures.d.ts',
                 '../../**/page-objects/**/common.ts',
+                '../../**/page-objects/**/common.tsx',
                 '../../**/support/**/common.*',
                 '../../**/global-hooks/**/common.*',
                 '../../**/specs/**/hooks/**/common.*',
                 '../../**/specs/**/common.test.ts',
+                '../../**/specs/**/common.test.tsx',
                 '../../spectra.config.ts',
             ],
             exclude: [
@@ -210,7 +245,7 @@ export class TsConfigGenerator {
         const relCache = path.relative(subConfigDir, path.join(options.cwd, '.testspectra', 'cache')).replace(/\\/g, '/');
         const platformDts = `${relTypesDir}/${platform}.d.ts`;
         const fixturesDts = `${relTypesDir}/fixtures.d.ts`;
-        const include = [platformDts, fixturesDts, `${relScope}/**/*.ts`, relSpectraConfig];
+        const include = [platformDts, fixturesDts, `${relScope}/**/*.ts`, `${relScope}/**/*.tsx`, relSpectraConfig];
         const baseExcludes = [relNodeModules, relDist, relReports, relRuns, relCache];
         const stemMap = {
             web: ['android', 'ios', 'mobile'],
@@ -229,7 +264,7 @@ export class TsConfigGenerator {
                 noEmit: true,
                 skipLibCheck: true,
                 strict: true,
-                types: ['node', '@wdio/globals/types', '@wdio/mocha-framework'],
+                types: ['node'],
             },
             include,
             exclude: [...baseExcludes, ...platformExcludes],

package/dist/generator/type-generator.d.ts

@@ -18,11 +18,23 @@ export interface EntityScope {
  *    - Directory with page-objects/support/fixtures and NO specs => Shared Scope
  */
 export declare function discoverEntityScopes(cwd: string): EntityScope[];
+/**
+ * Detects a component-testing project (`@testspectra/react`'s Vitest browser-mode runner), via
+ * the same signal `cli/src/commands/test.ts` uses to gate `spectra test` itself. Used to augment
+ * the generated `Spectra` ambient type with `.mount()`, which only exists in that runtime.
+ */
+export declare function isComponentTestingProject(cwd: string): boolean;
 export declare class TypeGenerator {
     /**
      * Main entry point to generate all ambient type declarations.
      */
     static generateAll(cwd: string): void;
+    /**
+     * Reloads `spectra.config.ts` and refreshes `.testspectra/types/env.d.ts` with the current
+     * `executionConfig.environmentVariables`. Separate from `writeDeclarationFiles`/`generateAll`
+     * (which must stay synchronous) because reading the config file is unavoidably async.
+     */
+    static syncEnvDeclaration(cwd: string): Promise<void>;
     /**
      * Discovers all feature directories and shared library directories.
      * Returns a map of scope -> base directory
@@ -30,7 +42,18 @@ export declare class TypeGenerator {
     static getEntityScopes(cwd: string): EntityScope[];
     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<PlatformTarget, string>;
+    static generateDeclarationsForScope(cwd: string, outputTypesDir: string, scopeDir: string, sharedDir?: string, rootTypesDir?: string): Record<PlatformTarget, string>;
     static generateFixturesDeclarationForScope(cwd: string, outputTypesDir: string, scopeDir: string, sharedDir?: string): string;
+    /**
+     * Generates the typed `Spectra.env` ambient declaration from `spectra.config.ts`'s
+     * `executionConfig.environmentVariables` — mirrors `generateFixturesDeclarationForScope`, but
+     * env vars come from a single project-level config rather than a scanned directory.
+     *
+     * Emits a bare global `interface SpectraEnv { readonly KEY: string; ... }`, which TypeScript
+     * interface-merges with the empty `SpectraEnv` shipped by `@testspectra/matchers` (the same
+     * mechanism `@types/node` uses for projects to augment `NodeJS.ProcessEnv`) — so `Spectra.env.KEY`
+     * resolves to `string`, never `string | undefined` like raw `process.env.KEY`.
+     */
+    static generateEnvDeclaration(environmentVariables: Record<string, string>): string;
     static writeDeclarationFiles(cwd: string): void;
 }

package/dist/generator/type-generator.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { ConfigLoader } from '../config/loader.js';
 import { TsConfigGenerator } from './tsconfig-generator.js';
 export const PLATFORM_HIERARCHY = {
     web: ['web', 'common'],
@@ -180,6 +181,23 @@ export function discoverEntityScopes(cwd) {
     fallbackScan(cwd, 5);
     return scopes;
 }
+/**
+ * Detects a component-testing project (`@testspectra/react`'s Vitest browser-mode runner), via
+ * the same signal `cli/src/commands/test.ts` uses to gate `spectra test` itself. Used to augment
+ * the generated `Spectra` ambient type with `.mount()`, which only exists in that runtime.
+ */
+export function isComponentTestingProject(cwd) {
+    try {
+        const pkgPath = path.join(cwd, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return false;
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return Boolean(pkg.dependencies?.['@testspectra/react'] || pkg.devDependencies?.['@testspectra/react']);
+    }
+    catch {
+        return false;
+    }
+}
 export class TypeGenerator {
     /**
      * Main entry point to generate all ambient type declarations.
@@ -188,6 +206,24 @@ export class TypeGenerator {
         this.writeDeclarationFiles(cwd);
         TsConfigGenerator.scaffoldConfigs(cwd);
     }
+    /**
+     * Reloads `spectra.config.ts` and refreshes `.testspectra/types/env.d.ts` with the current
+     * `executionConfig.environmentVariables`. Separate from `writeDeclarationFiles`/`generateAll`
+     * (which must stay synchronous) because reading the config file is unavoidably async.
+     */
+    static async syncEnvDeclaration(cwd) {
+        const rootTypesDir = path.join(cwd, '.testspectra', 'types');
+        if (!fs.existsSync(rootTypesDir)) {
+            fs.mkdirSync(rootTypesDir, { recursive: true });
+        }
+        let environmentVariables = {};
+        try {
+            const config = await ConfigLoader.loadConfig(cwd);
+            environmentVariables = config.executionConfig?.environmentVariables ?? {};
+        }
+        catch { }
+        fs.writeFileSync(path.join(rootTypesDir, 'env.d.ts'), this.generateEnvDeclaration(environmentVariables), 'utf-8');
+    }
     /**
      * Discovers all feature directories and shared library directories.
      * Returns a map of scope -> base directory
@@ -267,10 +303,11 @@ export class TypeGenerator {
         }
         return dirs;
     }
-    static generateDeclarationsForScope(cwd, outputTypesDir, scopeDir, sharedDir) {
+    static generateDeclarationsForScope(cwd, outputTypesDir, scopeDir, sharedDir, rootTypesDir) {
         const poDirs = this.getPageObjectsDirsForScope(scopeDir, sharedDir);
         const actionsDirs = this.getEntityDirsForScope('actions', scopeDir, sharedDir);
         const stepsDirs = this.getEntityDirsForScope('steps', scopeDir, sharedDir);
+        const isComponentTesting = isComponentTestingProject(cwd);
         const platforms = ['web', 'android', 'ios', 'mobile', 'common'];
         const results = {
             web: '',
@@ -279,14 +316,39 @@ export class TypeGenerator {
             mobile: '',
             common: '',
         };
+        // `env.d.ts` always lives at the workspace root types dir (env vars come from a single
+        // `spectra.config.ts`, unlike per-scope fixtures/page-objects), so a shared/feature scope's
+        // own declarations reference it via a relative path back up to the root.
+        let envRefPath = './env.d.ts';
+        if (rootTypesDir && rootTypesDir !== outputTypesDir) {
+            envRefPath = path.relative(outputTypesDir, path.join(rootTypesDir, 'env.d.ts')).replace(/\\/g, '/');
+            if (!envRefPath.startsWith('.'))
+                envRefPath = `./${envRefPath}`;
+        }
         for (const platform of platforms) {
             const hierarchy = PLATFORM_HIERARCHY[platform];
             let content = `// Auto-generated ambient declarations for TestSpectra [${platform.toUpperCase()}]\n`;
             content += `// Managed automatically by TestSpectra Language Service Plugin.\n\n`;
-            content += `/// <reference types="@wdio/globals/types" />\n`;
-            content += `/// <reference types="@wdio/mocha-framework" />\n`;
+            // TestSpectra's Rust-native orchestrator worker (core/orchestrator/src/worker/bdd_runner.ts)
+            // registers its own `it`/`test`/lifecycle-hook globals directly — there is no WDIO or Mocha
+            // runtime involved at all (not just for component testing; this is true across every
+            // platform). `describe` is intentionally NOT declared here even though the runtime has a
+            // transparent no-op implementation of it — spec-schema-linter's no-describe-block rule
+            // forbids authoring it, so leaving it undeclared makes that a compile error too, not just a
+            // lint error.
+            content += `declare function it(title: string, fn: () => Promise<void> | void): void;\n`;
+            if (isComponentTesting) {
+                // Vitest's own `expect` global (test.globals: true in tools/react/vitest.config.ts) — the
+                // one thing component specs legitimately need beyond the Spectra.* DSL, for asserting
+                // plain closure/callback state (e.g. "was this onClick handler invoked") that has no DOM
+                // element to target. Reuses @testspectra/react's own re-exported `ExpectStatic` type
+                // rather than hand-duplicating Vitest's expect API surface. Not declared for E2E projects
+                // — the Rust orchestrator's BDD runtime has no `expect` global at all.
+                content += `declare const expect: import('@testspectra/react').ExpectStatic;\n`;
+            }
             content += `/// <reference types="@testspectra/matchers" />\n`;
-            content += `/// <reference path="./fixtures.d.ts" />\n\n`;
+            content += `/// <reference path="./fixtures.d.ts" />\n`;
+            content += `/// <reference path="${envRefPath}" />\n\n`;
             // 1. Page Objects Global Declarations
             const declaredPOMs = new Set();
             for (const poDir of poDirs) {
@@ -423,7 +485,10 @@ export class TypeGenerator {
                 }
             }
             content += `}\n`;
-            content += `type TestSpectraActions = import('@testspectra/matchers').SpectraStatic & TestSpectraCustomActions;\n`;
+            // Reuses @testspectra/react's own exported `mount` type rather than hand-duplicating its
+            // signature here — stays in sync automatically if that signature ever changes.
+            const mountAugment = isComponentTesting ? ` & { mount: typeof import('@testspectra/react').mount }` : '';
+            content += `type TestSpectraActions = import('@testspectra/matchers').SpectraStatic & TestSpectraCustomActions${mountAugment};\n`;
             content += `declare const Spectra: TestSpectraActions;\n\n`;
             // 3. Built-in Steps Declaration
             content += `interface TestSpectraSteps {\n`;
@@ -543,11 +608,42 @@ export class TypeGenerator {
         content += `declare const Fixture: TestSpectraFixtures;\n`;
         return content;
     }
+    /**
+     * Generates the typed `Spectra.env` ambient declaration from `spectra.config.ts`'s
+     * `executionConfig.environmentVariables` — mirrors `generateFixturesDeclarationForScope`, but
+     * env vars come from a single project-level config rather than a scanned directory.
+     *
+     * Emits a bare global `interface SpectraEnv { readonly KEY: string; ... }`, which TypeScript
+     * interface-merges with the empty `SpectraEnv` shipped by `@testspectra/matchers` (the same
+     * mechanism `@types/node` uses for projects to augment `NodeJS.ProcessEnv`) — so `Spectra.env.KEY`
+     * resolves to `string`, never `string | undefined` like raw `process.env.KEY`.
+     */
+    static generateEnvDeclaration(environmentVariables) {
+        let content = `// Auto-generated ambient Spectra.env declarations for TestSpectra\n`;
+        content += `// Managed automatically by TestSpectra Language Service Plugin.\n\n`;
+        content += `interface SpectraEnv {\n`;
+        for (const key of Object.keys(environmentVariables)) {
+            content += `  readonly ${JSON.stringify(key)}: string;\n`;
+        }
+        content += `}\n`;
+        return content;
+    }
     static writeDeclarationFiles(cwd) {
         const rootTypesDir = path.join(cwd, '.testspectra', 'types');
         if (!fs.existsSync(rootTypesDir)) {
             fs.mkdirSync(rootTypesDir, { recursive: true });
         }
+        // env.d.ts always lives at the root, regardless of Nx scopes — a single spectra.config.ts's
+        // executionConfig.environmentVariables applies workspace-wide (see generateEnvDeclaration).
+        // Reading spectra.config.ts itself is unavoidably async (ESM dynamic import), which would ripple
+        // an async signature through every caller of this long-standing sync method — instead, this only
+        // guarantees env.d.ts *exists* (so the reference below never points at a missing file) and
+        // leaves it accurate as of the last real sync. `syncEnvDeclaration` (called at the actual
+        // execution entry points: run/watch/sync-types) is what keeps its content up to date.
+        const envDtsPath = path.join(rootTypesDir, 'env.d.ts');
+        if (!fs.existsSync(envDtsPath)) {
+            fs.writeFileSync(envDtsPath, this.generateEnvDeclaration({}), 'utf-8');
+        }
         const scopes = this.getEntityScopes(cwd);
         const sharedScope = scopes.find((s) => s.isShared);
         const featureScopes = scopes.filter((s) => !s.isShared);
@@ -561,7 +657,7 @@ export class TypeGenerator {
         if (!hasScopes || hasRootEntities) {
             const rootFixtures = this.generateFixturesDeclarationForScope(cwd, rootTypesDir, cwd);
             fs.writeFileSync(path.join(rootTypesDir, 'fixtures.d.ts'), rootFixtures, 'utf-8');
-            const rootDeclarations = this.generateDeclarationsForScope(cwd, rootTypesDir, cwd);
+            const rootDeclarations = this.generateDeclarationsForScope(cwd, rootTypesDir, cwd, undefined, rootTypesDir);
             for (const [platform, content] of Object.entries(rootDeclarations)) {
                 fs.writeFileSync(path.join(rootTypesDir, `${platform}.d.ts`), content, 'utf-8');
             }
@@ -587,7 +683,7 @@ export class TypeGenerator {
                 fs.mkdirSync(sharedTypesDir, { recursive: true });
             const sharedFixtures = this.generateFixturesDeclarationForScope(cwd, sharedTypesDir, sharedScope.dir);
             fs.writeFileSync(path.join(sharedTypesDir, 'fixtures.d.ts'), sharedFixtures, 'utf-8');
-            const sharedDeclarations = this.generateDeclarationsForScope(cwd, sharedTypesDir, sharedScope.dir);
+            const sharedDeclarations = this.generateDeclarationsForScope(cwd, sharedTypesDir, sharedScope.dir, undefined, rootTypesDir);
             for (const [platform, content] of Object.entries(sharedDeclarations)) {
                 fs.writeFileSync(path.join(sharedTypesDir, `${platform}.d.ts`), content, 'utf-8');
             }
@@ -609,7 +705,7 @@ export class TypeGenerator {
                 fs.mkdirSync(featureTypesDir, { recursive: true });
             const featureFixtures = this.generateFixturesDeclarationForScope(cwd, featureTypesDir, feature.dir, sharedScope?.dir);
             fs.writeFileSync(path.join(featureTypesDir, 'fixtures.d.ts'), featureFixtures, 'utf-8');
-            const featureDeclarations = this.generateDeclarationsForScope(cwd, featureTypesDir, feature.dir, sharedScope?.dir);
+            const featureDeclarations = this.generateDeclarationsForScope(cwd, featureTypesDir, feature.dir, sharedScope?.dir, rootTypesDir);
             for (const [platform, content] of Object.entries(featureDeclarations)) {
                 fs.writeFileSync(path.join(featureTypesDir, `${platform}.d.ts`), content, 'utf-8');
             }

package/dist/index.js

@@ -6,6 +6,7 @@ import { doctorCommand } from './commands/doctor.js';
 import { initCommand } from './commands/init.js';
 import { installCommand } from './commands/install.js';
 import { runCommand } from './commands/run.js';
+import { testCommand } from './commands/test.js';
 import { updateCommand } from './commands/update.js';
 import { watchCommand } from './commands/watch.js';
 import { syncTypesCommand } from './commands/sync-types.js';
@@ -27,7 +28,7 @@ export function createCliProgram() {
     program
         .command('init')
         .description('Initialize testspectra.config.json and project directories')
-        .option('-t, --template <template>', 'Project template: default, nx')
+        .option('-t, --template <template>', 'Project template: default, nx, react-component')
         .option('-f, --force', 'Overwrite existing configuration if present')
         .action(initCommand);
     program
@@ -167,6 +168,19 @@ Examples:
         .option('-w, --workdir <dir>', 'Custom app data / temp workdir')
         .option('-o, --output <path>', 'Custom test report JSON output path')
         .action(runCommand);
+    program
+        .command('test')
+        .description('Run React component tests via @testspectra/react (bundled Vitest browser mode)')
+        .option('-w, --cwd <dir>', 'Custom workspace directory')
+        .option('-s, --spec <path>', 'Spec file path (or substring filter) to execute')
+        .option('--headless', 'Run in headless mode (default)')
+        .option('--no-headless', 'Run in headed mode')
+        .option('--headed', 'Run the browser in visible GUI mode (alias for --no-headless)')
+        .option('--step-delay <ms>', 'Delay after each action/assertion in milliseconds (slow motion, for observing DOM transitions in --headed mode)')
+        .option('--delay <ms>', 'Alias for --step-delay')
+        .option('-c, --concurrency <number>', 'Run spec files sequentially (1) or in parallel (>1, default). Browser mode has no numeric N-worker sizing like `spectra run`.')
+        .option('-o, --output <path>', 'Write a Vitest JSON test report to this path')
+        .action(testCommand);
     return program;
 }
 export async function runCli(args = process.argv) {

package/dist/linter/__tests__/component-test-imports.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linter/__tests__/component-test-imports.test.js

@@ -0,0 +1,115 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SpecLinter } from '../spec-linter.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Covers the component-testing `.tsx` import exception (see
+ * docs/v2/features/component-testing/react/mount-convention.md §"Static Imports Are Allowed
+ * Here"): imports are allowed in `.test.tsx` files EXCEPT ones resolving into ambient-global-
+ * backed directories (page-objects/, support/steps/, fixtures/). Structural rules
+ * (single-it-required, no-describe-block) stay fully enforced for `.tsx` exactly as for `.ts`.
+ */
+describe('Component Test (.tsx) Import Exception', () => {
+    const tempDir = path.join(__dirname, '__temp_tsx_imports__');
+    const specFrontmatter = `---
+id: TC-0200
+title: Sample component test
+priority: High
+caseType: Positive
+status: automated
+coverage:
+  web: automated
+---
+
+# Sample component test
+
+## Test Steps
+1. Mount the component and assert it is visible.
+`;
+    beforeEach(() => {
+        fs.mkdirSync(tempDir, { recursive: true });
+        fs.writeFileSync(path.join(tempDir, 'spec.md'), specFrontmatter);
+    });
+    afterEach(() => {
+        if (fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('does not flag no-manual-import for ordinary component/library imports in .test.tsx', () => {
+        fs.writeFileSync(path.join(tempDir, 'web.test.tsx'), `import { Button } from '../../src/components/Button/Button.js';
+import React from 'react';
+
+it('Sample component test', async () => {
+  await Spectra.mount(<Button label="Save" />);
+});
+`);
+        const { diagnostics } = SpecLinter.validateSpecFile(path.join(tempDir, 'spec.md'));
+        const importErrors = diagnostics.filter((d) => d.code === 'testspectra/no-manual-import');
+        expect(importErrors).toHaveLength(0);
+    });
+    it('still flags no-manual-import when a .test.tsx import resolves into page-objects/', () => {
+        fs.writeFileSync(path.join(tempDir, 'web.test.tsx'), `import ButtonComponent from '../../page-objects/ButtonComponent/web.js';
+
+it('Sample component test', async () => {
+  await ButtonComponent.root.shouldBeVisible();
+});
+`);
+        const { diagnostics } = SpecLinter.validateSpecFile(path.join(tempDir, 'spec.md'));
+        const importErrors = diagnostics.filter((d) => d.code === 'testspectra/no-manual-import');
+        expect(importErrors).toHaveLength(1);
+        expect(importErrors[0].message).toContain('page-objects');
+    });
+    it('still flags no-manual-import when a .test.tsx import resolves into support/steps/', () => {
+        fs.writeFileSync(path.join(tempDir, 'web.test.tsx'), `import verifyButtonState from '../../support/steps/verifyButtonState/web.step.js';
+
+it('Sample component test', async () => {
+  await verifyButtonState('Save', true);
+});
+`);
+        const { diagnostics } = SpecLinter.validateSpecFile(path.join(tempDir, 'spec.md'));
+        const importErrors = diagnostics.filter((d) => d.code === 'testspectra/no-manual-import');
+        expect(importErrors).toHaveLength(1);
+    });
+    it('still flags no-manual-import when a .test.tsx import resolves into fixtures/', () => {
+        fs.writeFileSync(path.join(tempDir, 'web.test.tsx'), `import users from '../../fixtures/users.json';
+
+it('Sample component test', async () => {
+  expect(users).toBeDefined();
+});
+`);
+        const { diagnostics } = SpecLinter.validateSpecFile(path.join(tempDir, 'spec.md'));
+        const importErrors = diagnostics.filter((d) => d.code === 'testspectra/no-manual-import');
+        expect(importErrors).toHaveLength(1);
+    });
+    it('still enforces single-it-required and no-describe-block in .test.tsx files', () => {
+        fs.writeFileSync(path.join(tempDir, 'web.test.tsx'), `import { Button } from '../../src/components/Button/Button.js';
+
+describe('Button', () => {
+  it('Sample component test', async () => {
+    await Spectra.mount(<Button label="Save" />);
+  });
+
+  it('Another test', async () => {
+    await Spectra.mount(<Button label="Cancel" />);
+  });
+});
+`);
+        const { diagnostics } = SpecLinter.validateSpecFile(path.join(tempDir, 'spec.md'));
+        expect(diagnostics.some((d) => d.code === 'testspectra/no-describe-block')).toBe(true);
+        expect(diagnostics.some((d) => d.code === 'testspectra/single-it-required')).toBe(true);
+    });
+    it('still forbids all imports (unchanged behavior) in plain .test.ts E2E specs', () => {
+        fs.writeFileSync(path.join(tempDir, 'web.test.ts'), `import { LoginPage } from '../../page-objects/LoginPage/web.js';
+
+it('Sample component test', async () => {
+  await LoginPage.submitButton.click();
+});
+`);
+        const { diagnostics } = SpecLinter.validateSpecFile(path.join(tempDir, 'spec.md'));
+        const importErrors = diagnostics.filter((d) => d.code === 'testspectra/no-manual-import');
+        expect(importErrors).toHaveLength(1);
+    });
+});

package/dist/linter/extractor.d.ts

@@ -28,6 +28,7 @@ export interface ExtractedCodeSymbols {
     importStatements: Array<{
         line: number;
         column: number;
+        specifier: string;
     }>;
 }
 /**

package/dist/linter/extractor.js

@@ -50,11 +50,21 @@ export function extractSymbolsFromTestCode(code, filePath) {
     const importStatements = [];
     function visit(node) {
         // 1. Detect manual import statements (TS-LINT-006)
-        if (ts.isImportDeclaration(node) || ts.isImportEqualsDeclaration(node)) {
+        if (ts.isImportDeclaration(node)) {
             const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            const specifier = ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : '';
             importStatements.push({
                 line: line + 1,
                 column: character + 1,
+                specifier,
+            });
+        }
+        else if (ts.isImportEqualsDeclaration(node)) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            importStatements.push({
+                line: line + 1,
+                column: character + 1,
+                specifier: '',
             });
         }
         // 2. Detect it(...) / test(...) [forbidden] and describe(...) / suite(...) call expressions (TS-LINT-007, TS-LINT-008, TS-LINT-005)

package/dist/linter/schemas/spec.schema.d.ts

@@ -11,11 +11,11 @@ export declare const CoverageSchema: z.ZodObject<{
     web: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
     mobile: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
 }, "strip", z.ZodTypeAny, {
-    web?: "automated" | "manual" | "unsupported" | undefined;
     mobile?: "automated" | "manual" | "unsupported" | undefined;
-}, {
     web?: "automated" | "manual" | "unsupported" | undefined;
+}, {
     mobile?: "automated" | "manual" | "unsupported" | undefined;
+    web?: "automated" | "manual" | "unsupported" | undefined;
 }>;
 export declare const SpecFrontmatterSchema: z.ZodObject<{
     id: z.ZodString;
@@ -27,33 +27,33 @@ export declare const SpecFrontmatterSchema: z.ZodObject<{
         web: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
         mobile: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
     }, "strip", z.ZodTypeAny, {
-        web?: "automated" | "manual" | "unsupported" | undefined;
         mobile?: "automated" | "manual" | "unsupported" | undefined;
-    }, {
         web?: "automated" | "manual" | "unsupported" | undefined;
+    }, {
         mobile?: "automated" | "manual" | "unsupported" | undefined;
+        web?: "automated" | "manual" | "unsupported" | undefined;
     }>>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-    priority: "Critical" | "High" | "Medium" | "Low";
-    id: string;
+    status: "draft" | "ready-for-automation" | "automated" | "deprecated";
     title: string;
+    id: string;
+    priority: "Critical" | "High" | "Medium" | "Low";
     caseType: "Positive" | "Negative" | "Edge";
-    status: "draft" | "ready-for-automation" | "automated" | "deprecated";
     coverage?: {
-        web?: "automated" | "manual" | "unsupported" | undefined;
         mobile?: "automated" | "manual" | "unsupported" | undefined;
+        web?: "automated" | "manual" | "unsupported" | undefined;
     } | undefined;
     tags?: string[] | undefined;
 }, {
-    priority: "Critical" | "High" | "Medium" | "Low";
-    id: string;
+    status: "draft" | "ready-for-automation" | "automated" | "deprecated";
     title: string;
+    id: string;
+    priority: "Critical" | "High" | "Medium" | "Low";
     caseType: "Positive" | "Negative" | "Edge";
-    status: "draft" | "ready-for-automation" | "automated" | "deprecated";
     coverage?: {
-        web?: "automated" | "manual" | "unsupported" | undefined;
         mobile?: "automated" | "manual" | "unsupported" | undefined;
+        web?: "automated" | "manual" | "unsupported" | undefined;
     } | undefined;
     tags?: string[] | undefined;
 }>;