diff --git a/CHANGELOG.md b/CHANGELOG.md
index 363e08e3..a84ceee5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,7 @@
 # Changelog
 
+* use the closest `.luaurc` configuration to each file when bundling code ([#339](https://github.com/seaofvoices/darklua/pull/339))
+
 ## 0.19.0
 
 * add `json_lines` content loader and `/zstd`, `/gzip`, `/zlib` encoding variants for `string`, `buffer`, and `bytes` loaders ([#356](https://github.com/seaofvoices/darklua/pull/356))
diff --git a/src/rules/bundle/path_require_mode/mod.rs b/src/rules/bundle/path_require_mode/mod.rs
index 3b4c9096..a33dc57d 100644
--- a/src/rules/bundle/path_require_mode/mod.rs
+++ b/src/rules/bundle/path_require_mode/mod.rs
@@ -27,10 +27,10 @@ pub(crate) enum RequiredResource {
 }
 
 #[derive(Debug)]
-struct RequirePathProcessor<'a, 'b, 'resources, PathLocatorImpl> {
+struct RequirePathProcessor<'a, 'resources, PathLocatorImpl> {
     options: &'a BundleOptions,
     identifier_tracker: IdentifierTracker,
-    path_locator: &'b PathLocatorImpl,
+    path_locator: PathLocatorImpl,
     module_definitions: BuildModuleDefinitions,
     source: PathBuf,
     module_cache: HashMap<PathBuf, Expression>,
@@ -40,13 +40,13 @@ struct RequirePathProcessor<'a, 'b, 'resources, PathLocatorImpl> {
     errors: Vec<String>,
 }
 
-impl<'a, 'b, 'resources, PathLocatorImpl: PathLocator>
-    RequirePathProcessor<'a, 'b, 'resources, PathLocatorImpl>
+impl<'a, 'b, 'resources, PathLocatorImpl: PathLocator + Clone>
+    RequirePathProcessor<'a, 'resources, PathLocatorImpl>
 {
     fn new<'context, 'code>(
         context: &'context Context<'b, 'resources, 'code>,
         options: &'a BundleOptions,
-        path_locator: &'b PathLocatorImpl,
+        path_locator: PathLocatorImpl,
     ) -> Self
     where
         'context: 'b,
@@ -229,8 +229,8 @@ impl<'a, 'b, 'resources, PathLocatorImpl: PathLocator>
     }
 }
 
-impl<'a, 'b, 'resources, PathLocatorImpl: PathLocator> Deref
-    for RequirePathProcessor<'a, 'b, 'resources, PathLocatorImpl>
+impl<'a, 'resources, PathLocatorImpl: PathLocator> Deref
+    for RequirePathProcessor<'a, 'resources, PathLocatorImpl>
 {
     type Target = IdentifierTracker;
 
@@ -239,16 +239,16 @@ impl<'a, 'b, 'resources, PathLocatorImpl: PathLocator> Deref
     }
 }
 
-impl<'a, 'b, 'resources, PathLocatorImpl: PathLocator> DerefMut
-    for RequirePathProcessor<'a, 'b, 'resources, PathLocatorImpl>
+impl<'a, 'resources, PathLocatorImpl: PathLocator> DerefMut
+    for RequirePathProcessor<'a, 'resources, PathLocatorImpl>
 {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.identifier_tracker
     }
 }
 
-impl<'a, 'b, 'resources, PathLocatorImpl: PathLocator> NodeProcessor
-    for RequirePathProcessor<'a, 'b, 'resources, PathLocatorImpl>
+impl<'a, 'resources, PathLocatorImpl: PathLocator + Clone> NodeProcessor
+    for RequirePathProcessor<'a, 'resources, PathLocatorImpl>
 {
     fn process_expression(&mut self, expression: &mut Expression) {
         if let Expression::Call(call) = expression {
@@ -291,7 +291,7 @@ pub(crate) fn process_block(
     block: &mut Block,
     context: &Context,
     options: &BundleOptions,
-    locator: impl PathLocator,
+    locator: impl PathLocator + Clone,
 ) -> Result<(), String> {
     if options.parser().is_preserving_tokens() {
         log::trace!(
@@ -311,7 +311,7 @@ pub(crate) fn process_block(
         );
     }
 
-    let mut processor = RequirePathProcessor::new(context, options, &locator);
+    let mut processor = RequirePathProcessor::new(context, options, locator);
     ScopeVisitor::visit_block(block, &mut processor);
     processor.apply(block, context)
 }
diff --git a/src/rules/bundle/require_mode.rs b/src/rules/bundle/require_mode.rs
index 81f13a4c..f3263a7e 100644
--- a/src/rules/bundle/require_mode.rs
+++ b/src/rules/bundle/require_mode.rs
@@ -56,7 +56,7 @@ impl BundleRequireMode {
                     .map_err(|err| err.to_string())?;
 
                 let locator = RequirePathLocator::new(
-                    &require_mode,
+                    require_mode,
                     context.project_location(),
                     context.resources(),
                 );
@@ -70,7 +70,7 @@ impl BundleRequireMode {
                     .map_err(|err| err.to_string())?;
 
                 let locator = LuauPathLocator::new(
-                    &require_mode,
+                    require_mode,
                     context.project_location(),
                     context.resources(),
                 );
diff --git a/src/rules/require/luau_path_locator.rs b/src/rules/require/luau_path_locator.rs
index 3528711a..e546a61b 100644
--- a/src/rules/require/luau_path_locator.rs
+++ b/src/rules/require/luau_path_locator.rs
@@ -1,4 +1,7 @@
-use std::path::{Path, PathBuf};
+use std::{
+    cell::RefCell,
+    path::{Path, PathBuf},
+};
 
 use super::{path_iterator, LuauRequireMode};
 use crate::rules::require::path_utils::{get_relative_parent_path, is_require_relative};
@@ -6,28 +9,34 @@ use crate::{utils, DarkluaError, Resources};
 
 /// A path locator specifically for Luau require mode that implements
 /// the behavior defined in the Luau RFCs for module path resolution.
-#[derive(Debug)]
-pub(crate) struct LuauPathLocator<'a, 'b, 'resources> {
-    luau_require_mode: &'a LuauRequireMode,
+#[derive(Clone, Debug)]
+pub(crate) struct LuauPathLocator<'b, 'resources> {
+    luau_require_mode: RefCell<LuauRequireMode>,
     extra_module_relative_location: &'b Path,
     resources: &'resources Resources,
 }
 
-impl<'a, 'b, 'c> LuauPathLocator<'a, 'b, 'c> {
+impl<'b, 'c> LuauPathLocator<'b, 'c> {
     pub(crate) fn new(
-        luau_require_mode: &'a LuauRequireMode,
+        luau_require_mode: LuauRequireMode,
         extra_module_relative_location: &'b Path,
         resources: &'c Resources,
     ) -> Self {
         Self {
-            luau_require_mode,
+            luau_require_mode: RefCell::new(luau_require_mode),
             extra_module_relative_location,
             resources,
         }
     }
+
+    fn load_aliases(&self, source: &Path) -> Result<(), DarkluaError> {
+        self.luau_require_mode
+            .borrow_mut()
+            .load_aliases(source, self.resources)
+    }
 }
 
-impl super::PathLocator for LuauPathLocator<'_, '_, '_> {
+impl super::PathLocator for LuauPathLocator<'_, '_> {
     fn find_require_path(
         &self,
         path: impl Into<PathBuf>,
@@ -39,9 +48,12 @@ impl super::PathLocator for LuauPathLocator<'_, '_, '_> {
             path.display(),
             source.display()
         );
+        self.load_aliases(source)?;
+
+        let require_mode = self.luau_require_mode.borrow();
 
         if is_require_relative(&path) {
-            if self.luau_require_mode.is_module_folder_name(source) {
+            if require_mode.is_module_folder_name(source) {
                 path = get_relative_parent_path(get_relative_parent_path(source)).join(path);
             } else {
                 path = get_relative_parent_path(source).join(path);
@@ -61,8 +73,7 @@ impl super::PathLocator for LuauPathLocator<'_, '_, '_> {
             if source_name == "@self" {
                 path = get_relative_parent_path(source).join(components);
             } else if source_name.starts_with("@") {
-                let mut extra_module_location = self
-                    .luau_require_mode
+                let mut extra_module_location = require_mode
                     .get_source(source_name, self.extra_module_relative_location)
                     .ok_or_else(|| {
                         DarkluaError::invalid_resource_path(
@@ -76,10 +87,9 @@ impl super::PathLocator for LuauPathLocator<'_, '_, '_> {
         }
 
         let normalized_path = utils::normalize_path_with_current_dir(&path);
-        for potential_path in path_iterator::find_require_paths(
-            &normalized_path,
-            self.luau_require_mode.module_folder_name(),
-        ) {
+        for potential_path in
+            path_iterator::find_require_paths(&normalized_path, require_mode.module_folder_name())
+        {
             if self.resources.is_file(&potential_path)? {
                 return Ok(utils::normalize_path_with_current_dir(potential_path));
             }
@@ -90,7 +100,7 @@ impl super::PathLocator for LuauPathLocator<'_, '_, '_> {
                 "tried `{}`",
                 path_iterator::find_require_paths(
                     &normalized_path,
-                    self.luau_require_mode.module_folder_name(),
+                    require_mode.module_folder_name(),
                 )
                 .map(|potential_path| potential_path.display().to_string())
                 .collect::<Vec<_>>()
diff --git a/src/rules/require/luau_require_mode.rs b/src/rules/require/luau_require_mode.rs
index 58400536..9c2d3b84 100644
--- a/src/rules/require/luau_require_mode.rs
+++ b/src/rules/require/luau_require_mode.rs
@@ -4,8 +4,8 @@ use crate::frontend::DarkluaResult;
 use crate::nodes::{Arguments, FunctionCall, StringExpression};
 use crate::rules::require::{match_path_require_call, path_utils, LuauPathLocator, PathLocator};
 use crate::rules::{Context, RequireMode};
-use crate::utils;
 use crate::DarkluaError;
+use crate::{utils, Resources};
 
 use std::collections::HashMap;
 use std::ffi::OsStr;
@@ -39,6 +39,25 @@ impl Default for LuauRequireMode {
 }
 
 impl LuauRequireMode {
+    pub(crate) fn load_aliases(
+        &mut self,
+        luau_file: &Path,
+        resources: &Resources,
+    ) -> Result<(), DarkluaError> {
+        if !self.use_luau_configuration {
+            return Ok(());
+        }
+
+        // Load aliases from .luaurc configuration
+        if let Some(config) = utils::find_luau_configuration(luau_file, resources)? {
+            self.luau_rc_aliases.replace(config.aliases);
+        } else {
+            self.luau_rc_aliases.take();
+        }
+
+        Ok(())
+    }
+
     /// Set if the require mode should use `.luaurc` configuration to resolve aliases.
     pub fn with_configuration(mut self, use_luau_configuration: bool) -> Self {
         self.use_luau_configuration = use_luau_configuration;
@@ -52,21 +71,7 @@ impl LuauRequireMode {
     }
 
     pub(crate) fn initialize(&mut self, context: &Context) -> Result<(), DarkluaError> {
-        if !self.use_luau_configuration {
-            self.luau_rc_aliases.take();
-            return Ok(());
-        }
-
-        // Load aliases from .luaurc configuration
-        if let Some(config) =
-            utils::find_luau_configuration(context.current_path(), context.resources())?
-        {
-            self.luau_rc_aliases.replace(config.aliases);
-        } else {
-            self.luau_rc_aliases.take();
-        }
-
-        Ok(())
+        self.load_aliases(context.current_path(), context.resources)
     }
 
     #[inline]
@@ -86,8 +91,11 @@ impl LuauRequireMode {
         context: &Context,
     ) -> DarkluaResult<Option<PathBuf>> {
         if let Some(literal_path) = match_path_require_call(call) {
-            let path_locator =
-                LuauPathLocator::new(self, context.project_location(), context.resources());
+            let path_locator = LuauPathLocator::new(
+                self.clone(),
+                context.project_location(),
+                context.resources(),
+            );
 
             let required_path =
                 path_locator.find_require_path(literal_path, context.current_path())?;
diff --git a/src/rules/require/path_locator.rs b/src/rules/require/path_locator.rs
index f7a5d6ee..c1992515 100644
--- a/src/rules/require/path_locator.rs
+++ b/src/rules/require/path_locator.rs
@@ -1,30 +1,39 @@
-use std::path::{Path, PathBuf};
+use std::{
+    cell::RefCell,
+    path::{Path, PathBuf},
+};
 
 use super::{path_iterator, PathRequireMode};
 use crate::{rules::require::path_utils::is_require_relative, utils, DarkluaError, Resources};
 
-#[derive(Debug)]
-pub(crate) struct RequirePathLocator<'a, 'b, 'resources> {
-    path_require_mode: &'a PathRequireMode,
-    extra_module_relative_location: &'b Path,
+#[derive(Clone, Debug)]
+pub(crate) struct RequirePathLocator<'a, 'resources> {
+    path_require_mode: RefCell<PathRequireMode>,
+    extra_module_relative_location: &'a Path,
     resources: &'resources Resources,
 }
 
-impl<'a, 'b, 'c> RequirePathLocator<'a, 'b, 'c> {
+impl<'a, 'resources> RequirePathLocator<'a, 'resources> {
     pub(crate) fn new(
-        path_require_mode: &'a PathRequireMode,
-        extra_module_relative_location: &'b Path,
-        resources: &'c Resources,
+        path_require_mode: PathRequireMode,
+        extra_module_relative_location: &'a Path,
+        resources: &'resources Resources,
     ) -> Self {
         Self {
-            path_require_mode,
+            path_require_mode: RefCell::new(path_require_mode),
             extra_module_relative_location,
             resources,
         }
     }
+
+    fn load_aliases(&self, source: &Path) -> Result<(), DarkluaError> {
+        self.path_require_mode
+            .borrow_mut()
+            .load_aliases(source, self.resources)
+    }
 }
 
-impl super::PathLocator for RequirePathLocator<'_, '_, '_> {
+impl super::PathLocator for RequirePathLocator<'_, '_> {
     fn find_require_path(
         &self,
         path: impl Into<PathBuf>,
@@ -36,6 +45,9 @@ impl super::PathLocator for RequirePathLocator<'_, '_, '_> {
             path.display(),
             source.display()
         );
+        self.load_aliases(source)?;
+
+        let require_mode = self.path_require_mode.borrow();
 
         if is_require_relative(&path) {
             let mut new_path = source.to_path_buf();
@@ -43,38 +55,34 @@ impl super::PathLocator for RequirePathLocator<'_, '_, '_> {
             new_path.push(path);
             path = new_path;
         } else if !path.is_absolute() {
-            {
-                let mut components = path.components();
-                let root = components.next().ok_or_else(|| {
-                    DarkluaError::invalid_resource_path(path.display().to_string(), "path is empty")
-                })?;
-                let source_name = utils::convert_os_string(root.as_os_str()).map_err(|err| {
-                    err.context(format!(
-                        "cannot convert source name to utf-8 in `{}`",
-                        path.display(),
-                    ))
-                })?;
+            let mut components = path.components();
+            let root = components.next().ok_or_else(|| {
+                DarkluaError::invalid_resource_path(path.display().to_string(), "path is empty")
+            })?;
+            let source_name = utils::convert_os_string(root.as_os_str()).map_err(|err| {
+                err.context(format!(
+                    "cannot convert source name to utf-8 in `{}`",
+                    path.display(),
+                ))
+            })?;
 
-                let mut extra_module_location = self
-                    .path_require_mode
-                    .get_source(source_name, self.extra_module_relative_location)
-                    .ok_or_else(|| {
-                        DarkluaError::invalid_resource_path(
-                            path.display().to_string(),
-                            format!("unknown source name `{}`", source_name),
-                        )
-                    })?;
-                extra_module_location.extend(components);
-                path = extra_module_location;
-            }
+            let mut extra_module_location = require_mode
+                .get_source(source_name, self.extra_module_relative_location)
+                .ok_or_else(|| {
+                    DarkluaError::invalid_resource_path(
+                        path.display().to_string(),
+                        format!("unknown source name `{}`", source_name),
+                    )
+                })?;
+            extra_module_location.extend(components);
+            path = extra_module_location;
         }
         // else: the path is absolute so darklua should attempt to require it directly
 
         let normalized_path = utils::normalize_path_with_current_dir(&path);
-        for potential_path in path_iterator::find_require_paths(
-            &normalized_path,
-            self.path_require_mode.module_folder_name(),
-        ) {
+        for potential_path in
+            path_iterator::find_require_paths(&normalized_path, require_mode.module_folder_name())
+        {
             if self.resources.is_file(&potential_path)? {
                 return Ok(utils::normalize_path_with_current_dir(potential_path));
             }
@@ -85,7 +93,7 @@ impl super::PathLocator for RequirePathLocator<'_, '_, '_> {
                 "tried `{}`",
                 path_iterator::find_require_paths(
                     &normalized_path,
-                    self.path_require_mode.module_folder_name(),
+                    require_mode.module_folder_name(),
                 )
                 .map(|potential_path| potential_path.display().to_string())
                 .collect::<Vec<_>>()
diff --git a/src/rules/require/path_require_mode.rs b/src/rules/require/path_require_mode.rs
index 093a7917..a35079df 100644
--- a/src/rules/require/path_require_mode.rs
+++ b/src/rules/require/path_require_mode.rs
@@ -5,8 +5,8 @@ use crate::nodes::{Arguments, FunctionCall, StringExpression};
 use crate::rules::require::path_utils::get_relative_path;
 use crate::rules::require::{match_path_require_call, path_utils, PathLocator};
 use crate::rules::{Context, RequireMode};
-use crate::utils;
 use crate::DarkluaError;
+use crate::{utils, Resources};
 
 use std::collections::HashMap;
 use std::ffi::OsStr;
@@ -68,15 +68,16 @@ impl PathRequireMode {
         }
     }
 
-    pub(crate) fn initialize(&mut self, context: &Context) -> Result<(), DarkluaError> {
+    pub(crate) fn load_aliases(
+        &mut self,
+        luau_file: &Path,
+        resources: &Resources,
+    ) -> Result<(), DarkluaError> {
         if !self.use_luau_configuration {
-            self.luau_rc_aliases.take();
             return Ok(());
         }
 
-        if let Some(config) =
-            utils::find_luau_configuration(context.current_path(), context.resources())?
-        {
+        if let Some(config) = utils::find_luau_configuration(luau_file, resources)? {
             self.luau_rc_aliases.replace(config.aliases);
         } else {
             self.luau_rc_aliases.take();
@@ -85,6 +86,10 @@ impl PathRequireMode {
         Ok(())
     }
 
+    pub(crate) fn initialize(&mut self, context: &Context) -> Result<(), DarkluaError> {
+        self.load_aliases(context.current_path(), context.resources())
+    }
+
     pub(crate) fn module_folder_name(&self) -> &str {
         &self.module_folder_name
     }
@@ -113,9 +118,12 @@ impl PathRequireMode {
         context: &Context,
     ) -> DarkluaResult<Option<PathBuf>> {
         if let Some(literal_path) = match_path_require_call(call) {
-            let required_path =
-                RequirePathLocator::new(self, context.project_location(), context.resources())
-                    .find_require_path(literal_path, context.current_path())?;
+            let required_path = RequirePathLocator::new(
+                self.clone(),
+                context.project_location(),
+                context.resources(),
+            )
+            .find_require_path(literal_path, context.current_path())?;
 
             Ok(Some(required_path))
         } else {
diff --git a/tests/bundle.rs b/tests/bundle.rs
index 96e5f3e6..8505595b 100644
--- a/tests/bundle.rs
+++ b/tests/bundle.rs
@@ -75,13 +75,21 @@ mod without_rules {
     use super::*;
 
     fn process_main(resources: &Resources, snapshot_name: &'static str) {
-        process(
+        match process(
             resources,
             Options::new("src/main.lua").with_output("out.lua"),
-        )
-        .unwrap()
-        .result()
-        .unwrap();
+        ) {
+            Ok(worker_tree) => match worker_tree.result() {
+                Ok(()) => {}
+                Err(err) => {
+                    let err_display: Vec<_> = err.into_iter().map(|err| err.to_string()).collect();
+                    panic!("failed to process main.lua:\n{}", err_display.join("\n\n"));
+                }
+            },
+            Err(err) => {
+                panic!("failed to create worker tree for main.lua: {}", err);
+            }
+        }
 
         let out_file = resources.get("out.lua");
 
@@ -741,6 +749,48 @@ data:
         process_main(&resources, "require_small_bundle_case");
     }
 
+    #[test]
+    fn small_bundle_multi_luaurc_case() {
+        let resources = memory_resources!(
+            "src/try-1/value.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/try-1/value.lua"),
+            "src/try-1/.luaurc" => include_str!("./test_cases/small_bundle_multi_luaurc/try-1/.luaurc"),
+            "src/try-2/value.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/try-2/value.lua"),
+            "src/try-2/.luaurc" => include_str!("./test_cases/small_bundle_multi_luaurc/try-2/.luaurc"),
+
+            "src/values/value-1.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/values/value-1.lua"),
+            "src/values/value-2.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/values/value-2.lua"),
+            "src/values/value-default.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/values/value-default.lua"),
+
+            "src/value.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/value.lua"),
+            "src/main.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/main.lua"),
+            "src/.luaurc" => include_str!("./test_cases/small_bundle_multi_luaurc/.luaurc"),
+            ".darklua.json" => DARKLUA_BUNDLE_ONLY_READABLE_CONFIG,
+        );
+
+        process_main(&resources, "small_bundle_multi_luaurc_case");
+    }
+
+    #[test]
+    fn small_bundle_multi_luaurc_case_luau_mode() {
+        let resources = memory_resources!(
+            "src/try-1/value.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/try-1/value.lua"),
+            "src/try-1/.luaurc" => include_str!("./test_cases/small_bundle_multi_luaurc/try-1/.luaurc"),
+            "src/try-2/value.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/try-2/value.lua"),
+            "src/try-2/.luaurc" => include_str!("./test_cases/small_bundle_multi_luaurc/try-2/.luaurc"),
+
+            "src/values/value-1.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/values/value-1.lua"),
+            "src/values/value-2.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/values/value-2.lua"),
+            "src/values/value-default.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/values/value-default.lua"),
+
+            "src/value.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/value.lua"),
+            "src/main.lua" => include_str!("./test_cases/small_bundle_multi_luaurc/main.lua"),
+            "src/.luaurc" => include_str!("./test_cases/small_bundle_multi_luaurc/.luaurc"),
+            ".darklua.json" => DARKLUA_BUNDLE_ONLY_READABLE_CONFIG_LUAU_MODE,
+        );
+
+        process_main(&resources, "small_bundle_multi_luaurc_case");
+    }
+
     #[test]
     fn fuzz_bundle() {
         utils::run_for_minimum_time(Duration::from_millis(250), || {
diff --git a/tests/rule_tests/convert_require.rs b/tests/rule_tests/convert_require.rs
index d120c80a..cae35bd8 100644
--- a/tests/rule_tests/convert_require.rs
+++ b/tests/rule_tests/convert_require.rs
@@ -754,6 +754,39 @@ mod luaurc {
             "local value = require(script:FindFirstChild('value'):FindFirstChild('default'))",
         );
     }
+
+    #[test]
+    fn convert_alias_module_from_module_with_multiple_luaurc_files() {
+        let resources = memory_resources!(
+            "src/value-1.lua" => "return 1",
+            "src/value-2.lua" => "return 2",
+            "src/value-default.lua" => "return 0",
+
+            "input.lua" => "local value = require('@value')",
+            "try-1/input.lua" => "local value = require('@value')",
+            "try-2/input.lua" => "local value = require('@value')",
+
+            ".luaurc" => r#"{ "aliases": { "value": "./src/value-default.lua" } }"#,
+            "try-1/.luaurc" => r#"{ "aliases": { "value": "../src/value-1.lua" } }"#,
+            "try-2/.luaurc" => r#"{ "aliases": { "value": "../src/value-2.lua" } }"#,
+            ".darklua.json" => CONVERT_PATH_TO_ROBLOX_DEFAULT_CONFIG,
+        );
+        expect_file_process(
+            &resources,
+            "input.lua",
+            "local value = require(script.Parent:FindFirstChild('src'):FindFirstChild('value-default'))",
+        );
+        expect_file_process(
+            &resources,
+            "try-1/input.lua",
+            "local value = require(script.Parent.Parent:FindFirstChild('src'):FindFirstChild('value-1'))",
+        );
+        expect_file_process(
+            &resources,
+            "try-2/input.lua",
+            "local value = require(script.Parent.Parent:FindFirstChild('src'):FindFirstChild('value-2'))",
+        );
+    }
 }
 
 mod sourcemap {
diff --git a/tests/snapshots/bundle__without_rules__bundle_without_rules_small_bundle_multi_luaurc_case.snap b/tests/snapshots/bundle__without_rules__bundle_without_rules_small_bundle_multi_luaurc_case.snap
new file mode 100644
index 00000000..8c09400f
--- /dev/null
+++ b/tests/snapshots/bundle__without_rules__bundle_without_rules_small_bundle_multi_luaurc_case.snap
@@ -0,0 +1,130 @@
+---
+source: tests/bundle.rs
+expression: main
+---
+local __DARKLUA_BUNDLE_MODULES = {
+    cache = {}::any,
+}
+
+do
+    do
+        local function __modImpl()
+            return 0
+        end
+
+        function __DARKLUA_BUNDLE_MODULES.a(): typeof(__modImpl())
+            local v = __DARKLUA_BUNDLE_MODULES.cache.a
+
+            if not v then
+                v = {
+                    c = __modImpl(),
+                }
+                __DARKLUA_BUNDLE_MODULES.cache.a = v
+            end
+
+            return v.c
+        end
+    end
+    do
+        local function __modImpl()
+            local tryValueDefault = __DARKLUA_BUNDLE_MODULES.a()
+
+            return tryValueDefault
+        end
+
+        function __DARKLUA_BUNDLE_MODULES.b(): typeof(__modImpl())
+            local v = __DARKLUA_BUNDLE_MODULES.cache.b
+
+            if not v then
+                v = {
+                    c = __modImpl(),
+                }
+                __DARKLUA_BUNDLE_MODULES.cache.b = v
+            end
+
+            return v.c
+        end
+    end
+    do
+        local function __modImpl()
+            return 1
+        end
+
+        function __DARKLUA_BUNDLE_MODULES.c(): typeof(__modImpl())
+            local v = __DARKLUA_BUNDLE_MODULES.cache.c
+
+            if not v then
+                v = {
+                    c = __modImpl(),
+                }
+                __DARKLUA_BUNDLE_MODULES.cache.c = v
+            end
+
+            return v.c
+        end
+    end
+    do
+        local function __modImpl()
+            local tryValue1 = __DARKLUA_BUNDLE_MODULES.c()
+
+            return tryValue1
+        end
+
+        function __DARKLUA_BUNDLE_MODULES.d(): typeof(__modImpl())
+            local v = __DARKLUA_BUNDLE_MODULES.cache.d
+
+            if not v then
+                v = {
+                    c = __modImpl(),
+                }
+                __DARKLUA_BUNDLE_MODULES.cache.d = v
+            end
+
+            return v.c
+        end
+    end
+    do
+        local function __modImpl()
+            return 2
+        end
+
+        function __DARKLUA_BUNDLE_MODULES.e(): typeof(__modImpl())
+            local v = __DARKLUA_BUNDLE_MODULES.cache.e
+
+            if not v then
+                v = {
+                    c = __modImpl(),
+                }
+                __DARKLUA_BUNDLE_MODULES.cache.e = v
+            end
+
+            return v.c
+        end
+    end
+    do
+        local function __modImpl()
+            local tryValue2 = __DARKLUA_BUNDLE_MODULES.e()
+
+            return tryValue2
+        end
+
+        function __DARKLUA_BUNDLE_MODULES.f(): typeof(__modImpl())
+            local v = __DARKLUA_BUNDLE_MODULES.cache.f
+
+            if not v then
+                v = {
+                    c = __modImpl(),
+                }
+                __DARKLUA_BUNDLE_MODULES.cache.f = v
+            end
+
+            return v.c
+        end
+    end
+end
+
+local tryValueDefaultModule = __DARKLUA_BUNDLE_MODULES.b()
+local tryValue1Module = __DARKLUA_BUNDLE_MODULES.d()
+local tryValue2Module = __DARKLUA_BUNDLE_MODULES.f()
+
+print(tryValueDefaultModule, tryValue1Module, tryValue2Module)
diff --git a/tests/test_cases/small_bundle_multi_luaurc/.luaurc b/tests/test_cases/small_bundle_multi_luaurc/.luaurc
new file mode 100644
index 00000000..adef9b49
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/.luaurc
@@ -0,0 +1,5 @@
+{
+  "aliases": {
+    "value": "./values/value-default.lua"
+  }
+}
diff --git a/tests/test_cases/small_bundle_multi_luaurc/main.lua b/tests/test_cases/small_bundle_multi_luaurc/main.lua
new file mode 100644
index 00000000..ed13ba08
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/main.lua
@@ -0,0 +1,7 @@
+local tryValueDefaultModule = require("./value")
+
+local tryValue1Module = require("./try-1/value")
+
+local tryValue2Module = require("./try-2/value")
+
+print(tryValueDefaultModule, tryValue1Module, tryValue2Module)
diff --git a/tests/test_cases/small_bundle_multi_luaurc/try-1/.luaurc b/tests/test_cases/small_bundle_multi_luaurc/try-1/.luaurc
new file mode 100644
index 00000000..54e15033
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/try-1/.luaurc
@@ -0,0 +1,5 @@
+{
+  "aliases": {
+    "value": "../values/value-1.lua"
+  }
+}
diff --git a/tests/test_cases/small_bundle_multi_luaurc/try-1/value.lua b/tests/test_cases/small_bundle_multi_luaurc/try-1/value.lua
new file mode 100644
index 00000000..2776c980
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/try-1/value.lua
@@ -0,0 +1,3 @@
+local tryValue1 = require("@value")
+
+return tryValue1
diff --git a/tests/test_cases/small_bundle_multi_luaurc/try-2/.luaurc b/tests/test_cases/small_bundle_multi_luaurc/try-2/.luaurc
new file mode 100644
index 00000000..993d9c1c
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/try-2/.luaurc
@@ -0,0 +1,5 @@
+{
+  "aliases": {
+    "value": "../values/value-2.lua"
+  }
+}
diff --git a/tests/test_cases/small_bundle_multi_luaurc/try-2/value.lua b/tests/test_cases/small_bundle_multi_luaurc/try-2/value.lua
new file mode 100644
index 00000000..518e0001
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/try-2/value.lua
@@ -0,0 +1,3 @@
+local tryValue2 = require('@value')
+
+return tryValue2
diff --git a/tests/test_cases/small_bundle_multi_luaurc/value.lua b/tests/test_cases/small_bundle_multi_luaurc/value.lua
new file mode 100644
index 00000000..f413fd11
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/value.lua
@@ -0,0 +1,3 @@
+local tryValueDefault = require('@value')
+
+return tryValueDefault
diff --git a/tests/test_cases/small_bundle_multi_luaurc/values/value-1.lua b/tests/test_cases/small_bundle_multi_luaurc/values/value-1.lua
new file mode 100644
index 00000000..a4325f62
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/values/value-1.lua
@@ -0,0 +1 @@
+return 1
diff --git a/tests/test_cases/small_bundle_multi_luaurc/values/value-2.lua b/tests/test_cases/small_bundle_multi_luaurc/values/value-2.lua
new file mode 100644
index 00000000..3ee3fcaa
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/values/value-2.lua
@@ -0,0 +1 @@
+return 2
diff --git a/tests/test_cases/small_bundle_multi_luaurc/values/value-default.lua b/tests/test_cases/small_bundle_multi_luaurc/values/value-default.lua
new file mode 100644
index 00000000..61c7ebff
--- /dev/null
+++ b/tests/test_cases/small_bundle_multi_luaurc/values/value-default.lua
@@ -0,0 +1 @@
+return 0