@@ -2295,7 +2295,12 @@ def expand_typevars(
             result: list[tuple[FuncItem, CallableType]] = []
             for substitutions in itertools.product(*subst):
                 mapping = dict(substitutions)
-                result.append((expand_func(defn, mapping), expand_type(typ, mapping)))
+                result.append(
+                    (
+                        expand_func(defn, mapping),
+                        expand_type(typ, mapping, normalize_callables=False),
+                    )
+                )
             return result
         else:
             return [(defn, typ)]
 
@@ -52,7 +52,9 @@
 
 
 @overload
-def expand_type(typ: CallableType, env: Mapping[TypeVarId, Type]) -> CallableType: ...
+def expand_type(
+    typ: CallableType, env: Mapping[TypeVarId, Type], normalize_callables: bool = True
+) -> CallableType: ...
 
 
 @overload
@@ -63,11 +65,13 @@ def expand_type(typ: ProperType, env: Mapping[TypeVarId, Type]) -> ProperType: .
 def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type: ...
 
 
-def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
+def expand_type(
+    typ: Type, env: Mapping[TypeVarId, Type], normalize_callables: bool = True
+) -> Type:
     """Substitute any type variable references in a type given by a type
     environment.
     """
-    return typ.accept(ExpandTypeVisitor(env))
+    return typ.accept(ExpandTypeVisitor(env, normalize_callables))
 
 
 @overload
@@ -182,9 +186,15 @@ class ExpandTypeVisitor(TrivialSyntheticTypeTranslator):
 
     variables: Mapping[TypeVarId, Type]  # TypeVar id -> TypeVar value
 
-    def __init__(self, variables: Mapping[TypeVarId, Type]) -> None:
+    def __init__(
+        self, variables: Mapping[TypeVarId, Type], normalize_callables: bool = True
+    ) -> None:
         super().__init__()
         self.variables = variables
+        # Usually we want normalized callables (therefore default is True), but there
+        # are some cases when we don't. For example, when expanding callable with
+        # type variables with values. We want to keep the shape matching argument structure.
+        self.normalize_callables = normalize_callables
 
     def visit_unbound_type(self, t: UnboundType) -> Type:
         return t
@@ -497,7 +507,7 @@ def visit_callable_type(self, t: CallableType) -> CallableType:
             type_is=t.type_is.accept(self) if t.type_is is not None else None,
             instance_type=instance_type,
         )
-        if needs_normalization:
+        if needs_normalization and self.normalize_callables:
             return expanded.with_normalized_var_args()
         return expanded
 
 
@@ -6148,3 +6148,18 @@ def test(f: Callable[[object], object]) -> None: ...
 test(foo)  # E: Argument 1 to "test" has incompatible type overloaded function; expected "Callable[[object], object]"
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
+
+
+[case testTypeDictCallableUnpackExpansionNoCrash]
+from typing import TypeVar, Unpack, Generic
+from typing_extensions import TypedDict
+
+class TD(TypedDict, Generic[T]):
+    x: int
+    y: T
+
+T = TypeVar("T", int, str)
+def foo(t: T, **kwargs: Unpack[TD[T]]) -> None:
+    reveal_type(kwargs)  # N: Revealed type is "TypedDict('__main__.TD', {'x': builtins.int, 'y': builtins.int})" \
+                         # N: Revealed type is "TypedDict('__main__.TD', {'x': builtins.int, 'y': builtins.str})"
+[builtins fixtures/dict.pyi]
@@ -3216,6 +3216,16 @@ reveal_type(mix2(b2))  # N: Revealed type is "tuple[Any, tuple[builtins.int, bui
 reveal_type(mix2(b3))  # N: Revealed type is "tuple[builtins.int, tuple[Any, builtins.str]]"
 [builtins fixtures/tuple.pyi]
 
+[case testTupleTypeCallableUnpackExpansionNoCrash]
+from typing import TypeVar, Unpack
+
+T = TypeVar("T", int, str)
+
+def foo(*args: Unpack[tuple[int, T]]) -> None:
+    reveal_type(args)  # N: Revealed type is "tuple[builtins.int, builtins.int]" \
+                       # N: Revealed type is "tuple[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
 [case testTypeVarTupleOverloadNoCrash]
 from typing import Any, overload, Callable
 from typing_extensions import TypeVarTuple, Unpack