pds param on credential session login, logic to handle emails, language tag deserialization bugfix.

crates/jacquard-common/src/types/language.rs

···
+use langtag::InvalidLangTag;
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use smol_str::{SmolStr, ToSmolStr};
 use std::fmt;
···
         Ok(Language(SmolStr::new_static(tag.as_str())))
     }
 
+    fn new_owned(lang: SmolStr) -> Result<Self, SmolStr> {
+        let tag = langtag::LangTag::new(&lang).map_err(|e| e.to_smolstr())?;
+        Ok(Language(SmolStr::new(tag.as_str())))
+    }
+
     /// Infallible constructor for when you *know* the string is a valid IETF language tag.
     /// Will panic on invalid tag. If you're manually decoding atproto records
     /// or API values you know are valid (rather than using serde), this is the one to use.
···
     where
         D: Deserializer<'de>,
     {
-        let value: &str = Deserialize::deserialize(deserializer)?;
-        Self::new(value).map_err(D::Error::custom)
+        let value = Deserialize::deserialize(deserializer)?;
+        Self::new_owned(value).map_err(D::Error::custom)
     }
 }
 

crates/jacquard/src/client.rs

···
         identifier: CowStr<'_>,
         password: CowStr<'_>,
         session_id: Option<CowStr<'_>>,
+        pds: Option<Url>,
     ) -> ClientResult<(Self, AtpSession)> {
         let session = MemoryCredentialSession::unauthenticated();
         let auth = session
-            .login(identifier, password, session_id, None, None)
+            .login(identifier, password, session_id, None, None, pds)
             .await?;
         Ok((session, auth))
     }

crates/jacquard/src/client/credential_session.rs

···
         session_id: Option<CowStr<'_>>,
         allow_takendown: Option<bool>,
         auth_factor_token: Option<CowStr<'_>>,
+        pds: Option<Url>,
     ) -> std::result::Result<AtpSession, ClientError>
     where
         S: Any + 'static,
···
             tracing::info_span!("credential_session_login", identifier = %identifier).entered();
 
         // Resolve PDS base
-        let pds = if identifier.as_ref().starts_with("http://")
+        let pds = if let Some(pds) = pds {
+            pds
+        } else if identifier.as_ref().starts_with("http://")
             || identifier.as_ref().starts_with("https://")
         {
             Url::parse(identifier.as_ref()).map_err(|e: url::ParseError| {
···
             resp.into_owned()?.pds_endpoint().ok_or_else(|| {
                 ClientError::invalid_request("missing PDS endpoint")
                     .with_help("DID document must include a PDS service endpoint")
+            })?
+        } else if identifier.as_ref().contains("@") && !identifier.as_ref().starts_with("@") {
+            // we're going to assume its an email
+            pds.ok_or_else(|| {
+                ClientError::invalid_request("missing PDS endpoint")
+                    .with_help("When logging in with email, we need your PDS")
             })?
         } else {
             // treat as handle

crates/jacquard/tests/credential_session.rs

···
             Some(jacquard::CowStr::from("session")),
             None,
             None,
+            None,
         )
         .await
         .expect("login ok");