diff --git a/main.go b/main.go
index e83ef30..51ed911 100644
--- a/main.go
+++ b/main.go
@@ -13,8 +13,10 @@ import (
 	"log"
 	"net"
 	"net/http"
+	"net/url"
 	"os"
 	"os/signal"
+	"path"
 	"path/filepath"
 	"runtime"
 	"runtime/pprof"
@@ -28,6 +30,7 @@ import (
 
 	"source.toby3d.me/toby3d/home/internal/common"
 	"source.toby3d.me/toby3d/home/internal/domain"
+	"source.toby3d.me/toby3d/home/internal/middleware"
 	"source.toby3d.me/toby3d/home/internal/page"
 	pagefsrepo "source.toby3d.me/toby3d/home/internal/page/repository/fs"
 	pageucase "source.toby3d.me/toby3d/home/internal/page/usecase"
@@ -80,117 +83,151 @@ func NewApp(ctx context.Context, config *domain.Config) (*App, error) {
 	pages := pagefsrepo.NewFileSystemPageRepository(contentDir)
 	pager := pageucase.NewPageUseCase(pages, resources)
 
-	server := &http.Server{
-		Addr: config.AddrPort().String(),
-		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			// TODO(toby3d): use exists static use case or split that on static and resource modules?
-			// INFO(toby3d): any static file is public and unprotected by design, so it's safe to search it
-			// first before deep down to any page or it's resource which might be secured by middleware or
-			// something else.
-			static, err := statics.Get(r.Context(), strings.TrimPrefix(r.URL.Path, "/"))
-			if err == nil {
-				http.ServeContent(w, r, static.Name(), domain.ResourceModTime(static), static)
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// TODO(toby3d): use exists static use case or split that on static and resource modules?
+		// INFO(toby3d): any static file is public and unprotected by design, so it's safe to search it first
+		// before deep down to any page or it's resource which might be secured by middleware or something else.
+		static, err := statics.Get(r.Context(), strings.TrimPrefix(r.URL.Path, "/"))
+		if err == nil {
+			http.ServeContent(w, r, static.Name(), domain.ResourceModTime(static), static)
+
+			return
+		}
+
+		lang := domain.LanguageUnd
+
+		s, err := siter.Do(r.Context(), lang)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+
+			return
+		}
+
+		if s.IsMultiLingual() {
+			head, tail := urlutil.ShiftPath(r.URL.Path)
+
+			if head == "" {
+				supported := make([]language.Tag, len(s.Languages))
+				for i := range s.Languages {
+					supported[i] = language.Make(s.Languages[i].Lang())
+				}
+
+				if s.DefaultLanguage != domain.LanguageUnd {
+					supported = append(
+						[]language.Tag{language.Make(s.DefaultLanguage.Code())},
+						supported...,
+					)
+				}
+
+				requested, _, err := language.ParseAcceptLanguage(
+					r.Header.Get(common.HeaderAcceptLanguage))
+				if err != nil || len(requested) == 0 {
+					requested = append(requested, language.English)
+				}
+
+				matched, _, _ := language.NewMatcher(supported).Match(requested...)
+				lang = domain.NewLanguage(matched.String())
+
+				http.Redirect(w, r, "/"+lang.Lang()+"/", http.StatusSeeOther)
 
 				return
 			}
 
-			lang := domain.LanguageUnd
+			lang = domain.NewLanguage(head)
+			r.URL.Path = tail
+		}
 
-			s, err := siter.Do(r.Context(), lang)
-			if err != nil {
+		if s, err = siter.Do(r.Context(), lang); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+
+			return
+		}
+
+		p, err := pager.Do(r.Context(), lang, r.URL.Path)
+		if err != nil {
+			if !errors.Is(err, page.ErrNotExist) {
 				http.Error(w, err.Error(), http.StatusInternalServerError)
 
 				return
 			}
 
-			if s.IsMultiLingual() {
-				head, tail := urlutil.ShiftPath(r.URL.Path)
-
-				if head == "" {
-					supported := make([]language.Tag, len(s.Languages))
-					for i := range s.Languages {
-						supported[i] = language.Make(s.Languages[i].Lang())
-					}
-
-					if s.DefaultLanguage != domain.LanguageUnd {
-						supported = append(
-							[]language.Tag{language.Make(s.DefaultLanguage.Code())},
-							supported...,
-						)
-					}
-
-					requested, _, err := language.ParseAcceptLanguage(
-						r.Header.Get(common.HeaderAcceptLanguage))
-					if err != nil || len(requested) == 0 {
-						requested = append(requested, language.English)
-					}
-
-					matched, _, _ := language.NewMatcher(supported).Match(requested...)
-					lang = domain.NewLanguage(matched.String())
-
-					http.Redirect(w, r, "/"+lang.Lang()+"/", http.StatusSeeOther)
+			res, err := resourcer.Do(r.Context(), r.URL.Path)
+			if err != nil {
+				if errors.Is(err, fs.ErrNotExist) {
+					http.Error(w, err.Error(), http.StatusNotFound)
 
 					return
 				}
 
-				lang = domain.NewLanguage(head)
-				r.URL.Path = tail
-			}
-
-			if s, err = siter.Do(r.Context(), lang); err != nil {
 				http.Error(w, err.Error(), http.StatusInternalServerError)
 
 				return
 			}
 
-			p, err := pager.Do(r.Context(), lang, r.URL.Path)
-			if err != nil {
-				if !errors.Is(err, page.ErrNotExist) {
-					http.Error(w, err.Error(), http.StatusInternalServerError)
+			http.ServeContent(w, r, res.Name(), domain.ResourceModTime(res), res)
 
-					return
+			return
+		}
+
+		contentLanguage := make([]string, len(p.Translations))
+		for i := range p.Translations {
+			contentLanguage[i] = p.Translations[i].Language.Code()
+		}
+
+		w.Header().Set(common.HeaderContentLanguage, strings.Join(contentLanguage, ", "))
+
+		tpl, err := themer.Do(r.Context())
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+
+			return
+		}
+
+		w.Header().Set(common.HeaderContentType, common.MIMETextHTMLCharsetUTF8)
+		if err = tpl.Execute(w, &Context{
+			Site: s,
+			Page: p,
+		}); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+	})
+
+	mw := middleware.Chain{
+		middleware.Redirect(middleware.RedirectConfig{
+			Code: http.StatusSeeOther,
+			Skipper: func(r *http.Request) bool {
+				return r.UserAgent() != "TelegramBot (like TwitterBot)"
+			},
+		}, func(u *url.URL) (string, bool) {
+			s, err := siter.Do(ctx, domain.LanguageUnd)
+			if err != nil {
+				return "", false
+			}
+
+			if ivHash, ok := s.Params["instantViewHash"].(string); ok {
+				target := &url.URL{
+					Scheme: "https",
+					Host:   "t.me",
+					Path:   path.Join("/share", "url"),
 				}
 
-				res, err := resourcer.Do(r.Context(), r.URL.Path)
-				if err != nil {
-					if errors.Is(err, fs.ErrNotExist) {
-						http.Error(w, err.Error(), http.StatusNotFound)
+				q := target.Query()
 
-						return
-					}
+				q.Set("url", u.String())
+				q.Set("hash", ivHash)
 
-					http.Error(w, err.Error(), http.StatusInternalServerError)
+				target.RawQuery = q.Encode()
 
-					return
-				}
-
-				http.ServeContent(w, r, res.Name(), domain.ResourceModTime(res), res)
-
-				return
+				return target.String(), ok
 			}
 
-			contentLanguage := make([]string, len(p.Translations))
-			for i := range p.Translations {
-				contentLanguage[i] = p.Translations[i].Language.Code()
-			}
-
-			w.Header().Set(common.HeaderContentLanguage, strings.Join(contentLanguage, ", "))
-
-			tpl, err := themer.Do(r.Context())
-			if err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-
-				return
-			}
-
-			w.Header().Set(common.HeaderContentType, common.MIMETextHTMLCharsetUTF8)
-			if err = tpl.Execute(w, &Context{
-				Site: s,
-				Page: p,
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
+			return "", false
 		}),
+	}
+
+	server := &http.Server{
+		Addr:         config.AddrPort().String(),
+		Handler:      mw.Handler(handler),
 		ErrorLog:     logger,
 		BaseContext:  func(ln net.Listener) context.Context { return ctx },
 		WriteTimeout: 500 * time.Millisecond,