@@ -1297,3 +1297,56 @@ def overwritten_target(value: object):
     else:
         reveal_type(value)  # revealed: TypeGuard[list[int] @ value] & ~AlwaysTruthy
 ```
+
+## Recursive TypeIs targets
+
+An unresolved recursive `TypeIs` target does not make the negative branch unreachable. We retain the
+recursive input while inferring assignments in both branches.
+
+```py
+from typing import Generic, TypeVar
+from typing_extensions import TypeIs
+
+T = TypeVar("T")
+
+class Container(Generic[T]): ...
+
+def is_container(value: object, other: T) -> TypeIs[Container[T]]:
+    return True
+
+while True:
+    # error: [possibly-unresolved-reference]
+    # error: [possibly-unresolved-reference]
+    if is_container(value, type(value)):
+        value = value.__str__  # error: [possibly-unresolved-reference]
+        bad: str = 42  # error: [invalid-assignment]
+    else:
+        value = {value}  # error: [possibly-unresolved-reference]
+        bad: str = 42  # error: [invalid-assignment]
+    reveal_type(value)  # revealed: Divergent | set[Divergent]
+```
+
+## Recursive TypeIs targets with PEP 695 generics
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from typing_extensions import TypeIs
+
+class Container[T]: ...
+
+def is_container[T](value: object, other: T) -> TypeIs[Container[T]]:
+    return True
+
+while True:
+    # error: [possibly-unresolved-reference]
+    # error: [possibly-unresolved-reference]
+    if is_container(value, type(value)):
+        value = value.__str__  # error: [possibly-unresolved-reference]
+    else:
+        value = {value}  # error: [possibly-unresolved-reference]
+    reveal_type(value)  # revealed: Divergent | set[Divergent]
+```
@@ -4682,6 +4682,14 @@ impl<'db> NarrowingConstraintsBuilder<'db, '_> {
                 let (_, place) = type_is.place_info(db)?;
                 let mut target = type_is.return_type(db);
 
+                // An unresolved target does not establish that either branch is unreachable.
+                // Materializing Divergent to object here would discard the recursive marker
+                // from the negative branch before its target type becomes available.
+                if target.is_divergent() {
+                    self.is_provisional = true;
+                    return None;
+                }
+
                 if let Some(kind) = type_is.materialization_kind(db) {
                     let kind = if is_positive { kind } else { kind.flip() };
                     target = target.materialization(db, &self.env, kind);