@testspectra/cli 1.0.59 → 1.0.63

package/README.md

@@ -179,35 +179,36 @@ export default defineConfig({
 ├── tsconfig.android.json        # Android platform TypeScript scope
 ├── tsconfig.ios.json            # iOS platform TypeScript scope
 ├── page-objects/                # Page Object Model folders
-│   └── LoginPage/
+│   └── PlaygroundPage/
 │         ├── web.ts
 │         └── mobile.ts
-├── actions/                     # Reusable atomic actions
-│   └── verifyOtp/
-│         ├── web.action.ts
-│         └── mobile.action.ts
-├── steps/                       # High-level business flows
-│   └── loginUser/
-│         ├── web.step.ts
-│         └── mobile.step.ts
+├── support/
+│   ├── actions/                 # Reusable atomic actions
+│   │   └── fillCredentials/
+│   │         ├── web.action.ts
+│   │         └── mobile.action.ts
+│   └── steps/                   # High-level business flows
+│       └── verifyPlaygroundState/
+│             ├── web.step.ts
+│             └── mobile.step.ts
 ├── global-hooks/                # Global lifecycle hooks
-│   └── before.web.hook.ts
+│   └── before/
+│         └── web.hook.ts
 ├── specs/                       # Layered zero-import test cases
-│   └── Auth/
-│         └── TC-AUTH-01/
+│   └── Playground/
+│         └── TC-0001-form-controls/
 │               ├── web.test.ts
-│               ├── android.test.ts
-│               └── ios.test.ts
+│               └── mobile.test.ts
 ├── fixtures/                    # Platform-agnostic test data
-│   └── userData.json
-└── .testspectra/                # Auto-generated ambient typings & cache
-    └── types/
-          ├── fixtures.d.ts
-          ├── web.d.ts
-          ├── android.d.ts
-          ├── ios.d.ts
-          ├── mobile.d.ts
-          └── common.d.ts
+│   └── playgroundData.json
+├── .testspectra/                # Auto-generated ambient typings & cache
+│     └── types/
+│           ├── fixtures.d.ts
+│           ├── web.d.ts
+│           ├── android.d.ts
+│           ├── ios.d.ts
+│           ├── mobile.d.ts
+│           └── common.d.ts
 ```
 
 ---
@@ -230,19 +231,19 @@ TestSpectra features an enterprise-grade architecture for large monorepos: **"Ce
                  ┌──────────────────────────────┴──────────────────────────────┐
                  ▼                                                             ▼
   ┌───────────────────────────────┐                             ┌───────────────────────────────┐
-  │   shared/testing/ (Library)   │                             │  packages/features/auth/e2e/  │
+  │   shared/testing/ (Library)   │                             │    packages/playground/e2e/   │
   ├───────────────────────────────┤                             ├───────────────────────────────┤
   │ - Shared Page Objects         │ ◄─── Auto-Scanned Globals ──│ - Feature Specs (specs/)      │
-  │ - Shared Steps (loginAsAdmin) │     (100% Zero-Import!)     │ - Feature Page Objects (POMs) │
-  │ - Shared Actions (dismissBtn) │                             │ - project.json (Nx Target)    │
-  │ - Shared Fixtures (appConfig) │                             │ - tsconfig.web/android/ios    │
+  │ - Shared Steps (verifyState)  │     (100% Zero-Import!)     │ - Feature Page Objects (POMs) │
+  │ - Shared Actions (fillCreds)  │                             │ - project.json (Nx Target)    │
+  │ - Shared Fixtures (playData)  │                             │ - tsconfig.web/android/ios    │
   └───────────────────────────────┘                             └───────────────────────────────┘
 ```
 
 ### Key Pillars of Monorepo Integration:
 
 1. **Interactive Workspace Auto-Discovery (`spectra init`)**:
-   - Parses `pnpm-workspace.yaml` (e.g. `packages/features/*`, `modules/**`).
+   - Parses `pnpm-workspace.yaml` (e.g. `packages/*`, `modules/**`).
    - Scans sub-directories for existing `project.json` or `package.json`.
    - Prompts the user with an interactive multi-select checkbox to choose which features will receive E2E testing.
    - Prompts for customizable E2E folder names (e.g. `e2e`, `test/e2e`) and the shared testing library path (`shared/testing`).
@@ -253,18 +254,18 @@ TestSpectra features an enterprise-grade architecture for large monorepos: **"Ce
    - Driver caches, binaries, and logs reside in `<root>/.testspectra/`, preventing repository clutter across individual feature folders.
 
 3. **Global Zero-Import Consumption of Shared Library**:
-   - Entities placed inside `shared/testing/page-objects/`, `shared/testing/steps/`, `shared/testing/actions/`, and `shared/testing/fixtures/` are automatically aggregated into ambient declarations.
-   - Feature test specs consume shared Page Objects (`NavigationBar.goToHome()`), steps (`Step.loginAsAdmin()`), actions (`Spectra.dismissBanner()`), and fixtures (`Fixture.appConfig`) **without a single line of `import` statement**.
+   - Entities placed inside `shared/testing/page-objects/`, `shared/testing/support/steps/`, `shared/testing/support/actions/`, and `shared/testing/fixtures/` are automatically aggregated into ambient declarations.
+   - Feature test specs consume shared Page Objects (`PlaygroundPage.open()`), steps (`Step.verifyPlaygroundState()`), actions (`Spectra.fillCredentials()`), and fixtures (`Fixture.playgroundData`) **without a single line of `import` statement**.
 
 4. **Nx Target Execution & Affected Caching**:
    - Each feature E2E folder includes an Nx `project.json`:
      ```json
      {
-       "name": "auth-e2e",
+       "name": "playground-e2e",
        "targets": {
          "e2e": {
            "executor": "nx:run-commands",
-           "options": { "command": "spectra run", "cwd": "modules/auth/e2e" },
+           "options": { "command": "spectra run", "cwd": "packages/playground/e2e" },
            "configurations": {
              "android": { "command": "spectra run --target android" },
              "ios": { "command": "spectra run --target ios" },

package/dist/commands/add.js

@@ -130,7 +130,7 @@ export async function addCommand(moduleNameArg, options = {}) {
     if (!fs.existsSync(templateDir)) {
         templateDir = path.resolve(__dirname, "../../../templates/nx");
     }
-    const sampleE2eSrc = path.join(templateDir, "modules/auth/e2e");
+    const sampleE2eSrc = path.join(templateDir, "packages/playground/e2e");
     if (!fs.existsSync(sampleE2eSrc)) {
         p.cancel(chalk.red(`Template directory not found at: ${sampleE2eSrc}`));
         return;
@@ -151,18 +151,12 @@ export async function addCommand(moduleNameArg, options = {}) {
     cur = rootDir;
     while (cur !== path.dirname(cur)) {
         if (fs.existsSync(path.join(cur, "pnpm-workspace.yaml"))) {
-            try {
-                const wsContent = fs.readFileSync(path.join(cur, "pnpm-workspace.yaml"), "utf-8");
-                if (wsContent.includes("cli")) {
-                    isInternalWorkspace = true;
-                    break;
-                }
-            }
-            catch { }
+            isInternalWorkspace = true;
+            break;
         }
         cur = path.dirname(cur);
     }
-    const cliDepVersion = isInternalWorkspace ? "workspace:*" : cliVersion;
+    const cliDepVersion = isInternalWorkspace ? "workspace:*" : (cliVersion.startsWith("^") ? cliVersion : `^${cliVersion}`);
     function copyRecursive(src, dest, replacements = {}) {
         const base = path.basename(src);
         if (base === "node_modules" || base === "dist" || base === ".testspectra" || base === ".git") {
@@ -289,9 +283,9 @@ export async function addCommand(moduleNameArg, options = {}) {
         const s = p.spinner();
         s.start(`Scaffolding ${e2eProjectName} in ./${path.relative(rootDir, targetE2eDir)}...`);
         copyRecursive(sampleE2eSrc, targetE2eDir, {
-            "auth-e2e": e2eProjectName,
-            "modules/auth/e2e": path.relative(rootDir, targetE2eDir).replace(/\\/g, "/"),
-            "scope:auth": `scope:${featureName}`,
+            "playground-e2e": e2eProjectName,
+            "packages/playground/e2e": path.relative(rootDir, targetE2eDir).replace(/\\/g, "/"),
+            "scope:playground": `scope:${featureName}`,
         });
         // Adjust project.json
         const projJsonPath = path.join(targetE2eDir, "project.json");

package/dist/commands/init.js

@@ -256,19 +256,13 @@ export async function initCommand(options = {}) {
     let cur = cwd;
     while (cur !== path.dirname(cur)) {
         if (fs.existsSync(path.join(cur, "pnpm-workspace.yaml"))) {
-            try {
-                const wsContent = fs.readFileSync(path.join(cur, "pnpm-workspace.yaml"), "utf-8");
-                if (wsContent.includes("cli")) {
-                    isInternalWorkspace = true;
-                    break;
-                }
-            }
-            catch { }
+            isInternalWorkspace = true;
+            break;
         }
         cur = path.dirname(cur);
     }
     const projectName = path.basename(cwd);
-    const cliDepVersion = isInternalWorkspace ? "workspace:*" : cliVersion;
+    const cliDepVersion = isInternalWorkspace ? "workspace:*" : (cliVersion.startsWith("^") ? cliVersion : `^${cliVersion}`);
     // Helper: Copy directory contents recursively
     function copyRecursive(src, dest, replacements = {}) {
         const base = path.basename(src);
@@ -344,7 +338,7 @@ export async function initCommand(options = {}) {
             p.log.warn(chalk.yellow("No feature packages found in workspace. You can enter feature names to scaffold."));
             const featureNamesInput = await p.text({
                 message: "Enter feature module names (comma-separated), or leave blank to skip:",
-                placeholder: "auth, catalog, payment",
+                placeholder: "playground, matchers, navigation",
                 defaultValue: "",
             });
             if (p.isCancel(featureNamesInput)) {
@@ -356,14 +350,14 @@ export async function initCommand(options = {}) {
                 // Build relPaths from feature names using a sensible default location
                 const featureBaseInput = await p.text({
                     message: "Enter base directory for feature modules:",
-                    placeholder: "packages/features",
-                    defaultValue: "packages/features",
+                    placeholder: "packages",
+                    defaultValue: "packages",
                 });
                 if (p.isCancel(featureBaseInput)) {
                     p.cancel("Setup cancelled.");
                     return;
                 }
-                const featureBase = featureBaseInput.trim() || "packages/features";
+                const featureBase = featureBaseInput.trim() || "packages";
                 chosenProjects = raw.split(",").map((n) => `${featureBase}/${n.trim()}`).filter(Boolean);
             }
         }
@@ -442,6 +436,14 @@ export async function initCommand(options = {}) {
                     rootPkg.devDependencies["@testspectra/matchers"] = cliDepVersion;
                 if (!rootPkg.devDependencies["typescript"])
                     rootPkg.devDependencies["typescript"] = "^5.4.5";
+                if (!rootPkg.devDependencies["@wdio/cli"])
+                    rootPkg.devDependencies["@wdio/cli"] = "^9.2.8";
+                if (!rootPkg.devDependencies["@wdio/local-runner"])
+                    rootPkg.devDependencies["@wdio/local-runner"] = "^9.2.8";
+                if (!rootPkg.devDependencies["@wdio/spec-reporter"])
+                    rootPkg.devDependencies["@wdio/spec-reporter"] = "^9.2.8";
+                if (!rootPkg.devDependencies["@wdio/devtools-service"])
+                    rootPkg.devDependencies["@wdio/devtools-service"] = "^9.2.8";
                 if (!rootPkg.devDependencies["@wdio/globals"])
                     rootPkg.devDependencies["@wdio/globals"] = "^9.2.8";
                 if (!rootPkg.devDependencies["@wdio/mocha-framework"])
@@ -465,16 +467,16 @@ export async function initCommand(options = {}) {
             copyRecursive(sharedTestingSrc, sharedTestingAbsPath);
         }
         // 4. Distribute E2E Folders to Selected Feature Modules
-        const sampleE2eSrc = path.join(templateDir, "modules/auth/e2e");
+        const sampleE2eSrc = path.join(templateDir, "packages/playground/e2e");
         const featureE2eDirs = [];
         for (const projRel of chosenProjects) {
             const targetE2eDir = path.join(cwd, projRel, e2eFolderName);
             const featureName = path.basename(projRel);
             const e2eProjectName = `${featureName}-${e2eFolderName}`;
             copyRecursive(sampleE2eSrc, targetE2eDir, {
-                "auth-e2e": e2eProjectName,
-                "modules/auth/e2e": path.relative(cwd, targetE2eDir).replace(/\\/g, "/"),
-                "scope:auth": `scope:${featureName}`,
+                "playground-e2e": e2eProjectName,
+                "packages/playground/e2e": path.relative(cwd, targetE2eDir).replace(/\\/g, "/"),
+                "scope:playground": `scope:${featureName}`,
             });
             // Adjust project.json
             const projJsonPath = path.join(targetE2eDir, "project.json");
@@ -704,12 +706,10 @@ pnpm type-check
     const s = p.spinner();
     s.start("Scaffolding standalone TestSpectra project...");
     copyRecursive(templateDir, cwd);
-    if (!isInternalWorkspace) {
-        const pnpmWorkspacePath = path.join(cwd, "pnpm-workspace.yaml");
-        if (!fs.existsSync(pnpmWorkspacePath) || options.force) {
-            const pnpmWsContent = `allowBuilds:\n  chromedriver: true\n  edgedriver: true\n  geckodriver: true\n`;
-            fs.writeFileSync(pnpmWorkspacePath, pnpmWsContent, "utf-8");
-        }
+    const standaloneWsPath = path.join(cwd, "pnpm-workspace.yaml");
+    if (!fs.existsSync(standaloneWsPath) || options.force) {
+        const pnpmWsContent = `allowBuilds:\n  chromedriver: true\n  edgedriver: true\n  geckodriver: true\n`;
+        fs.writeFileSync(standaloneWsPath, pnpmWsContent, "utf-8");
     }
     TypeGenerator.writeDeclarationFiles(cwd);
     ensureVsCodeExtensions(cwd);

package/dist/commands/run.d.ts

@@ -1,4 +1,5 @@
 export interface RunCommandOptions {
+    spec?: string;
     target?: "web" | "android" | "ios" | "common";
     device?: string;
     headless?: boolean;

package/dist/commands/run.js

@@ -6,6 +6,7 @@ import { Reporter } from "../runner/reporter.js";
 import { TypeGenerator } from "../types/generator.js";
 export async function runCommand(specPath, options = {}) {
     const cwd = process.cwd();
+    const effectiveSpecPath = specPath || options.spec;
     // Ensure latest ambient types are up-to-date
     TypeGenerator.writeDeclarationFiles(cwd);
     const config = await ConfigLoader.loadConfig(cwd);
@@ -13,11 +14,11 @@ export async function runCommand(specPath, options = {}) {
         config.webConfig.headlessMode = options.headless;
     }
     const platform = options.target || "web";
-    // Find workspace root for centralized .testspectra
+    // Find workspace root for centralized .testspectra (monorepo root or current test project)
     let workspaceRoot = cwd;
     let cur = cwd;
     while (cur !== path.dirname(cur)) {
-        if (fs.existsSync(path.join(cur, "pnpm-workspace.yaml")) || fs.existsSync(path.join(cur, "nx.json")) || fs.existsSync(path.join(cur, "spectra.config.ts")) || fs.existsSync(path.join(cur, "testspectra.config.ts"))) {
+        if (fs.existsSync(path.join(cur, "pnpm-workspace.yaml")) || fs.existsSync(path.join(cur, "nx.json"))) {
             workspaceRoot = cur;
             break;
         }
@@ -30,18 +31,25 @@ export async function runCommand(specPath, options = {}) {
     // Determine suite/test case name
     let suiteName = "default";
     let testCases = [];
-    if (specPath) {
-        const parsed = path.parse(specPath);
-        const baseName = parsed.name.replace(/\.(web|android|ios|common|test|spec)/g, "");
-        suiteName = baseName;
+    if (effectiveSpecPath) {
+        const relSpec = path.isAbsolute(effectiveSpecPath) ? path.relative(cwd, effectiveSpecPath) : effectiveSpecPath;
+        const normalized = relSpec.replace(/\\/g, "/");
+        const parts = normalized.split("/");
+        if (parts.length >= 2 && (parts[0] === "specs" || parts[0] === "suites")) {
+            suiteName = parts[1];
+        }
+        else {
+            const parsed = path.parse(normalized);
+            suiteName = parsed.name.replace(/\.(web|android|ios|common|test|spec)/g, "") || "default";
+        }
         testCases.push({
-            id: baseName,
-            title: baseName,
+            id: normalized,
+            title: normalized,
             executionOrder: 1,
         });
     }
     else {
-        // 1. Scan specs/ directory (Option A: specs/<Suite>/<CaseId>/web.test.ts)
+        // 1. Scan specs/ directory (specs/<Suite>/<CaseId>/web.test.ts)
         const specsDir = path.join(cwd, "specs");
         if (fs.existsSync(specsDir)) {
             const suiteEntries = fs.readdirSync(specsDir, { withFileTypes: true });
@@ -55,11 +63,11 @@ export async function runCommand(specPath, options = {}) {
                     if (cEntry.name.startsWith(".") || cEntry.name === "hooks")
                         continue;
                     if (cEntry.isDirectory()) {
-                        testCases.push({ id: cEntry.name, title: `${currentSuite} / ${cEntry.name}` });
+                        testCases.push({ id: path.join("specs", currentSuite, cEntry.name).replace(/\\/g, "/"), title: `${currentSuite} / ${cEntry.name}` });
                     }
                     else if (cEntry.isFile() && (cEntry.name.endsWith(".test.ts") || cEntry.name.endsWith(".spec.ts"))) {
-                        const id = cEntry.name.replace(/\.(web|android|ios|common|all|mobile|test|spec)\.ts$/g, "");
-                        testCases.push({ id, title: `${currentSuite} / ${id}` });
+                        const id = path.join("specs", currentSuite, cEntry.name).replace(/\\/g, "/");
+                        testCases.push({ id, title: `${currentSuite} / ${cEntry.name}` });
                     }
                 }
             }
@@ -77,7 +85,7 @@ export async function runCommand(specPath, options = {}) {
                 for (const cEntry of caseEntries) {
                     if (cEntry.name.startsWith(".") || cEntry.name === "hooks" || !cEntry.isDirectory())
                         continue;
-                    testCases.push({ id: cEntry.name, title: `${currentSuite} / ${cEntry.name}` });
+                    testCases.push({ id: path.join("suites", currentSuite, cEntry.name).replace(/\\/g, "/"), title: `${currentSuite} / ${cEntry.name}` });
                 }
             }
         }
@@ -93,6 +101,7 @@ export async function runCommand(specPath, options = {}) {
         ? path.resolve(options.output)
         : path.join(appDataPath, "reports/result.json");
     console.log(`\x1b[36m[TestSpectra]\x1b[0m Starting execution on target \x1b[1m${platform}\x1b[0m...`);
+    console.log(`\x1b[36m[TestSpectra]\x1b[0m Base URL: \x1b[33m${config.webConfig.baseUrl}\x1b[0m`);
     console.log(`\x1b[36m[TestSpectra]\x1b[0m Suite: ${suiteName} (${testCases.length} case(s))\n`);
     const reporter = new Reporter();
     try {

package/dist/index.js

@@ -45,6 +45,7 @@ export function createCliProgram() {
     program
         .command("run [path]")
         .description("Execute test suite or individual test case")
+        .option("-s, --spec <path>", "Spec file path to execute")
         .option("-t, --target <target>", "Target platform: web, android, ios, common", "web")
         .option("-d, --device <device>", "Target device name or UDID")
         .option("--headless", "Run in headless mode")

package/dist/server/demo.d.ts

@@ -0,0 +1,8 @@
+export declare class DemoAppServer {
+    private server;
+    port: number;
+    url: string;
+    static findDemoAppDir(cwd: string): string | null;
+    start(cwd: string): Promise<string>;
+    stop(): void;
+}

package/dist/server/demo.js

@@ -0,0 +1,104 @@
+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 = "";
+    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"))) {
+                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"))) {
+            return relCand;
+        }
+        return null;
+    }
+    async start(cwd) {
+        const demoDir = DemoAppServer.findDemoAppDir(cwd);
+        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 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",
+        };
+        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);
+                // Fallback to index.html for SPA client-side routing
+                if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+                    filePath = path.join(distDir, "index.html");
+                }
+                const ext = path.extname(filePath).toLowerCase();
+                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");
+                    }
+                    else {
+                        res.writeHead(200, {
+                            "Content-Type": contentType,
+                            "Cache-Control": "no-cache",
+                            "Access-Control-Allow-Origin": "*",
+                        });
+                        res.end(content);
+                    }
+                });
+            });
+            this.server.listen(0, "127.0.0.1", () => {
+                const addr = this.server?.address();
+                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"));
+                }
+            });
+            this.server.on("error", reject);
+        });
+    }
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+}

package/dist/types/generator.d.ts

@@ -12,6 +12,6 @@ export declare class TypeGenerator {
     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(scopeDir: string, sharedDir?: string): string;
+    static generateFixturesDeclarationForScope(cwd: string, outputTypesDir: string, scopeDir: string, sharedDir?: string): string;
     static writeDeclarationFiles(cwd: string): void;
 }

package/dist/types/generator.js

@@ -2,10 +2,10 @@ import fs from "fs";
 import path from "path";
 const PLATFORM_HIERARCHY = {
     web: ["web", "common"],
-    ios: ["ios", "mobile", "common"],
-    android: ["android", "mobile", "common"],
-    mobile: ["mobile", "common"],
-    common: ["common"],
+    ios: ["ios", "mobile", "common", "web"],
+    android: ["android", "mobile", "common", "web"],
+    mobile: ["mobile", "common", "android", "ios", "web"],
+    common: ["common", "web", "mobile", "android", "ios"],
 };
 export class TypeGenerator {
     /**
@@ -21,7 +21,12 @@ export class TypeGenerator {
             path.join(cwd, "testing"),
         ];
         for (const cand of sharedCandidates) {
-            if (fs.existsSync(cand) && (fs.existsSync(path.join(cand, "page-objects")) || fs.existsSync(path.join(cand, "steps")) || fs.existsSync(path.join(cand, "actions")))) {
+            if (fs.existsSync(cand) &&
+                (fs.existsSync(path.join(cand, "page-objects")) ||
+                    fs.existsSync(path.join(cand, "support")) ||
+                    fs.existsSync(path.join(cand, "steps")) ||
+                    fs.existsSync(path.join(cand, "actions")) ||
+                    fs.existsSync(path.join(cand, "fixtures")))) {
                 if (!scopes.some((s) => s.dir === cand)) {
                     scopes.push({ name: "shared", dir: cand, isShared: true });
                 }
@@ -124,9 +129,15 @@ export class TypeGenerator {
             scanDir(scopeDir, 6);
         }
         else {
-            const candidates = [path.join(scopeDir, entityType)];
+            const candidates = [
+                path.join(scopeDir, entityType),
+                path.join(scopeDir, "support", entityType),
+                path.join(scopeDir, "support", "testing", entityType),
+            ];
             if (sharedDir) {
                 candidates.push(path.join(sharedDir, entityType));
+                candidates.push(path.join(sharedDir, "support", entityType));
+                candidates.push(path.join(sharedDir, "support", "testing", entityType));
             }
             for (const c of candidates) {
                 if (fs.existsSync(c) && !dirs.includes(c))
@@ -244,7 +255,11 @@ export class TypeGenerator {
                         if (matchedFile) {
                             if (!matchedFile.startsWith("."))
                                 matchedFile = `./${matchedFile}`;
-                            content += `  ${actionName}: (typeof import('${matchedFile}') extends { default: infer T } ? T : typeof import('${matchedFile}'));\n`;
+                            const camel = actionName.replace(/[-_]+([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+                            content += `  "${actionName}": (typeof import('${matchedFile}') extends { default: infer T } ? T : typeof import('${matchedFile}'));\n`;
+                            if (camel !== actionName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(camel)) {
+                                content += `  ${camel}: (typeof import('${matchedFile}') extends { default: infer T } ? T : typeof import('${matchedFile}'));\n`;
+                            }
                             declaredActions.add(actionName);
                         }
                     }
@@ -258,7 +273,11 @@ export class TypeGenerator {
                             let rel = path.relative(outputTypesDir, path.join(actionsDir, entry.name)).replace(/\\/g, "/").replace(/\.ts$/, ".js");
                             if (!rel.startsWith("."))
                                 rel = `./${rel}`;
-                            content += `  ${actionName}: (typeof import('${rel}') extends { default: infer T } ? T : typeof import('${rel}'));\n`;
+                            const camel = actionName.replace(/[-_]+([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+                            content += `  "${actionName}": (typeof import('${rel}') extends { default: infer T } ? T : typeof import('${rel}'));\n`;
+                            if (camel !== actionName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(camel)) {
+                                content += `  ${camel}: (typeof import('${rel}') extends { default: infer T } ? T : typeof import('${rel}'));\n`;
+                            }
                             declaredActions.add(actionName);
                         }
                     }
@@ -298,7 +317,11 @@ export class TypeGenerator {
                         if (matchedFile) {
                             if (!matchedFile.startsWith("."))
                                 matchedFile = `./${matchedFile}`;
-                            content += `  ${stepName}: (typeof import('${matchedFile}') extends { default: infer T } ? T : typeof import('${matchedFile}'));\n`;
+                            const camel = stepName.replace(/[-_]+([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+                            content += `  "${stepName}": (typeof import('${matchedFile}') extends { default: infer T } ? T : typeof import('${matchedFile}'));\n`;
+                            if (camel !== stepName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(camel)) {
+                                content += `  ${camel}: (typeof import('${matchedFile}') extends { default: infer T } ? T : typeof import('${matchedFile}'));\n`;
+                            }
                             declaredSteps.add(stepName);
                         }
                     }
@@ -312,7 +335,11 @@ export class TypeGenerator {
                             let rel = path.relative(outputTypesDir, path.join(stepsDir, entry.name)).replace(/\\/g, "/").replace(/\.ts$/, ".js");
                             if (!rel.startsWith("."))
                                 rel = `./${rel}`;
-                            content += `  ${stepName}: (typeof import('${rel}') extends { default: infer T } ? T : typeof import('${rel}'));\n`;
+                            const camel = stepName.replace(/[-_]+([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+                            content += `  "${stepName}": (typeof import('${rel}') extends { default: infer T } ? T : typeof import('${rel}'));\n`;
+                            if (camel !== stepName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(camel)) {
+                                content += `  ${camel}: (typeof import('${rel}') extends { default: infer T } ? T : typeof import('${rel}'));\n`;
+                            }
                             declaredSteps.add(stepName);
                         }
                     }
@@ -324,7 +351,7 @@ export class TypeGenerator {
         }
         return results;
     }
-    static generateFixturesDeclarationForScope(scopeDir, sharedDir) {
+    static generateFixturesDeclarationForScope(cwd, outputTypesDir, scopeDir, sharedDir) {
         const fixturesDirs = this.getEntityDirsForScope("fixtures", scopeDir, sharedDir);
         let content = `// Auto-generated ambient fixture declarations for TestSpectra\n`;
         content += `// Managed automatically by TestSpectra Language Service Plugin.\n\n`;
@@ -346,7 +373,15 @@ export class TypeGenerator {
                         const varName = parsed.name.replace(/[^a-zA-Z0-9_$]/g, "_");
                         if (declaredFixtures.has(varName))
                             continue;
-                        content += `  readonly ${varName}: string;\n`;
+                        if (entry.name.endsWith(".json")) {
+                            let rel = path.relative(outputTypesDir, path.join(dir, entry.name)).replace(/\\/g, "/");
+                            if (!rel.startsWith("."))
+                                rel = `./${rel}`;
+                            content += `  readonly ${varName}: typeof import('${rel}');\n`;
+                        }
+                        else {
+                            content += `  readonly ${varName}: string;\n`;
+                        }
                         declaredFixtures.add(varName);
                     }
                 }
@@ -368,7 +403,7 @@ export class TypeGenerator {
         const scopes = this.getEntityScopes(cwd);
         const sharedScope = scopes.find((s) => s.isShared);
         // 1. Generate Global / Standalone Root Types (or fallback)
-        const rootFixtures = this.generateFixturesDeclarationForScope(cwd);
+        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);
         for (const [platform, content] of Object.entries(rootDeclarations)) {
@@ -379,7 +414,7 @@ export class TypeGenerator {
             const sharedTypesDir = path.join(rootTypesDir, "shared");
             if (!fs.existsSync(sharedTypesDir))
                 fs.mkdirSync(sharedTypesDir, { recursive: true });
-            const sharedFixtures = this.generateFixturesDeclarationForScope(sharedScope.dir);
+            const sharedFixtures = this.generateFixturesDeclarationForScope(cwd, sharedTypesDir, sharedScope.dir);
             fs.writeFileSync(path.join(sharedTypesDir, "fixtures.d.ts"), sharedFixtures, "utf-8");
             // Shared scope has NO feature dependencies (only shared itself)
             const sharedDeclarations = this.generateDeclarationsForScope(cwd, sharedTypesDir, sharedScope.dir);
@@ -393,7 +428,7 @@ export class TypeGenerator {
             const featureTypesDir = path.join(rootTypesDir, "features", feature.name);
             if (!fs.existsSync(featureTypesDir))
                 fs.mkdirSync(featureTypesDir, { recursive: true });
-            const featureFixtures = this.generateFixturesDeclarationForScope(feature.dir, sharedScope?.dir);
+            const featureFixtures = this.generateFixturesDeclarationForScope(cwd, featureTypesDir, feature.dir, sharedScope?.dir);
             fs.writeFileSync(path.join(featureTypesDir, "fixtures.d.ts"), featureFixtures, "utf-8");
             // Feature scope gets (feature + shared) ONLY
             const featureDeclarations = this.generateDeclarationsForScope(cwd, featureTypesDir, feature.dir, sharedScope?.dir);