Since its conception, Rust has always acknowledged that memory safety is not the only kind of safety that is important.
For example, another important safety property is exception safety per Rustonomicon, borrowing the C++ term, though the stdlib calls it a much better, more accurate term, unwind safety (but the docs also refers to panic safety which means there's 3 expressions for the same thing, which is unfortunate).
Another common programming term, not specific to Rust (but also used in Rust) is thread safety.
Both exception safety and thread safety has a memory safety component (in unsafe code, we can't be so careless as to allow unwinding or concurrency bugs to make the program memory unsafe), but they generally entail something stronger than just memory safety.
(There's also another kind safety, type safety, but it's intertwined with memory safety: Rust guarantees that, as long as you uphold memory safety in unsafe code, your code is type safe as well)
As a rule of thumb, having some kind of "safety" means upholding an important invariant (which are properties that we can rely upon when thinking about the code). Memory safety is very prominent but was never meant to be the only kind of safety that Rust programmers care about; it's just the bare minimum.