dealing with url crate issues

crates/jacquard-common/src/xrpc.rs

···
 #[cfg_attr(not(target_arch = "wasm32"), trait_variant::make(Send))]
 pub trait XrpcClient: HttpClient {
     /// Get the base URI for the client.
-    fn base_uri(&self) -> impl Future<Output = Url>;
+    fn base_uri(&self) -> impl Future<Output = CowStr<'static>>;
 
     /// Set the base URI for the client.
     fn set_base_uri(&self, url: Url) -> impl Future<Output = ()> {

crates/jacquard-common/src/xrpc/subscription.rs

···
 use std::marker::PhantomData;
 use url::Url;
 
+use crate::cowstr::ToCowStr;
 use crate::error::DecodeError;
 use crate::stream::StreamError;
 use crate::websocket::{WebSocketClient, WebSocketConnection, WsSink, WsStream};
···
 #[cfg_attr(not(target_arch = "wasm32"), trait_variant::make(Send))]
 pub trait SubscriptionClient: WebSocketClient {
     /// Get the base URI for the client.
-    fn base_uri(&self) -> impl Future<Output = Url>;
+    fn base_uri(&self) -> impl Future<Output = CowStr<'static>>;
 
     /// Get the subscription options for the client.
     fn subscription_opts(&self) -> impl Future<Output = SubscriptionOptions<'_>> {
···
 /// or when you want to handle auth manually via headers.
 pub struct BasicSubscriptionClient<W: WebSocketClient> {
     client: W,
-    base_uri: Url,
+    base_uri: CowStr<'static>,
     opts: SubscriptionOptions<'static>,
 }
 
 impl<W: WebSocketClient> BasicSubscriptionClient<W> {
     /// Create a new basic subscription client with the given WebSocket client and base URI.
     pub fn new(client: W, base_uri: Url) -> Self {
+        let base_uri = base_uri.as_str().trim_end_matches("/");
         Self {
             client,
-            base_uri,
+            base_uri: base_uri.to_cowstr().into_static(),
             opts: SubscriptionOptions::default(),
         }
     }
···
 }
 
 impl<W: WebSocketClient> SubscriptionClient for BasicSubscriptionClient<W> {
-    async fn base_uri(&self) -> Url {
+    async fn base_uri(&self) -> CowStr<'static> {
         self.base_uri.clone()
     }
 
···
         Self: Sync,
     {
         let base = self.base_uri().await;
+        let base = Url::parse(&base).expect("Failed to parse base URL");
         self.subscription(base)
             .with_options(opts)
             .subscribe(params)
···
         Sub: XrpcSubscription + Send + Sync,
     {
         let base = self.base_uri().await;
+        let base = Url::parse(&base).expect("Failed to parse base URL");
         self.subscription(base)
             .with_options(opts)
             .subscribe(params)

crates/jacquard-oauth/src/atproto.rs

···
 
 use crate::types::OAuthClientMetadata;
 use crate::{keyset::Keyset, scopes::Scope};
-use jacquard_common::CowStr;
+use jacquard_common::cowstr::ToCowStr;
+use jacquard_common::{CowStr, IntoStatic};
 use serde::{Deserialize, Serialize};
 use smol_str::{SmolStr, ToSmolStr};
 use thiserror::Error;
···
     };
 
     Ok(OAuthClientMetadata {
-        client_id: metadata.client_id,
-        client_uri: metadata.client_uri,
-        redirect_uris: metadata.redirect_uris,
+        client_id: metadata.client_id.to_cowstr().into_static(),
+        client_uri: metadata.client_uri.map(|u| u.to_cowstr().into_static()),
+        redirect_uris: metadata
+            .redirect_uris
+            .iter()
+            .map(|u| u.to_cowstr().into_static())
+            .collect(),
         token_endpoint_auth_method: Some(auth_method.into()),
         grant_types: if keyset.is_some() {
             Some(metadata.grant_types.into_iter().map(|v| v.into()).collect())
···
         },
         scope: Some(Scope::serialize_multiple(metadata.scopes.as_slice())),
         dpop_bound_access_tokens: Some(true),
-        jwks_uri,
+        jwks_uri: jwks_uri.map(|u| u.to_cowstr().into_static()),
         jwks,
         token_endpoint_auth_signing_alg: if keyset.is_some() {
             Some(CowStr::new_static("ES256"))
···
             None
         },
         client_name: metadata.client_name,
-        logo_uri: metadata.logo_uri,
-        tos_uri: metadata.tos_uri,
-        privacy_policy_uri: metadata.privacy_policy_uri,
+        logo_uri: metadata.logo_uri.map(|u| u.to_cowstr().into_static()),
+        tos_uri: metadata.tos_uri.map(|u| u.to_cowstr().into_static()),
+        privacy_policy_uri: metadata
+            .privacy_policy_uri
+            .map(|u| u.to_cowstr().into_static()),
     })
 }
 
···
             atproto_client_metadata(AtprotoClientMetadata::new_localhost(None, None), &None)
                 .unwrap(),
             OAuthClientMetadata {
-                client_id: Url::from_str("http://localhost").unwrap(),
+                client_id: CowStr::new_static("http://localhost"),
                 client_uri: None,
                 redirect_uris: vec![
-                    Url::from_str("http://127.0.0.1/").unwrap(),
-                    Url::from_str("http://[::1]/").unwrap(),
+                    CowStr::new_static("http://127.0.0.1/"),
+                    CowStr::new_static("http://[::1]/"),
                 ],
                 scope: Some(CowStr::new_static("atproto")),
                 grant_types: None,
···
     #[test]
     fn test_localhost_client_metadata_custom() {
         assert_eq!(
-            atproto_client_metadata(AtprotoClientMetadata::new_localhost(
-                Some(vec![
-                     Url::from_str("http://127.0.0.1/callback").unwrap(),
-                     Url::from_str("http://[::1]/callback").unwrap(),
-                ]),
-                Some(
-                    vec![
+            atproto_client_metadata(
+                AtprotoClientMetadata::new_localhost(
+                    Some(vec![
+                        Url::parse("http://127.0.0.1/callback").unwrap(),
+                        Url::parse("http://[::1]/callback").unwrap(),
+                    ]),
+                    Some(vec![
                         Scope::Atproto,
                         Scope::Transition(TransitionScope::Generic),
                         Scope::parse("account:email").unwrap()
-                    ]
-                )
-            ), &None)
+                    ])
+                ),
+                &None
+            )
             .expect("failed to convert metadata"),
             OAuthClientMetadata {
-                client_id: Url::from_str(
+                client_id: CowStr::new_static(
                     "http://localhost?redirect_uri=http%3A%2F%2F127.0.0.1%2Fcallback&redirect_uri=http%3A%2F%2F127.0.0.1%2Fcallback&scope=account%3Aemail+atproto+transition%3Ageneric"
-                ).unwrap(),
+                ),
                 client_uri: None,
                 redirect_uris: vec![
-                    Url::from_str("http://127.0.0.1/callback").unwrap(),
+                    CowStr::new_static("http://127.0.0.1/callback"),
                     // TODO: fix this so that it respects IPv6
-                    Url::from_str("http://127.0.0.1/callback").unwrap(),
+                    CowStr::new_static("http://127.0.0.1/callback"),
                 ],
-                scope: Some(CowStr::new_static("account:email atproto transition:generic")),
+                scope: Some(CowStr::new_static(
+                    "account:email atproto transition:generic"
+                )),
                 grant_types: None,
                 token_endpoint_auth_method: Some(AuthMethod::None.into()),
                 dpop_bound_access_tokens: Some(true),
···
         {
             let out = atproto_client_metadata(
                 AtprotoClientMetadata::new_localhost(
-                    Some(vec![Url::from_str("https://127.0.0.1/").unwrap()]),
+                    Some(vec![Url::from_str("https://127.0.0.1").unwrap()]),
                     None,
                 ),
                 &None,
···
             assert_eq!(
                 out,
                 OAuthClientMetadata {
-                    client_id: Url::from_str(
+                    client_id: CowStr::new_static(
                         "http://localhost?redirect_uri=http%3A%2F%2F127.0.0.1%2F"
-                    )
-                    .unwrap(),
+                    ),
                     client_uri: None,
-                    redirect_uris: vec![Url::from_str("http://127.0.0.1/").unwrap()],
+                    redirect_uris: vec![CowStr::new_static("http://127.0.0.1")],
                     scope: Some(CowStr::new_static("atproto")),
                     grant_types: None,
                     token_endpoint_auth_method: Some(AuthMethod::None.into()),
···
         {
             let out = atproto_client_metadata(
                 AtprotoClientMetadata::new_localhost(
-                    Some(vec![Url::from_str("http://localhost:8000/").unwrap()]),
+                    Some(vec![Url::from_str("http://localhost:8000").unwrap()]),
                     None,
                 ),
                 &None,
···
             assert_eq!(
                 out,
                 OAuthClientMetadata {
-                    client_id: Url::from_str(
+                    client_id: CowStr::new_static(
                         "http://localhost?redirect_uri=http%3A%2F%2F127.0.0.1%3A8000%2F"
-                    )
-                    .unwrap(),
+                    ),
                     client_uri: None,
-                    redirect_uris: vec![Url::from_str("http://127.0.0.1:8000/").unwrap()],
+                    redirect_uris: vec![CowStr::new_static("http://127.0.0.1:8000")],
                     scope: Some(CowStr::new_static("atproto")),
                     grant_types: None,
                     token_endpoint_auth_method: Some(AuthMethod::None.into()),
···
             assert_eq!(
                 out,
                 OAuthClientMetadata {
-                    client_id: Url::from_str(
+                    client_id: CowStr::new_static(
                         "http://localhost?redirect_uri=http%3A%2F%2F127.0.0.1%2F"
-                    )
-                    .unwrap(),
+                    ),
                     client_uri: None,
-                    redirect_uris: vec![Url::from_str("http://127.0.0.1/").unwrap()],
+                    redirect_uris: vec![CowStr::new_static("http://127.0.0.1/")],
                     scope: Some(CowStr::new_static("atproto")),
                     grant_types: None,
                     token_endpoint_auth_method: Some(AuthMethod::None.into()),
···
                 atproto_client_metadata(metadata, &Some(keyset.clone()))
                     .expect("failed to convert metadata"),
                 OAuthClientMetadata {
-                    client_id: Url::from_str("https://example.com/client_metadata.json").unwrap(),
-                    client_uri: Some(Url::from_str("https://example.com").unwrap()),
-                    redirect_uris: vec![Url::from_str("https://example.com/callback").unwrap()],
+                    client_id: CowStr::new_static("https://example.com/client_metadata.json"),
+                    client_uri: Some(CowStr::new_static("https://example.com")),
+                    redirect_uris: vec![CowStr::new_static("https://example.com/callback")],
                     scope: Some(CowStr::new_static("atproto")),
                     grant_types: Some(vec![CowStr::new_static("authorization_code")]),
                     token_endpoint_auth_method: Some(AuthMethod::PrivateKeyJwt.into()),

crates/jacquard-oauth/src/client.rs

···
 };
 use jacquard_common::{
     AuthorizationToken, CowStr, IntoStatic,
+    cowstr::ToCowStr,
     error::{AuthError, ClientError, XrpcResult},
     http_client::HttpClient,
     types::{did::Did, string::Handle},
···
     resolver::{DidDocResponse, IdentityError, IdentityResolver, ResolverOptions},
 };
 use jose_jwk::JwkSet;
+use smol_str::ToSmolStr;
 use std::{future::Future, sync::Arc};
 use tokio::sync::RwLock;
 use url::Url;
···
 {
     pub registry: Arc<SessionRegistry<T, S>>,
     pub options: RwLock<CallOptions<'static>>,
-    pub endpoint: RwLock<Option<Url>>,
+    pub endpoint: RwLock<Option<CowStr<'static>>>,
     pub client: Arc<T>,
 }
 
···
 
         #[derive(serde::Serialize)]
         struct Parameters<'s> {
-            client_id: Url,
+            client_id: CowStr<'s>,
             request_uri: CowStr<'s>,
         }
         Ok(metadata.server_metadata.authorization_endpoint.to_string()
             + "?"
             + &serde_html_form::to_string(Parameters {
-                client_id: metadata.client_metadata.client_id.clone(),
+                client_id: metadata.client_metadata.client_id,
                 request_uri: auth_req_info.request_uri,
             })
             .unwrap())
···
 
         let metadata = self
             .client
-            .get_authorization_server_metadata(&auth_req_info.authserver_url)
+            .get_authorization_server_metadata(&auth_req_info.authserver_url.to_cowstr())
             .await?;
 
         if let Some(iss) = params.iss {
···
                 let client_data = ClientSessionData {
                     account_did: token_set.sub.clone(),
                     session_id: auth_req_info.state,
-                    host_url: Url::parse(&token_set.iss).expect("Failed to parse host URL"),
-                    authserver_url: auth_req_info.authserver_url,
+                    host_url: token_set.iss.clone(),
+                    authserver_url: auth_req_info.authserver_url.to_cowstr(),
                     authserver_token_endpoint: auth_req_info.authserver_token_endpoint,
                     authserver_revocation_endpoint: auth_req_info.authserver_revocation_endpoint,
                     scopes,
···
     S: ClientAuthStore + Send + Sync + 'static,
     T: OAuthResolver + DpopExt + Send + Sync + 'static,
 {
-    async fn base_uri(&self) -> Url {
-        self.endpoint.read().await.clone().unwrap_or(
-            Url::parse("https://public.api.bsky.app").expect("public appview should be valid url"),
-        )
+    async fn base_uri(&self) -> CowStr<'static> {
+        self.endpoint
+            .read()
+            .await
+            .clone()
+            .unwrap_or(CowStr::new_static("https://public.api.bsky.app"))
     }
 
     async fn opts(&self) -> CallOptions<'_> {
···
 
     async fn set_base_uri(&self, url: Url) {
         let mut guard = self.endpoint.write().await;
-        *guard = Some(url);
+        *guard = Some(url.to_cowstr().into_static());
     }
 
     async fn send<R>(&self, request: R) -> XrpcResult<XrpcResponse<R>>
···
     {
         let base_uri = self.base_uri().await;
         self.client
-            .xrpc(base_uri.clone())
+            .xrpc(Url::parse(&base_uri).map_err(|e| ClientError::encode(e.to_smolstr()))?)
             .with_options(opts.clone())
             .send(&request)
             .await
···
         (data.account_did.clone(), data.session_id.clone())
     }
 
-    pub async fn endpoint(&self) -> Url {
+    pub async fn endpoint(&self) -> CowStr<'static> {
         self.data.read().await.host_url.clone()
     }
 
···
     T: OAuthResolver + DpopExt + XrpcExt + Send + Sync + 'static,
     W: Send + Sync,
 {
-    async fn base_uri(&self) -> Url {
+    async fn base_uri(&self) -> CowStr<'static> {
         self.data.read().await.host_url.clone()
     }
 
···
 
     async fn set_base_uri(&self, url: Url) {
         let mut guard = self.data.write().await;
-        guard.host_url = url;
+        guard.host_url = url.to_cowstr().into_static();
     }
 
     async fn send<R>(&self, request: R) -> XrpcResult<XrpcResponse<R>>
···
         opts.auth = Some(self.access_token().await);
         let guard = self.data.read().await;
         let mut dpop = guard.dpop_data.clone();
+        let base_uri = Url::parse(&base_uri).map_err(|e| ClientError::transport(e))?;
         let http_response = self
             .client
             .dpop_call(&mut dpop)
···
         use jacquard_common::StreamError;
 
         let base_uri = <Self as XrpcClient>::base_uri(self).await;
+        let base_uri = Url::parse(&base_uri).map_err(|e| StreamError::protocol(e.to_string()))?;
         let mut opts = self.options.read().await.clone();
         opts.auth = Some(self.access_token().await);
         let http_request = build_http_request(&base_uri, &request, &opts)
···
         let mut opts = self.options.read().await.clone();
         opts.auth = Some(self.access_token().await);
 
-        let mut url = base_uri;
+        let mut url = Url::parse(&base_uri).map_err(|e| StreamError::encode(e))?;
         let mut path = url.path().trim_end_matches('/').to_owned();
         path.push_str("/xrpc/");
         path.push_str(<Str::Request as jacquard_common::xrpc::XrpcRequest>::NSID);
···
     T: OAuthResolver + Send + Sync + 'static,
     W: WebSocketClient + Send + Sync,
 {
-    async fn base_uri(&self) -> Url {
-        #[cfg(not(target_arch = "wasm32"))]
-        if tokio::runtime::Handle::try_current().is_ok() {
-            return tokio::task::block_in_place(|| self.data.blocking_read().host_url.clone());
-        }
-
-        self.data.blocking_read().host_url.clone()
+    async fn base_uri(&self) -> CowStr<'static> {
+        self.data.read().await.host_url.clone()
     }
 
     async fn subscription_opts(&self) -> jacquard_common::xrpc::SubscriptionOptions<'_> {
···
     {
         use jacquard_common::xrpc::SubscriptionExt;
         let base = self.base_uri().await;
+        let base = Url::parse(&base).expect("Failed to parse base URL");
         self.subscription(base)
             .with_options(opts)
             .subscribe(params)

crates/jacquard-oauth/src/request.rs

···
     use crate::types::{OAuthAuthorizationServerMetadata, OAuthClientMetadata};
     use bytes::Bytes;
     use http::{Response as HttpResponse, StatusCode};
-    use jacquard_common::http_client::HttpClient;
+    use jacquard_common::{http_client::HttpClient, types::string::Did};
     use jacquard_identity::resolver::IdentityResolver;
     use std::sync::Arc;
     use tokio::sync::Mutex;
···
         async fn resolve_handle(
             &self,
             _handle: &jacquard_common::types::string::Handle<'_>,
-        ) -> std::result::Result<
-            jacquard_common::types::string::Did<'static>,
-            jacquard_identity::resolver::IdentityError,
-        > {
-            Ok(jacquard_common::types::string::Did::new_static("did:plc:alice").unwrap())
+        ) -> std::result::Result<Did<'static>, jacquard_identity::resolver::IdentityError> {
+            Ok(Did::new_static("did:plc:alice").unwrap())
         }
         async fn resolve_did_doc(
             &self,
-            _did: &jacquard_common::types::string::Did<'_>,
+            _did: &Did<'_>,
         ) -> std::result::Result<
             jacquard_identity::resolver::DidDocResponse,
             jacquard_identity::resolver::IdentityError,
···
         OAuthMetadata {
             server_metadata: server,
             client_metadata: OAuthClientMetadata {
-                client_id: url::Url::parse("https://client").unwrap(),
+                client_id: CowStr::new_static("https://client"),
                 client_uri: None,
-                redirect_uris: vec![url::Url::parse("https://client/cb").unwrap()],
+                redirect_uris: vec![CowStr::new_static("https://client/cb")],
                 scope: Some(CowStr::from("atproto")),
                 grant_types: None,
                 token_endpoint_auth_method: Some(CowStr::from("none")),
···
         let client = MockClient::default();
         let meta = base_metadata();
         let session = ClientSessionData {
-            account_did: jacquard_common::types::string::Did::new_static("did:plc:alice").unwrap(),
+            account_did: Did::new_static("did:plc:alice").unwrap(),
             session_id: CowStr::from("state"),
-            host_url: url::Url::parse("https://pds").unwrap(),
-            authserver_url: url::Url::parse("https://issuer").unwrap(),
+            host_url: CowStr::new_static("https://pds"),
+            authserver_url: CowStr::new_static("https://issuer"),
             authserver_token_endpoint: CowStr::from("https://issuer/token"),
             authserver_revocation_endpoint: None,
             scopes: vec![],
···
             },
             token_set: crate::types::TokenSet {
                 iss: CowStr::from("https://issuer"),
-                sub: jacquard_common::types::string::Did::new_static("did:plc:alice").unwrap(),
+                sub: Did::new_static("did:plc:alice").unwrap(),
                 aud: CowStr::from("https://pds"),
                 scope: None,
                 refresh_token: None,

crates/jacquard-oauth/src/resolver.rs

···
     // when the user forgot their handle, or when the handle does not
     // resolve to a DID)
     Ok(if input.starts_with("https://") {
+        use jacquard_common::cowstr::ToCowStr;
+
         let url = Url::parse(input).map_err(|_| ResolverError::not_found())?;
-        (resolver.resolve_from_service(&url).await?, None)
+        (resolver.resolve_from_service(&url.to_cowstr()).await?, None)
     } else {
         let (metadata, identity) = resolver.resolve_from_identity(input).await?;
         (metadata, Some(identity))
···
 #[cfg(not(target_arch = "wasm32"))]
 async fn resolve_from_service_impl<T: OAuthResolver + Sync + ?Sized>(
     resolver: &T,
-    input: &Url,
+    input: &CowStr<'_>,
 ) -> Result<OAuthAuthorizationServerMetadata<'static>> {
     // Assume first that input is a PDS URL (as required by ATPROTO)
     if let Ok(metadata) = resolver.get_resource_server_metadata(input).await {
···
 #[cfg(target_arch = "wasm32")]
 async fn resolve_from_service_impl<T: OAuthResolver + ?Sized>(
     resolver: &T,
-    input: &Url,
+    input: &CowStr<'_>,
 ) -> Result<OAuthAuthorizationServerMetadata<'static>> {
     // Assume first that input is a PDS URL (as required by ATPROTO)
     if let Ok(metadata) = resolver.get_resource_server_metadata(input).await {
···
         .map_err(|e| ResolverError::at_identifier(smol_str::format_smolstr!("{:?}", e)))?;
     let identity = resolver.resolve_ident_owned(&actor).await?;
     if let Some(pds) = &identity.pds_endpoint() {
-        let metadata = resolver.get_resource_server_metadata(pds).await?;
+        use jacquard_common::cowstr::ToCowStr;
+
+        let metadata = resolver
+            .get_resource_server_metadata(&pds.to_cowstr())
+            .await?;
         Ok((metadata, identity))
     } else {
         Err(ResolverError::did_document("Did doc lacking pds"))
···
 #[cfg(not(target_arch = "wasm32"))]
 async fn get_authorization_server_metadata_impl<T: HttpClient + Sync + ?Sized>(
     client: &T,
-    issuer: &Url,
+    issuer: &CowStr<'_>,
 ) -> Result<OAuthAuthorizationServerMetadata<'static>> {
     let mut md = resolve_authorization_server(client, issuer).await?;
-    // Normalize issuer string to the input URL representation to avoid slash quirks
-    md.issuer = jacquard_common::CowStr::from(issuer.as_str()).into_static();
+    md.issuer = issuer.clone().into_static();
     Ok(md)
 }
 
 #[cfg(target_arch = "wasm32")]
 async fn get_authorization_server_metadata_impl<T: HttpClient + ?Sized>(
     client: &T,
-    issuer: &Url,
+    issuer: &CowStr<'_>,
 ) -> Result<OAuthAuthorizationServerMetadata<'static>> {
     let mut md = resolve_authorization_server(client, issuer).await?;
-    // Normalize issuer string to the input URL representation to avoid slash quirks
-    md.issuer = jacquard_common::CowStr::from(issuer.as_str()).into_static();
+    md.issuer = issuer.into_static();
     Ok(md)
 }
 
 #[cfg(not(target_arch = "wasm32"))]
 async fn get_resource_server_metadata_impl<T: OAuthResolver + Sync + ?Sized>(
     resolver: &T,
-    pds: &Url,
+    pds: &CowStr<'_>,
 ) -> Result<OAuthAuthorizationServerMetadata<'static>> {
     let rs_metadata = resolve_protected_resource_info(resolver, pds).await?;
     // ATPROTO requires one, and only one, authorization server entry
···
 #[cfg(target_arch = "wasm32")]
 async fn get_resource_server_metadata_impl<T: OAuthResolver + ?Sized>(
     resolver: &T,
-    pds: &Url,
+    pds: &CowStr<'_>,
 ) -> Result<OAuthAuthorizationServerMetadata<'static>> {
     let rs_metadata = resolve_protected_resource_info(resolver, pds).await?;
     // ATPROTO requires one, and only one, authorization server entry
···
     #[cfg(not(target_arch = "wasm32"))]
     fn resolve_from_service(
         &self,
-        input: &Url,
+        input: &CowStr<'_>,
     ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>>> + Send
     where
         Self: Sync,
···
     #[cfg(target_arch = "wasm32")]
     fn resolve_from_service(
         &self,
-        input: &Url,
+        input: &CowStr<'_>,
     ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>>> {
         resolve_from_service_impl(self, input)
     }
···
     #[cfg(not(target_arch = "wasm32"))]
     fn get_authorization_server_metadata(
         &self,
-        issuer: &Url,
+        issuer: &CowStr<'_>,
     ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>>> + Send
     where
         Self: Sync,
···
     #[cfg(target_arch = "wasm32")]
     fn get_authorization_server_metadata(
         &self,
-        issuer: &Url,
+        issuer: &CowStr<'_>,
     ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>>> {
         get_authorization_server_metadata_impl(self, issuer)
     }
···
     #[cfg(not(target_arch = "wasm32"))]
     fn get_resource_server_metadata(
         &self,
-        pds: &Url,
+        pds: &CowStr<'_>,
     ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>>> + Send
     where
         Self: Sync,
···
     #[cfg(target_arch = "wasm32")]
     fn get_resource_server_metadata(
         &self,
-        pds: &Url,
+        pds: &CowStr<'_>,
     ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>>> {
         get_resource_server_metadata_impl(self, pds)
     }
···
 
 pub async fn resolve_authorization_server<T: HttpClient + ?Sized>(
     client: &T,
-    server: &Url,
+    server: &CowStr<'_>,
 ) -> Result<OAuthAuthorizationServerMetadata<'static>> {
-    let url = server
-        .join("/.well-known/oauth-authorization-server")
-        .map_err(|e| ResolverError::transport(e))?;
+    let url = format!(
+        "{}/.well-known/oauth-authorization-server",
+        server.trim_end_matches("/")
+    );
 
     let req = Request::builder()
-        .uri(url.to_string())
+        .uri(url)
         .body(Vec::new())
         .map_err(|e| ResolverError::transport(e))?;
     let res = client
···
 
 pub async fn resolve_protected_resource_info<T: HttpClient + ?Sized>(
     client: &T,
-    server: &Url,
+    server: &CowStr<'_>,
 ) -> Result<OAuthProtectedResourceMetadata<'static>> {
-    let url = server
-        .join("/.well-known/oauth-protected-resource")
-        .map_err(|e| ResolverError::transport(e))?;
+    let url = format!(
+        "{}/.well-known/oauth-protected-resource",
+        server.trim_end_matches("/")
+    );
 
     let req = Request::builder()
         .uri(url.to_string())
···
                 .body(Vec::new())
                 .unwrap(),
         );
-        let issuer = url::Url::parse("https://issuer").unwrap();
+        let issuer = CowStr::new_static("https://issuer");
         let err = super::resolve_authorization_server(&client, &issuer)
             .await
             .unwrap_err();
···
                 .body(b"{not json}".to_vec())
                 .unwrap(),
         );
-        let issuer = url::Url::parse("https://issuer").unwrap();
+        let issuer = CowStr::new_static("https://issuer");
         let err = super::resolve_authorization_server(&client, &issuer)
             .await
             .unwrap_err();

crates/jacquard-oauth/src/session.rs

···
     pub session_id: CowStr<'s>,
 
     // Base URL of the "resource server" (eg, PDS). Should include scheme, hostname, port; no path or auth info.
-    pub host_url: Url,
+    pub host_url: CowStr<'s>,
 
     // Base URL of the "auth server" (eg, PDS or entryway). Should include scheme, hostname, port; no path or auth info.
-    pub authserver_url: Url,
+    pub authserver_url: CowStr<'s>,
 
     // Full token endpoint
     pub authserver_token_endpoint: CowStr<'s>,
···
 
     fn into_static(self) -> Self::Output {
         ClientSessionData {
-            authserver_url: self.authserver_url,
+            authserver_url: self.authserver_url.into_static(),
             authserver_token_endpoint: self.authserver_token_endpoint.into_static(),
             authserver_revocation_endpoint: self
                 .authserver_revocation_endpoint
···
             token_set: self.token_set.into_static(),
             account_did: self.account_did.into_static(),
             session_id: self.session_id.into_static(),
-            host_url: self.host_url,
+            host_url: self.host_url.into_static(),
         }
     }
 }

crates/jacquard-oauth/src/types/client_metadata.rs

···
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 pub struct OAuthClientMetadata<'c> {
-    pub client_id: Url,
+    pub client_id: CowStr<'c>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub client_uri: Option<Url>,
-    pub redirect_uris: Vec<Url>,
+    pub client_uri: Option<CowStr<'c>>,
+    pub redirect_uris: Vec<CowStr<'c>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(borrow)]
     pub scope: Option<CowStr<'c>>,
···
     pub dpop_bound_access_tokens: Option<bool>,
     // https://datatracker.ietf.org/doc/html/rfc7591#section-2
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub jwks_uri: Option<Url>,
+    pub jwks_uri: Option<CowStr<'c>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub jwks: Option<JwkSet>,
     // https://openid.net/specs/openid-connect-registration-1_0.html#ClientMetadata
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub client_name: Option<SmolStr>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub logo_uri: Option<Url>,
+    pub logo_uri: Option<CowStr<'c>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub tos_uri: Option<Url>,
+    pub tos_uri: Option<CowStr<'c>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub privacy_policy_uri: Option<Url>,
+    pub privacy_policy_uri: Option<CowStr<'c>>,
 }
 
 impl OAuthClientMetadata<'_> {}
···
 
     fn into_static(self) -> Self::Output {
         OAuthClientMetadata {
-            client_id: self.client_id,
-            client_uri: self.client_uri,
-            redirect_uris: self.redirect_uris,
+            client_id: self.client_id.into_static(),
+            client_uri: self.client_uri.into_static(),
+            redirect_uris: self.redirect_uris.into_static(),
             scope: self.scope.map(|scope| scope.into_static()),
             grant_types: self.grant_types.map(|types| types.into_static()),
             token_endpoint_auth_method: self
                 .token_endpoint_auth_method
                 .map(|method| method.into_static()),
             dpop_bound_access_tokens: self.dpop_bound_access_tokens,
-            jwks_uri: self.jwks_uri,
+            jwks_uri: self.jwks_uri.into_static(),
             jwks: self.jwks,
             token_endpoint_auth_signing_alg: self
                 .token_endpoint_auth_signing_alg
                 .map(|alg| alg.into_static()),
             client_name: self.client_name,
-            logo_uri: self.logo_uri,
-            tos_uri: self.tos_uri,
-            privacy_policy_uri: self.privacy_policy_uri,
+            logo_uri: self.logo_uri.into_static(),
+            tos_uri: self.tos_uri.into_static(),
+            privacy_policy_uri: self.privacy_policy_uri.into_static(),
         }
     }
 }

crates/jacquard-oauth/src/types/metadata.rs

···
 pub struct OAuthProtectedResourceMetadata<'s> {
     #[serde(borrow)]
     pub resource: CowStr<'s>,
-    pub authorization_servers: Option<Vec<Url>>,
+    pub authorization_servers: Option<Vec<CowStr<'s>>>,
     pub jwks_uri: Option<CowStr<'s>>,
     pub scopes_supported: Vec<CowStr<'s>>,
     pub bearer_methods_supported: Option<Vec<CowStr<'s>>>,
···
     fn into_static(self) -> Self::Output {
         OAuthProtectedResourceMetadata {
             resource: self.resource.into_static(),
-            authorization_servers: self.authorization_servers,
+            authorization_servers: self.authorization_servers.into_static(),
             jwks_uri: self.jwks_uri.map(|v| v.into_static()),
             scopes_supported: self.scopes_supported.into_static(),
             bearer_methods_supported: self.bearer_methods_supported.map(|v| v.into_static()),

crates/jacquard/src/client.rs

···
     },
     server::{create_session::CreateSessionOutput, refresh_session::RefreshSessionOutput},
 };
+use jacquard_common::cowstr::ToCowStr;
 use jacquard_common::error::XrpcResult;
 pub use jacquard_common::error::{ClientError, XrpcResult as ClientResult};
 use jacquard_common::http_client::HttpClient;
···
     fn session_info(&self)
     -> impl Future<Output = Option<(Did<'static>, Option<CowStr<'static>>)>>;
     /// Current base endpoint.
-    fn endpoint(&self) -> impl Future<Output = url::Url>;
+    fn endpoint(&self) -> impl Future<Output = CowStr<'static>>;
     /// Override per-session call options.
     fn set_options<'a>(&'a self, opts: CallOptions<'a>) -> impl Future<Output = ()>;
     /// Refresh the session and return a fresh AuthorizationToken.
···
 }
 pub struct UnauthenticatedSession<T> {
     resolver: Arc<T>,
-    endpoint: Arc<RwLock<Option<Url>>>,
+    endpoint: Arc<RwLock<Option<CowStr<'static>>>>,
     options: Arc<RwLock<CallOptions<'static>>>,
 }
 
···
     T: Sync + Send,
 {
     #[doc = " Get the base URI for the client."]
-    fn base_uri(&self) -> impl Future<Output = Url> + Send {
+    fn base_uri(&self) -> impl Future<Output = CowStr<'static>> + Send {
         async move {
-            self.endpoint.read().await.clone().unwrap_or(
-                Url::parse("https://public.bsky.app").expect("public appview should be valid url"),
-            )
+            self.endpoint
+                .read()
+                .await
+                .clone()
+                .unwrap_or(CowStr::new_static("https://public.bsky.app"))
         }
     }
 
···
     {
         async move {
             let base_uri = self.base_uri().await;
+            let base_uri = Url::parse(&base_uri).expect("base_uri should be valid url");
             self.resolver
                 .xrpc(base_uri.clone())
                 .with_options(opts.clone())
···
     fn set_base_uri(&self, url: Url) -> impl Future<Output = ()> + Send {
         async move {
             let mut guard = self.endpoint.write().await;
-            *guard = Some(url);
+            *guard = Some(url.to_cowstr().into_static());
         }
     }
 
···
         async { None } // no session
     }
 
-    fn endpoint(&self) -> impl Future<Output = Url> {
+    fn endpoint(&self) -> impl Future<Output = CowStr<'static>> {
         async { self.base_uri().await }
     }
 
···
     }
 
     /// Get current endpoint.
-    pub async fn endpoint(&self) -> url::Url {
+    pub async fn endpoint(&self) -> CowStr<'static> {
         self.inner.endpoint().await
     }
 
···
                 .map(|(did, sid)| (did, Some(sid)))
         }
     }
-    fn endpoint(&self) -> impl Future<Output = url::Url> {
+    fn endpoint(&self) -> impl Future<Output = CowStr<'static>> {
         async move { CredentialSession::<S, T, W>::endpoint(self).await }
     }
     fn set_options<'a>(&'a self, opts: CallOptions<'a>) -> impl Future<Output = ()> {
···
             Some((did.into_static(), Some(sid.into_static())))
         }
     }
-    fn endpoint(&self) -> impl Future<Output = url::Url> {
+    fn endpoint(&self) -> impl Future<Output = CowStr<'static>> {
         async { self.endpoint().await }
     }
     fn set_options<'a>(&'a self, opts: CallOptions<'a>) -> impl Future<Output = ()> {
···
     ) -> impl Future<Output = Option<(Did<'static>, Option<CowStr<'static>>)>> {
         async { None }
     }
-    fn endpoint(&self) -> impl Future<Output = url::Url> {
+    fn endpoint(&self) -> impl Future<Output = CowStr<'static>> {
         async { self.base_uri().await }
     }
     fn set_options<'a>(&'a self, opts: CallOptions<'a>) -> impl Future<Output = ()> {
···
 }
 
 impl<A: AgentSession> XrpcClient for Agent<A> {
-    async fn base_uri(&self) -> url::Url {
+    async fn base_uri(&self) -> CowStr<'static> {
         self.inner.base_uri().await
     }
     fn opts(&self) -> impl Future<Output = CallOptions<'_>> {
···
         async { self.info().await }
     }
 
-    fn endpoint(&self) -> impl Future<Output = url::Url> {
+    fn endpoint(&self) -> impl Future<Output = CowStr<'static>> {
         async { self.endpoint().await }
     }
 

crates/jacquard/src/client/credential_session.rs

···
 };
 use jacquard_common::{
     AuthorizationToken, CowStr, IntoStatic,
+    cowstr::ToCowStr,
     error::{AuthError, ClientError, XrpcResult},
     http_client::HttpClient,
     session::SessionStore,
···
         CallOptions, Response, XrpcClient, XrpcError, XrpcExt, XrpcRequest, XrpcResp, XrpcResponse,
     },
 };
+use smol_str::ToSmolStr;
 use tokio::sync::RwLock;
 use url::Url;
 
···
     /// Active session key, if any.
     pub key: RwLock<Option<SessionKey>>,
     /// Current base endpoint (PDS); defaults to public appview when unset.
-    pub endpoint: RwLock<Option<Url>>,
+    pub endpoint: RwLock<Option<CowStr<'static>>>,
 }
 
 impl<S, T> CredentialSession<S, T, ()>
···
     }
 
     /// Current base endpoint. Defaults to the public appview when unset.
-    pub async fn endpoint(&self) -> Url {
-        self.endpoint.read().await.clone().unwrap_or(
-            Url::parse("https://public.bsky.app").expect("public appview should be valid url"),
-        )
+    pub async fn endpoint(&self) -> CowStr<'static> {
+        self.endpoint
+            .read()
+            .await
+            .clone()
+            .unwrap_or(CowStr::new_static("https://public.bsky.app"))
     }
 
     /// Override the current base endpoint.
     pub async fn set_endpoint(&self, endpoint: Url) {
-        *self.endpoint.write().await = Some(endpoint);
+        *self.endpoint.write().await = Some(endpoint.to_cowstr().into_static());
     }
 
     /// Current access token (Bearer), if logged in.
···
             .ok_or_else(|| ClientError::auth(AuthError::NotAuthenticated))?;
         let session = self.store.get(&key).await;
         let endpoint = self.endpoint().await;
+        let endpoint = Url::parse(endpoint.as_str()).map_err(|_| {
+            ClientError::auth(AuthError::NotAuthenticated)
+                .with_help("ensure endpoint is valid")
+                .with_url("com.atproto.server.refreshSession")
+        })?;
         let mut opts = self.options.read().await.clone();
         opts.auth = session.map(|s| AuthorizationToken::Bearer(s.refresh_jwt));
         let response = self
···
         }
         // Activate
         *self.key.write().await = Some(key);
-        *self.endpoint.write().await = Some(pds);
+        *self.endpoint.write().await = Some(pds.to_cowstr().into_static());
 
         Ok(session)
     }
···
 
         // Activate
         *self.key.write().await = Some(key.clone());
-        *self.endpoint.write().await = Some(pds);
+        *self.endpoint.write().await = Some(pds.to_cowstr().into_static());
         // ensure store has the session (no-op if it existed)
         self.store
             .set((sess.did.clone(), session_id.into_static()), sess)
···
         if let Some(file_store) =
             (&*self.store as &dyn Any).downcast_ref::<crate::client::token::FileAuthStore>()
         {
-            let _ = file_store.set_atp_pds(&key, &self.endpoint().await);
+            let _ = file_store.set_atp_pds(
+                &key,
+                &Url::parse(&self.endpoint().await).map_err(|e| {
+                    ClientError::invalid_request("invalid PDS endpoint")
+                        .with_help(format!("Failed to parse PDS endpoint: {}", e))
+                })?,
+            );
         }
         Ok(())
     }
···
             })?
         });
         *self.key.write().await = Some(key.clone());
-        *self.endpoint.write().await = Some(pds);
+        *self.endpoint.write().await = Some(pds.to_cowstr().into_static());
         if let Some(file_store) =
             (&*self.store as &dyn Any).downcast_ref::<crate::client::token::FileAuthStore>()
         {
-            let _ = file_store.set_atp_pds(&key, &self.endpoint().await);
+            let _ = file_store.set_atp_pds(
+                &key,
+                &Url::parse(&self.endpoint().await).map_err(|e| {
+                    ClientError::invalid_request("invalid PDS endpoint")
+                        .with_help(format!("Failed to parse PDS endpoint: {}", e))
+                })?,
+            );
         }
         Ok(())
     }
···
     T: HttpClient + XrpcExt + Send + Sync + 'static,
     W: Send + Sync,
 {
-    async fn base_uri(&self) -> Url {
-        self.endpoint.read().await.clone().unwrap_or(
-            Url::parse("https://public.bsky.app").expect("public appview should be valid url"),
-        )
+    async fn base_uri(&self) -> CowStr<'static> {
+        self.endpoint
+            .read()
+            .await
+            .clone()
+            .unwrap_or(CowStr::new_static("https://public.bsky.app"))
     }
 
     async fn opts(&self) -> CallOptions<'_> {
···
 
     async fn set_base_uri(&self, url: Url) {
         let mut guard = self.endpoint.write().await;
-        *guard = Some(url);
+        *guard = Some(url.to_cowstr().into_static());
     }
 
     async fn send<R>(&self, request: R) -> XrpcResult<XrpcResponse<R>>
···
         <R as XrpcRequest>::Response: Send + Sync,
     {
         let base_uri = self.base_uri().await;
+        let base_uri =
+            Url::parse(&base_uri).map_err(|e| ClientError::invalid_request(e.to_smolstr()))?;
         let auth = self.access_token().await;
         opts.auth = auth;
         let resp = self
···
         use jacquard_common::{StreamError, xrpc::build_http_request};
 
         let base_uri = <Self as XrpcClient>::base_uri(self).await;
+        let base_uri = Url::parse(&base_uri).map_err(|e| StreamError::encode(e))?;
         let mut opts = self.options.read().await.clone();
         opts.auth = self.access_token().await;
 
···
         use n0_future::TryStreamExt;
 
         let base_uri = self.base_uri().await;
+        let base_uri = Url::parse(&base_uri).map_err(|e| StreamError::encode(e))?;
         let mut opts = self.options.read().await.clone();
         opts.auth = self.access_token().await;
 
···
     T: Send + Sync + 'static,
     W: WebSocketClient + Send + Sync,
 {
-    async fn base_uri(&self) -> Url {
-        self.endpoint.read().await.clone().unwrap_or(
-            Url::parse("https://public.bsky.app").expect("public appview should be valid url"),
-        )
+    async fn base_uri(&self) -> CowStr<'static> {
+        self.endpoint
+            .read()
+            .await
+            .clone()
+            .unwrap_or(CowStr::new_static("https://public.bsky.app"))
     }
 
     async fn subscription_opts(&self) -> jacquard_common::xrpc::SubscriptionOptions<'_> {
···
     {
         use jacquard_common::xrpc::SubscriptionExt;
         let base = self.base_uri().await;
+        let base = Url::parse(&base).expect("base uri should be valid url");
         self.subscription(base)
             .with_options(opts)
             .subscribe(params)

crates/jacquard/src/client/token.rs

···
     session_id: String,
 
     /// Base URL of the resource server (PDS)
-    host_url: Url,
+    host_url: String,
 
     /// Base URL of the authorization server (PDS or entryway)
-    authserver_url: Url,
+    authserver_url: String,
 
     /// Full token endpoint URL
     authserver_token_endpoint: String,
···
         OAuthSession {
             account_did: data.account_did.to_string(),
             session_id: data.session_id.to_string(),
-            host_url: data.host_url,
-            authserver_url: data.authserver_url,
+            host_url: data.host_url.to_string(),
+            authserver_url: data.authserver_url.to_string(),
             authserver_token_endpoint: data.authserver_token_endpoint.to_string(),
             authserver_revocation_endpoint: data
                 .authserver_revocation_endpoint
···
         ClientSessionData {
             account_did: session.account_did.into(),
             session_id: session.session_id.to_cowstr(),
-            host_url: session.host_url,
-            authserver_url: session.authserver_url,
+            host_url: session.host_url.to_cowstr(),
+            authserver_url: session.authserver_url.to_cowstr(),
             authserver_token_endpoint: session.authserver_token_endpoint.to_cowstr(),
             authserver_revocation_endpoint: session
                 .authserver_revocation_endpoint

crates/jacquard/tests/oauth_auto_refresh.rs

···
 
 use bytes::Bytes;
 use http::{HeaderValue, Method, Response as HttpResponse, StatusCode};
-use jacquard::IntoStatic;
 use jacquard::client::Agent;
 use jacquard::types::did::Did;
 use jacquard::xrpc::XrpcClient;
+use jacquard::{CowStr, IntoStatic};
 use jacquard_common::http_client::HttpClient;
 use jacquard_oauth::atproto::AtprotoClientMetadata;
 use jacquard_oauth::client::OAuthSession;
···
 impl OAuthResolver for MockClient {
     async fn get_authorization_server_metadata(
         &self,
-        issuer: &url::Url,
+        issuer: &CowStr<'_>,
     ) -> Result<OAuthAuthorizationServerMetadata<'static>, jacquard_oauth::resolver::ResolverError>
     {
         // Return minimal metadata with supported auth method "none" and DPoP support
···
 
     async fn get_resource_server_metadata(
         &self,
-        _pds: &url::Url,
+        _pds: &CowStr<'_>,
     ) -> Result<OAuthAuthorizationServerMetadata<'static>, jacquard_oauth::resolver::ResolverError>
     {
         // Return metadata pointing to the same issuer as above
···
     let session_data = ClientSessionData {
         account_did: Did::new_static("did:plc:alice").unwrap(),
         session_id: jacquard::CowStr::from("state"),
-        host_url: url::Url::parse("https://pds").unwrap(),
-        authserver_url: url::Url::parse("https://issuer").unwrap(),
+        host_url: CowStr::new_static("https://pds"),
+        authserver_url: CowStr::new_static("https://issuer"),
         authserver_token_endpoint: jacquard::CowStr::from("https://issuer/token"),
         authserver_revocation_endpoint: None,
         scopes: vec![Scope::Atproto],
···
     let data_store = ClientSessionData {
         account_did: Did::new_static("did:plc:alice").unwrap(),
         session_id: jacquard::CowStr::from("state"),
-        host_url: url::Url::parse("https://pds").unwrap(),
-        authserver_url: url::Url::parse("https://issuer").unwrap(),
+        host_url: CowStr::new_static("https://pds"),
+        authserver_url: CowStr::new_static("https://issuer"),
         authserver_token_endpoint: jacquard::CowStr::from("https://issuer/token"),
         authserver_revocation_endpoint: None,
         scopes: vec![Scope::Atproto],
···
     let session_data = ClientSessionData {
         account_did: Did::new_static("did:plc:alice").unwrap(),
         session_id: jacquard::CowStr::from("state"),
-        host_url: url::Url::parse("https://pds").unwrap(),
-        authserver_url: url::Url::parse("https://issuer").unwrap(),
+        host_url: CowStr::new_static("https://pds"),
+        authserver_url: CowStr::new_static("https://issuer"),
         authserver_token_endpoint: jacquard::CowStr::from("https://issuer/token"),
         authserver_revocation_endpoint: None,
         scopes: vec![Scope::Atproto],

crates/jacquard/tests/oauth_flow.rs

···
 
 use bytes::Bytes;
 use http::{Response as HttpResponse, StatusCode};
-use jacquard::IntoStatic;
 use jacquard::client::Agent;
 use jacquard::xrpc::XrpcClient;
+use jacquard::{CowStr, IntoStatic};
 use jacquard_common::http_client::HttpClient;
 use jacquard_oauth::atproto::AtprotoClientMetadata;
 use jacquard_oauth::authstore::ClientAuthStore;
···
     }
     async fn get_authorization_server_metadata(
         &self,
-        issuer: &url::Url,
+        issuer: &CowStr<'_>,
     ) -> Result<
         jacquard_oauth::types::OAuthAuthorizationServerMetadata<'static>,
         jacquard_oauth::resolver::ResolverError,
···
 
     async fn get_resource_server_metadata(
         &self,
-        _pds: &url::Url,
+        _pds: &CowStr<'_>,
     ) -> Result<
         jacquard_oauth::types::OAuthAuthorizationServerMetadata<'static>,
         jacquard_oauth::resolver::ResolverError,
···
     // Construct authorization URL as OAuthClient::start_auth would do
     #[derive(serde::Serialize)]
     struct Parameters<'s> {
-        client_id: url::Url,
+        client_id: CowStr<'s>,
         request_uri: jacquard::CowStr<'s>,
     }
     let auth_url = format!(