@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import weakref
 from typing import Any
 
 from . import NODEFAULT, Struct, field
@@ -61,6 +62,15 @@ def required(self) -> bool:
         return self.default is NODEFAULT and self.default_factory is NODEFAULT
 
 
+# Caches the `fields()` result for non-generic structs. Keyed weakly on the
+# struct type so cached entries are dropped when the class is collected. Kept in
+# a side table rather than on the class itself to avoid mutating user types
+# during inspection.
+_fields_cache: weakref.WeakKeyDictionary[type, tuple[FieldInfo, ...]] = (
+    weakref.WeakKeyDictionary()
+)
+
+
 def fields(type_or_instance: Struct | type[Struct]) -> tuple[FieldInfo]:
     """Get information about the fields in a Struct.
 
@@ -91,7 +101,7 @@ def fields(type_or_instance: Struct | type[Struct]) -> tuple[FieldInfo]:
     # Return cached result for non-generic structs
     is_generic = annotated_cls is not cls
     if not is_generic:
-        cached = cls.__dict__.get("__struct_field_info__")
+        cached = _fields_cache.get(cls)
         if cached is not None:
             return cached
 
@@ -122,6 +132,6 @@ def fields(type_or_instance: Struct | type[Struct]) -> tuple[FieldInfo]:
 
     # Cache for non-generic structs
     if not is_generic:
-        cls.__struct_field_info__ = result
+        _fields_cache[cls] = result
 
     return result
@@ -2554,8 +2554,8 @@ class Example(msgspec.Struct, Generic[T]):
         assert result1 is not result2
 
     def test_fields_cached_frozen_struct(self):
-        # frozen=True blocks setattr on instances, not on the class itself,
-        # so the cache slot is still writable via StructMeta's tp_setattro.
+        # The cache is a side table keyed on the class, so frozen structs
+        # (which block setattr on instances) are cached like any other.
         class Example(msgspec.Struct, frozen=True):
             x: int
             y: str = "hello"
@@ -2564,6 +2564,29 @@ class Example(msgspec.Struct, frozen=True):
         result2 = msgspec.structs.fields(Example)
         assert result1 is result2
 
+    def test_fields_cache_does_not_mutate_class(self):
+        class Example(msgspec.Struct):
+            x: int
+
+        msgspec.structs.fields(Example)
+        # The cache lives in a side table, not on the class, so inspecting
+        # the struct must not add any attributes to it.
+        assert "__struct_field_info__" not in Example.__dict__
+        assert not any("field_info" in name for name in vars(Example))
+
+    def test_fields_cache_not_inherited_by_subclass(self):
+        class Base(msgspec.Struct):
+            x: int
+
+        class Child(Base):
+            y: int
+
+        base_fields = msgspec.structs.fields(Base)
+        child_fields = msgspec.structs.fields(Child)
+        assert [f.name for f in base_fields] == ["x"]
+        assert [f.name for f in child_fields] == ["x", "y"]
+        assert base_fields is not child_fields
+
 
 class TestClassVar:
     def case1(self):