pydantic
diff --git a/‎pydantic/_internal/_generate_schema.py
Lines changed: 1 addition & 1 deletion b/‎pydantic/_internal/_generate_schema.py
Lines changed: 1 addition & 1 deletion
diff --git a/‎tests/test_type_alias_type.py
Lines changed: 44 additions & 1 deletion b/‎tests/test_type_alias_type.py
Lines changed: 44 additions & 1 deletion
@@ -2813,7 +2813,7 @@ def _resolve_definition(self, ref: str, definitions: dict[str, CoreSchema]) -> C
         # Some `'definition-ref'` schemas might act as "intermediate" references (e.g. when using
         # a PEP 695 type alias (which is referenceable) that references another PEP 695 type alias):
         visited: set[str] = set()
-        while definition['type'] == 'definition-ref':
+        while definition['type'] == 'definition-ref' and _inlining_behavior(definition) == 'inline':
             schema_ref = definition['schema_ref']
             if schema_ref in visited:
                 raise PydanticUserError(
 
@@ -7,7 +7,7 @@
 from annotated_types import MaxLen
 from typing_extensions import TypeAliasType
 
-from pydantic import BaseModel, PydanticUserError, TypeAdapter, ValidationError
+from pydantic import BaseModel, PlainSerializer, PydanticUserError, TypeAdapter, ValidationError, WithJsonSchema
 
 T = TypeVar('T')
 
@@ -430,3 +430,46 @@ class MyModel(BaseModel):
 
     assert exc_info.value.code == 'circular-reference-schema'
     assert exc_info.value.message.startswith('tests.test_type_alias_type.C')
+
+
+def test_type_alias_type_with_serialization() -> None:
+    """Regression test for https://github.com/pydantic/pydantic/issues/11642.
+
+    The issue lied in the definition resolving logic, which wasn't taking
+    possible metadata or serialization attached to a `'definition-ref'` schema.
+
+    In this example, the core schema for `B` — before schema cleaning — will look like:
+
+    ```python
+    {
+        'type': 'definition-ref',
+        'schema_ref': '__main__.A',
+        'serialization': {...},
+        'ref': '__main__.B',
+    }
+    ```
+
+    and the "main"/"top-level" core schema is a `'definition-ref'` schema pointing to
+    `'__main__.B`.
+
+    In schema cleaning, when resolving this top-level core schema, we would recursively
+    unpack `'definition-ref'` schemas (and would end up with the actual schema for `__main__.A`),
+    without taking into account the fact that the schema of `B` had a `serialization` key!
+    """
+
+    A = TypeAliasType('A', int)
+    B = TypeAliasType('B', Annotated[A, PlainSerializer(lambda v: 3)])
+
+    ta = TypeAdapter(B)
+
+    assert ta.dump_python(1) == 3
+
+
+def test_type_alias_type_with_metadata() -> None:
+    """Same as `test_type_alias_type_with_serialization()` but with JSON Metadata."""
+
+    A = TypeAliasType('A', int)
+    B = TypeAliasType('B', Annotated[A, WithJsonSchema({'type': 'int', 'extra': 1})])
+
+    ta = TypeAdapter(B)
+    assert ta.json_schema() == {'type': 'int', 'extra': 1}