Fix pnpm module resolution and web test compilation

- Fix web extension test by using test-compile instead of just webpack
  (TypeScript needs to be compiled before running web tests)
- Add findPkgThroughTransitiveDeps to ModuleResolver to support pnpm's
  strict node_modules structure (non-hoisted dependencies)
- Pin prettier version in module-dep test fixture to 2.0.2 for test
  consistency

The new module resolution logic:
1. First checks for explicit prettier dependency in package.json
2. Then checks transitive dependencies by looking at installed packages
   in node_modules and resolving prettier from within each dependency
3. Falls back to looking for node_modules/prettier directly

This ensures the extension works correctly with npm, yarn, and pnpm
regardless of their dependency hoisting behavior.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ntotten

package.json

@@ -82,7 +82,7 @@
     "webpack-dev": "webpack --mode development --watch",
     "webpack": "webpack --mode development",
     "chrome": "pnpm webpack && vscode-test-web --browserType=chromium --extensionDevelopmentPath=. .",
-    "test:web": "pnpm webpack && node ./out/test/web/runTests.js",
+    "test:web": "pnpm test-compile && node ./out/test/web/runTests.js",
     "prepare": "husky"
   },
   "lint-staged": {

src/ModuleResolver.ts

@@ -465,6 +465,123 @@ export class ModuleResolver implements ModuleResolverInterface {
     }
   }
 
+  /**
+   * Find a package through transitive dependencies. This is necessary for
+   * package managers like pnpm that don't hoist dependencies to the root
+   * node_modules. For example, if project A depends on package B, and B
+   * depends on prettier, pnpm won't make prettier accessible from A's directory.
+   * This method checks each dependency to see if it provides access to the target package.
+   *
+   * @param {string} startDir Directory to start searching from
+   * @param {string} pkgName Package name to search for
+   * @returns {string | undefined} Resolved path to the package, or undefined if not found
+   */
+  private findPkgThroughTransitiveDeps(
+    startDir: string,
+    pkgName: string,
+  ): string | undefined {
+    const searchResult = findUp.sync(
+      (dir) => {
+        const nodeModulesPath = path.join(dir, "node_modules");
+        if (!fs.existsSync(nodeModulesPath)) {
+          if (this.isInternalTestRoot(dir)) {
+            return findUp.stop;
+          }
+          return;
+        }
+
+        // Get list of installed dependencies from node_modules
+        let installedDeps: string[];
+        try {
+          installedDeps = fs.readdirSync(nodeModulesPath).filter((name) => {
+            // Skip hidden files and pnpm internal directories
+            if (name.startsWith(".")) return false;
+            // Check if it's a directory or symlink
+            const depPath = path.join(nodeModulesPath, name);
+            try {
+              const stat = fs.lstatSync(depPath);
+              return stat.isDirectory() || stat.isSymbolicLink();
+            } catch {
+              return false;
+            }
+          });
+        } catch {
+          if (this.isInternalTestRoot(dir)) {
+            return findUp.stop;
+          }
+          return;
+        }
+
+        // Check each dependency to see if it provides access to the target package
+        for (const depName of installedDeps) {
+          // Skip scoped packages for now (would need special handling)
+          if (depName.startsWith("@")) continue;
+
+          const depPath = path.join(nodeModulesPath, depName);
+          try {
+            // Get the real path (resolves symlinks)
+            const realDepPath = fs.realpathSync(depPath);
+
+            // Try to resolve the target package from within the dependency's directory
+            try {
+              resolve.sync(pkgName, {
+                basedir: realDepPath,
+                preserveSymlinks: false,
+              });
+              // Found! Return this directory
+              return dir;
+            } catch {
+              // This dependency doesn't provide access to the target package
+            }
+          } catch {
+            // Couldn't get real path for this dependency, skip it
+          }
+        }
+
+        if (this.isInternalTestRoot(dir)) {
+          return findUp.stop;
+        }
+      },
+      { cwd: startDir, type: "directory" },
+    );
+
+    if (searchResult) {
+      // Now we need to find the actual path through the dependency
+      const nodeModulesPath = path.join(searchResult, "node_modules");
+      const installedDeps = fs.readdirSync(nodeModulesPath).filter((name) => {
+        if (name.startsWith(".")) return false;
+        const depPath = path.join(nodeModulesPath, name);
+        try {
+          const stat = fs.lstatSync(depPath);
+          return stat.isDirectory() || stat.isSymbolicLink();
+        } catch {
+          return false;
+        }
+      });
+
+      for (const depName of installedDeps) {
+        if (depName.startsWith("@")) continue;
+
+        const depPath = path.join(nodeModulesPath, depName);
+        try {
+          const realDepPath = fs.realpathSync(depPath);
+          try {
+            return resolve.sync(pkgName, {
+              basedir: realDepPath,
+              preserveSymlinks: false,
+            });
+          } catch {
+            // Continue to next dependency
+          }
+        } catch {
+          // Continue to next dependency
+        }
+      }
+    }
+
+    return undefined;
+  }
+
   /**
    * Recursively search upwards for a given module definition based on
    * package.json or node_modules existence
@@ -524,7 +641,21 @@ export class ModuleResolver implements ModuleResolverInterface {
       return packagePath;
     }
 
-    // If no explicit package.json dep found, instead look for implicit dep
+    // If no explicit package.json dep found, try to resolve through transitive
+    // dependencies. This handles cases where prettier is a dependency of one of the
+    // project's dependencies. This is important for pnpm which doesn't hoist
+    // dependencies to the root node_modules.
+    const transitiveResult = this.findPkgThroughTransitiveDeps(
+      finalPath,
+      pkgName,
+    );
+
+    if (transitiveResult) {
+      this.findPkgCache.set(cacheKey, transitiveResult);
+      return transitiveResult;
+    }
+
+    // If no transitive dep found, instead look for implicit dep in node_modules
     const nodeModulesResDir = findUp.sync(
       (dir) => {
         if (fs.existsSync(path.join(dir, "node_modules", pkgName))) {

test-fixtures/module-dep/package.json

@@ -10,7 +10,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "prettier": "^2.0.2"
+    "prettier": "2.0.2"
   },
   "packageManager": "pnpm@10.24.0"
 }