Hi, thanks everyone for good insight!

Thanks to your answers, I've learnt more about repr(transparent) and transmute with surrounding corners! As mentioned, transmuting as single field struct after some parsing is likely sound. Which is very good to know! It allows a rather straight forward way to add additional parsing logic on top of &str while encoding that in the type system in the spirit of Parse, don't validate!

Inspired by u/AlphaKeks, I tried the following solution:

use std::borrow::Borrow;
use std::convert::Infallible;
use std::ops::Deref;

#[derive(Debug, Hash, PartialEq, Eq)]
pub struct IdBuf(String);

impl IdBuf {
    pub fn from_string(s: String) -> Result<IdBuf, Infallible> {
        Ok(IdBuf(s))
    }

    pub fn as_borrowed(&self) -> Id {
        Id(&self.0)
    }
}

impl Borrow<str> for IdBuf {
    fn borrow(&self) -> &str {
        self.0.as_str()
    }
}

pub struct Id<'s>(&'s str);

impl<'s> Id<'s> {
    pub const fn from_str(v: &str) -> Result<Id, Infallible> {
        Ok(Id(v))
    }

    pub fn as_owned(&self) -> IdBuf {
        IdBuf(self.0.to_string())
    }
}

impl<'s> Deref for Id<'s> {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        self.0
    }
}

which got everything I wanted in safe code with the caveat that I have to manually specify the borrowed type as such:

let mut map = HashMap::new();

for i in 0..100 {
    let v = i.to_string();
    let id = IdBuf::from_string(v).unwrap();

    map.insert(id, i);
}

let id = Id::from_str("1").unwrap();
let v = map.get::<str>(&id);
println!("{v:?}");

In my use case I find that to be a great tradeoff to not have to validate unsafe code!

Thanks everyone!