@@ -99,6 +99,28 @@ function parsePackageName(url: string): { packageName: string; readonly pathSegm
   };
 }
 
+/**
+ * Returns the scope that qualifies the cached package resolutions of a stylesheet. A stylesheet
+ * within `node_modules` uses the root of its enclosing package, since every file of a package
+ * resolves its dependencies against the same `node_modules` directories. All other stylesheets use
+ * the working directory, allowing component stylesheets to share package resolutions.
+ */
+export function getPackageScope(
+  containingPath: string | undefined,
+  workingDirectory: string | undefined,
+): string {
+  // The directory segments of the stylesheet, excluding the file name
+  const segments = containingPath?.split(/[\\/]/).slice(0, -1) ?? [];
+  const index = segments.lastIndexOf('node_modules');
+  if (index === -1) {
+    return workingDirectory ?? '';
+  }
+
+  const packageNameLength = segments[index + 1]?.[0] === '@' ? 2 : 1;
+
+  return segments.slice(0, index + 1 + packageNameLength).join('/');
+}
+
 async function compileString(
   data: string,
   filePath: string,
@@ -123,7 +145,7 @@ async function compileString(
 
   // Caching follows Sass behavior where a given package url will always resolve to the same value
   // regardless of its importer's path, except for importers within `node_modules`, which are
-  // scoped to their own directory. Relative paths are qualified with the containing URL.
+  // scoped to their enclosing package. Relative paths are qualified with the containing URL.
   // A null value indicates that the cached resolution attempt failed to find a location and
   // later stage resolution should be attempted. This avoids potentially expensive repeat
   // failing resolution attempts.
@@ -155,12 +177,7 @@ async function compileString(
                 : undefined;
             const resolveDir = containingPath ? dirname(containingPath) : workingDirectory;
             const isPackage = isPackageUrl(url);
-
-            // Package urls from files within `node_modules` are scoped to the directory of the
-            // importer to isolate nested dependency versions. All other files share the working
-            // directory, allowing component stylesheets to share package resolutions.
-            const isNodeModules = /[\\/]node_modules[\\/]/.test(containingPath ?? '');
-            const scope = isNodeModules ? (resolveDir ?? '') : (workingDirectory ?? '');
+            const scope = getPackageScope(containingPath, workingDirectory);
             const cacheKey = isPackage
               ? `${scope}:${url}`
               : `${options.containingUrl?.href ?? ''}:${url}`;
 
@@ -15,6 +15,7 @@ import { pathToFileURL } from 'node:url';
 import { SassCompiler } from '../../sass/sass-service';
 import {
   SassStylesheetLanguage,
+  getPackageScope,
   isPackageUrl,
   resetSassWorkerPoolCaches,
   shutdownSassWorkerPool,
@@ -59,6 +60,43 @@ describe('sass-language', () => {
     });
   });
 
+  describe('getPackageScope', () => {
+    const scope = (containingPath?: string) => getPackageScope(containingPath, '/app');
+
+    it('should use the working directory for a stylesheet outside node_modules', () => {
+      expect(scope('/app/src/app.scss')).toBe('/app');
+      expect(scope('/app/src/foo-node_modules/a.scss')).toBe('/app');
+      expect(scope('/app/src/node_modules.scss')).toBe('/app');
+      expect(scope(undefined)).toBe('/app');
+    });
+
+    it('should use the enclosing package root for a stylesheet within node_modules', () => {
+      expect(scope('/app/node_modules/pkg/a.scss')).toBe('/app/node_modules/pkg');
+      expect(scope('/app/node_modules/pkg/sub/a.scss')).toBe('/app/node_modules/pkg');
+      expect(scope('/app/node_modules/@scope/pkg/sub/a.scss')).toBe('/app/node_modules/@scope/pkg');
+      expect(scope('/app/node_modules/foo-node_modules/a.scss')).toBe(
+        '/app/node_modules/foo-node_modules',
+      );
+      expect(scope('/app/node_modules/a.scss')).toBe('/app/node_modules');
+    });
+
+    it('should use the innermost package root for a nested dependency', () => {
+      expect(scope('/app/node_modules/dep/node_modules/pkg/a.scss')).toBe(
+        '/app/node_modules/dep/node_modules/pkg',
+      );
+      expect(scope('/app/node_modules/.pnpm/pkg@1.0.0/node_modules/pkg/a.scss')).toBe(
+        '/app/node_modules/.pnpm/pkg@1.0.0/node_modules/pkg',
+      );
+    });
+
+    it('should support Windows path separators', () => {
+      expect(getPackageScope('C:\\app\\node_modules\\pkg\\sub\\a.scss', 'C:\\app')).toBe(
+        'C:/app/node_modules/pkg',
+      );
+      expect(getPackageScope('C:\\app\\src\\app.scss', 'C:\\app')).toBe('C:\\app');
+    });
+  });
+
   describe('package resolution caching', () => {
     let temporaryRoot: string;
     let projectRoot: string;
@@ -205,6 +243,26 @@ describe('sass-language', () => {
       expect(resolveRequests.length).toBe(1);
     });
 
+    it('should share a package resolution between the stylesheets of different folders of a dependency', async () => {
+      const dependencyRoot = join(projectRoot, 'node_modules', 'dependency');
+      const first = await compile(join(dependencyRoot, 'sub1', 'styles.scss'));
+      const second = await compile(join(dependencyRoot, 'sub2', 'styles.scss'));
+
+      expect(first).toContain('content: "dependency";');
+      expect(second).toContain('content: "dependency";');
+      expect(resolveRequests.length).toBe(1);
+    });
+
+    it('should share a package resolution between the stylesheets of different folders of a scoped package', async () => {
+      const packageRoot = join(projectRoot, 'node_modules', '@scope', 'pkg');
+      const first = await compile(join(packageRoot, 'sub1', 'styles.scss'));
+      const second = await compile(join(packageRoot, 'sub2', 'styles.scss'));
+
+      expect(first).toContain('content: "project";');
+      expect(second).toContain('content: "project";');
+      expect(resolveRequests.length).toBe(1);
+    });
+
     it('should resolve a package url of a non-file containing URL from the working directory', async () => {
       // The stylesheets of a build have file URLs, but Sass does not limit a containing URL to them.
       spyOn(SassCompiler.prototype, 'compileStringAsync').and.callFake(async (_, options) => {