fix: make module code hash content-only for portable .module archives

calculate_build_folder_hash baked the absolute build-folder path into the hash, so
a required module's code hash changed when the project moved to another directory or
machine. Consuming a .module archive elsewhere then reported a spurious 'code changes
detected in required module <x>' and forced a re-render.

Hash the code content only (relative paths + file contents). This also drops the
hash_as_folder workaround from the previous commit, since a content-only hash is
already stable across scratch extraction, in-place folders, and locations.

Note: existing archives/metadata must be regenerated (stored hashes include the old
path), and existing in-place multi-module projects will see a one-time 'required
module code changed' on the next render.

Author: NejcS

plain_modules.py

@@ -312,13 +312,10 @@ def get_module_non_functional_source_hash(self) -> str:
         return plain_spec.get_hash_value([stripped] + self.resources_list)
 
     def get_module_code_hash(self) -> str:
-        # Read content from the resolved (possibly scratch) folder, but pin the hashed folder
-        # identity to the module's logical location so an archived module read from scratch hashes
-        # identically to the same module rendered in place.
-        logical_build_folder = os.path.join(self._default_module_folder, MODULE_CODE_SUBFOLDER)
-        return ImplementationCodeHelpers.calculate_build_folder_hash(
-            self.module_build_folder, hash_as_folder=logical_build_folder
-        )
+        # Content-only hash (see calculate_build_folder_hash): reading from the resolved (possibly
+        # scratch) folder yields the same hash as the in-place folder and the same hash across
+        # locations, so archived modules stay portable.
+        return ImplementationCodeHelpers.calculate_build_folder_hash(self.module_build_folder)
 
     def has_required_modules_code_changed(
         self,

render_machine/implementation_code_helpers.py

@@ -7,13 +7,13 @@
 
 class ImplementationCodeHelpers:
     @staticmethod
-    def calculate_build_folder_hash(build_folder: str, hash_as_folder: str | None = None) -> str:
-        # ``hash_as_folder`` lets the caller pin the folder identity baked into the hash to the
-        # module's logical location even when content is read from elsewhere (e.g. a scratch
-        # extraction of a "<module>.module" archive), so the hash is stable across storage forms.
+    def calculate_build_folder_hash(build_folder: str) -> str:
+        # Hash the code content only (relative paths + file contents), NOT the build folder's
+        # absolute path, so the hash is stable across directories and machines. This is required for
+        # distributable "<module>.module" archives: a module's code hash must match regardless of
+        # where plain_modules/ lives, or consuming an archive elsewhere falsely reports a code change.
         _, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(build_folder)
-        folder_key = hash_as_folder if hash_as_folder is not None else build_folder
-        return plain_spec.hash_text(f"folder={folder_key}|{json.dumps(existing_files_content)}")
+        return plain_spec.hash_text(json.dumps(existing_files_content))
 
     @staticmethod
     def fetch_existing_files(build_folder: str):

tests/test_plain_modules.py

@@ -539,6 +539,21 @@ def test_render_status_parity_folder_vs_archive(fixtures_dir, tmp_build_folder):
     module.cleanup_scratch()
 
 
+def test_code_hash_is_location_independent(fixtures_dir):
+    """The code hash depends only on content, not the build folder's absolute path, so it is stable
+    across directories/machines. This is what makes .module archives distributable: consuming the
+    same code at a different location must not report a spurious 'required module code changed'."""
+    with tempfile.TemporaryDirectory() as build_a, tempfile.TemporaryDirectory() as build_b:
+        mod_a = PlainModule("pr_solo.plain", build_a, [fixtures_dir])
+        mod_b = PlainModule("pr_solo.plain", build_b, [fixtures_dir])
+        for mod in (mod_a, mod_b):
+            os.makedirs(mod.module_build_folder, exist_ok=True)
+            (Path(mod.module_build_folder) / "main.py").write_text("print('hi')\n")
+
+        assert mod_a.module_build_folder != mod_b.module_build_folder
+        assert mod_a.get_module_code_hash() == mod_b.get_module_code_hash()
+
+
 def test_materialize_rejects_non_zip(solo_module):
     with open(solo_module.module_archive_path, "w") as f:
         f.write("not a zip")