diff --git a/.gitignore b/.gitignore
index e5067852..64faee7b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,5 @@ client_session_key.aes
 cabal-dev/
 yesod/foobar/
 .virthualenv
+/vendor/
+/.shelly/
diff --git a/.travis.yml b/.travis.yml
index a2a948b3..bac77556 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,13 @@
 language: haskell
 
 install:
+    - cabal update
     - cabal install mega-sdist hspec cabal-meta cabal-src
-    - cabal-meta install --force-reinstalls
+    - git clone https://github.com/snoyberg/tagstream-conduit.git
+    - cd tagstream-conduit
+    - cabal-src-install --src-only
+    - cd ..
+    - cabal-meta install --force-reinstalls --enable-tests
 
-script: mega-sdist --test
+script:
+    - echo Done
diff --git a/demo/appcache/AppCache.hs b/demo/appcache/AppCache.hs
new file mode 100644
index 00000000..5283d17a
--- /dev/null
+++ b/demo/appcache/AppCache.hs
@@ -0,0 +1,60 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell   #-}
+module AppCache where
+
+import           Control.Monad              (when)
+import           Control.Monad.Trans.Writer
+import           Data.Hashable              (hashWithSalt)
+import           Data.List                  (intercalate)
+import qualified Data.Set                   as Set
+import           Data.Text                  (Text)
+import           Data.Text                  (pack)
+import           Language.Haskell.TH.Syntax
+import           Yesod.Core
+import           Yesod.Routes.TH
+
+newtype AppCache = AppCache { unAppCache :: Text }
+
+appCache :: [ResourceTree String] -> Q Exp
+appCache trees = do
+    piecesSet <- execWriterT $ mapM_ (goTree id) trees
+    let body = unlines $ map toPath $ Set.toList piecesSet
+        hash = hashWithSalt 0 body
+        total = concat
+            [ "CACHE MANIFEST\n# Version: "
+            , show hash
+            , "\n\nCACHE:\n"
+            , body
+            ]
+    [|return (AppCache (pack total))|]
+  where
+    toPath [] = "/"
+    toPath x = concatMap ('/':) x
+
+goTree :: Monad m
+       => ([String] -> [String])
+       -> ResourceTree String
+       -> WriterT (Set.Set [String]) m ()
+goTree front (ResourceLeaf res) = do
+    pieces' <- goPieces (resourceName res) $ resourcePieces res
+    when ("CACHE" `elem` resourceAttrs res) $
+        tell $ Set.singleton $ front pieces'
+goTree front (ResourceParent name pieces trees) = do
+    pieces' <- goPieces name pieces
+    mapM_ (goTree $ front . (pieces' ++)) trees
+
+goPieces :: Monad m => String -> [(CheckOverlap, Piece String)] -> m [String]
+goPieces name =
+    mapM (goPiece . snd)
+  where
+    goPiece (Static s) = return s
+    goPiece (Dynamic _) = fail $ concat
+        [ "AppCache only applies to fully-static paths, but "
+        , name
+        , " has dynamic pieces."
+        ]
+
+instance ToContent AppCache where
+    toContent = toContent . unAppCache
+instance ToTypedContent AppCache where
+    toTypedContent = TypedContent "text/cache-manifest" . toContent
diff --git a/demo/appcache/Main.hs b/demo/appcache/Main.hs
new file mode 100644
index 00000000..d48c6830
--- /dev/null
+++ b/demo/appcache/Main.hs
@@ -0,0 +1,23 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeFamilies          #-}
+import           AppCache
+import           Routes
+import           Yesod.Core
+
+instance Yesod App
+
+mkYesodDispatch "App" resourcesApp
+
+getHomeR :: Handler String
+getHomeR = return "Hello"
+
+getSomethingR :: Handler String
+getSomethingR = return "Hello"
+
+getAppCacheR :: Handler AppCache
+getAppCacheR = $(appCache resourcesApp)
+
+main :: IO ()
+main = warp 3000 App
diff --git a/demo/appcache/Routes.hs b/demo/appcache/Routes.hs
new file mode 100644
index 00000000..78f2826b
--- /dev/null
+++ b/demo/appcache/Routes.hs
@@ -0,0 +1,15 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeFamilies          #-}
+module Routes where
+
+import           Yesod.Core
+
+data App = App
+
+mkYesodData "App" [parseRoutes|
+/ HomeR GET
+/some/thing SomethingR GET !CACHE
+/appcache AppCacheR GET
+|]
diff --git a/demo/lite/lite.hs b/demo/lite/lite.hs
new file mode 100644
index 00000000..4c9e2fa6
--- /dev/null
+++ b/demo/lite/lite.hs
@@ -0,0 +1,21 @@
+{-# LANGUAGE OverloadedStrings #-}
+import Yesod.Core
+import Data.Aeson
+import Data.Monoid ((<>))
+import Data.Text (Text, pack)
+
+people :: [(Text, Int)]
+people = [("Alice", 25), ("Bob", 43), ("Charlie", 37)]
+
+main = warp 3000 $ liteApp $ do
+    onStatic "people" $ dispatchTo getPeople
+    onStatic "person" $ withDynamic $ dispatchTo . getPerson
+
+getPeople = return $ toJSON $ map fst people
+
+getPerson name =
+    case lookup name people of
+        Nothing -> notFound
+        Just age -> selectRep $ do
+            provideRep $ return $ object ["name" .= name, "age" .= age]
+            provideRep $ return $ name <> " is " <> pack (show age) <> " years old"
diff --git a/demo/streaming-db/streaming-db.hs b/demo/streaming-db/streaming-db.hs
new file mode 100644
index 00000000..bcc0b2e9
--- /dev/null
+++ b/demo/streaming-db/streaming-db.hs
@@ -0,0 +1,67 @@
+{-# LANGUAGE EmptyDataDecls    #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE GADTs             #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE TypeFamilies      #-}
+import           Control.Monad.Logger    (runNoLoggingT)
+import           Data.Conduit            (awaitForever, runResourceT, ($=))
+import           Data.Text               (Text)
+import           Database.Persist.Sqlite (ConnectionPool, SqlPersist,
+                                          SqliteConf (..), runMigration,
+                                          runSqlPool)
+import           Database.Persist.Store  (createPoolConfig)
+import           Yesod.Core
+import           Yesod.Persist
+
+share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persist|
+Person
+    name Text
+|]
+
+data App = App
+    { appConfig :: SqliteConf
+    , appPool   :: ConnectionPool
+    }
+
+mkYesod "App" [parseRoutes|
+/ HomeR GET
+|]
+
+instance Yesod App
+instance YesodPersist App where
+    type YesodPersistBackend App = SqlPersist
+    runDB = defaultRunDB appConfig appPool
+instance YesodPersistRunner App where
+    getDBRunner = defaultGetDBRunner appPool
+
+getHomeR :: Handler TypedContent
+getHomeR = do
+    runDB $ do
+        runMigration migrateAll
+        deleteWhere ([] :: [Filter Person])
+        insert_ $ Person "Charlie"
+        insert_ $ Person "Alice"
+        insert_ $ Person "Bob"
+    respondSourceDB typePlain $ selectSource [] [Asc PersonName] $= awaitForever toBuilder
+  where
+    toBuilder (Entity _ (Person name)) = do
+        sendChunkText name
+        sendChunkText "\n"
+        sendFlush
+
+main :: IO ()
+main = do
+    let config = SqliteConf ":memory:" 1
+    pool <- createPoolConfig config
+    runNoLoggingT $ runResourceT $ flip runSqlPool pool $ do
+        runMigration migrateAll
+        deleteWhere ([] :: [Filter Person])
+        insert_ $ Person "Charlie"
+        insert_ $ Person "Alice"
+        insert_ $ Person "Bob"
+    warp 3000 App
+        { appConfig = config
+        , appPool = pool
+        }
diff --git a/demo/streaming/streaming.hs b/demo/streaming/streaming.hs
new file mode 100644
index 00000000..481759ba
--- /dev/null
+++ b/demo/streaming/streaming.hs
@@ -0,0 +1,48 @@
+{-# LANGUAGE OverloadedStrings, TemplateHaskell, QuasiQuotes, TypeFamilies #-}
+import Yesod.Core
+import Data.Conduit
+import qualified Data.Conduit.Binary as CB
+import Control.Concurrent.Lifted (threadDelay)
+import Data.Monoid ((<>))
+import qualified Data.Text as T
+import Control.Monad (forM_)
+
+data App = App
+
+mkYesod "App" [parseRoutes|
+/ HomeR GET
+|]
+
+instance Yesod App
+
+fibs :: [Int]
+fibs = 1 : 1 : zipWith (+) fibs (tail fibs)
+
+getHomeR :: Handler TypedContent
+getHomeR = do
+    value <- lookupGetParam "x"
+    case value of
+        Just "file" -> respondSource typePlain $ do
+            sendChunkText "Going to read a file\n\n"
+            CB.sourceFile "streaming.hs" $= awaitForever sendChunkBS
+            sendChunkText "Finished reading the file\n"
+        Just "fibs" -> respondSource typePlain $ do
+            forM_ fibs $ \fib -> do
+                $logError $ "Got fib: " <> T.pack (show fib)
+                sendChunkText $ "Next fib is: " <> T.pack (show fib) <> "\n"
+                yield Flush
+                sendFlush
+                threadDelay 1000000
+        _ -> fmap toTypedContent $ defaultLayout $ do
+            setTitle "Streaming"
+            [whamlet|
+                <p>Notice how in the code above we perform selection before starting the stream.
+                <p>Anyway, choose one of the options below.
+                <ul>
+                    <li>
+                        <a href=?x=file>Read a file
+                    <li>
+                        <a href=?x=fibs>See the fibs
+            |]
+
+main = warp 3000 App
diff --git a/demo/subsite/Main.hs b/demo/subsite/Main.hs
new file mode 100644
index 00000000..387b259c
--- /dev/null
+++ b/demo/subsite/Main.hs
@@ -0,0 +1,40 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeFamilies          #-}
+module Main where
+
+import           Control.Applicative ((<$>))
+import           Wiki
+import           Yesod
+
+-- A very simple App, doesn't do anything except provide the Wiki.
+data App = App
+    { appWiki :: Wiki
+    }
+
+mkYesod "App" [parseRoutes|
+/ HomeR GET
+/wiki WikiR Wiki appWiki
+|]
+
+instance Yesod App
+instance YesodWiki App -- Just use the defaults
+instance RenderMessage App FormMessage where
+    renderMessage _ _ = defaultFormMessage
+
+getHomeR :: Handler Html
+getHomeR = defaultLayout
+    [whamlet|
+        <p>
+            Welcome to my test application.
+            The application is pretty boring.
+            You probably want to go to
+            <a href=@{WikiR WikiHomeR}>the wiki#
+            .
+    |]
+
+main :: IO ()
+main = do
+    app <- App <$> newWiki
+    warp 3000 app
diff --git a/demo/subsite/Wiki.hs b/demo/subsite/Wiki.hs
new file mode 100644
index 00000000..a7722c74
--- /dev/null
+++ b/demo/subsite/Wiki.hs
@@ -0,0 +1,147 @@
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE RankNTypes            #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeFamilies          #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+-- | Define the dispatch for a Wiki. You should probably start off by reading
+-- WikiRoutes.
+module Wiki
+    ( module WikiRoutes
+    ) where
+
+import           Control.Applicative ((<$>))
+import           Control.Monad       (unless)
+import           Data.IORef.Lifted   (readIORef, atomicModifyIORef)
+import           Data.Map            (Map)
+import qualified Data.Map            as Map
+import           Data.Text           (Text)
+import           WikiRoutes
+import           Yesod
+
+-- | A subsite needs to be an instance of YesodSubDispatch, which states how to
+-- dispatch. By using constraints, we can make requirements of our master site.
+-- In this example, we're saying that the master site must be an instance of
+-- YesodWiki.
+instance YesodWiki master => YesodSubDispatch Wiki (HandlerT master IO) where
+    -- | This is all the TH magic for dispatch. WikiRoutes provides the
+    -- resourcesWiki value automatically, and mkYesodSubDispatch will generate
+    -- a dispatch function that will call out to the appropriate handler
+    -- functions.
+    yesodSubDispatch = $(mkYesodSubDispatch resourcesWiki)
+
+-- | Helper type synonym to be used below.
+type WikiHandler a = forall master. YesodWiki master
+                  => HandlerT Wiki (HandlerT master IO) a
+
+------------- Helper functions
+
+-- | Get all of the content in the Wiki.
+getContent :: WikiHandler (Map Texts Textarea)
+getContent = getYesod >>= readIORef . wikiContent
+
+-- | Put a single new value into the Wiki.
+putContent :: Texts -> Textarea -> WikiHandler ()
+putContent k v = do
+    refMap <- wikiContent <$> getYesod
+    atomicModifyIORef refMap $ \m -> (Map.insert k v m, ())
+
+-- | Gets the homepage, which lists all of the pages available.
+getWikiHomeR :: WikiHandler TypedContent
+getWikiHomeR = do
+    content <- getContent
+    -- We use the new selectRep/provideRep functionality to provide either an
+    -- HTML or JSON representation of the page. You could just as easily
+    -- provide YAML, plain text, RSS, or anything else.
+    selectRep $ do
+        provideRep $ do
+            -- We'll use toParent to convert Wiki routes into our master site
+            -- routes.
+            toParent <- getRouteToParent
+
+            -- Run the master site's defaultLayout to style the page.
+            lift $ defaultLayout
+                [whamlet|
+                    <p>This wiki has the following pages:
+                    <ul>
+                        $forall page <- Map.keys content
+                            <li>
+                                -- Notice the usage of toParent!
+                                <a href=@{toParent $ WikiReadR page}>#{show page}
+                |]
+        -- You provide a JSON representation just by returning a JSON value.
+        -- aeson's toJSON make it easy to convert a list of values into JSON.
+        provideRep $ return $ toJSON $ Map.keys content
+
+getWikiReadR :: Texts -> WikiHandler TypedContent
+getWikiReadR page = do
+    content <- getContent
+    selectRep $ do
+        provideRep $
+            case Map.lookup page content of
+                Nothing -> do
+                    setMessage $ "Page does not exist, please create it."
+
+                    -- We don't need to convert or lift here: we're using a
+                    -- route from our subsite, and redirect lives in our
+                    -- subsite.
+                    redirect $ WikiEditR page
+                Just t -> do
+                    toParent <- getRouteToParent
+
+                    -- Notice that we lift the canEditPage function from the
+                    -- master site.
+                    canEdit <- lift $ canEditPage page
+
+                    lift $ defaultLayout
+                        [whamlet|
+                            <article>#{t}
+                            $if canEdit
+                                <p>
+                                    <a href=@{toParent $ WikiEditR page}>Edit
+                        |]
+        provideRep $ return $ toJSON $
+            case Map.lookup page content of
+                -- Our HTML representation sends a redirect if the page isn't
+                -- found, but our JSON representation just returns a JSON value
+                -- instead.
+                Nothing -> object ["error" .= ("Page not found" :: Text)]
+                Just (Textarea t) -> object ["content" .= t]
+
+getWikiEditR :: Texts -> WikiHandler Html
+getWikiEditR page = do
+    canEdit <- lift $ canEditPage page
+    unless canEdit $ permissionDenied "You do not have permissions to edit this page."
+
+    content <- getContent
+    let form = renderTable
+             $ areq textareaField "Content" (Map.lookup page content)
+
+    -- We need to use lift here since the widget will be used below.
+    -- Practically speaking, this means that we'll be rendering form messages
+    -- using the master site's translation functions.
+    ((res, widget), enctype) <- lift $ runFormPost form
+
+    case res of
+        FormSuccess t -> do
+            putContent page t
+            setMessage "Content updated"
+            redirect $ WikiEditR page
+        _ -> do
+            toParent <- getRouteToParent
+            lift $ defaultLayout
+                [whamlet|
+                    <p>
+                        <a href=@{toParent $ WikiReadR page}>Read page
+                    <form method=post action=@{toParent $ WikiEditR page} enctype=#{enctype}>
+                        <table>
+                            ^{widget}
+                            <tr>
+                                <td colspan=2>
+                                    <button>Update page
+                |]
+
+postWikiEditR :: Texts -> WikiHandler Html
+postWikiEditR = getWikiEditR
diff --git a/demo/subsite/WikiRoutes.hs b/demo/subsite/WikiRoutes.hs
new file mode 100644
index 00000000..f22c0222
--- /dev/null
+++ b/demo/subsite/WikiRoutes.hs
@@ -0,0 +1,41 @@
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeFamilies          #-}
+-- | Define our Wiki data type, routes, and the YesodWiki typeclass. Due to the
+-- GHC stage restriction, the routes must be declared in a separate module from
+-- our dispatch instance.
+module WikiRoutes where
+
+import           Control.Monad          (liftM)
+import           Control.Monad.IO.Class (MonadIO)
+import           Data.IORef             (IORef, newIORef)
+import           Data.Map               (Map, empty)
+import           Yesod
+
+-- | Simple Wiki datatype: just store a Map from Wiki path to the contents of
+-- the page.
+data Wiki = Wiki
+    { wikiContent :: IORef (Map Texts Textarea)
+    }
+
+-- | A typeclass that all master sites that want a Wiki must implement. A
+-- master must be able to render form messages, as we use yesod-forms for
+-- processing user input.
+class (RenderMessage master FormMessage, Yesod master) => YesodWiki master where
+    -- | Write protection. By default, no protection.
+    canEditPage :: Texts -> HandlerT master IO Bool
+    canEditPage _ = return True
+
+-- | Define our routes. We'll have a homepage that lists all of the pages, a
+-- read route for reading a page, and an edit route.
+mkYesodSubData "Wiki" [parseRoutes|
+/ WikiHomeR GET
+/read/*Texts WikiReadR GET
+/edit/*Texts WikiEditR GET POST
+|]
+
+-- | A convenience function for creating an empty Wiki.
+newWiki :: MonadIO m => m Wiki
+newWiki = Wiki `liftM` liftIO (newIORef empty)
diff --git a/sources.txt b/sources.txt
index 3830938b..7f19d275 100644
--- a/sources.txt
+++ b/sources.txt
@@ -1,12 +1,12 @@
 ./yesod-routes
 ./yesod-core
-./yesod-json
 ./yesod-static
 ./yesod-persistent
 ./yesod-newsfeed
 ./yesod-form
 ./yesod-auth
 ./yesod-sitemap
-./yesod-default
 ./yesod-test
+./yesod-bin
 ./yesod
+https://github.com/yesodweb/persistent persistent1.2
diff --git a/yesod-auth/Yesod/Auth.hs b/yesod-auth/Yesod/Auth.hs
index 8c560c70..19448c75 100644
--- a/yesod-auth/Yesod/Auth.hs
+++ b/yesod-auth/Yesod/Auth.hs
@@ -1,4 +1,6 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE QuasiQuotes, TypeFamilies, TemplateHaskell #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
@@ -15,6 +17,8 @@ module Yesod.Auth
     , AuthPlugin (..)
     , getAuth
     , YesodAuth (..)
+    , YesodAuthPersist
+    , AuthEntity
       -- * Plugin interface
     , Creds (..)
     , setCreds
@@ -26,11 +30,14 @@ module Yesod.Auth
     , requireAuth
       -- * Exception
     , AuthException (..)
+      -- * Helper
+    , AuthHandler
     ) where
 
-import Control.Monad                 (when)  
+import Control.Monad                 (when)
 import Control.Monad.Trans.Maybe
 
+import Yesod.Auth.Routes
 import Data.Aeson
 import Data.Text.Encoding (decodeUtf8With)
 import Data.Text.Encoding.Error (lenientDecode)
@@ -39,31 +46,28 @@ import qualified Data.Text as T
 import qualified Data.HashMap.Lazy as Map
 import Network.HTTP.Conduit (Manager)
 
-import Language.Haskell.TH.Syntax hiding (lift)
-
 import qualified Network.Wai as W
 import Text.Hamlet (shamlet)
 
 import Yesod.Core
 import Yesod.Persist
-import Yesod.Json
 import Yesod.Auth.Message (AuthMessage, defaultMessage)
 import qualified Yesod.Auth.Message as Msg
 import Yesod.Form (FormMessage)
 import Data.Typeable (Typeable)
 import Control.Exception (Exception)
 
-data Auth = Auth
-
 type AuthRoute = Route Auth
 
+type AuthHandler master a = YesodAuth master => HandlerT Auth (HandlerT master IO) a
+
 type Method = Text
 type Piece = Text
 
 data AuthPlugin master = AuthPlugin
     { apName :: Text
-    , apDispatch :: Method -> [Piece] -> GHandler Auth master ()
-    , apLogin :: forall sub. (Route Auth -> Route master) -> GWidget sub master ()
+    , apDispatch :: Method -> [Piece] -> AuthHandler master ()
+    , apLogin :: (Route Auth -> Route master) -> WidgetT master IO ()
     }
 
 getAuth :: a -> Auth
@@ -88,23 +92,25 @@ class (Yesod master, PathPiece (AuthId master), RenderMessage master FormMessage
     logoutDest :: master -> Route master
 
     -- | Determine the ID associated with the set of credentials.
-    getAuthId :: Creds master -> GHandler sub master (Maybe (AuthId master))
+    getAuthId :: Creds master -> HandlerT master IO (Maybe (AuthId master))
 
     -- | Which authentication backends to use.
     authPlugins :: master -> [AuthPlugin master]
 
     -- | What to show on the login page.
-    loginHandler :: GHandler Auth master RepHtml
-    loginHandler = defaultLayout $ do
-        setTitleI Msg.LoginTitle
-        tm <- lift getRouteToMaster
-        master <- lift getYesod
-        mapM_ (flip apLogin tm) (authPlugins master)
+    loginHandler :: AuthHandler master RepHtml
+    loginHandler = do
+        tp <- getRouteToParent
+        lift $ defaultLayout $ do
+            setTitleI Msg.LoginTitle
+            master <- getYesod
+            mapM_ (flip apLogin tp) (authPlugins master)
 
     -- | Used for i18n of messages provided by this package.
     renderAuthMessage :: master
                       -> [Text] -- ^ languages
-                      -> AuthMessage -> Text
+                      -> AuthMessage
+                      -> Text
     renderAuthMessage _ _ = defaultMessage
 
     -- | After login and logout, redirect to the referring page, instead of
@@ -120,11 +126,11 @@ class (Yesod master, PathPiece (AuthId master), RenderMessage master FormMessage
 
     -- | Called on a successful login. By default, calls
     -- @setMessageI NowLoggedIn@.
-    onLogin :: GHandler sub master ()
+    onLogin :: HandlerT master IO ()
     onLogin = setMessageI Msg.NowLoggedIn
 
     -- | Called on logout. By default, does nothing
-    onLogout :: GHandler sub master ()
+    onLogout :: HandlerT master IO ()
     onLogout = return ()
 
     -- | Retrieves user credentials, if user is authenticated.
@@ -135,8 +141,20 @@ class (Yesod master, PathPiece (AuthId master), RenderMessage master FormMessage
     -- especially useful for creating an API to be accessed via some means
     -- other than a browser.
     --
-    -- Since 1.1.2
-    maybeAuthId :: GHandler sub master (Maybe (AuthId master))
+    -- Since 1.2.0
+    maybeAuthId :: HandlerT master IO (Maybe (AuthId master))
+
+    default maybeAuthId
+        :: ( YesodAuth master
+           , PersistMonadBackend (b (HandlerT master IO)) ~ PersistEntityBackend val
+           , b ~ YesodPersistBackend master
+           , Key val ~ AuthId master
+           , PersistStore (b (HandlerT master IO))
+           , PersistEntity val
+           , YesodPersist master
+           , Typeable val
+           )
+        => HandlerT master IO (Maybe (AuthId master))
     maybeAuthId = defaultMaybeAuthId
 
 credsKey :: Text
@@ -144,50 +162,80 @@ credsKey = "_ID"
 
 -- | Retrieves user credentials from the session, if user is authenticated.
 --
+-- This function does /not/ confirm that the credentials are valid, see
+-- 'maybeAuthIdRaw' for more information.
+--
 -- Since 1.1.2
-defaultMaybeAuthId :: YesodAuth master
-                   => GHandler sub master (Maybe (AuthId master))
+defaultMaybeAuthId
+          :: ( YesodAuth master
+             , PersistMonadBackend (b (HandlerT master IO)) ~ PersistEntityBackend val
+             , b ~ YesodPersistBackend master
+             , Key val ~ AuthId master
+             , PersistStore (b (HandlerT master IO))
+             , PersistEntity val
+             , YesodPersist master
+             , Typeable val
+             ) => HandlerT master IO (Maybe (AuthId master))
 defaultMaybeAuthId = do
     ms <- lookupSession credsKey
     case ms of
         Nothing -> return Nothing
-        Just s -> return $ fromPathPiece s
+        Just s ->
+            case fromPathPiece s of
+                Nothing -> return Nothing
+                Just aid -> fmap (fmap entityKey) $ cachedAuth aid
 
-mkYesodSub "Auth"
-    [ ClassP ''YesodAuth [VarT $ mkName "master"]
-    ]
-#define STRINGS *Texts
-    [parseRoutes|
-/check                 CheckR      GET
-/login                 LoginR      GET
-/logout                LogoutR     GET POST
-/page/#Text/STRINGS PluginR
-|]
+cachedAuth :: ( YesodAuth master
+             , PersistMonadBackend (b (HandlerT master IO)) ~ PersistEntityBackend val
+             , b ~ YesodPersistBackend master
+             , Key val ~ AuthId master
+             , PersistStore (b (HandlerT master IO))
+             , PersistEntity val
+             , YesodPersist master
+             , Typeable val
+             ) => AuthId master -> HandlerT master IO (Maybe (Entity val))
+cachedAuth aid = runMaybeT $ do
+    a <- MaybeT $ fmap unCachedMaybeAuth
+                $ cached
+                $ fmap CachedMaybeAuth
+                $ runDB
+                $ get aid
+    return $ Entity aid a
 
 -- | Sets user credentials for the session after checking them with authentication backends.
 setCreds :: YesodAuth master
          => Bool         -- ^ if HTTP redirects should be done
          -> Creds master -- ^ new credentials
-         -> GHandler sub master ()
+         -> HandlerT master IO ()
 setCreds doRedirects creds = do
     y    <- getYesod
     maid <- getAuthId creds
     case maid of
-        Nothing ->
-          when doRedirects $ do
+        Nothing -> when doRedirects $ do
             case authRoute y of
-              Nothing -> do rh <- defaultLayout $ toWidget [shamlet|
-$newline never
-<h1>Invalid login
-|]
-                            sendResponse rh
-              Just ar -> do setMessageI Msg.InvalidLogin
-                            redirect ar
+                Nothing -> do
+                    res <- selectRep $ do
+                        provideRep $ defaultLayout $ toWidget [shamlet|<h1>Invalid login|]
+                        provideRep $ return $ object ["message" .= ("Invalid Login" :: Text)]
+                    sendResponse res
+                Just ar -> do
+                    res <- selectRep $ do
+                        provideRepType typeHtml $ do
+                            setMessageI Msg.InvalidLogin
+                            _ <- redirect ar
+                            return ()
+                        provideRep $ return $ object ["message" .= ("Invalid Login" :: Text)]
+                    sendResponse res
         Just aid -> do
             setSession credsKey $ toPathPiece aid
             when doRedirects $ do
               onLogin
-              redirectUltDest $ loginDest y
+              res <- selectRep $ do
+                  provideRepType typeHtml $ do
+                      _ <- redirectUltDest $ loginDest y
+                      return ()
+                  provideRep $ return $ object ["message" .= ("Login Successful" :: Text)]
+              sendResponse res
 
 -- | Clears current user credentials for the session.
 --
@@ -202,12 +250,12 @@ clearCreds doRedirects = do
         onLogout
         redirectUltDest $ logoutDest y
 
-getCheckR :: YesodAuth master => GHandler Auth master RepHtmlJson
-getCheckR = do
+getCheckR :: AuthHandler master TypedContent
+getCheckR = lift $ do
     creds <- maybeAuthId
     defaultLayoutJson (do
         setTitle "Authentication Status"
-        toWidget $ html' creds) (jsonCreds creds)
+        toWidget $ html' creds) (return $ jsonCreds creds)
   where
     html' creds =
         [shamlet|
@@ -223,25 +271,32 @@ $nothing
             [ (T.pack "logged_in", Bool $ maybe False (const True) creds)
             ]
 
-setUltDestReferer' :: YesodAuth master => GHandler sub master ()
-setUltDestReferer' = do
+setUltDestReferer' :: AuthHandler master ()
+setUltDestReferer' = lift $ do
     master <- getYesod
     when (redirectToReferer master) setUltDestReferer
 
-getLoginR :: YesodAuth master => GHandler Auth master RepHtml
+getLoginR :: AuthHandler master RepHtml
 getLoginR = setUltDestReferer' >> loginHandler
 
-getLogoutR :: YesodAuth master => GHandler Auth master ()
-getLogoutR = do
-    tm <- getRouteToMaster
-    setUltDestReferer' >> redirectToPost (tm LogoutR)
+getLogoutR :: AuthHandler master ()
+getLogoutR = setUltDestReferer' >> redirectToPost LogoutR
 
+<<<<<<< HEAD
 postLogoutR :: YesodAuth master => GHandler Auth master ()
 postLogoutR = clearCreds True
+=======
+postLogoutR :: AuthHandler master ()
+postLogoutR = lift $ do
+    y <- getYesod
+    deleteSession credsKey
+    onLogout
+    redirectUltDest $ logoutDest y
+>>>>>>> origin/yesod1.2
 
-handlePluginR :: YesodAuth master => Text -> [Text] -> GHandler Auth master ()
+handlePluginR :: Text -> [Text] -> AuthHandler master ()
 handlePluginR plugin pieces = do
-    master <- getYesod
+    master <- lift getYesod
     env <- waiRequest
     let method = decodeUtf8With lenientDecode $ W.requestMethod env
     case filter (\x -> apName x == plugin) (authPlugins master) of
@@ -249,45 +304,58 @@ handlePluginR plugin pieces = do
         ap:_ -> apDispatch ap method pieces
 
 maybeAuth :: ( YesodAuth master
-#if MIN_VERSION_persistent(1, 1, 0)
-             , PersistMonadBackend (b (GHandler sub master)) ~ PersistEntityBackend val
+             , PersistMonadBackend (b (HandlerT master IO)) ~ PersistEntityBackend val
              , b ~ YesodPersistBackend master
              , Key val ~ AuthId master
-             , PersistStore (b (GHandler sub master))
-#else
-             , b ~ YesodPersistBackend master
-             , b ~ PersistEntityBackend val
-             , Key b val ~ AuthId master
-             , PersistStore b (GHandler sub master)
-#endif
+             , PersistStore (b (HandlerT master IO))
              , PersistEntity val
              , YesodPersist master
-             ) => GHandler sub master (Maybe (Entity val))
+             , Typeable val
+             ) => HandlerT master IO (Maybe (Entity val))
 maybeAuth = runMaybeT $ do
-    aid <- MaybeT $ maybeAuthId
-    a   <- MaybeT $ runDB $ get aid
-    return $ Entity aid a
+    aid <- MaybeT maybeAuthId
+    MaybeT $ cachedAuth aid
 
-requireAuthId :: YesodAuth master => GHandler sub master (AuthId master)
+newtype CachedMaybeAuth val = CachedMaybeAuth { unCachedMaybeAuth :: Maybe val }
+    deriving Typeable
+
+-- | Constraint which states that the given site is an instance of @YesodAuth@
+-- and that its @AuthId@ is in fact a persistent @Key@ for the given value.
+-- This is the common case in Yesod, and means that you can easily look up the
+-- full informatin on a given user.
+--
+-- Since 1.2.0
+type YesodAuthPersist master =
+    ( YesodAuth master
+    , PersistMonadBackend (YesodPersistBackend master (HandlerT master IO))
+        ~ PersistEntityBackend (AuthEntity master)
+    , Key (AuthEntity master) ~ AuthId master
+    , PersistStore (YesodPersistBackend master (HandlerT master IO))
+    , PersistEntity (AuthEntity master)
+    , YesodPersist master
+    , Typeable (AuthEntity master)
+    )
+
+-- | If the @AuthId@ for a given site is a persistent ID, this will give the
+-- value for that entity. E.g.:
+--
+-- > type AuthId MySite = UserId
+-- > AuthEntity MySite ~ User
+--
+-- Since 1.2.0
+type AuthEntity master = KeyEntity (AuthId master)
+
+-- | Similar to 'maybeAuthId', but redirects to a login page if user is not
+-- authenticated.
+--
+-- Since 1.1.0
+requireAuthId :: YesodAuthPersist master => HandlerT master IO (AuthId master)
 requireAuthId = maybeAuthId >>= maybe redirectLogin return
 
-requireAuth :: ( YesodAuth master
-               , b ~ YesodPersistBackend master
-#if MIN_VERSION_persistent(1, 1, 0)
-               , PersistMonadBackend (b (GHandler sub master)) ~ PersistEntityBackend val
-               , Key val ~ AuthId master
-               , PersistStore (b (GHandler sub master))
-#else
-               , b ~ PersistEntityBackend val
-               , Key b val ~ AuthId master
-               , PersistStore b (GHandler sub master)
-#endif
-               , PersistEntity val
-               , YesodPersist master
-               ) => GHandler sub master (Entity val)
+requireAuth :: YesodAuthPersist master => HandlerT master IO (Entity (AuthEntity master))
 requireAuth = maybeAuth >>= maybe redirectLogin return
 
-redirectLogin :: Yesod master => GHandler sub master a
+redirectLogin :: Yesod master => HandlerT master IO a
 redirectLogin = do
     y <- getYesod
     setUltDestCurrent
@@ -302,3 +370,6 @@ data AuthException = InvalidBrowserIDAssertion
                    | InvalidFacebookResponse
     deriving (Show, Typeable)
 instance Exception AuthException
+
+instance YesodAuth master => YesodSubDispatch Auth (HandlerT master IO) where
+    yesodSubDispatch = $(mkYesodSubDispatch resourcesAuth)
diff --git a/yesod-auth/Yesod/Auth/BrowserId.hs b/yesod-auth/Yesod/Auth/BrowserId.hs
index 9aab88ac..402453b4 100644
--- a/yesod-auth/Yesod/Auth/BrowserId.hs
+++ b/yesod-auth/Yesod/Auth/BrowserId.hs
@@ -1,10 +1,14 @@
 {-# LANGUAGE QuasiQuotes #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE RecordWildCards #-}
 module Yesod.Auth.BrowserId
     ( authBrowserId
-    , authBrowserIdAudience
     , createOnClick
+    , def
+    , BrowserIdSettings
+    , bisAudience
+    , bisLazyLoad
     ) where
 
 import Yesod.Auth
@@ -14,14 +18,13 @@ import Yesod.Core
 import Text.Hamlet (hamlet)
 import qualified Data.Text as T
 import Data.Maybe (fromMaybe)
-import Control.Monad.IO.Class (liftIO)
-import Control.Monad (when)
+import Control.Monad (when, unless)
 import Control.Exception (throwIO)
 import Text.Julius (julius, rawJS)
-import Data.Aeson (toJSON)
 import Network.URI (uriPath, parseURI)
 import Data.FileEmbed (embedFile)
 import Data.ByteString (ByteString)
+import Data.Default
 
 pid :: Text
 pid = "browserid"
@@ -29,38 +32,50 @@ pid = "browserid"
 complete :: Route Auth
 complete = PluginR pid []
 
--- | Log into browser ID with an audience value determined from the 'approot'.
-authBrowserId :: YesodAuth m => AuthPlugin m
-authBrowserId = helper Nothing
+-- | A settings type for various configuration options relevant to BrowserID.
+--
+-- See: <http://www.yesodweb.com/book/settings-types>
+--
+-- Since 1.2.0
+data BrowserIdSettings = BrowserIdSettings
+    { bisAudience :: Maybe Text
+    -- ^ BrowserID audience value. If @Nothing@, will be extracted based on the
+    -- approot.
+    --
+    -- Default: @Nothing@
+    --
+    -- Since 1.2.0
+    , bisLazyLoad :: Bool
+    -- ^ Use asynchronous Javascript loading for the BrowserID JS file.
+    --
+    -- Default: @True@.
+    --
+    -- Since 1.2.0
+    }
 
--- | Log into browser ID with the given audience value. Note that this must be
--- your actual hostname, or login will fail.
-authBrowserIdAudience
-    :: YesodAuth m
-    => Text -- ^ audience
-    -> AuthPlugin m
-authBrowserIdAudience = helper . Just
+instance Default BrowserIdSettings where
+    def = BrowserIdSettings
+        { bisAudience = Nothing
+        , bisLazyLoad = True
+        }
 
-helper :: YesodAuth m
-       => Maybe Text -- ^ audience
-       -> AuthPlugin m
-helper maudience = AuthPlugin
+authBrowserId :: YesodAuth m => BrowserIdSettings -> AuthPlugin m
+authBrowserId bis@BrowserIdSettings {..} = AuthPlugin
     { apName = pid
     , apDispatch = \m ps ->
         case (m, ps) of
             ("GET", [assertion]) -> do
-                master <- getYesod
+                master <- lift getYesod
                 audience <-
-                    case maudience of
+                    case bisAudience of
                         Just a -> return a
                         Nothing -> do
-                            tm <- getRouteToMaster
                             r <- getUrlRender
-                            return $ T.takeWhile (/= '/') $ stripScheme $ r $ tm LoginR
+                            return $ T.takeWhile (/= '/') $ stripScheme $ r LoginR
                 memail <- lift $ checkAssertion audience assertion (authHttpManager master)
                 case memail of
                     Nothing -> liftIO $ throwIO InvalidBrowserIDAssertion
-                    Just email -> setCreds True Creds
+                    Just email -> lift $ setCreds True Creds
                         { credsPlugin = pid
                         , credsIdent = email
                         , credsExtra = []
@@ -72,12 +87,10 @@ helper maudience = AuthPlugin
             (_, []) -> badMethod
             _ -> notFound
     , apLogin = \toMaster -> do
-        onclick <- createOnClick toMaster
+        onclick <- createOnClick bis toMaster
 
-        autologin <- fmap (== Just "true") $ lift $ lookupGetParam "autologin"
-        when autologin $ toWidget [julius|
-#{rawJS onclick}();
-|]
+        autologin <- fmap (== Just "true") $ lookupGetParam "autologin"
+        when autologin $ toWidget [julius|#{rawJS onclick}();|]
 
         toWidget [hamlet|
 $newline never
@@ -92,29 +105,45 @@ $newline never
 
 -- | Generates a function to handle on-click events, and returns that function
 -- name.
-createOnClick :: (Route Auth -> Route master) -> GWidget sub master Text
-createOnClick toMaster = do
-    addScriptRemote browserIdJs
-    onclick <- lift newIdent
-    render <- lift getUrlRender
+createOnClick :: BrowserIdSettings
+              -> (Route Auth -> Route master)
+              -> WidgetT master IO Text
+createOnClick BrowserIdSettings {..} toMaster = do
+    unless bisLazyLoad $ addScriptRemote browserIdJs
+    onclick <- newIdent
+    render <- getUrlRender
     let login = toJSON $ getPath $ render (toMaster LoginR)
     toWidget [julius|
         function #{rawJS onclick}() {
-            navigator.id.watch({
-                onlogin: function (assertion) {
-                    if (assertion) {
-                        document.location = "@{toMaster complete}/" + assertion;
-                    }
-                },
-                onlogout: function () {}
-            });
-            navigator.id.request({
-                returnTo: #{login} + "?autologin=true"
-            });
+            if (navigator.id) {
+                navigator.id.watch({
+                    onlogin: function (assertion) {
+                        if (assertion) {
+                            document.location = "@{toMaster complete}/" + assertion;
+                        }
+                    },
+                    onlogout: function () {}
+                });
+                navigator.id.request({
+                    returnTo: #{login} + "?autologin=true"
+                });
+            }
+            else {
+                alert("Loading, please try again");
+            }
         }
     |]
+    when bisLazyLoad $ toWidget [julius|
+        (function(){
+            var bid = document.createElement("script");
+            bid.async = true;
+            bid.src = #{toJSON browserIdJs};
+            var s = document.getElementsByTagName('script')[0];
+            s.parentNode.insertBefore(bid, s);
+        })();
+    |]
 
-    autologin <- fmap (== Just "true") $ lift $ lookupGetParam "autologin"
+    autologin <- fmap (== Just "true") $ lookupGetParam "autologin"
     when autologin $ toWidget [julius|#{rawJS onclick}();|]
     return onclick
   where
diff --git a/yesod-auth/Yesod/Auth/Dummy.hs b/yesod-auth/Yesod/Auth/Dummy.hs
index 7ba931e5..9670f709 100644
--- a/yesod-auth/Yesod/Auth/Dummy.hs
+++ b/yesod-auth/Yesod/Auth/Dummy.hs
@@ -9,17 +9,16 @@ module Yesod.Auth.Dummy
 
 import Yesod.Auth
 import Yesod.Form (runInputPost, textField, ireq)
-import Yesod.Handler (notFound)
 import Text.Hamlet (hamlet)
-import Yesod.Widget (toWidget)
+import Yesod.Core
 
 authDummy :: YesodAuth m => AuthPlugin m
 authDummy =
     AuthPlugin "dummy" dispatch login
   where
     dispatch "POST" [] = do
-        ident <- runInputPost $ ireq textField "ident"
-        setCreds True $ Creds "dummy" ident []
+        ident <- lift $ runInputPost $ ireq textField "ident"
+        lift $ setCreds True $ Creds "dummy" ident []
     dispatch _ _ = notFound
     url = PluginR "dummy" []
     login authToMaster =
diff --git a/yesod-auth/Yesod/Auth/Email.hs b/yesod-auth/Yesod/Auth/Email.hs
index 2fe5d7e7..5b383cc3 100644
--- a/yesod-auth/Yesod/Auth/Email.hs
+++ b/yesod-auth/Yesod/Auth/Email.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE QuasiQuotes, TypeFamilies #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE PatternGuards #-}
 module Yesod.Auth.Email
     ( -- * Plugin
       authEmail
@@ -10,33 +11,40 @@ module Yesod.Auth.Email
       -- * Routes
     , loginR
     , registerR
+    , forgotPasswordR
     , setpassR
     , isValidPass
+      -- * Types
+    , Email
+    , VerKey
+    , VerUrl
+    , SaltedPass
+    , VerStatus
+    , Identifier
     ) where
 
 import Network.Mail.Mime (randomString)
 import Yesod.Auth
 import System.Random
-import Control.Monad (when)
-import Control.Applicative ((<$>), (<*>))
 import Data.Digest.Pure.MD5
-import qualified Data.Text.Lazy as T
 import qualified Data.Text as TS
-import Data.Text.Lazy.Encoding (encodeUtf8)
+import qualified Data.Text.Lazy as TL
+import qualified Data.Text.Lazy.Encoding as TLE
+import Data.Text.Encoding (encodeUtf8, decodeUtf8With)
+import Data.Text.Encoding.Error (lenientDecode)
 import Data.Text (Text)
+import Yesod.Core
 import qualified Crypto.PasswordStore as PS
-import qualified Data.Text.Encoding as DTE
-
-import Yesod.Form
-import Yesod.Handler
-import Yesod.Content
-import Yesod.Core (PathPiece, fromPathPiece, whamlet, defaultLayout, setTitleI, toPathPiece)
-import Control.Monad.IO.Class (liftIO)
+import qualified Text.Email.Validate
 import qualified Yesod.Auth.Message as Msg
+import Control.Applicative ((<$>), (<*>))
+import Yesod.Form
+import Control.Monad (when)
 
-loginR, registerR, setpassR :: AuthRoute
+loginR, registerR, forgotPasswordR, setpassR :: AuthRoute
 loginR = PluginR "email" ["login"]
 registerR = PluginR "email" ["register"]
+forgotPasswordR = PluginR "email" ["forgot-password"]
 setpassR = PluginR "email" ["set-password"]
 
 verify :: Text -> Text -> AuthRoute -- FIXME
@@ -48,33 +56,86 @@ type VerUrl = Text
 type SaltedPass = Text
 type VerStatus = Bool
 
+-- | An Identifier generalizes an email address to allow users to log in with
+-- some other form of credentials (e.g., username).
+--
+-- Note that any of these other identifiers must not be valid email addresses.
+--
+-- Since 1.2.0
+type Identifier = Text
+
 -- | Data stored in a database for each e-mail address.
-data EmailCreds m = EmailCreds
-    { emailCredsId :: AuthEmailId m
-    , emailCredsAuthId :: Maybe (AuthId m)
+data EmailCreds site = EmailCreds
+    { emailCredsId :: AuthEmailId site
+    , emailCredsAuthId :: Maybe (AuthId site)
     , emailCredsStatus :: VerStatus
     , emailCredsVerkey :: Maybe VerKey
+    , emailCredsEmail :: Email
     }
 
-class (YesodAuth m, PathPiece (AuthEmailId m)) => YesodAuthEmail m where
-    type AuthEmailId m
+class (YesodAuth site, PathPiece (AuthEmailId site)) => YesodAuthEmail site where
+    type AuthEmailId site
 
-    addUnverified :: Email -> VerKey -> GHandler Auth m (AuthEmailId m)
-    sendVerifyEmail :: Email -> VerKey -> VerUrl -> GHandler Auth m ()
-    getVerifyKey :: AuthEmailId m -> GHandler Auth m (Maybe VerKey)
-    setVerifyKey :: AuthEmailId m -> VerKey -> GHandler Auth m ()
-    verifyAccount :: AuthEmailId m -> GHandler Auth m (Maybe (AuthId m))
-    getPassword :: AuthId m -> GHandler Auth m (Maybe SaltedPass)
-    setPassword :: AuthId m -> SaltedPass -> GHandler Auth m ()
-    getEmailCreds :: Email -> GHandler Auth m (Maybe (EmailCreds m))
-    getEmail :: AuthEmailId m -> GHandler Auth m (Maybe Email)
+    -- | Add a new email address to the database, but indicate that the address
+    -- has not yet been verified.
+    --
+    -- Since 1.1.0
+    addUnverified :: Email -> VerKey -> HandlerT site IO (AuthEmailId site)
+
+    -- | Send an email to the given address to verify ownership.
+    --
+    -- Since 1.1.0
+    sendVerifyEmail :: Email -> VerKey -> VerUrl -> HandlerT site IO ()
+
+    -- | Get the verification key for the given email ID.
+    --
+    -- Since 1.1.0
+    getVerifyKey :: AuthEmailId site -> HandlerT site IO (Maybe VerKey)
+
+    -- | Set the verification key for the given email ID.
+    --
+    -- Since 1.1.0
+    setVerifyKey :: AuthEmailId site -> VerKey -> HandlerT site IO ()
+
+    -- | Verify the email address on the given account.
+    --
+    -- Since 1.1.0
+    verifyAccount :: AuthEmailId site -> HandlerT site IO (Maybe (AuthId site))
+
+    -- | Get the salted password for the given account.
+    --
+    -- Since 1.1.0
+    getPassword :: AuthId site -> HandlerT site IO (Maybe SaltedPass)
+
+    -- | Set the salted password for the given account.
+    --
+    -- Since 1.1.0
+    setPassword :: AuthId site -> SaltedPass -> HandlerT site IO ()
+
+    -- | Get the credentials for the given @Identifier@, which may be either an
+    -- email address or some other identification (e.g., username).
+    --
+    -- Since 1.2.0
+    getEmailCreds :: Identifier -> HandlerT site IO (Maybe (EmailCreds site))
+
+    -- | Get the email address for the given email ID.
+    --
+    -- Since 1.1.0
+    getEmail :: AuthEmailId site -> HandlerT site IO (Maybe Email)
 
     -- | Generate a random alphanumeric string.
-    randomKey :: m -> IO Text
+    --
+    -- Since 1.1.0
+    randomKey :: site -> IO Text
     randomKey _ = do
         stdgen <- newStdGen
         return $ TS.pack $ fst $ randomString 10 stdgen
 
+    -- | Route to send user to after password has been set correctly.
+    --
+    -- Since 1.2.0
+    afterPasswordRoute :: site -> Route site
+
 authEmail :: YesodAuthEmail m => AuthPlugin m
 authEmail =
     AuthPlugin "email" dispatch $ \tm ->
@@ -98,6 +159,8 @@ $newline never
   where
     dispatch "GET" ["register"] = getRegisterR >>= sendResponse
     dispatch "POST" ["register"] = postRegisterR >>= sendResponse
+    dispatch "GET" ["forgot-password"] = getForgotPasswordR >>= sendResponse
+    dispatch "POST" ["forgot-password"] = postForgotPasswordR >>= sendResponse
     dispatch "GET" ["verify", eid, verkey] =
         case fromPathPiece eid of
             Nothing -> notFound
@@ -107,113 +170,157 @@ $newline never
     dispatch "POST" ["set-password"] = postPasswordR >>= sendResponse
     dispatch _ _ = notFound
 
-getRegisterR :: YesodAuthEmail master => GHandler Auth master RepHtml
+getRegisterR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) Html
 getRegisterR = do
-    toMaster <- getRouteToMaster
     email <- newIdent
-    defaultLayout $ do
+    tp <- getRouteToParent
+    lift $ defaultLayout $ do
         setTitleI Msg.RegisterLong
         [whamlet|
-$newline never
-<p>_{Msg.EnterEmail}
-<form method="post" action="@{toMaster registerR}">
-    <label for=#{email}>_{Msg.Email}
-    <input ##{email} type="email" name="email" width="150">
-    <input type="submit" value=_{Msg.Register}>
-|]
+            <p>_{Msg.EnterEmail}
+            <form method="post" action="@{tp registerR}">
+                <div id="registerForm">
+                    <label for=#{email}>_{Msg.Email}:
+                    <input ##{email} type="email" name="email" width="150">
+                <button .btn>_{Msg.Register}
+        |]
 
-postRegisterR :: YesodAuthEmail master => GHandler Auth master RepHtml
-postRegisterR = do
-    y <- getYesod
-    email <- runInputPost $ ireq emailField "email"
-    mecreds <- getEmailCreds email
-    (lid, verKey) <-
-        case mecreds of
-            Just (EmailCreds lid _ _ (Just key)) -> return (lid, key)
-            Just (EmailCreds lid _ _ Nothing) -> do
-                key <- liftIO $ randomKey y
-                setVerifyKey lid key
-                return (lid, key)
+registerHelper :: YesodAuthEmail master
+               => Bool -- ^ allow usernames?
+               -> Route Auth
+               -> HandlerT Auth (HandlerT master IO) Html
+registerHelper allowUsername dest = do
+    y <- lift getYesod
+    midentifier <- lookupPostParam "email"
+    identifier <-
+        case midentifier of
             Nothing -> do
+                lift $ setMessageI Msg.NoIdentifierProvided
+                redirect dest
+            Just x
+                | Just x' <- Text.Email.Validate.canonicalizeEmail (encodeUtf8 x) ->
+                    return $ decodeUtf8With lenientDecode x'
+                | allowUsername -> return $ TS.strip x
+                | otherwise -> do
+                    lift $ setMessageI Msg.InvalidEmailAddress
+                    redirect dest
+    mecreds <- lift $ getEmailCreds identifier
+    (lid, verKey, email) <-
+        case mecreds of
+            Just (EmailCreds lid _ _ (Just key) email) -> return (lid, key, email)
+            Just (EmailCreds lid _ _ Nothing email) -> do
                 key <- liftIO $ randomKey y
-                lid <- addUnverified email key
-                return (lid, key)
+                lift $ setVerifyKey lid key
+                return (lid, key, email)
+            Nothing
+                | allowUsername -> do
+                    setMessage $ toHtml $ "No record for that identifier in our database: " `TS.append` identifier
+                    redirect dest
+                | otherwise -> do
+                    key <- liftIO $ randomKey y
+                    lid <- lift $ addUnverified identifier key
+                    return (lid, key, identifier)
     render <- getUrlRender
-    tm <- getRouteToMaster
-    let verUrl = render $ tm $ verify (toPathPiece lid) verKey
-    sendVerifyEmail email verKey verUrl
-    defaultLayout $ do
+    let verUrl = render $ verify (toPathPiece lid) verKey
+    lift $ sendVerifyEmail email verKey verUrl
+    lift $ defaultLayout $ do
         setTitleI Msg.ConfirmationEmailSentTitle
+        [whamlet|<p>_{Msg.ConfirmationEmailSent identifier}|]
+
+postRegisterR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) Html
+postRegisterR = registerHelper False registerR
+
+getForgotPasswordR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) Html
+getForgotPasswordR = do
+    tp <- getRouteToParent
+    email <- newIdent
+    lift $ defaultLayout $ do
+        setTitleI Msg.PasswordResetTitle
         [whamlet|
-$newline never
-<p>_{Msg.ConfirmationEmailSent email}
-|]
+            <p>_{Msg.PasswordResetPrompt}
+            <form method="post" action="@{tp forgotPasswordR}">
+                <div id="registerForm">
+                    <label for=#{email}>_{Msg.ProvideIdentifier}
+                    <input ##{email} type=text name="email" width="150">
+                <button .btn>_{Msg.SendPasswordResetEmail}
+        |]
+
+postForgotPasswordR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) Html
+postForgotPasswordR = registerHelper True forgotPasswordR
 
 getVerifyR :: YesodAuthEmail m
-           => AuthEmailId m -> Text -> GHandler Auth m RepHtml
+           => AuthEmailId m -> Text -> HandlerT Auth (HandlerT m IO) Html
 getVerifyR lid key = do
-    realKey <- getVerifyKey lid
-    memail <- getEmail lid
+    realKey <- lift $ getVerifyKey lid
+    memail <- lift $ getEmail lid
     case (realKey == Just key, memail) of
         (True, Just email) -> do
-            muid <- verifyAccount lid
+            muid <- lift $ verifyAccount lid
             case muid of
                 Nothing -> return ()
                 Just _uid -> do
-                    setCreds False $ Creds "email" email [("verifiedEmail", email)] -- FIXME uid?
-                    toMaster <- getRouteToMaster
-                    setMessageI Msg.AddressVerified
-                    redirect $ toMaster setpassR
+                    lift $ setCreds False $ Creds "email-verify" email [("verifiedEmail", email)] -- FIXME uid?
+                    lift $ setMessageI Msg.AddressVerified
+                    redirect setpassR
         _ -> return ()
-    defaultLayout $ do
+    lift $ defaultLayout $ do
         setTitleI Msg.InvalidKey
         [whamlet|
 $newline never
 <p>_{Msg.InvalidKey}
 |]
 
-postLoginR :: YesodAuthEmail master => GHandler Auth master ()
+postLoginR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) ()
 postLoginR = do
-    (email, pass) <- runInputPost $ (,)
-        <$> ireq emailField "email"
+    (identifier, pass) <- lift $ runInputPost $ (,)
+        <$> ireq textField "email"
         <*> ireq textField "password"
-    mecreds <- getEmailCreds email
+    mecreds <- lift $ getEmailCreds identifier
     maid <-
-        case (mecreds >>= emailCredsAuthId, fmap emailCredsStatus mecreds) of
-            (Just aid, Just True) -> do
-                mrealpass <- getPassword aid
+        case ( mecreds >>= emailCredsAuthId
+             , emailCredsEmail <$> mecreds
+             , emailCredsStatus <$> mecreds
+             ) of
+            (Just aid, Just email, Just True) -> do
+                mrealpass <- lift $ getPassword aid
                 case mrealpass of
                     Nothing -> return Nothing
                     Just realpass -> return $
                         if isValidPass pass realpass
-                            then Just aid
+                            then Just email
                             else Nothing
             _ -> return Nothing
+    let isEmail = Text.Email.Validate.isValid $ encodeUtf8 identifier
     case maid of
-        Just _aid ->
-            setCreds True $ Creds "email" email [("verifiedEmail", email)] -- FIXME aid?
+        Just email ->
+            lift $ setCreds True $ Creds
+                (if isEmail then "email" else "username")
+                email
+                [("verifiedEmail", email)]
         Nothing -> do
-            setMessageI Msg.InvalidEmailPass
-            toMaster <- getRouteToMaster
-            redirect $ toMaster LoginR
+            lift $ setMessageI $
+                if isEmail
+                    then Msg.InvalidEmailPass
+                    else Msg.InvalidUsernamePass
+            redirect LoginR
 
-getPasswordR :: YesodAuthEmail master => GHandler Auth master RepHtml
+getPasswordR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) Html
 getPasswordR = do
-    toMaster <- getRouteToMaster
-    maid <- maybeAuthId
+    maid <- lift maybeAuthId
     pass1 <- newIdent
     pass2 <- newIdent
     case maid of
         Just _ -> return ()
         Nothing -> do
-            setMessageI Msg.BadSetPass
-            redirect $ toMaster LoginR
-    defaultLayout $ do
+            lift $ setMessageI Msg.BadSetPass
+            redirect LoginR
+    tp <- getRouteToParent
+    lift $ defaultLayout $ do
         setTitleI Msg.SetPassTitle
         [whamlet|
 $newline never
 <h3>_{Msg.SetPass}
-<form method="post" action="@{toMaster setpassR}">
+<form method="post" action="@{tp setpassR}">
     <table>
         <tr>
             <th>
@@ -227,50 +334,47 @@ $newline never
                 <input ##{pass2} type="password" name="confirm">
         <tr>
             <td colspan="2">
-                <input type="submit" value="_{Msg.SetPassTitle}">
+                <input type="submit" value=_{Msg.SetPassTitle}>
 |]
 
-postPasswordR :: YesodAuthEmail master => GHandler Auth master ()
+postPasswordR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) ()
 postPasswordR = do
-    (new, confirm) <- runInputPost $ (,)
+    (new, confirm) <- lift $ runInputPost $ (,)
         <$> ireq textField "new"
         <*> ireq textField "confirm"
-    toMaster <- getRouteToMaster
-    y <- getYesod
     when (new /= confirm) $ do
-        setMessageI Msg.PassMismatch
-        redirect $ toMaster setpassR
-    maid <- maybeAuthId
+        lift $ setMessageI Msg.PassMismatch
+        redirect setpassR
+    maid <- lift maybeAuthId
     aid <- case maid of
             Nothing -> do
-                setMessageI Msg.BadSetPass
-                redirect $ toMaster LoginR
+                lift $ setMessageI Msg.BadSetPass
+                redirect LoginR
             Just aid -> return aid
     salted <- liftIO $ saltPass new
-    setPassword aid salted
-    setMessageI Msg.PassUpdated
-    redirect $ loginDest y
+    lift $ do
+        y <- getYesod
+        setPassword aid salted
+        setMessageI Msg.PassUpdated
+        redirect $ afterPasswordRoute y
 
 saltLength :: Int
 saltLength = 5
 
 -- | Salt a password with a randomly generated salt.
 saltPass :: Text -> IO Text
-saltPass = fmap DTE.decodeUtf8
+saltPass = fmap (decodeUtf8With lenientDecode)
          . flip PS.makePassword 12
-         . DTE.encodeUtf8
+         . encodeUtf8
 
 saltPass' :: String -> String -> String
-saltPass' salt pass =
-    salt ++ show (md5 $ fromString $ salt ++ pass)
-  where
-    fromString = encodeUtf8 . T.pack
+saltPass' salt pass = salt ++ show (md5 $ TLE.encodeUtf8 $ TL.pack $ salt ++ pass)
 
 isValidPass :: Text -- ^ cleartext password
             -> SaltedPass -- ^ salted password
             -> Bool
 isValidPass ct salted =
-    PS.verifyPassword (DTE.encodeUtf8 ct) (DTE.encodeUtf8 salted) || isValidPass' ct salted
+    PS.verifyPassword (encodeUtf8 ct) (encodeUtf8 salted) || isValidPass' ct salted
 
 isValidPass' :: Text -- ^ cleartext password
             -> SaltedPass -- ^ salted password
diff --git a/yesod-auth/Yesod/Auth/GoogleEmail.hs b/yesod-auth/Yesod/Auth/GoogleEmail.hs
index 8f06abe3..d9ce98fe 100644
--- a/yesod-auth/Yesod/Auth/GoogleEmail.hs
+++ b/yesod-auth/Yesod/Auth/GoogleEmail.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE QuasiQuotes #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE RankNTypes #-}
 -- | Use an email address as an identifier via Google's OpenID login system.
 --
 -- This backend will not use the OpenID identifier at all. It only uses OpenID
@@ -18,14 +19,7 @@ module Yesod.Auth.GoogleEmail
 import Yesod.Auth
 import qualified Web.Authenticate.OpenId as OpenId
 
-import Yesod.Handler
-import Yesod.Widget (whamlet)
-import Yesod.Request
-#if MIN_VERSION_blaze_html(0, 5, 0)
-import Text.Blaze.Html (toHtml)
-#else
-import Text.Blaze (toHtml)
-#endif
+import Yesod.Core
 import Data.Text (Text)
 import qualified Yesod.Auth.Message as Msg
 import qualified Data.Text as T
@@ -46,15 +40,11 @@ authGoogleEmail =
   where
     complete = PluginR pid ["complete"]
     login tm =
-        [whamlet|
-$newline never
-<a href=@{tm forwardUrl}>_{Msg.LoginGoogle}
-|]
+        [whamlet|<a href=@{tm forwardUrl}>_{Msg.LoginGoogle}|]
     dispatch "GET" ["forward"] = do
         render <- getUrlRender
-        toMaster <- getRouteToMaster
-        let complete' = render $ toMaster complete
-        master <- getYesod
+        let complete' = render complete
+        master <- lift getYesod
         eres <- lift $ try $ OpenId.getForwardUrl googleIdent complete' Nothing
             [ ("openid.ax.type.email", "http://schema.openid.net/contact/email")
             , ("openid.ns.ax", "http://openid.net/srv/ax/1.0")
@@ -66,7 +56,7 @@ $newline never
         either
           (\err -> do
                 setMessage $ toHtml $ show (err :: SomeException)
-                redirect $ toMaster LoginR
+                redirect LoginR
                 )
           redirect
           eres
@@ -80,23 +70,22 @@ $newline never
         completeHelper posts
     dispatch _ _ = notFound
 
-completeHelper :: YesodAuth m => [(Text, Text)] -> GHandler Auth m ()
+completeHelper :: YesodAuth master => [(Text, Text)] -> AuthHandler master ()
 completeHelper gets' = do
-        master <- getYesod
+        master <- lift getYesod
         eres <- lift $ try $ OpenId.authenticateClaimed gets' (authHttpManager master)
-        toMaster <- getRouteToMaster
         let onFailure err = do
             setMessage $ toHtml $ show (err :: SomeException)
-            redirect $ toMaster LoginR
+            redirect LoginR
         let onSuccess oir = do
                 let OpenId.Identifier ident = OpenId.oirOpLocal oir
                 memail <- lookupGetParam "openid.ext1.value.email"
                 case (memail, "https://www.google.com/accounts/o8/id" `T.isPrefixOf` ident) of
-                    (Just email, True) -> setCreds True $ Creds pid email []
+                    (Just email, True) -> lift $ setCreds True $ Creds pid email []
                     (_, False) -> do
                         setMessage "Only Google login is supported"
-                        redirect $ toMaster LoginR
+                        redirect LoginR
                     (Nothing, _) -> do
                         setMessage "No email address provided"
-                        redirect $ toMaster LoginR
+                        redirect LoginR
         either onFailure onSuccess eres
diff --git a/yesod-auth/Yesod/Auth/HashDB.hs b/yesod-auth/Yesod/Auth/HashDB.hs
index 356ac62f..16117e2a 100644
--- a/yesod-auth/Yesod/Auth/HashDB.hs
+++ b/yesod-auth/Yesod/Auth/HashDB.hs
@@ -74,15 +74,13 @@ module Yesod.Auth.HashDB
     ) where
 
 import Yesod.Persist
-import Yesod.Handler
 import Yesod.Form
 import Yesod.Auth
-import Yesod.Widget (toWidget)
+import Yesod.Core
 import Text.Hamlet (hamlet)
 
 import Control.Applicative         ((<$>), (<*>))
 import Control.Monad               (replicateM,liftM)
-import Control.Monad.IO.Class      (MonadIO, liftIO)
 
 import qualified Data.ByteString.Lazy.Char8 as BS (pack)
 import Data.Digest.Pure.SHA        (sha1, showDigest)
@@ -135,26 +133,15 @@ setPassword pwd u = do salt <- randomSalt
 -- | Given a user ID and password in plaintext, validate them against
 --   the database values.
 validateUser :: ( YesodPersist yesod
-#if MIN_VERSION_persistent(1, 1, 0)
                 , b ~ YesodPersistBackend yesod
-                , PersistMonadBackend (b (GHandler sub yesod)) ~ PersistEntityBackend user
-                , PersistUnique (b (GHandler sub yesod))
-#else
-                , b ~ YesodPersistBackend yesod
-                , b ~ PersistEntityBackend user
-                , PersistStore b (GHandler sub yesod)
-                , PersistUnique b (GHandler sub yesod)
-#endif
+                , PersistMonadBackend (b (HandlerT yesod IO)) ~ PersistEntityBackend user
+                , PersistUnique (b (HandlerT yesod IO))
                 , PersistEntity user
                 , HashDBUser    user
                 ) => 
-#if MIN_VERSION_persistent(1, 1, 0)
                 Unique user     -- ^ User unique identifier
-#else
-                Unique user b   -- ^ User unique identifier
-#endif
              -> Text            -- ^ Password in plaint-text
-             -> GHandler sub yesod Bool
+             -> HandlerT yesod IO Bool
 validateUser userID passwd = do
   -- Checks that hash and password match
   let validate u = do hash <- userPasswordHash u
@@ -173,62 +160,38 @@ login = PluginR "hashdb" ["login"]
 --   username (whatever it might be) to unique user ID.
 postLoginR :: ( YesodAuth y, YesodPersist y
               , HashDBUser user, PersistEntity user
-#if MIN_VERSION_persistent(1, 1, 0)
               , b ~ YesodPersistBackend y
-              , PersistMonadBackend (b (GHandler Auth y)) ~ PersistEntityBackend user
-              , PersistUnique (b (GHandler Auth y))
-#else
-              , b ~ YesodPersistBackend y
-              , b ~ PersistEntityBackend user
-              , PersistStore b (GHandler Auth y)
-              , PersistUnique b (GHandler Auth y)
-#endif
+              , PersistMonadBackend (b (HandlerT y IO)) ~ PersistEntityBackend user
+              , PersistUnique (b (HandlerT y IO))
               )
-#if MIN_VERSION_persistent(1, 1, 0)
            => (Text -> Maybe (Unique user))
-#else
-           => (Text -> Maybe (Unique user b))
-#endif
-           -> GHandler Auth y ()
+           -> HandlerT Auth (HandlerT y IO) ()
 postLoginR uniq = do
-    (mu,mp) <- runInputPost $ (,)
+    (mu,mp) <- lift $ runInputPost $ (,)
         <$> iopt textField "username"
         <*> iopt textField "password"
 
-    isValid <- fromMaybe (return False) 
+    isValid <- lift $ fromMaybe (return False) 
                  (validateUser <$> (uniq =<< mu) <*> mp)
     if isValid 
-       then setCreds True $ Creds "hashdb" (fromMaybe "" mu) []
+       then lift $ setCreds True $ Creds "hashdb" (fromMaybe "" mu) []
        else do setMessage "Invalid username/password"
-               toMaster <- getRouteToMaster
-               redirect $ toMaster LoginR
+               redirect LoginR
 
 
 -- | A drop in for the getAuthId method of your YesodAuth instance which
 --   can be used if authHashDB is the only plugin in use.
 getAuthIdHashDB :: ( YesodAuth master, YesodPersist master
                    , HashDBUser user, PersistEntity user
-#if MIN_VERSION_persistent(1, 1, 0)
                    , Key user ~ AuthId master
                    , b ~ YesodPersistBackend master
-                   , PersistMonadBackend (b (GHandler sub master)) ~ PersistEntityBackend user
-                   , PersistUnique (b (GHandler sub master))
-#else
-                   , Key b user ~ AuthId master
-                   , b ~ YesodPersistBackend master
-                   , b ~ PersistEntityBackend user
-                   , PersistUnique b (GHandler sub master)
-                   , PersistStore b (GHandler sub master)
-#endif
+                   , PersistMonadBackend (b (HandlerT master IO)) ~ PersistEntityBackend user
+                   , PersistUnique (b (HandlerT master IO))
                    )
                 => (AuthRoute -> Route master)   -- ^ your site's Auth Route
-#if MIN_VERSION_persistent(1, 1, 0)
                 -> (Text -> Maybe (Unique user)) -- ^ gets user ID
-#else
-                -> (Text -> Maybe (Unique user b)) -- ^ gets user ID
-#endif
                 -> Creds master                  -- ^ the creds argument
-                -> GHandler sub master (Maybe (AuthId master))
+                -> HandlerT master IO (Maybe (AuthId master))
 getAuthIdHashDB authR uniq creds = do
     muid <- maybeAuthId
     case muid of
@@ -250,18 +213,10 @@ getAuthIdHashDB authR uniq creds = do
 authHashDB :: ( YesodAuth m, YesodPersist m
               , HashDBUser user
               , PersistEntity user
-#if MIN_VERSION_persistent(1, 1, 0)
               , b ~ YesodPersistBackend m
-              , PersistMonadBackend (b (GHandler Auth m)) ~ PersistEntityBackend user
-              , PersistUnique (b (GHandler Auth m)))
+              , PersistMonadBackend (b (HandlerT m IO)) ~ PersistEntityBackend user
+              , PersistUnique (b (HandlerT m IO)))
            => (Text -> Maybe (Unique user)) -> AuthPlugin m
-#else
-              , b ~ YesodPersistBackend m
-              , b ~ PersistEntityBackend user
-              , PersistStore b (GHandler Auth m)
-              , PersistUnique b (GHandler Auth m))
-           => (Text -> Maybe (Unique user b)) -> AuthPlugin m
-#endif
 authHashDB uniq = AuthPlugin "hashdb" dispatch $ \tm -> toWidget [hamlet|
 $newline never
     <div id="header">
diff --git a/yesod-auth/Yesod/Auth/Message.hs b/yesod-auth/Yesod/Auth/Message.hs
index 97457238..085c496a 100644
--- a/yesod-auth/Yesod/Auth/Message.hs
+++ b/yesod-auth/Yesod/Auth/Message.hs
@@ -12,6 +12,8 @@ module Yesod.Auth.Message
     , norwegianBokmålMessage
     , japaneseMessage
     , finnishMessage
+    , chineseMessage
+    , spanishMessage
     ) where
 
 import Data.Monoid (mappend)
@@ -47,6 +49,13 @@ data AuthMessage =
     | LoginTitle
     | PleaseProvideUsername
     | PleaseProvidePassword
+    | NoIdentifierProvided
+    | InvalidEmailAddress
+    | PasswordResetTitle
+    | ProvideIdentifier
+    | SendPasswordResetEmail
+    | PasswordResetPrompt
+    | InvalidUsernamePass
 
 -- | Defaults to 'englishMessage'.
 defaultMessage :: AuthMessage -> Text
@@ -85,6 +94,13 @@ englishMessage NowLoggedIn = "You are now logged in"
 englishMessage LoginTitle = "Login"
 englishMessage PleaseProvideUsername = "Please fill in your username"
 englishMessage PleaseProvidePassword = "Please fill in your password"
+englishMessage NoIdentifierProvided = "No email/username provided"
+englishMessage InvalidEmailAddress = "Invalid email address provided"
+englishMessage PasswordResetTitle = "Password Reset"
+englishMessage ProvideIdentifier = "Email or Username"
+englishMessage SendPasswordResetEmail = "Send password reset email"
+englishMessage PasswordResetPrompt = "Enter your e-mail address or username below, and a password reset e-mail will be sent to you."
+englishMessage InvalidUsernamePass = "Invalid username/password combination"
 
 portugueseMessage :: AuthMessage -> Text
 portugueseMessage NoOpenID = "Nenhum identificador OpenID encontrado"
@@ -119,6 +135,54 @@ portugueseMessage NowLoggedIn = "Você acaba de entrar no site com sucesso!"
 portugueseMessage LoginTitle = "Entrar no site"
 portugueseMessage PleaseProvideUsername = "Por favor digite seu nome de usuário"
 portugueseMessage PleaseProvidePassword = "Por favor digite sua senha"
+portugueseMessage NoIdentifierProvided = "Nenhum e-mail ou nome de usuário informado"
+portugueseMessage InvalidEmailAddress = "Endereço de e-mail inválido informado"
+portugueseMessage PasswordResetTitle = "Resetar senha"
+portugueseMessage ProvideIdentifier = "E-mail ou nome de usuário"
+portugueseMessage SendPasswordResetEmail = "Enviar e-mail para resetar senha"
+portugueseMessage PasswordResetPrompt = "Insira seu endereço de e-mail ou nome de usuário abaixo.  Um e-mail para resetar sua senha será enviado para você."
+portugueseMessage InvalidUsernamePass = "Nome de usuário ou senha inválidos"
+
+spanishMessage :: AuthMessage -> Text
+spanishMessage NoOpenID = "No se encuentra el identificador OpenID"
+spanishMessage LoginOpenID = "Entrar utilizando OpenID"
+spanishMessage LoginGoogle = "Entrar utilizando Google"
+spanishMessage LoginYahoo = "Entrar utilizando Yahoo"
+spanishMessage Email = "Correo electrónico"
+spanishMessage Password = "Contraseña"
+spanishMessage Register = "Registrarse"
+spanishMessage RegisterLong = "Registrar una nueva cuenta"
+spanishMessage EnterEmail = "Coloque su dirección de correo electrónico, y un correo de confirmación le será enviado a su cuenta."
+spanishMessage ConfirmationEmailSentTitle = "La confirmación de correo ha sido enviada"
+spanishMessage (ConfirmationEmailSent email) =
+    "Una confirmación de correo electrónico ha sido enviada a " `mappend`
+    email `mappend`
+    "."
+spanishMessage AddressVerified = "Dirección verificada, por favor introduzca una contraseña"
+spanishMessage InvalidKeyTitle = "Clave de verificación invalida"
+spanishMessage InvalidKey = "Lo sentimos, pero esa clave de verificación es inválida."
+spanishMessage InvalidEmailPass = "La combinación cuenta de correo/contraseña es inválida"
+spanishMessage BadSetPass = "Debe acceder a la aplicación para modificar la contraseña"
+spanishMessage SetPassTitle = "Modificar contraseña"
+spanishMessage SetPass = "Actualizar nueva contraseña"
+spanishMessage NewPass = "Nueva contraseña"
+spanishMessage ConfirmPass = "Confirmar"
+spanishMessage PassMismatch = "Las contraseñas no coinciden, inténtelo de nuevo"
+spanishMessage PassUpdated = "Contraseña actualizada"
+spanishMessage Facebook = "Entrar mediante Facebook"
+spanishMessage LoginViaEmail = "Entrar mediante una cuenta de correo"
+spanishMessage InvalidLogin = "Login inválido"
+spanishMessage NowLoggedIn = "Usted ha ingresado al sitio"
+spanishMessage LoginTitle = "Login"
+spanishMessage PleaseProvideUsername = "Por favor escriba su nombre de usuario"
+spanishMessage PleaseProvidePassword = "Por favor escriba su contraseña"
+spanishMessage NoIdentifierProvided = "No ha indicado una cuenta de correo/nombre de usuario"
+spanishMessage InvalidEmailAddress = "La cuenta de correo es inválida"
+spanishMessage PasswordResetTitle = "Contraseña actualizada"
+spanishMessage ProvideIdentifier = "Cuenta de correo o nombre de usuario"
+spanishMessage SendPasswordResetEmail = "Correo de actualización de contraseña enviado"
+spanishMessage PasswordResetPrompt = "Escriba su cuenta de correo o nombre de usuario, y una confirmación de actualización de contraseña será enviada a su cuenta de correo."
+spanishMessage InvalidUsernamePass = "Combinación de nombre de usuario/contraseña invalida"
 
 swedishMessage :: AuthMessage -> Text
 swedishMessage NoOpenID = "Fann ej OpenID identifierare"
@@ -153,6 +217,14 @@ swedishMessage NowLoggedIn = "Du är nu inloggad"
 swedishMessage LoginTitle = "Logga in"
 swedishMessage PleaseProvideUsername = "Vänligen fyll i användarnamn"
 swedishMessage PleaseProvidePassword = "Vänligen fyll i lösenord"
+swedishMessage NoIdentifierProvided = "Emailadress eller användarnamn saknas"
+swedishMessage InvalidEmailAddress = "Ogiltig emailadress angiven"
+swedishMessage PasswordResetTitle = "Återställning av lösenord"
+swedishMessage ProvideIdentifier = "Epost eller användarnamn"
+swedishMessage SendPasswordResetEmail = "Skicka email för återställning av lösenord"
+swedishMessage PasswordResetPrompt = "Skriv in din emailadress eller användarnamn nedan och " `mappend`
+                                     "ett email för återställning av lösenord kommmer att skickas till dig."
+swedishMessage InvalidUsernamePass = "Ogiltig kombination av användarnamn och lösenord"
 
 germanMessage :: AuthMessage -> Text
 germanMessage NoOpenID = "Kein OpenID-Identifier gefunden"
@@ -187,8 +259,13 @@ germanMessage NowLoggedIn = "Login erfolgreich"
 germanMessage LoginTitle = "Login"
 germanMessage PleaseProvideUsername = "Bitte Nutzername angeben"
 germanMessage PleaseProvidePassword = "Bitte Passwort angeben"
-
-
+germanMessage NoIdentifierProvided = "Keine Email-Adresse oder kein Nutzername angegeben"
+germanMessage InvalidEmailAddress = "Unzulässiger Email-Anbieter"
+germanMessage PasswordResetTitle = "Passwort zurücksetzen"
+germanMessage ProvideIdentifier = "Email-Adresse oder Nutzername"
+germanMessage SendPasswordResetEmail = "Email zusenden um Passwort zurückzusetzen"
+germanMessage PasswordResetPrompt = "Nach Einhabe der Email-Adresse oder des Nutzernamen wird eine Email zugesendet mit welcher das Passwort zurückgesetzt werden kann."
+germanMessage InvalidUsernamePass = "Ungültige Kombination aus Nutzername und Passwort"
 
 frenchMessage :: AuthMessage -> Text
 frenchMessage NoOpenID = "Aucun fournisseur OpenID n'a été trouvé"
@@ -223,6 +300,13 @@ frenchMessage NowLoggedIn = "Vous êtes maintenant connecté"
 frenchMessage LoginTitle = "Se connecter"
 frenchMessage PleaseProvideUsername = "Merci de renseigner votre nom d'utilisateur"
 frenchMessage PleaseProvidePassword = "Merci de spécifier un mot de passe"
+frenchMessage NoIdentifierProvided = "No email/username provided"
+frenchMessage InvalidEmailAddress = "Invalid email address provided"
+frenchMessage PasswordResetTitle = "Password Reset"
+frenchMessage ProvideIdentifier = "Email or Username"
+frenchMessage SendPasswordResetEmail = "Send password reset email"
+frenchMessage PasswordResetPrompt = "Enter your e-mail address or username below, and a password reset e-mail will be sent to you."
+frenchMessage InvalidUsernamePass = "Invalid username/password combination"
 
 norwegianBokmålMessage :: AuthMessage -> Text
 norwegianBokmålMessage NoOpenID = "Ingen OpenID-identifiserer funnet"
@@ -257,6 +341,13 @@ norwegianBokmålMessage NowLoggedIn = "Du er nå logget inn"
 norwegianBokmålMessage LoginTitle = "Logg inn"
 norwegianBokmålMessage PleaseProvideUsername = "Vennligst fyll inn ditt brukernavn"
 norwegianBokmålMessage PleaseProvidePassword = "Vennligst fyll inn ditt passord"
+norwegianBokmålMessage NoIdentifierProvided = "No email/username provided"
+norwegianBokmålMessage InvalidEmailAddress = "Invalid email address provided"
+norwegianBokmålMessage PasswordResetTitle = "Password Reset"
+norwegianBokmålMessage ProvideIdentifier = "Email or Username"
+norwegianBokmålMessage SendPasswordResetEmail = "Send password reset email"
+norwegianBokmålMessage PasswordResetPrompt = "Enter your e-mail address or username below, and a password reset e-mail will be sent to you."
+norwegianBokmålMessage InvalidUsernamePass = "Invalid username/password combination"
 
 japaneseMessage :: AuthMessage -> Text
 japaneseMessage NoOpenID = "OpenID識別子がありません"
@@ -291,6 +382,13 @@ japaneseMessage NowLoggedIn = "ログインしました"
 japaneseMessage LoginTitle = "ログイン"
 japaneseMessage PleaseProvideUsername = "ユーザ名を入力してください"
 japaneseMessage PleaseProvidePassword = "パスワードを入力してください"
+japaneseMessage NoIdentifierProvided = "No email/username provided"
+japaneseMessage InvalidEmailAddress = "Invalid email address provided"
+japaneseMessage PasswordResetTitle = "Password Reset"
+japaneseMessage ProvideIdentifier = "Email or Username"
+japaneseMessage SendPasswordResetEmail = "Send password reset email"
+japaneseMessage PasswordResetPrompt = "Enter your e-mail address or username below, and a password reset e-mail will be sent to you."
+japaneseMessage InvalidUsernamePass = "Invalid username/password combination"
 
 finnishMessage :: AuthMessage -> Text
 finnishMessage NoOpenID = "OpenID-tunnistetta ei löydy"
@@ -307,6 +405,7 @@ finnishMessage (ConfirmationEmailSent email) =
     "Vahvistussähköposti on lähetty osoitteeseen " `mappend`
     email `mappend`
     "."
+
 finnishMessage AddressVerified = "Sähköpostiosoite vahvistettu. Anna uusi salasana"
 finnishMessage InvalidKeyTitle = "Virheellinen varmistusavain"
 finnishMessage InvalidKey = "Valitettavasti varmistusavain on virheellinen."
@@ -325,5 +424,53 @@ finnishMessage NowLoggedIn = "Olet nyt kirjautunut sisään"
 finnishMessage LoginTitle = "Kirjautuminen"
 finnishMessage PleaseProvideUsername = "Käyttäjänimi puuttuu"
 finnishMessage PleaseProvidePassword = "Salasana puuttuu"
+finnishMessage NoIdentifierProvided = "Sähköpostiosoite/käyttäjänimi puuttuu"
+finnishMessage InvalidEmailAddress = "Annettu sähköpostiosoite ei kelpaa"
+finnishMessage PasswordResetTitle = "Uuden salasanan tilaaminen"
+finnishMessage ProvideIdentifier = "Sähköpostiosoite tai käyttäjänimi"
+finnishMessage SendPasswordResetEmail = "Lähetä uusi salasana sähköpostitse"
+finnishMessage PasswordResetPrompt = "Anna sähköpostiosoitteesi tai käyttäjätunnuksesi alla, niin lähetämme uuden salasanan sähköpostitse."
+finnishMessage InvalidUsernamePass = "Virheellinen käyttäjänimi tai salasana."
+
+chineseMessage :: AuthMessage -> Text
+chineseMessage NoOpenID = "无效的OpenID"
+chineseMessage LoginOpenID = "用OpenID登录"
+chineseMessage LoginGoogle = "用Google帐户登录"
+chineseMessage LoginYahoo = "用Yahoo帐户登录"
+chineseMessage Email = "邮箱"
+chineseMessage Password = "密码"
+chineseMessage Register = "注册"
+chineseMessage RegisterLong = "注册新帐户"
+chineseMessage EnterEmail = "输入你的邮箱地址，你将收到一封确认邮件。"
+chineseMessage ConfirmationEmailSentTitle = "确认邮件已发送"
+chineseMessage (ConfirmationEmailSent email) =
+    "确认邮件已发送至 " `mappend`
+    email `mappend`
+    "."
+chineseMessage AddressVerified = "地址验证成功，请设置新密码"
+chineseMessage InvalidKeyTitle = "无效的验证码"
+chineseMessage InvalidKey = "对不起，验证码无效。"
+chineseMessage InvalidEmailPass = "无效的邮箱/密码组合"
+chineseMessage BadSetPass = "你需要登录才能设置密码"
+chineseMessage SetPassTitle = "设置密码"
+chineseMessage SetPass = "设置新密码"
+chineseMessage NewPass = "新密码"
+chineseMessage ConfirmPass = "确认"
+chineseMessage PassMismatch = "密码不匹配，请重新输入"
+chineseMessage PassUpdated = "密码更新成功"
+chineseMessage Facebook = "用Facebook帐户登录"
+chineseMessage LoginViaEmail = "用邮箱登录"
+chineseMessage InvalidLogin = "登录失败"
+chineseMessage NowLoggedIn = "登录成功"
+chineseMessage LoginTitle = "登录"
+chineseMessage PleaseProvideUsername = "请输入用户名"
+chineseMessage PleaseProvidePassword = "请输入密码"
+chineseMessage NoIdentifierProvided = "缺少邮箱/用户名"
+chineseMessage InvalidEmailAddress = "无效的邮箱地址"
+chineseMessage PasswordResetTitle = "重置密码"
+chineseMessage ProvideIdentifier = "邮箱或用户名"
+chineseMessage SendPasswordResetEmail = "发送密码重置邮件"
+chineseMessage PasswordResetPrompt = "输入你的邮箱地址或用户名，你将收到一封密码重置邮件。"
+chineseMessage InvalidUsernamePass = "无效的用户名/密码组合"
 
 
diff --git a/yesod-auth/Yesod/Auth/OpenId.hs b/yesod-auth/Yesod/Auth/OpenId.hs
index 5e216bf6..d2e20c5b 100644
--- a/yesod-auth/Yesod/Auth/OpenId.hs
+++ b/yesod-auth/Yesod/Auth/OpenId.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE QuasiQuotes #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE RankNTypes #-}
 module Yesod.Auth.OpenId
     ( authOpenId
     , forwardUrl
@@ -14,15 +15,8 @@ import Yesod.Auth
 import qualified Web.Authenticate.OpenId as OpenId
 
 import Yesod.Form
-import Yesod.Handler
-import Yesod.Widget (toWidget, whamlet)
-import Yesod.Request
+import Yesod.Core
 import Text.Cassius (cassius)
-#if MIN_VERSION_blaze_html(0, 5, 0)
-import Text.Blaze.Html (toHtml)
-#else
-import Text.Blaze (toHtml)
-#endif
 import Data.Text (Text, isPrefixOf)
 import qualified Yesod.Auth.Message as Msg
 import Control.Exception.Lifted (SomeException, try)
@@ -43,7 +37,7 @@ authOpenId idType extensionFields =
     complete = PluginR "openid" ["complete"]
     name = "openid_identifier"
     login tm = do
-        ident <- lift newIdent
+        ident <- newIdent
         -- FIXME this is a hack to get GHC 7.6's type checker to allow the
         -- code, but it shouldn't be necessary
         let y :: a -> [(Text, Text)] -> Text
@@ -66,23 +60,21 @@ $newline never
     <input type="submit" value="_{Msg.LoginOpenID}">
 |]
     dispatch "GET" ["forward"] = do
-        roid <- runInputGet $ iopt textField name
+        roid <- lift $ runInputGet $ iopt textField name
         case roid of
             Just oid -> do
                 render <- getUrlRender
-                toMaster <- getRouteToMaster
-                let complete' = render $ toMaster complete
-                master <- getYesod
+                let complete' = render complete
+                master <- lift getYesod
                 eres <- lift $ try $ OpenId.getForwardUrl oid complete' Nothing extensionFields (authHttpManager master)
                 case eres of
                     Left err -> do
                         setMessage $ toHtml $ show (err :: SomeException)
-                        redirect $ toMaster LoginR
+                        redirect LoginR
                     Right x -> redirect x
             Nothing -> do
-                toMaster <- getRouteToMaster
-                setMessageI Msg.NoOpenID
-                redirect $ toMaster LoginR
+                lift $ setMessageI Msg.NoOpenID
+                redirect LoginR
     dispatch "GET" ["complete", ""] = dispatch "GET" ["complete"] -- compatibility issues
     dispatch "GET" ["complete"] = do
         rr <- getRequest
@@ -93,14 +85,13 @@ $newline never
         completeHelper idType posts
     dispatch _ _ = notFound
 
-completeHelper :: YesodAuth m => IdentifierType -> [(Text, Text)] -> GHandler Auth m ()
+completeHelper :: IdentifierType -> [(Text, Text)] -> AuthHandler master ()
 completeHelper idType gets' = do
-        master <- getYesod
-        eres <- lift $ try $ OpenId.authenticateClaimed gets' (authHttpManager master)
-        toMaster <- getRouteToMaster
+        master <- lift getYesod
+        eres <- try $ OpenId.authenticateClaimed gets' (authHttpManager master)
         let onFailure err = do
             setMessage $ toHtml $ show (err :: SomeException)
-            redirect $ toMaster LoginR
+            redirect LoginR
         let onSuccess oir = do
                 let claimed =
                         case OpenId.oirClaimed oir of
@@ -114,7 +105,7 @@ completeHelper idType gets' = do
                             case idType of
                                 OPLocal -> OpenId.oirOpLocal oir
                                 Claimed -> fromMaybe (OpenId.oirOpLocal oir) $ OpenId.oirClaimed oir
-                setCreds True $ Creds "openid" i gets''
+                lift $ setCreds True $ Creds "openid" i gets''
         either onFailure onSuccess eres
 
 -- | The main identifier provided by the OpenID authentication plugin is the
diff --git a/yesod-auth/Yesod/Auth/Routes.hs b/yesod-auth/Yesod/Auth/Routes.hs
new file mode 100644
index 00000000..cb182d58
--- /dev/null
+++ b/yesod-auth/Yesod/Auth/Routes.hs
@@ -0,0 +1,20 @@
+{-# LANGUAGE QuasiQuotes, TypeFamilies, TemplateHaskell #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DeriveDataTypeable #-}
+module Yesod.Auth.Routes where
+
+import Yesod.Core
+import Data.Text (Text)
+
+data Auth = Auth
+
+mkYesodSubData "Auth" [parseRoutes|
+/check                 CheckR      GET
+/login                 LoginR      GET
+/logout                LogoutR     GET POST
+/page/#Text/*Texts     PluginR
+|]
diff --git a/yesod-auth/Yesod/Auth/Rpxnow.hs b/yesod-auth/Yesod/Auth/Rpxnow.hs
index 0c803004..dc674e68 100644
--- a/yesod-auth/Yesod/Auth/Rpxnow.hs
+++ b/yesod-auth/Yesod/Auth/Rpxnow.hs
@@ -10,9 +10,7 @@ import Yesod.Auth
 import qualified Web.Authenticate.Rpxnow as Rpxnow
 import Control.Monad (mplus)
 
-import Yesod.Handler
-import Yesod.Widget
-import Yesod.Request
+import Yesod.Core
 import Text.Hamlet (hamlet)
 import Data.Text (pack, unpack)
 import Data.Text.Encoding (encodeUtf8, decodeUtf8With)
@@ -27,12 +25,8 @@ authRpxnow :: YesodAuth m
 authRpxnow app apiKey =
     AuthPlugin "rpxnow" dispatch login
   where
-    login ::
-        forall sub master.
-        ToWidget sub master (GWidget sub master ())
-        => (Route Auth -> Route master) -> GWidget sub master ()
     login tm = do
-        render <- lift getUrlRender
+        render <- getUrlRender
         let queryString = decodeUtf8With lenientDecode
                         $ renderQuery True [("token_url", Just $ encodeUtf8 $ render $ tm $ PluginR "rpxnow" [])]
         toWidget [hamlet|
@@ -45,7 +39,7 @@ $newline never
         token <- case token1 ++ token2 of
                         [] -> invalidArgs ["token: Value not supplied"]
                         x:_ -> return $ unpack x
-        master <- getYesod
+        master <- lift getYesod
         Rpxnow.Identifier ident extra <- lift $ Rpxnow.authenticate apiKey token (authHttpManager master)
         let creds =
                 Creds "rpxnow" ident
@@ -54,7 +48,7 @@ $newline never
                 $ maybe id (\x -> (:) ("displayName", x))
                     (fmap pack $ getDisplayName $ map (unpack *** unpack) extra)
                   []
-        setCreds True creds
+        lift $ setCreds True creds
     dispatch _ _ = notFound
 
 -- | Get some form of a display name.
diff --git a/yesod-auth/yesod-auth.cabal b/yesod-auth/yesod-auth.cabal
index 4bebd901..59baf769 100644
--- a/yesod-auth/yesod-auth.cabal
+++ b/yesod-auth/yesod-auth.cabal
@@ -1,5 +1,5 @@
 name:            yesod-auth
-version:         1.1.7
+version:         1.2.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman, Patrick Brisbin
@@ -17,24 +17,23 @@ library
     build-depends:   base                    >= 4         && < 5
                    , authenticate            >= 1.3
                    , bytestring              >= 0.9.1.4
-                   , yesod-core              >= 1.1       && < 1.2
-                   , wai                     >= 1.3
+                   , yesod-core              >= 1.2       && < 1.3
+                   , wai                     >= 1.4
                    , template-haskell
                    , pureMD5                 >= 2.0
                    , random                  >= 1.0.0.2
                    , text                    >= 0.7
                    , mime-mail               >= 0.3
-                   , yesod-persistent        >= 1.1
+                   , yesod-persistent        >= 1.2
                    , hamlet                  >= 1.1       && < 1.2
                    , shakespeare-css         >= 1.0       && < 1.1
                    , shakespeare-js          >= 1.0.2     && < 1.2
-                   , yesod-json              >= 1.1       && < 1.2
                    , containers
                    , unordered-containers
-                   , yesod-form              >= 1.1       && < 1.3
+                   , yesod-form              >= 1.3       && < 1.4
                    , transformers            >= 0.2.2
-                   , persistent              >= 1.0       && < 1.2
-                   , persistent-template     >= 1.0       && < 1.2
+                   , persistent              >= 1.2       && < 1.3
+                   , persistent-template     >= 1.2       && < 1.3
                    , SHA                     >= 1.4.1.3
                    , http-conduit            >= 1.5
                    , aeson                   >= 0.5
@@ -45,6 +44,8 @@ library
                    , network
                    , http-types
                    , file-embed
+                   , email-validate          >= 1.0
+                   , data-default
 
     exposed-modules: Yesod.Auth
                      Yesod.Auth.BrowserId
@@ -55,6 +56,7 @@ library
                      Yesod.Auth.HashDB
                      Yesod.Auth.Message
                      Yesod.Auth.GoogleEmail
+    other-modules:   Yesod.Auth.Routes
     ghc-options:     -Wall
 
 source-repository head
diff --git a/yesod/AddHandler.hs b/yesod-bin/AddHandler.hs
similarity index 99%
rename from yesod/AddHandler.hs
rename to yesod-bin/AddHandler.hs
index 04ffc8cf..49fe5685 100644
--- a/yesod/AddHandler.hs
+++ b/yesod-bin/AddHandler.hs
@@ -89,7 +89,7 @@ mkHandler name pattern methods = unlines
   where
     go method =
         [ ""
-        , concat $ func : " :: " : map toArrow types ++ ["Handler RepHtml"]
+        , concat $ func : " :: " : map toArrow types ++ ["Handler Html"]
         , concat
             [ func
             , " = error \"Not yet implemented: "
diff --git a/yesod/Build.hs b/yesod-bin/Build.hs
similarity index 100%
rename from yesod/Build.hs
rename to yesod-bin/Build.hs
diff --git a/yesod/Devel.hs b/yesod-bin/Devel.hs
similarity index 98%
rename from yesod/Devel.hs
rename to yesod-bin/Devel.hs
index 7958ac7e..378d9575 100644
--- a/yesod/Devel.hs
+++ b/yesod-bin/Devel.hs
@@ -123,7 +123,10 @@ reverseProxy opts iappPort = do
                     return $ Right $ ProxyDest "127.0.0.1" appPort)
                 def
                     { wpsOnExc = onExc
-                    , wpsTimeout = Just (1000000 * proxyTimeout opts)
+                    , wpsTimeout =
+                        if proxyTimeout opts == 0
+                            then Nothing
+                            else Just (1000000 * proxyTimeout opts)
                     }
                 manager
             putStrLn "Reverse proxy stopped, but it shouldn't"
diff --git a/yesod/GhcBuild.hs b/yesod-bin/GhcBuild.hs
similarity index 100%
rename from yesod/GhcBuild.hs
rename to yesod-bin/GhcBuild.hs
diff --git a/yesod/Keter.hs b/yesod-bin/Keter.hs
similarity index 100%
rename from yesod/Keter.hs
rename to yesod-bin/Keter.hs
diff --git a/yesod-default/LICENSE b/yesod-bin/LICENSE
similarity index 100%
rename from yesod-default/LICENSE
rename to yesod-bin/LICENSE
diff --git a/yesod/Options.hs b/yesod-bin/Options.hs
similarity index 95%
rename from yesod/Options.hs
rename to yesod-bin/Options.hs
index d0b94765..25b3d940 100644
--- a/yesod/Options.hs
+++ b/yesod-bin/Options.hs
@@ -70,13 +70,8 @@ injectDefaultP env path p@(OptP o)
            let (Just parseri) = f cmd
            in  parseri { infoParser = injectDefaultP env (path ++ [normalizeName cmd]) (infoParser parseri) }
      in  OptP (Option (CmdReader cmds (`M.lookup` cmdMap)) props)
-#if MIN_VERSION_optparse_applicative(0, 5, 0)
   | (Option (OptReader names (CReader _ rdr) _) _) <- o =
      p <|> either (const empty) pure (msum $ map (rdr <=< (maybe (Left $ ErrorMsg "Missing environment variable") Right . getEnvValue env path)) names)
-#else
-  | (Option (OptReader names (CReader _ rdr)) _) <- o =
-     p <|> maybe empty pure (msum $ map (rdr <=< getEnvValue env path) names)
-#endif
   | (Option (FlagReader names a) _) <- o =
      p <|> if any ((==Just "1") . getEnvValue env path) names then pure a else empty
   | otherwise = p
diff --git a/yesod/Scaffolding/Scaffolder.hs b/yesod-bin/Scaffolding/Scaffolder.hs
similarity index 100%
rename from yesod/Scaffolding/Scaffolder.hs
rename to yesod-bin/Scaffolding/Scaffolder.hs
diff --git a/yesod-default/Setup.lhs b/yesod-bin/Setup.lhs
similarity index 100%
rename from yesod-default/Setup.lhs
rename to yesod-bin/Setup.lhs
diff --git a/yesod/ghcwrapper.hs b/yesod-bin/ghcwrapper.hs
similarity index 100%
rename from yesod/ghcwrapper.hs
rename to yesod-bin/ghcwrapper.hs
diff --git a/yesod/hsfiles/mongo.hsfiles b/yesod-bin/hsfiles/mongo.hsfiles
similarity index 100%
rename from yesod/hsfiles/mongo.hsfiles
rename to yesod-bin/hsfiles/mongo.hsfiles
diff --git a/yesod/hsfiles/mysql.hsfiles b/yesod-bin/hsfiles/mysql.hsfiles
similarity index 100%
rename from yesod/hsfiles/mysql.hsfiles
rename to yesod-bin/hsfiles/mysql.hsfiles
diff --git a/yesod/hsfiles/postgres-fay.hsfiles b/yesod-bin/hsfiles/postgres-fay.hsfiles
similarity index 100%
rename from yesod/hsfiles/postgres-fay.hsfiles
rename to yesod-bin/hsfiles/postgres-fay.hsfiles
diff --git a/yesod/hsfiles/postgres.hsfiles b/yesod-bin/hsfiles/postgres.hsfiles
similarity index 100%
rename from yesod/hsfiles/postgres.hsfiles
rename to yesod-bin/hsfiles/postgres.hsfiles
diff --git a/yesod/hsfiles/simple.hsfiles b/yesod-bin/hsfiles/simple.hsfiles
similarity index 100%
rename from yesod/hsfiles/simple.hsfiles
rename to yesod-bin/hsfiles/simple.hsfiles
diff --git a/yesod/hsfiles/sqlite.hsfiles b/yesod-bin/hsfiles/sqlite.hsfiles
similarity index 100%
rename from yesod/hsfiles/sqlite.hsfiles
rename to yesod-bin/hsfiles/sqlite.hsfiles
diff --git a/yesod/input/database.cg b/yesod-bin/input/database.cg
similarity index 100%
rename from yesod/input/database.cg
rename to yesod-bin/input/database.cg
diff --git a/yesod/input/done.cg b/yesod-bin/input/done.cg
similarity index 100%
rename from yesod/input/done.cg
rename to yesod-bin/input/done.cg
diff --git a/yesod/input/welcome.cg b/yesod-bin/input/welcome.cg
similarity index 100%
rename from yesod/input/welcome.cg
rename to yesod-bin/input/welcome.cg
diff --git a/yesod/main.hs b/yesod-bin/main.hs
similarity index 94%
rename from yesod/main.hs
rename to yesod-bin/main.hs
index 9a8a482f..df72e2a1 100755
--- a/yesod/main.hs
+++ b/yesod-bin/main.hs
@@ -8,18 +8,14 @@ import           Options.Applicative
 import           System.Exit            (ExitCode (ExitSuccess), exitWith)
 import           System.Process         (rawSystem)
 
-import           Yesod.Core             (yesodVersion)
-
 import           AddHandler             (addHandler)
 import           Devel                  (DevelOpts (..), devel)
 import           Keter                  (keter)
 import           Options                (injectDefaults)
-import qualified Paths_yesod
+import qualified Paths_yesod_bin
 import           Scaffolding.Scaffolder
 
-#if MIN_VERSION_optparse_applicative(0, 5, 0)
 import           Options.Applicative.Builder.Internal (Mod, OptionFields)
-#endif
 
 #ifndef WINDOWS
 import           Build                  (touch)
@@ -98,8 +94,7 @@ main = do
     Touch                   -> touch'
     Devel da s f r b _ig es p t -> devel (DevelOpts (optCabalPgm o == CabalDev) da (optVerbose o) r s f b p t) es
     Keter noRebuild         -> keter (cabalCommand o) noRebuild
-    Version                 -> do putStrLn ("yesod-core version:" ++ yesodVersion)
-                                  putStrLn ("yesod version:" ++ showVersion Paths_yesod.version)
+    Version                 -> do putStrLn ("yesod-bin version: " ++ showVersion Paths_yesod_bin.version)
     AddHandler              -> addHandler
     Test                    -> do touch'
                                   cabal ["configure", "--enable-tests", "-flibrary-only"]
@@ -153,8 +148,8 @@ develOptions = Devel <$> switch ( long "disable-api"  <> short 'd'
                      <*> extraCabalArgs
                      <*> option ( long "port" <> short 'p' <> value 3000 <> metavar "N"
                             <> help "Devel server listening port" )
-                     <*> option ( long "proxy-timeout" <> short 'x' <> value 10 <> metavar "N"
-                            <> help "Devel server timeout before returning 'not ready' message (in seconds)" )
+                     <*> option ( long "proxy-timeout" <> short 'x' <> value 0 <> metavar "N"
+                            <> help "Devel server timeout before returning 'not ready' message (in seconds, 0 for none)" )
 
 extraCabalArgs :: Parser [String]
 extraCabalArgs = many (strOption ( long "extra-cabal-arg" <> short 'e' <> metavar "ARG"
@@ -166,11 +161,7 @@ optStr :: Mod OptionFields (Maybe String) -> Parser (Maybe String)
 optStr m =
     nullOption $ value Nothing <> reader (success . str)  <> m
   where
-#if MIN_VERSION_optparse_applicative(0, 5, 0)
     success = Right
-#else
-    success = Just
-#endif
 
 -- | Like @rawSystem@, but exits if it receives a non-success result.
 rawSystem' :: String -> [String] -> IO ()
diff --git a/yesod/update-hsfiles.sh b/yesod-bin/update-hsfiles.sh
similarity index 100%
rename from yesod/update-hsfiles.sh
rename to yesod-bin/update-hsfiles.sh
diff --git a/yesod-bin/yesod-bin.cabal b/yesod-bin/yesod-bin.cabal
new file mode 100644
index 00000000..b4257db9
--- /dev/null
+++ b/yesod-bin/yesod-bin.cabal
@@ -0,0 +1,103 @@
+name:            yesod-bin
+version:         1.2.0
+license:         MIT
+license-file:    LICENSE
+author:          Michael Snoyman <michael@snoyman.com>
+maintainer:      Michael Snoyman <michael@snoyman.com>
+synopsis:        The yesod helper executable.
+description:     Provides scaffolding, devel server, and some simple code generation helpers.
+category:        Web, Yesod
+stability:       Stable
+cabal-version:   >= 1.6
+build-type:      Simple
+homepage:        http://www.yesodweb.com/
+
+extra-source-files:
+  input/*.cg
+  hsfiles/mongo.hsfiles
+  hsfiles/mysql.hsfiles
+  hsfiles/postgres.hsfiles
+  hsfiles/postgres-fay.hsfiles
+  hsfiles/simple.hsfiles
+  hsfiles/sqlite.hsfiles
+
+executable             yesod-ghc-wrapper
+    main-is: ghcwrapper.hs
+    build-depends:
+                    base                       >= 4         && < 5
+                  , Cabal
+
+executable             yesod-ld-wrapper
+    main-is: ghcwrapper.hs
+    cpp-options:     -DLDCMD
+    build-depends:
+                    base                       >= 4         && < 5
+                  , Cabal
+executable             yesod-ar-wrapper
+    main-is: ghcwrapper.hs
+    cpp-options:     -DARCMD
+    build-depends:
+                     base                       >= 4         && < 5
+                   , Cabal
+
+executable             yesod
+    if os(windows)
+        cpp-options:     -DWINDOWS
+    build-depends:     base               >= 4.3          && < 5
+                     , ghc                >= 7.0.3        && < 7.8
+                     , ghc-paths          >= 0.1
+                     , parsec             >= 2.1          && < 4
+                     , text               >= 0.11
+                     , shakespeare-text   >= 1.0          && < 1.1
+                     , shakespeare        >= 1.0.2        && < 1.1
+                     , shakespeare-js     >= 1.0.2        && < 1.2
+                     , shakespeare-css    >= 1.0.2        && < 1.1
+                     , bytestring         >= 0.9.1.4
+                     , time               >= 1.1.4
+                     , template-haskell
+                     , directory          >= 1.0
+                     , Cabal
+                     , unix-compat        >= 0.2          && < 0.5
+                     , containers         >= 0.2
+                     , attoparsec         >= 0.10
+                     , http-types         >= 0.7
+                     , blaze-builder      >= 0.2.1.4      && < 0.4
+                     , filepath           >= 1.1
+                     , process
+                     , zlib               >= 0.5          && < 0.6
+                     , tar                >= 0.4          && < 0.5
+                     , system-filepath    >= 0.4          && < 0.5
+                     , system-fileio      >= 0.3          && < 0.4
+                     , unordered-containers
+                     , yaml               >= 0.8          && < 0.9
+                     , optparse-applicative >= 0.5
+                     , fsnotify           >= 0.0          && < 0.1
+                     , split              >= 0.2          && < 0.3
+                     , file-embed
+                     , conduit            >= 0.5          && < 1.1
+                     , resourcet          >= 0.3          && < 0.5
+                     , base64-bytestring
+                     , lifted-base
+                     , http-reverse-proxy >= 0.1.1
+                     , network
+                     , http-conduit
+                     , network-conduit
+                     , project-template   >= 0.1.1
+                     , transformers
+                     , warp               >= 1.3.7.5
+                     , wai                >= 1.4
+
+    ghc-options:       -Wall -threaded
+    main-is:           main.hs
+    other-modules:     Scaffolding.Scaffolder
+                       Devel
+                       Build
+                       GhcBuild
+                       Keter
+                       AddHandler
+                       Paths_yesod_bin
+                       Options
+
+source-repository head
+  type:     git
+  location: https://github.com/yesodweb/yesod
diff --git a/yesod-core/Yesod/Content.hs b/yesod-core/Yesod/Content.hs
deleted file mode 100644
index 0ececbb8..00000000
--- a/yesod-core/Yesod/Content.hs
+++ /dev/null
@@ -1,263 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE Rank2Types #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE CPP #-}
-module Yesod.Content
-    ( -- * Content
-      Content (..)
-    , emptyContent
-    , ToContent (..)
-      -- * Mime types
-      -- ** Data type
-    , ContentType
-    , typeHtml
-    , typePlain
-    , typeJson
-    , typeXml
-    , typeAtom
-    , typeRss
-    , typeJpeg
-    , typePng
-    , typeGif
-    , typeSvg
-    , typeJavascript
-    , typeCss
-    , typeFlv
-    , typeOgv
-    , typeOctet
-      -- * Utilities
-    , simpleContentType
-      -- * Evaluation strategy
-    , DontFullyEvaluate (..)
-      -- * Representations
-    , ChooseRep
-    , HasReps (..)
-    , defChooseRep
-      -- ** Specific content types
-    , RepHtml (..)
-    , RepJson (..)
-    , RepHtmlJson (..)
-    , RepPlain (..)
-    , RepXml (..)
-      -- * Utilities
-    , formatW3
-    , formatRFC1123
-    , formatRFC822
-    ) where
-
-import Data.Maybe (mapMaybe)
-import qualified Data.ByteString as B
-import qualified Data.ByteString.Lazy as L
-import Data.Text.Lazy (Text, pack)
-import qualified Data.Text as T
-
-import Data.Time
-import System.Locale
-
-import qualified Data.Text.Encoding
-import qualified Data.Text.Lazy.Encoding
-
-import Blaze.ByteString.Builder (Builder, fromByteString, fromLazyByteString)
-import Data.Monoid (mempty)
-
-import Text.Hamlet (Html)
-import Text.Blaze.Html.Renderer.Utf8 (renderHtmlBuilder)
-import Data.String (IsString (fromString))
-import Network.Wai (FilePart)
-import Data.Conduit (Source, ResourceT, Flush)
-
-import qualified Data.Aeson as J
-import Data.Aeson.Encode (fromValue)
-import qualified Blaze.ByteString.Builder.Char.Utf8 as Blaze
-import Data.Text.Lazy.Builder (toLazyText)
-
-data Content = ContentBuilder !Builder !(Maybe Int) -- ^ The content and optional content length.
-             | ContentSource !(Source (ResourceT IO) (Flush Builder))
-             | ContentFile !FilePath !(Maybe FilePart)
-             | ContentDontEvaluate !Content
-
--- | Zero-length enumerator.
-emptyContent :: Content
-emptyContent = ContentBuilder mempty $ Just 0
-
-instance IsString Content where
-    fromString = toContent
-
--- | Anything which can be converted into 'Content'. Most of the time, you will
--- want to use the 'ContentBuilder' constructor. An easier approach will be to use
--- a pre-defined 'toContent' function, such as converting your data into a lazy
--- bytestring and then calling 'toContent' on that.
---
--- Please note that the built-in instances for lazy data structures ('String',
--- lazy 'L.ByteString', lazy 'Text' and 'Html') will not automatically include
--- the content length for the 'ContentBuilder' constructor.
-class ToContent a where
-    toContent :: a -> Content
-
-instance ToContent Builder where
-    toContent = flip ContentBuilder Nothing
-instance ToContent B.ByteString where
-    toContent bs = ContentBuilder (fromByteString bs) $ Just $ B.length bs
-instance ToContent L.ByteString where
-    toContent = flip ContentBuilder Nothing . fromLazyByteString
-instance ToContent T.Text where
-    toContent = toContent . Data.Text.Encoding.encodeUtf8
-instance ToContent Text where
-    toContent = toContent . Data.Text.Lazy.Encoding.encodeUtf8
-instance ToContent String where
-    toContent = toContent . pack
-instance ToContent Html where
-    toContent bs = ContentBuilder (renderHtmlBuilder bs) Nothing
-
--- | A function which gives targetted representations of content based on the
--- content-types the user accepts.
-type ChooseRep =
-    [ContentType] -- ^ list of content-types user accepts, ordered by preference
- -> IO (ContentType, Content)
-
--- | Any type which can be converted to representations.
-class HasReps a where
-    chooseRep :: a -> ChooseRep
-
--- | A helper method for generating 'HasReps' instances.
---
--- This function should be given a list of pairs of content type and conversion
--- functions. If none of the content types match, the first pair is used.
-defChooseRep :: [(ContentType, a -> IO Content)] -> a -> ChooseRep
-defChooseRep reps a ts = do
-  let (ct, c) =
-        case mapMaybe helper ts of
-            (x:_) -> x
-            [] -> case reps of
-                    [] -> error "Empty reps to defChooseRep"
-                    (x:_) -> x
-  c' <- c a
-  return (ct, c')
-        where
-            helper ct = do
-                c <- lookup ct reps
-                return (ct, c)
-
-instance HasReps ChooseRep where
-    chooseRep = id
-
-instance HasReps () where
-    chooseRep = defChooseRep [(typePlain, const $ return $ toContent B.empty)]
-
-instance HasReps (ContentType, Content) where
-    chooseRep = const . return
-
-instance HasReps [(ContentType, Content)] where
-    chooseRep a cts = return $
-        case filter (\(ct, _) -> go ct `elem` map go cts) a of
-            ((ct, c):_) -> (ct, c)
-            _ -> case a of
-                    (x:_) -> x
-                    _ -> error "chooseRep [(ContentType, Content)] of empty"
-      where
-        go = simpleContentType
-
-newtype RepHtml = RepHtml Content
-instance HasReps RepHtml where
-    chooseRep (RepHtml c) _ = return (typeHtml, c)
-newtype RepJson = RepJson Content
-instance HasReps RepJson where
-    chooseRep (RepJson c) _ = return (typeJson, c)
-data RepHtmlJson = RepHtmlJson Content Content
-instance HasReps RepHtmlJson where
-    chooseRep (RepHtmlJson html json) = chooseRep
-        [ (typeHtml, html)
-        , (typeJson, json)
-        ]
-newtype RepPlain = RepPlain Content
-instance HasReps RepPlain where
-    chooseRep (RepPlain c) _ = return (typePlain, c)
-newtype RepXml = RepXml Content
-instance HasReps RepXml where
-    chooseRep (RepXml c) _ = return (typeXml, c)
-
-type ContentType = B.ByteString -- FIXME Text?
-
-typeHtml :: ContentType
-typeHtml = "text/html; charset=utf-8"
-
-typePlain :: ContentType
-typePlain = "text/plain; charset=utf-8"
-
-typeJson :: ContentType
-typeJson = "application/json; charset=utf-8"
-
-typeXml :: ContentType
-typeXml = "text/xml"
-
-typeAtom :: ContentType
-typeAtom = "application/atom+xml"
-
-typeRss :: ContentType
-typeRss = "application/rss+xml"
-
-typeJpeg :: ContentType
-typeJpeg = "image/jpeg"
-
-typePng :: ContentType
-typePng = "image/png"
-
-typeGif :: ContentType
-typeGif = "image/gif"
-
-typeSvg :: ContentType
-typeSvg = "image/svg+xml"
-
-typeJavascript :: ContentType
-typeJavascript = "text/javascript; charset=utf-8"
-
-typeCss :: ContentType
-typeCss = "text/css; charset=utf-8"
-
-typeFlv :: ContentType
-typeFlv = "video/x-flv"
-
-typeOgv :: ContentType
-typeOgv = "video/ogg"
-
-typeOctet :: ContentType
-typeOctet = "application/octet-stream"
-
--- | Removes \"extra\" information at the end of a content type string. In
--- particular, removes everything after the semicolon, if present.
---
--- For example, \"text/html; charset=utf-8\" is commonly used to specify the
--- character encoding for HTML data. This function would return \"text/html\".
-simpleContentType :: ContentType -> ContentType
-simpleContentType = fst . B.breakByte 59 -- 59 == ;
-
--- | Format a 'UTCTime' in W3 format.
-formatW3 :: UTCTime -> T.Text
-formatW3 = T.pack . formatTime defaultTimeLocale "%FT%X-00:00"
-
--- | Format as per RFC 1123.
-formatRFC1123 :: UTCTime -> T.Text
-formatRFC1123 = T.pack . formatTime defaultTimeLocale "%a, %d %b %Y %X %Z"
-
--- | Format as per RFC 822.
-formatRFC822 :: UTCTime -> T.Text
-formatRFC822 = T.pack . formatTime defaultTimeLocale "%a, %d %b %Y %H:%M:%S %z"
-
--- | Prevents a response body from being fully evaluated before sending the
--- request.
---
--- Since 1.1.0
-newtype DontFullyEvaluate a = DontFullyEvaluate a
-
-instance HasReps a => HasReps (DontFullyEvaluate a) where
-    chooseRep (DontFullyEvaluate a) = fmap (fmap (fmap ContentDontEvaluate)) $ chooseRep a
-
-instance ToContent a => ToContent (DontFullyEvaluate a) where
-    toContent (DontFullyEvaluate a) = ContentDontEvaluate $ toContent a
-
-instance ToContent J.Value where
-    toContent = flip ContentBuilder Nothing
-              . Blaze.fromLazyText
-              . toLazyText
-              . fromValue
diff --git a/yesod-core/Yesod/Core.hs b/yesod-core/Yesod/Core.hs
index 7268d6cb..2c9879b9 100644
--- a/yesod-core/Yesod/Core.hs
+++ b/yesod-core/Yesod/Core.hs
@@ -1,16 +1,24 @@
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeFamilies #-}
 {-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
 module Yesod.Core
     ( -- * Type classes
       Yesod (..)
     , YesodDispatch (..)
+    , YesodSubDispatch (..)
     , RenderRoute (..)
+    , ParseRoute (..)
+    , RouteAttrs (..)
       -- ** Breadcrumbs
     , YesodBreadcrumbs (..)
     , breadcrumbs
       -- * Types
     , Approot (..)
     , FileUpload (..)
+    , ErrorResponse (..)
       -- * Utitlities
     , maybeAuthorized
     , widgetToPageContent
@@ -35,41 +43,96 @@ module Yesod.Core
     , SessionBackend (..)
     , defaultClientSessionBackend
     , clientSessionBackend
-    , clientSessionBackend2
     , clientSessionDateCacher
     , loadClientSession
     , Header(..)
-    , BackendSession
     -- * JS loaders
-    , loadJsYepnope
     , ScriptLoadPosition (..)
     , BottomOfHeadAsync
+      -- * Subsites
+    , MonadHandler (..)
+    , MonadWidget (..)
+    , getRouteToParent
+    , defaultLayoutSub
       -- * Misc
     , yesodVersion
     , yesodRender
     , runFakeHandler
+      -- * LiteApp
+    , module Yesod.Core.Internal.LiteApp
+      -- * Low-level
+    , yesodRunner
       -- * Re-exports
-    , module Yesod.Content
-    , module Yesod.Dispatch
-    , module Yesod.Handler
-    , module Yesod.Request
-    , module Yesod.Widget
-    , module Yesod.Message
+    , module Yesod.Core.Content
+    , module Yesod.Core.Dispatch
+    , module Yesod.Core.Handler
+    , module Yesod.Core.Widget
+    , module Yesod.Core.Json
+    , module Text.Shakespeare.I18N
+    , module Yesod.Core.Internal.Util
+    , module Text.Blaze.Html
+    , MonadTrans (..)
+    , MonadIO (..)
+    , MonadBase (..)
+    , MonadBaseControl
+    , MonadResource (..)
+    , MonadLogger
     ) where
 
-import Yesod.Internal.Core
-import Yesod.Internal (Header(..))
-import Yesod.Content
-import Yesod.Dispatch
-import Yesod.Handler
-import Yesod.Request
-import Yesod.Widget
-import Yesod.Message
+import Yesod.Core.Content
+import Yesod.Core.Dispatch
+import Yesod.Core.Handler
+import Yesod.Core.Class.Handler
+import Yesod.Core.Widget
+import Yesod.Core.Json
+import Yesod.Core.Types
+import Text.Shakespeare.I18N
+import Yesod.Core.Internal.Util (formatW3 , formatRFC1123 , formatRFC822)
+import Text.Blaze.Html (Html, toHtml, preEscapedToMarkup)
 
 import Control.Monad.Logger
+import Control.Monad.Trans.Class (MonadTrans (..))
+import Yesod.Core.Internal.Session
+import Yesod.Core.Internal.Run (yesodRunner)
+import Yesod.Core.Class.Yesod
+import Yesod.Core.Class.Dispatch
+import Yesod.Core.Class.Breadcrumbs
+import Yesod.Core.Internal.Run (yesodRender, runFakeHandler)
+import qualified Paths_yesod_core
+import Data.Version (showVersion)
+import Yesod.Routes.Class
+import Control.Monad.IO.Class (MonadIO (..))
+import Control.Monad.Base (MonadBase (..))
+import Control.Monad.Trans.Control (MonadBaseControl (..))
+
+import Control.Monad.Trans.Resource (MonadResource (..))
+import Yesod.Core.Internal.LiteApp
 
 -- | Return an 'Unauthorized' value, with the given i18n message.
-unauthorizedI :: RenderMessage master msg => msg -> GHandler sub master AuthResult
-unauthorizedI msg =do
+unauthorizedI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => msg -> m AuthResult
+unauthorizedI msg = do
     mr <- getMessageRender
     return $ Unauthorized $ mr msg
+
+yesodVersion :: String
+yesodVersion = showVersion Paths_yesod_core.version
+
+-- | Return the same URL if the user is authorized to see it.
+--
+-- Built on top of 'isAuthorized'. This is useful for building page that only
+-- contain links to pages the user is allowed to see.
+maybeAuthorized :: Yesod site
+                => Route site
+                -> Bool -- ^ is this a write request?
+                -> HandlerT site IO (Maybe (Route site))
+maybeAuthorized r isWrite = do
+    x <- isAuthorized r isWrite
+    return $ if x == Authorized then Just r else Nothing
+
+getRouteToParent :: Monad m => HandlerT child (HandlerT parent m) (Route child -> Route parent)
+getRouteToParent = HandlerT $ return . handlerToParent
+
+defaultLayoutSub :: Yesod parent
+                 => WidgetT child IO ()
+                 -> HandlerT child (HandlerT parent IO) Html
+defaultLayoutSub cwidget = widgetToParentWidget cwidget >>= lift . defaultLayout
diff --git a/yesod-core/Yesod/Core/Class/Breadcrumbs.hs b/yesod-core/Yesod/Core/Class/Breadcrumbs.hs
new file mode 100644
index 00000000..84586055
--- /dev/null
+++ b/yesod-core/Yesod/Core/Class/Breadcrumbs.hs
@@ -0,0 +1,31 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Yesod.Core.Class.Breadcrumbs where
+
+import Yesod.Core.Handler
+import Yesod.Routes.Class
+import Data.Text (Text)
+
+-- | A type-safe, concise method of creating breadcrumbs for pages. For each
+-- resource, you declare the title of the page and the parent resource (if
+-- present).
+class YesodBreadcrumbs site where
+    -- | Returns the title and the parent resource, if available. If you return
+    -- a 'Nothing', then this is considered a top-level page.
+    breadcrumb :: Route site -> HandlerT site IO (Text , Maybe (Route site))
+
+-- | Gets the title of the current page and the hierarchy of parent pages,
+-- along with their respective titles.
+breadcrumbs :: YesodBreadcrumbs site => HandlerT site IO (Text, [(Route site, Text)])
+breadcrumbs = do
+    x <- getCurrentRoute
+    case x of
+        Nothing -> return ("Not found", [])
+        Just y -> do
+            (title, next) <- breadcrumb y
+            z <- go [] next
+            return (title, z)
+  where
+    go back Nothing = return back
+    go back (Just this) = do
+        (title, next) <- breadcrumb this
+        go ((this, title) : back) next
diff --git a/yesod-core/Yesod/Core/Class/Dispatch.hs b/yesod-core/Yesod/Core/Class/Dispatch.hs
new file mode 100644
index 00000000..fe014ac2
--- /dev/null
+++ b/yesod-core/Yesod/Core/Class/Dispatch.hs
@@ -0,0 +1,43 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ViewPatterns #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleContexts  #-}
+module Yesod.Core.Class.Dispatch where
+
+import Yesod.Routes.Class
+import qualified Network.Wai as W
+import Yesod.Core.Types
+import Yesod.Core.Content
+import Yesod.Core.Class.Yesod
+import Yesod.Core.Class.Handler
+import Yesod.Core.Internal.Run
+
+-- | This class is automatically instantiated when you use the template haskell
+-- mkYesod function. You should never need to deal with it directly.
+class Yesod site => YesodDispatch site where
+    yesodDispatch :: YesodRunnerEnv site -> W.Application
+
+class YesodSubDispatch sub m where
+    yesodSubDispatch :: YesodSubRunnerEnv sub (HandlerSite m) m
+                     -> W.Application
+
+instance YesodSubDispatch WaiSubsite master where
+    yesodSubDispatch YesodSubRunnerEnv {..} req =
+        app req
+      where
+        WaiSubsite app = ysreGetSub $ yreSite $ ysreParentEnv
+
+-- | A helper function for creating YesodSubDispatch instances, used by the
+-- internal generated code.
+subHelper :: Monad m -- NOTE: This is incredibly similar in type signature to yesodRunner, should probably be pointed out/explained.
+          => HandlerT child (HandlerT parent m) TypedContent
+          -> YesodSubRunnerEnv child parent (HandlerT parent m)
+          -> Maybe (Route child)
+          -> W.Application
+subHelper handlert YesodSubRunnerEnv {..} route =
+    ysreParentRunner base ysreParentEnv (fmap ysreToParentRoute route)
+  where
+    base = stripHandlerT (fmap toTypedContent handlert) ysreGetSub ysreToParentRoute route
diff --git a/yesod-core/Yesod/Core/Class/Handler.hs b/yesod-core/Yesod/Core/Class/Handler.hs
new file mode 100644
index 00000000..370956b8
--- /dev/null
+++ b/yesod-core/Yesod/Core/Class/Handler.hs
@@ -0,0 +1,92 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE TupleSections #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE UndecidableInstances #-}
+module Yesod.Core.Class.Handler
+    ( MonadHandler (..)
+    , MonadWidget (..)
+    ) where
+
+import Yesod.Core.Types
+import Data.Monoid (mempty)
+import Control.Monad (liftM)
+import Control.Monad.IO.Class (MonadIO, liftIO)
+import Control.Monad.Trans.Resource (MonadResource, MonadResourceBase, ExceptionT (..))
+import Control.Monad.Trans.Class (lift)
+import Data.Monoid (Monoid)
+import Data.Conduit.Internal (Pipe, ConduitM)
+
+import Control.Monad.Trans.Identity ( IdentityT)
+import Control.Monad.Trans.List     ( ListT    )
+import Control.Monad.Trans.Maybe    ( MaybeT   )
+import Control.Monad.Trans.Error    ( ErrorT, Error)
+import Control.Monad.Trans.Reader   ( ReaderT  )
+import Control.Monad.Trans.State    ( StateT   )
+import Control.Monad.Trans.Writer   ( WriterT  )
+import Control.Monad.Trans.RWS      ( RWST     )
+import qualified Control.Monad.Trans.RWS.Strict    as Strict ( RWST   )
+import qualified Control.Monad.Trans.State.Strict  as Strict ( StateT )
+import qualified Control.Monad.Trans.Writer.Strict as Strict ( WriterT )
+
+class MonadResource m => MonadHandler m where
+    type HandlerSite m
+    liftHandlerT :: HandlerT (HandlerSite m) IO a -> m a
+
+replaceToParent :: HandlerData site route -> HandlerData site ()
+replaceToParent hd = hd { handlerToParent = const () }
+
+instance MonadResourceBase m => MonadHandler (HandlerT site m) where
+    type HandlerSite (HandlerT site m) = site
+    liftHandlerT (HandlerT f) = HandlerT $ liftIO . f . replaceToParent
+{-# RULES "liftHandlerT (HandlerT site IO)" forall action. liftHandlerT action = id #-}
+
+instance MonadResourceBase m => MonadHandler (WidgetT site m) where
+    type HandlerSite (WidgetT site m) = site
+    liftHandlerT (HandlerT f) = WidgetT $ liftIO . liftM (, mempty) . f . replaceToParent
+{-# RULES "liftHandlerT (WidgetT site IO)" forall f. liftHandlerT (HandlerT f) = WidgetT $ liftM (, mempty) . f #-}
+
+#define GO(T) instance MonadHandler m => MonadHandler (T m) where type HandlerSite (T m) = HandlerSite m; liftHandlerT = lift . liftHandlerT
+#define GOX(X, T) instance (X, MonadHandler m) => MonadHandler (T m) where type HandlerSite (T m) = HandlerSite m; liftHandlerT = lift . liftHandlerT
+GO(IdentityT)
+GO(ListT)
+GO(MaybeT)
+GOX(Error e, ErrorT e)
+GO(ReaderT r)
+GO(StateT s)
+GOX(Monoid w, WriterT w)
+GOX(Monoid w, RWST r w s)
+GOX(Monoid w, Strict.RWST r w s)
+GO(Strict.StateT s)
+GOX(Monoid w, Strict.WriterT w)
+GO(ExceptionT)
+GO(Pipe l i o u)
+GO(ConduitM i o)
+#undef GO
+#undef GOX
+
+class MonadHandler m => MonadWidget m where
+    liftWidgetT :: WidgetT (HandlerSite m) IO a -> m a
+instance MonadResourceBase m => MonadWidget (WidgetT site m) where
+    liftWidgetT (WidgetT f) = WidgetT $ liftIO . f . replaceToParent
+
+#define GO(T) instance MonadWidget m => MonadWidget (T m) where liftWidgetT = lift . liftWidgetT
+#define GOX(X, T) instance (X, MonadWidget m) => MonadWidget (T m) where liftWidgetT = lift . liftWidgetT
+GO(IdentityT)
+GO(ListT)
+GO(MaybeT)
+GOX(Error e, ErrorT e)
+GO(ReaderT r)
+GO(StateT s)
+GOX(Monoid w, WriterT w)
+GOX(Monoid w, RWST r w s)
+GOX(Monoid w, Strict.RWST r w s)
+GO(Strict.StateT s)
+GOX(Monoid w, Strict.WriterT w)
+GO(ExceptionT)
+GO(Pipe l i o u)
+GO(ConduitM i o)
+#undef GO
+#undef GOX
diff --git a/yesod-core/Yesod/Core/Class/Yesod.hs b/yesod-core/Yesod/Core/Class/Yesod.hs
new file mode 100644
index 00000000..ee964a23
--- /dev/null
+++ b/yesod-core/Yesod/Core/Class/Yesod.hs
@@ -0,0 +1,603 @@
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE TemplateHaskell   #-}
+module Yesod.Core.Class.Yesod where
+
+import           Control.Monad.Logger               (logErrorS)
+import           Yesod.Core.Content
+import           Yesod.Core.Handler
+
+import           Yesod.Routes.Class
+
+import           Blaze.ByteString.Builder           (Builder)
+import           Blaze.ByteString.Builder.Char.Utf8 (fromText)
+import           Control.Arrow                      ((***))
+import           Control.Monad                      (forM, when, void)
+import           Control.Monad.IO.Class             (MonadIO (liftIO))
+import           Control.Monad.Logger               (LogLevel (LevelInfo, LevelOther),
+                                                     LogSource)
+import qualified Data.ByteString.Char8              as S8
+import qualified Data.ByteString.Lazy               as L
+import Data.Aeson (object, (.=))
+import           Data.List                          (foldl')
+import           Data.List                          (nub)
+import qualified Data.Map                           as Map
+import           Data.Maybe                         (fromMaybe)
+import           Data.Monoid
+import           Data.Text                          (Text)
+import qualified Data.Text                          as T
+import qualified Data.Text.Encoding                 as TE
+import qualified Data.Text.Encoding.Error           as TEE
+import           Data.Text.Lazy.Builder             (toLazyText)
+import           Data.Text.Lazy.Encoding            (encodeUtf8)
+import           Data.Word                          (Word64)
+import           Language.Haskell.TH.Syntax         (Loc (..))
+import           Network.HTTP.Types                 (encodePath)
+import qualified Network.Wai                        as W
+import           Data.Default                       (def)
+import           Network.Wai.Parse                  (lbsBackEnd,
+                                                     tempFileBackEnd)
+import           System.IO                          (stdout)
+import           System.Log.FastLogger              (LogStr (..), Logger,
+                                                     loggerDate, loggerPutStr,
+                                                     mkLogger)
+import           System.Log.FastLogger.Date         (ZonedDate)
+import           Text.Blaze                         (customAttribute, textTag,
+                                                     toValue, (!))
+import           Text.Blaze                         (preEscapedToMarkup)
+import qualified Text.Blaze.Html5                   as TBH
+import           Text.Hamlet
+import           Text.Julius
+import qualified Web.ClientSession                  as CS
+import           Web.Cookie                         (parseCookies)
+import           Web.Cookie                         (SetCookie (..))
+import           Yesod.Core.Types
+import           Yesod.Core.Internal.Session
+import           Yesod.Core.Widget
+import Control.Monad.Trans.Class (lift)
+
+-- | Define settings for a Yesod applications. All methods have intelligent
+-- defaults, and therefore no implementation is required.
+class RenderRoute site => Yesod site where
+    -- | An absolute URL to the root of the application. Do not include
+    -- trailing slash.
+    --
+    -- Default value: 'ApprootRelative'. This is valid under the following
+    -- conditions:
+    --
+    -- * Your application is served from the root of the domain.
+    --
+    -- * You do not use any features that require absolute URLs, such as Atom
+    -- feeds and XML sitemaps.
+    --
+    -- If this is not true, you should override with a different
+    -- implementation.
+    approot :: Approot site
+    approot = ApprootRelative
+
+    -- | Output error response pages.
+    --
+    -- Default value: 'defaultErrorHandler'.
+    errorHandler :: ErrorResponse -> HandlerT site IO TypedContent
+    errorHandler = defaultErrorHandler
+
+    -- | Applies some form of layout to the contents of a page.
+    defaultLayout :: WidgetT site IO () -> HandlerT site IO RepHtml
+    defaultLayout w = do
+        p <- widgetToPageContent w
+        mmsg <- getMessage
+        hamletToRepHtml [hamlet|
+            $newline never
+            $doctype 5
+            <html>
+                <head>
+                    <title>#{pageTitle p}
+                    ^{pageHead p}
+                <body>
+                    $maybe msg <- mmsg
+                        <p .message>#{msg}
+                    ^{pageBody p}
+            |]
+
+    -- | Override the rendering function for a particular URL. One use case for
+    -- this is to offload static hosting to a different domain name to avoid
+    -- sending cookies.
+    urlRenderOverride :: site -> Route site -> Maybe Builder
+    urlRenderOverride _ _ = Nothing
+
+    -- | Determine if a request is authorized or not.
+    --
+    -- Return 'Authorized' if the request is authorized,
+    -- 'Unauthorized' a message if unauthorized.
+    -- If authentication is required, return 'AuthenticationRequired'.
+    isAuthorized :: Route site
+                 -> Bool -- ^ is this a write request?
+                 -> HandlerT site IO AuthResult
+    isAuthorized _ _ = return Authorized
+
+    -- | Determines whether the current request is a write request. By default,
+    -- this assumes you are following RESTful principles, and determines this
+    -- from request method. In particular, all except the following request
+    -- methods are considered write: GET HEAD OPTIONS TRACE.
+    --
+    -- This function is used to determine if a request is authorized; see
+    -- 'isAuthorized'.
+    isWriteRequest :: Route site -> HandlerT site IO Bool
+    isWriteRequest _ = do
+        wai <- waiRequest
+        return $ W.requestMethod wai `notElem`
+            ["GET", "HEAD", "OPTIONS", "TRACE"]
+
+    -- | The default route for authentication.
+    --
+    -- Used in particular by 'isAuthorized', but library users can do whatever
+    -- they want with it.
+    authRoute :: site -> Maybe (Route site)
+    authRoute _ = Nothing
+
+    -- | A function used to clean up path segments. It returns 'Right' with a
+    -- clean path or 'Left' with a new set of pieces the user should be
+    -- redirected to. The default implementation enforces:
+    --
+    -- * No double slashes
+    --
+    -- * There is no trailing slash.
+    --
+    -- Note that versions of Yesod prior to 0.7 used a different set of rules
+    -- involing trailing slashes.
+    cleanPath :: site -> [Text] -> Either [Text] [Text]
+    cleanPath _ s =
+        if corrected == s
+            then Right $ map dropDash s
+            else Left corrected
+      where
+        corrected = filter (not . T.null) s
+        dropDash t
+            | T.all (== '-') t = T.drop 1 t
+            | otherwise = t
+
+    -- | Builds an absolute URL by concatenating the application root with the
+    -- pieces of a path and a query string, if any.
+    -- Note that the pieces of the path have been previously cleaned up by 'cleanPath'.
+    joinPath :: site
+             -> T.Text -- ^ application root
+             -> [T.Text] -- ^ path pieces
+             -> [(T.Text, T.Text)] -- ^ query string
+             -> Builder
+    joinPath _ ar pieces' qs' =
+        fromText ar `mappend` encodePath pieces qs
+      where
+        pieces = if null pieces' then [""] else map addDash pieces'
+        qs = map (TE.encodeUtf8 *** go) qs'
+        go "" = Nothing
+        go x = Just $ TE.encodeUtf8 x
+        addDash t
+            | T.all (== '-') t = T.cons '-' t
+            | otherwise = t
+
+    -- | This function is used to store some static content to be served as an
+    -- external file. The most common case of this is stashing CSS and
+    -- JavaScript content in an external file; the "Yesod.Widget" module uses
+    -- this feature.
+    --
+    -- The return value is 'Nothing' if no storing was performed; this is the
+    -- default implementation. A 'Just' 'Left' gives the absolute URL of the
+    -- file, whereas a 'Just' 'Right' gives the type-safe URL. The former is
+    -- necessary when you are serving the content outside the context of a
+    -- Yesod application, such as via memcached.
+    addStaticContent :: Text -- ^ filename extension
+                     -> Text -- ^ mime-type
+                     -> L.ByteString -- ^ content
+                     -> HandlerT site IO (Maybe (Either Text (Route site, [(Text, Text)])))
+    addStaticContent _ _ _ = return Nothing
+
+    -- | Maximum allowed length of the request body, in bytes.
+    --
+    -- If @Nothing@, no maximum is applied.
+    --
+    -- Default: 2 megabytes.
+    maximumContentLength :: site -> Maybe (Route site) -> Maybe Word64
+    maximumContentLength _ _ = Just $ 2 * 1024 * 1024 -- 2 megabytes
+
+    -- | Creates a @Logger@ to use for log messages.
+    --
+    -- Note that a common technique (endorsed by the scaffolding) is to create
+    -- a @Logger@ value and place it in your foundation datatype, and have this
+    -- method return that already created value. That way, you can use that
+    -- same @Logger@ for printing messages during app initialization.
+    --
+    -- Default: Sends to stdout and automatically flushes on each write.
+    makeLogger :: site -> IO Logger
+    makeLogger _ = mkLogger True stdout
+
+    -- | Send a message to the @Logger@ provided by @getLogger@.
+    --
+    -- Default implementation: checks if the message should be logged using
+    -- 'shouldLog' and, if so, formats using 'formatLogMessage'.
+    messageLoggerSource :: site
+                        -> Logger
+                        -> Loc -- ^ position in source code
+                        -> LogSource
+                        -> LogLevel
+                        -> LogStr -- ^ message
+                        -> IO ()
+    messageLoggerSource a logger loc source level msg =
+        when (shouldLog a source level) $
+            formatLogMessage (loggerDate logger) loc source level msg >>= loggerPutStr logger
+
+    -- | Where to Load sripts from. We recommend the default value,
+    -- 'BottomOfBody'.  Alternatively use the built in async yepnope loader:
+    --
+    -- > BottomOfHeadAsync $ loadJsYepnope $ Right $ StaticR js_modernizr_js
+    --
+    -- Or write your own async js loader.
+    jsLoader :: site -> ScriptLoadPosition site
+    jsLoader _ = BottomOfBody
+
+    -- | Create a session backend. Returning `Nothing' disables sessions.
+    --
+    -- Default: Uses clientsession with a 2 hour timeout.
+    makeSessionBackend :: site -> IO (Maybe SessionBackend)
+    makeSessionBackend _ = fmap Just $ defaultClientSessionBackend 120 CS.defaultKeyFile
+
+    -- | How to store uploaded files.
+    --
+    -- Default: When the request body is greater than 50kb, store in a temp
+    -- file. For chunked request bodies, store in a temp file. Otherwise, store
+    -- in memory.
+    fileUpload :: site -> W.RequestBodyLength -> FileUpload
+    fileUpload _ (W.KnownLength size)
+        | size <= 50000 = FileUploadMemory lbsBackEnd
+    fileUpload _ _ = FileUploadDisk tempFileBackEnd
+
+    -- | Should we log the given log source/level combination.
+    --
+    -- Default: Logs everything at or above 'logLevel'
+    shouldLog :: site -> LogSource -> LogLevel -> Bool
+    shouldLog _ _ level = level >= LevelInfo
+
+    -- | A Yesod middleware, which will wrap every handler function. This
+    -- allows you to run code before and after a normal handler.
+    --
+    -- Default: the 'defaultYesodMiddleware' function.
+    --
+    -- Since: 1.1.6
+    yesodMiddleware :: HandlerT site IO res -> HandlerT site IO res
+    yesodMiddleware = defaultYesodMiddleware
+
+-- | Default implementation of 'yesodMiddleware'. Adds the response header
+-- \"Vary: Accept, Accept-Language\" and performs authorization checks.
+--
+-- Since 1.2.0
+defaultYesodMiddleware :: Yesod site => HandlerT site IO res -> HandlerT site IO res
+defaultYesodMiddleware handler = do
+    addHeader "Vary" "Accept, Accept-Language"
+    authorizationCheck
+    handler
+
+-- | Check if a given request is authorized via 'isAuthorized' and
+-- 'isWriteRequest'.
+--
+-- Since 1.2.0
+authorizationCheck :: Yesod site => HandlerT site IO ()
+authorizationCheck = do
+    getCurrentRoute >>= maybe (return ()) checkUrl
+  where
+    checkUrl url = do
+        isWrite <- isWriteRequest url
+        ar <- isAuthorized url isWrite
+        case ar of
+            Authorized -> return ()
+            AuthenticationRequired -> do
+                master <- getYesod
+                case authRoute master of
+                    Nothing -> void $ notAuthenticated
+                    Just url' -> do
+                      void $ selectRep $ do
+                          provideRepType typeHtml $ do
+                              setUltDestCurrent
+                              void $ redirect url'
+                          provideRepType typeJson $
+                              void $ notAuthenticated
+            Unauthorized s' -> permissionDenied s'
+
+-- | Convert a widget to a 'PageContent'.
+widgetToPageContent :: (Eq (Route site), Yesod site)
+                    => WidgetT site IO ()
+                    -> HandlerT site IO (PageContent (Route site))
+widgetToPageContent w = do
+    master <- getYesod
+    hd <- HandlerT return
+    ((), GWData (Body body) (Last mTitle) scripts' stylesheets' style jscript (Head head')) <- lift $ unWidgetT w hd
+    let title = maybe mempty unTitle mTitle
+        scripts = runUniqueList scripts'
+        stylesheets = runUniqueList stylesheets'
+
+    render <- getUrlRenderParams
+    let renderLoc x =
+            case x of
+                Nothing -> Nothing
+                Just (Left s) -> Just s
+                Just (Right (u, p)) -> Just $ render u p
+    css <- forM (Map.toList style) $ \(mmedia, content) -> do
+        let rendered = toLazyText $ content render
+        x <- addStaticContent "css" "text/css; charset=utf-8"
+           $ encodeUtf8 rendered
+        return (mmedia,
+            case x of
+                Nothing -> Left $ preEscapedToMarkup rendered
+                Just y -> Right $ either id (uncurry render) y)
+    jsLoc <-
+        case jscript of
+            Nothing -> return Nothing
+            Just s -> do
+                x <- addStaticContent "js" "text/javascript; charset=utf-8"
+                   $ encodeUtf8 $ renderJavascriptUrl render s
+                return $ renderLoc x
+
+    -- modernizr should be at the end of the <head> http://www.modernizr.com/docs/#installing
+    -- the asynchronous loader means your page doesn't have to wait for all the js to load
+    let (mcomplete, asyncScripts) = asyncHelper render scripts jscript jsLoc
+        regularScriptLoad = [hamlet|
+            $newline never
+            $forall s <- scripts
+                ^{mkScriptTag s}
+            $maybe j <- jscript
+                $maybe s <- jsLoc
+                    <script src="#{s}">
+                $nothing
+                    <script>^{jelper j}
+        |]
+
+        headAll = [hamlet|
+            $newline never
+            \^{head'}
+            $forall s <- stylesheets
+                ^{mkLinkTag s}
+            $forall s <- css
+                $maybe t <- right $ snd s
+                    $maybe media <- fst s
+                        <link rel=stylesheet media=#{media} href=#{t}>
+                    $nothing
+                        <link rel=stylesheet href=#{t}>
+                $maybe content <- left $ snd s
+                    $maybe media <- fst s
+                        <style media=#{media}>#{content}
+                    $nothing
+                        <style>#{content}
+            $case jsLoader master
+              $of BottomOfBody
+              $of BottomOfHeadAsync asyncJsLoader
+                  ^{asyncJsLoader asyncScripts mcomplete}
+              $of BottomOfHeadBlocking
+                  ^{regularScriptLoad}
+        |]
+    let bodyScript = [hamlet|
+            $newline never
+            ^{body}
+            ^{regularScriptLoad}
+        |]
+
+    return $ PageContent title headAll $
+        case jsLoader master of
+            BottomOfBody -> bodyScript
+            _ -> body
+  where
+    renderLoc' render' (Local url) = render' url []
+    renderLoc' _ (Remote s) = s
+
+    addAttr x (y, z) = x ! customAttribute (textTag y) (toValue z)
+    mkScriptTag (Script loc attrs) render' =
+        foldl' addAttr TBH.script (("src", renderLoc' render' loc) : attrs) $ return ()
+    mkLinkTag (Stylesheet loc attrs) render' =
+        foldl' addAttr TBH.link
+            ( ("rel", "stylesheet")
+            : ("href", renderLoc' render' loc)
+            : attrs
+            )
+
+    runUniqueList :: Eq x => UniqueList x -> [x]
+    runUniqueList (UniqueList x) = nub $ x []
+
+-- | The default error handler for 'errorHandler'.
+defaultErrorHandler :: Yesod site => ErrorResponse -> HandlerT site IO TypedContent
+defaultErrorHandler NotFound = selectRep $ do
+    provideRep $ defaultLayout $ do
+        r <- waiRequest
+        let path' = TE.decodeUtf8With TEE.lenientDecode $ W.rawPathInfo r
+        setTitle "Not Found"
+        toWidget [hamlet|
+            <h1>Not Found
+            <p>#{path'}
+        |]
+    provideRep $ return $ object ["message" .= ("Not Found" :: Text)]
+
+-- For API requests.
+-- For a user with a browser,
+-- if you specify an authRoute the user will be redirected there and
+-- this page will not be shown.
+defaultErrorHandler NotAuthenticated = selectRep $ do
+    provideRep $ defaultLayout $ do
+        setTitle "Not logged in"
+        toWidget [hamlet|
+            <h1>Not logged in
+            <p style="display:none;">Set the authRoute and the user will be redirected there.
+        |]
+
+    provideRep $ do
+        -- 401 *MUST* include a WWW-Authenticate header
+        -- however, there is no standard to indicate a redirection
+        --
+        -- change this to Basic or Digest if you allow those forms of authentications
+        addHeader "WWW-Authenticate" "RedirectJSON realm=\"application\", param=\"authentication_url\""
+
+        -- The client will just use the authentication_url in the JSON
+        site <- getYesod
+        rend <- getUrlRender
+        return $ object $ [
+          "message" .= ("Not logged in"::Text)
+          ] ++
+          case authRoute site of
+              Nothing -> []
+              Just url -> ["authentication_url" .= rend url]
+
+defaultErrorHandler (PermissionDenied msg) = selectRep $ do
+    provideRep $ defaultLayout $ do
+        setTitle "Permission Denied"
+        toWidget [hamlet|
+            <h1>Permission denied
+            <p>#{msg}
+        |]
+    provideRep $
+        return $ object $ [
+          "message" .= ("Permission Denied. " <> msg)
+          ]
+
+defaultErrorHandler (InvalidArgs ia) = selectRep $ do
+    provideRep $ defaultLayout $ do
+        setTitle "Invalid Arguments"
+        toWidget [hamlet|
+            <h1>Invalid Arguments
+            <ul>
+                $forall msg <- ia
+                    <li>#{msg}
+        |]
+    provideRep $ return $ object ["message" .= ("Invalid Arguments" :: Text), "errors" .= ia]
+defaultErrorHandler (InternalError e) = do
+    $logErrorS "yesod-core" e
+    selectRep $ do
+        provideRep $ defaultLayout $ do
+            setTitle "Internal Server Error"
+            toWidget [hamlet|
+                <h1>Internal Server Error
+                <pre>#{e}
+            |]
+        provideRep $ return $ object ["message" .= ("Internal Server Error" :: Text), "error" .= e]
+defaultErrorHandler (BadMethod m) = selectRep $ do
+    provideRep $ defaultLayout $ do
+        setTitle"Bad Method"
+        toWidget [hamlet|
+            <h1>Method Not Supported
+            <p>Method <code>#{S8.unpack m}</code> not supported
+        |]
+    provideRep $ return $ object ["message" .= ("Bad method" :: Text), "method" .= m]
+
+asyncHelper :: (url -> [x] -> Text)
+         -> [Script (url)]
+         -> Maybe (JavascriptUrl (url))
+         -> Maybe Text
+         -> (Maybe (HtmlUrl url), [Text])
+asyncHelper render scripts jscript jsLoc =
+    (mcomplete, scripts'')
+  where
+    scripts' = map goScript scripts
+    scripts'' =
+        case jsLoc of
+            Just s -> scripts' ++ [s]
+            Nothing -> scripts'
+    goScript (Script (Local url) _) = render url []
+    goScript (Script (Remote s) _) = s
+    mcomplete =
+        case jsLoc of
+            Just{} -> Nothing
+            Nothing ->
+                case jscript of
+                    Nothing -> Nothing
+                    Just j -> Just $ jelper j
+
+formatLogMessage :: IO ZonedDate
+                 -> Loc
+                 -> LogSource
+                 -> LogLevel
+                 -> LogStr -- ^ message
+                 -> IO [LogStr]
+formatLogMessage getdate loc src level msg = do
+    now <- getdate
+    return
+        [ LB now
+        , LB " ["
+        , LS $
+            case level of
+                LevelOther t -> T.unpack t
+                _ -> drop 5 $ show level
+        , LS $
+            if T.null src
+                then ""
+                else "#" ++ T.unpack src
+        , LB "] "
+        , msg
+        , LB " @("
+        , LS $ fileLocationToString loc
+        , LB ")\n"
+        ]
+
+defaultClientSessionBackend :: Int -- ^ minutes
+                            -> FilePath -- ^ key file
+                            -> IO SessionBackend
+defaultClientSessionBackend minutes fp = do
+  key <- CS.getKey fp
+  let timeout = fromIntegral (minutes * 60)
+  (getCachedDate, _closeDateCacher) <- clientSessionDateCacher timeout
+  return $ clientSessionBackend key getCachedDate
+
+jsToHtml :: Javascript -> Html
+jsToHtml (Javascript b) = preEscapedToMarkup $ toLazyText b
+
+jelper :: JavascriptUrl url -> HtmlUrl url
+jelper = fmap jsToHtml
+
+left :: Either a b -> Maybe a
+left (Left x) = Just x
+left _ = Nothing
+
+right :: Either a b -> Maybe b
+right (Right x) = Just x
+right _ = Nothing
+
+clientSessionBackend :: CS.Key  -- ^ The encryption key
+                     -> IO ClientSessionDateCache -- ^ See 'clientSessionDateCacher'
+                     -> SessionBackend
+clientSessionBackend key getCachedDate =
+  SessionBackend {
+    sbLoadSession = loadClientSession key getCachedDate "_SESSION"
+  }
+
+loadClientSession :: CS.Key
+                  -> IO ClientSessionDateCache -- ^ See 'clientSessionDateCacher'
+                  -> S8.ByteString -- ^ session name
+                  -> W.Request
+                  -> IO (SessionMap, SaveSession)
+loadClientSession key getCachedDate sessionName req = load
+  where
+    load = do
+      date <- getCachedDate
+      return (sess date, save date)
+    sess date = fromMaybe Map.empty $ do
+      raw <- lookup "Cookie" $ W.requestHeaders req
+      val <- lookup sessionName $ parseCookies raw
+      let host = "" -- fixme, properly lock sessions to client address
+      decodeClientSession key date host val
+    save date sess' = do
+      -- We should never cache the IV!  Be careful!
+      iv <- liftIO CS.randomIV
+      return [AddCookie def
+          { setCookieName = sessionName
+          , setCookieValue = encodeClientSession key iv date host sess'
+          , setCookiePath = Just "/"
+          , setCookieExpires = Just (csdcExpires date)
+          , setCookieDomain = Nothing
+          , setCookieHttpOnly = True
+          }]
+        where
+          host = "" -- fixme, properly lock sessions to client address
+
+-- taken from file-location package
+-- turn the TH Loc loaction information into a human readable string
+-- leaving out the loc_end parameter
+fileLocationToString :: Loc -> String
+fileLocationToString loc = (loc_package loc) ++ ':' : (loc_module loc) ++
+  ' ' : (loc_filename loc) ++ ':' : (line loc) ++ ':' : (char loc)
+  where
+    line = show . fst . loc_start
+    char = show . snd . loc_start
diff --git a/yesod-core/Yesod/Core/Content.hs b/yesod-core/Yesod/Core/Content.hs
new file mode 100644
index 00000000..2a9e5d9d
--- /dev/null
+++ b/yesod-core/Yesod/Core/Content.hs
@@ -0,0 +1,278 @@
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE CPP #-}
+module Yesod.Core.Content
+    ( -- * Content
+      Content (..)
+    , emptyContent
+    , ToContent (..)
+    , ToFlushBuilder (..)
+      -- * Mime types
+      -- ** Data type
+    , ContentType
+    , typeHtml
+    , typePlain
+    , typeJson
+    , typeXml
+    , typeAtom
+    , typeRss
+    , typeJpeg
+    , typePng
+    , typeGif
+    , typeSvg
+    , typeJavascript
+    , typeCss
+    , typeFlv
+    , typeOgv
+    , typeOctet
+      -- * Utilities
+    , simpleContentType
+    , contentTypeTypes
+      -- * Evaluation strategy
+    , DontFullyEvaluate (..)
+      -- * Representations
+    , TypedContent (..)
+    , ToTypedContent (..)
+    , HasContentType (..)
+      -- ** Specific content types
+    , RepHtml
+    , RepJson (..)
+    , RepPlain (..)
+    , RepXml (..)
+      -- ** Smart constructors
+    , repJson
+    , repPlain
+    , repXml
+    ) where
+
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Lazy as L
+import Data.Text.Lazy (Text, pack)
+import qualified Data.Text as T
+import Control.Monad (liftM)
+
+import Blaze.ByteString.Builder (Builder, fromByteString, fromLazyByteString)
+import Data.Monoid (mempty)
+
+import Text.Hamlet (Html)
+import Text.Blaze.Html.Renderer.Utf8 (renderHtmlBuilder)
+import Data.Conduit (Source, ResourceT, Flush (Chunk), ResumableSource, mapOutput)
+import Data.Conduit.Internal (ResumableSource (ResumableSource))
+
+import qualified Data.Aeson as J
+import Data.Aeson.Encode (fromValue)
+import qualified Blaze.ByteString.Builder.Char.Utf8 as Blaze
+import Data.Text.Lazy.Builder (toLazyText)
+import Yesod.Core.Types
+
+-- | Zero-length enumerator.
+emptyContent :: Content
+emptyContent = ContentBuilder mempty $ Just 0
+
+-- | Anything which can be converted into 'Content'. Most of the time, you will
+-- want to use the 'ContentBuilder' constructor. An easier approach will be to use
+-- a pre-defined 'toContent' function, such as converting your data into a lazy
+-- bytestring and then calling 'toContent' on that.
+--
+-- Please note that the built-in instances for lazy data structures ('String',
+-- lazy 'L.ByteString', lazy 'Text' and 'Html') will not automatically include
+-- the content length for the 'ContentBuilder' constructor.
+class ToContent a where
+    toContent :: a -> Content
+
+instance ToContent Content where
+    toContent = id
+instance ToContent Builder where
+    toContent = flip ContentBuilder Nothing
+instance ToContent B.ByteString where
+    toContent bs = ContentBuilder (fromByteString bs) $ Just $ B.length bs
+instance ToContent L.ByteString where
+    toContent = flip ContentBuilder Nothing . fromLazyByteString
+instance ToContent T.Text where
+    toContent = toContent . Blaze.fromText
+instance ToContent Text where
+    toContent = toContent . Blaze.fromLazyText
+instance ToContent String where
+    toContent = toContent . Blaze.fromString
+instance ToContent Html where
+    toContent bs = ContentBuilder (renderHtmlBuilder bs) Nothing
+instance ToContent () where
+    toContent () = toContent B.empty
+instance ToContent (ContentType, Content) where
+    toContent = snd
+instance ToContent TypedContent where
+    toContent (TypedContent _ c) = c
+
+instance ToFlushBuilder builder => ToContent (Source (ResourceT IO) builder) where
+    toContent src = ContentSource $ mapOutput toFlushBuilder src
+instance ToFlushBuilder builder => ToContent (ResumableSource (ResourceT IO) builder) where
+    toContent (ResumableSource src _) = toContent src
+
+-- | A class for all data which can be sent in a streaming response. Note that
+-- for textual data, instances must use UTF-8 encoding.
+--
+-- Since 1.2.0
+class ToFlushBuilder a where toFlushBuilder :: a -> Flush Builder
+instance ToFlushBuilder (Flush Builder) where toFlushBuilder = id
+instance ToFlushBuilder Builder where toFlushBuilder = Chunk
+instance ToFlushBuilder (Flush B.ByteString) where toFlushBuilder = fmap fromByteString
+instance ToFlushBuilder B.ByteString where toFlushBuilder = Chunk . fromByteString
+instance ToFlushBuilder (Flush L.ByteString) where toFlushBuilder = fmap fromLazyByteString
+instance ToFlushBuilder L.ByteString where toFlushBuilder = Chunk . fromLazyByteString
+instance ToFlushBuilder (Flush Text) where toFlushBuilder = fmap Blaze.fromLazyText
+instance ToFlushBuilder Text where toFlushBuilder = Chunk . Blaze.fromLazyText
+instance ToFlushBuilder (Flush T.Text) where toFlushBuilder = fmap Blaze.fromText
+instance ToFlushBuilder T.Text where toFlushBuilder = Chunk . Blaze.fromText
+instance ToFlushBuilder (Flush String) where toFlushBuilder = fmap Blaze.fromString
+instance ToFlushBuilder String where toFlushBuilder = Chunk . Blaze.fromString
+instance ToFlushBuilder (Flush Html) where toFlushBuilder = fmap renderHtmlBuilder
+instance ToFlushBuilder Html where toFlushBuilder = Chunk . renderHtmlBuilder
+
+repJson :: ToContent a => a -> RepJson
+repJson = RepJson . toContent
+
+repPlain :: ToContent a => a -> RepPlain
+repPlain = RepPlain . toContent
+
+repXml :: ToContent a => a -> RepXml
+repXml = RepXml . toContent
+
+class ToTypedContent a => HasContentType a where
+    getContentType :: Monad m => m a -> ContentType
+
+instance HasContentType RepJson where
+    getContentType _ = typeJson
+deriving instance ToContent RepJson
+
+instance HasContentType RepPlain where
+    getContentType _ = typePlain
+deriving instance ToContent RepPlain
+
+instance HasContentType RepXml where
+    getContentType _ = typeXml
+deriving instance ToContent RepXml
+
+
+typeHtml :: ContentType
+typeHtml = "text/html; charset=utf-8"
+
+typePlain :: ContentType
+typePlain = "text/plain; charset=utf-8"
+
+typeJson :: ContentType
+typeJson = "application/json; charset=utf-8"
+
+typeXml :: ContentType
+typeXml = "text/xml"
+
+typeAtom :: ContentType
+typeAtom = "application/atom+xml"
+
+typeRss :: ContentType
+typeRss = "application/rss+xml"
+
+typeJpeg :: ContentType
+typeJpeg = "image/jpeg"
+
+typePng :: ContentType
+typePng = "image/png"
+
+typeGif :: ContentType
+typeGif = "image/gif"
+
+typeSvg :: ContentType
+typeSvg = "image/svg+xml"
+
+typeJavascript :: ContentType
+typeJavascript = "text/javascript; charset=utf-8"
+
+typeCss :: ContentType
+typeCss = "text/css; charset=utf-8"
+
+typeFlv :: ContentType
+typeFlv = "video/x-flv"
+
+typeOgv :: ContentType
+typeOgv = "video/ogg"
+
+typeOctet :: ContentType
+typeOctet = "application/octet-stream"
+
+-- | Removes \"extra\" information at the end of a content type string. In
+-- particular, removes everything after the semicolon, if present.
+--
+-- For example, \"text/html; charset=utf-8\" is commonly used to specify the
+-- character encoding for HTML data. This function would return \"text/html\".
+simpleContentType :: ContentType -> ContentType
+simpleContentType = fst . B.breakByte 59 -- 59 == ;
+
+-- Give just the media types as a pair.
+-- For example, \"text/html; charset=utf-8\" returns ("text", "html")
+contentTypeTypes :: ContentType -> (B.ByteString, B.ByteString)
+contentTypeTypes ct = (main, fst $ B.breakByte semicolon (tailEmpty sub))
+  where
+    tailEmpty x = if B.null x then "" else B.tail x
+    (main, sub) = B.breakByte slash ct
+    slash = 47
+    semicolon = 59
+
+
+instance HasContentType a => HasContentType (DontFullyEvaluate a) where
+    getContentType = getContentType . liftM unDontFullyEvaluate
+
+instance ToContent a => ToContent (DontFullyEvaluate a) where
+    toContent (DontFullyEvaluate a) = ContentDontEvaluate $ toContent a
+
+instance ToContent J.Value where
+    toContent = flip ContentBuilder Nothing
+              . Blaze.fromLazyText
+              . toLazyText
+              . fromValue
+instance HasContentType J.Value where
+    getContentType _ = typeJson
+
+instance HasContentType Html where
+    getContentType _ = typeHtml
+
+instance HasContentType Text where
+    getContentType _ = typePlain
+
+instance HasContentType T.Text where
+    getContentType _ = typePlain
+
+-- | Any type which can be converted to 'TypedContent'.
+--
+-- Since 1.2.0
+class ToContent a => ToTypedContent a where
+    toTypedContent :: a -> TypedContent
+
+instance ToTypedContent TypedContent where
+    toTypedContent = id
+instance ToTypedContent () where
+    toTypedContent () = TypedContent typePlain (toContent ())
+instance ToTypedContent (ContentType, Content) where
+    toTypedContent (ct, content) = TypedContent ct content
+instance ToTypedContent RepJson where
+    toTypedContent (RepJson c) = TypedContent typeJson c
+instance ToTypedContent RepPlain where
+    toTypedContent (RepPlain c) = TypedContent typePlain c
+instance ToTypedContent RepXml where
+    toTypedContent (RepXml c) = TypedContent typeXml c
+instance ToTypedContent J.Value where
+    toTypedContent v = TypedContent typeJson (toContent v)
+instance ToTypedContent Html where
+    toTypedContent h = TypedContent typeHtml (toContent h)
+instance ToTypedContent T.Text where
+    toTypedContent t = TypedContent typePlain (toContent t)
+instance ToTypedContent [Char] where
+    toTypedContent = toTypedContent . pack
+instance ToTypedContent Text where
+    toTypedContent t = TypedContent typePlain (toContent t)
+instance ToTypedContent a => ToTypedContent (DontFullyEvaluate a) where
+    toTypedContent (DontFullyEvaluate a) =
+        let TypedContent ct c = toTypedContent a
+         in TypedContent ct (ContentDontEvaluate c)
diff --git a/yesod-core/Yesod/Core/Dispatch.hs b/yesod-core/Yesod/Core/Dispatch.hs
new file mode 100644
index 00000000..335a15c8
--- /dev/null
+++ b/yesod-core/Yesod/Core/Dispatch.hs
@@ -0,0 +1,193 @@
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+module Yesod.Core.Dispatch
+    ( -- * Quasi-quoted routing
+      parseRoutes
+    , parseRoutesNoCheck
+    , parseRoutesFile
+    , parseRoutesFileNoCheck
+    , mkYesod
+      -- ** More fine-grained
+    , mkYesodData
+    , mkYesodSubData
+    , mkYesodDispatch
+    , mkYesodSubDispatch
+      -- ** Path pieces
+    , PathPiece (..)
+    , PathMultiPiece (..)
+    , Texts
+      -- * Convert to WAI
+    , toWaiApp
+    , toWaiAppPlain
+    , warp
+    , warpDebug
+    , warpEnv
+    , mkDefaultMiddlewares
+      -- * WAI subsites
+    , WaiSubsite (..)
+    ) where
+
+import Prelude hiding (exp)
+import Yesod.Core.Internal.TH
+import Language.Haskell.TH.Syntax (qLocation)
+
+import Web.PathPieces
+
+import qualified Network.Wai as W
+
+import Data.ByteString.Lazy.Char8 ()
+
+import Data.Text (Text)
+import Data.Monoid (mappend)
+import qualified Data.ByteString as S
+import qualified Data.ByteString.Char8 as S8
+import qualified Blaze.ByteString.Builder
+import Network.HTTP.Types (status301)
+import Yesod.Routes.Parse
+import Yesod.Core.Types
+import Yesod.Core.Class.Yesod
+import Yesod.Core.Class.Dispatch
+import Yesod.Core.Internal.Run
+import Safe (readMay)
+import System.Environment (getEnvironment)
+
+import Network.Wai.Middleware.Autohead
+import Network.Wai.Middleware.AcceptOverride
+import Network.Wai.Middleware.RequestLogger
+import Network.Wai.Middleware.Gzip
+import Network.Wai.Middleware.MethodOverride
+
+import qualified Network.Wai.Handler.Warp
+import System.Log.FastLogger
+import Control.Monad.Logger
+import qualified Paths_yesod_core
+import Data.Version (showVersion)
+
+-- | Convert the given argument into a WAI application, executable with any WAI
+-- handler. This function will provide no middlewares; if you want commonly
+-- used middlewares, please use 'toWaiApp'.
+toWaiAppPlain :: YesodDispatch site => site -> IO W.Application
+toWaiAppPlain site = do
+    logger <- makeLogger site
+    sb <- makeSessionBackend site
+    return $ toWaiAppYre $ YesodRunnerEnv
+            { yreLogger = logger
+            , yreSite = site
+            , yreSessionBackend = sb
+            }
+
+toWaiAppYre :: YesodDispatch site => YesodRunnerEnv site -> W.Application
+toWaiAppYre yre req =
+    case cleanPath site $ W.pathInfo req of
+        Left pieces -> sendRedirect site pieces req
+        Right pieces -> yesodDispatch yre req
+            { W.pathInfo = pieces
+            }
+  where
+    site = yreSite yre
+    sendRedirect :: Yesod master => master -> [Text] -> W.Application
+    sendRedirect y segments' env =
+         return $ W.responseLBS status301
+                [ ("Content-Type", "text/plain")
+                , ("Location", Blaze.ByteString.Builder.toByteString dest')
+                ] "Redirecting"
+      where
+        dest = joinPath y (resolveApproot y env) segments' []
+        dest' =
+            if S.null (W.rawQueryString env)
+                then dest
+                else (dest `mappend`
+                     Blaze.ByteString.Builder.fromByteString (W.rawQueryString env))
+
+-- | Same as 'toWaiAppPlain', but provides a default set of middlewares. This
+-- set may change with future releases, but currently covers:
+--
+-- * Logging
+--
+-- * GZIP compression
+--
+-- * Automatic HEAD method handling
+--
+-- * Request method override with the _method query string parameter
+--
+-- * Accept header override with the _accept query string parameter
+toWaiApp :: YesodDispatch site => site -> IO W.Application
+toWaiApp site = do
+    logger <- makeLogger site
+    sb <- makeSessionBackend site
+    let yre = YesodRunnerEnv
+                { yreLogger = logger
+                , yreSite = site
+                , yreSessionBackend = sb
+                }
+    messageLoggerSource
+        site
+        logger
+        $(qLocation >>= liftLoc)
+        "yesod-core"
+        LevelInfo
+        (toLogStr ("Application launched" :: S.ByteString))
+    middleware <- mkDefaultMiddlewares logger
+    return $ middleware $ toWaiAppYre yre
+
+-- | A convenience method to run an application using the Warp webserver on the
+-- specified port. Automatically calls 'toWaiApp'. Provides a default set of
+-- middlewares. This set may change at any point without a breaking version
+-- number. Currently, it includes:
+--
+-- If you need more fine-grained control of middlewares, please use 'toWaiApp'
+-- directly.
+--
+-- Since 1.2.0
+warp :: YesodDispatch site => Int -> site -> IO ()
+warp port site = toWaiApp site >>= Network.Wai.Handler.Warp.runSettings
+    Network.Wai.Handler.Warp.defaultSettings
+        { Network.Wai.Handler.Warp.settingsPort = port
+        , Network.Wai.Handler.Warp.settingsServerName = S8.pack $ concat
+            [ "Warp/"
+            , Network.Wai.Handler.Warp.warpVersion
+            , " + Yesod/"
+            , showVersion Paths_yesod_core.version
+            , " (core)"
+            ]
+        }
+
+-- | A default set of middlewares.
+--
+-- Since 1.2.0
+mkDefaultMiddlewares :: Logger -> IO W.Middleware
+mkDefaultMiddlewares logger = do
+    logWare <- mkRequestLogger def
+        { destination = Logger logger
+        , outputFormat = Apache FromSocket
+        }
+    return $ logWare
+           . acceptOverride
+           . autohead
+           . gzip def
+           . methodOverride
+
+-- | Deprecated synonym for 'warp'.
+warpDebug :: YesodDispatch site => Int -> site -> IO ()
+warpDebug = warp
+{-# DEPRECATED warpDebug "Please use warp instead" #-}
+
+-- | Runs your application using default middlewares (i.e., via 'toWaiApp'). It
+-- reads port information from the PORT environment variable, as used by tools
+-- such as Keter and the FP Complete School of Haskell.
+--
+-- Note that the exact behavior of this function may be modified slightly over
+-- time to work correctly with external tools, without a change to the type
+-- signature.
+warpEnv :: YesodDispatch site => site -> IO ()
+warpEnv site = do
+    env <- getEnvironment
+    case lookup "PORT" env of
+        Nothing -> error $ "warpEnv: no PORT environment variable found"
+        Just portS ->
+            case readMay portS of
+                Nothing -> error $ "warpEnv: invalid PORT environment variable: " ++ show portS
+                Just port -> warp port site
diff --git a/yesod-core/Yesod/Core/Handler.hs b/yesod-core/Yesod/Core/Handler.hs
new file mode 100644
index 00000000..994f7b0d
--- /dev/null
+++ b/yesod-core/Yesod/Core/Handler.hs
@@ -0,0 +1,1028 @@
+{-# LANGUAGE FlexibleContexts           #-}
+{-# LANGUAGE ConstraintKinds            #-}
+{-# LANGUAGE FlexibleInstances          #-}
+{-# LANGUAGE FunctionalDependencies     #-}
+{-# LANGUAGE OverloadedStrings          #-}
+{-# LANGUAGE QuasiQuotes                #-}
+{-# LANGUAGE RecordWildCards            #-}
+{-# LANGUAGE TupleSections              #-}
+{-# LANGUAGE TypeFamilies               #-}
+{-# LANGUAGE RankNTypes                 #-}
+---------------------------------------------------------
+--
+-- Module        : Yesod.Handler
+-- Copyright     : Michael Snoyman
+-- License       : BSD3
+--
+-- Maintainer    : Michael Snoyman <michael@snoyman.com>
+-- Stability     : stable
+-- Portability   : portable
+--
+-- Define Handler stuff.
+--
+---------------------------------------------------------
+module Yesod.Core.Handler
+    ( -- * Handler monad
+      HandlerT
+      -- ** Read information from handler
+    , getYesod
+    , getUrlRender
+    , getUrlRenderParams
+    , getCurrentRoute
+    , getRequest
+    , waiRequest
+    , runRequestBody
+    , rawRequestBody
+      -- ** Request information
+      -- *** Request datatype
+    , RequestBodyContents
+    , YesodRequest (..)
+    , FileInfo
+    , fileName
+    , fileContentType
+    , fileSource
+    , fileMove
+      -- *** Convenience functions
+    , languages
+      -- *** Lookup parameters
+    , lookupGetParam
+    , lookupPostParam
+    , lookupCookie
+    , lookupFile
+      -- **** Multi-lookup
+    , lookupGetParams
+    , lookupPostParams
+    , lookupCookies
+    , lookupFiles
+      -- * Responses
+      -- ** Pure
+    , respond
+      -- ** Streaming
+    , respondSource
+    , sendChunk
+    , sendFlush
+    , sendChunkBS
+    , sendChunkLBS
+    , sendChunkText
+    , sendChunkLazyText
+    , sendChunkHtml
+      -- ** Redirecting
+    , RedirectUrl (..)
+    , redirect
+    , redirectWith
+    , redirectToPost
+      -- ** Errors
+    , notFound
+    , badMethod
+    , notAuthenticated
+    , permissionDenied
+    , permissionDeniedI
+    , invalidArgs
+    , invalidArgsI
+      -- ** Short-circuit responses.
+    , sendFile
+    , sendFilePart
+    , sendResponse
+    , sendResponseStatus
+    , sendResponseCreated
+    , sendWaiResponse
+      -- * Different representations
+      -- $representations
+    , selectRep
+    , provideRep
+    , provideRepType
+    , ProvidedRep
+      -- * Setting headers
+    , setCookie
+    , getExpires
+    , deleteCookie
+    , addHeader
+    , setHeader
+    , setLanguage
+      -- ** Content caching and expiration
+    , cacheSeconds
+    , neverExpires
+    , alreadyExpired
+    , expiresAt
+      -- * Session
+    , SessionMap
+    , lookupSession
+    , lookupSessionBS
+    , getSession
+    , setSession
+    , setSessionBS
+    , deleteSession
+    , clearSession
+      -- ** Ultimate destination
+    , setUltDest
+    , setUltDestCurrent
+    , setUltDestReferer
+    , redirectUltDest
+    , clearUltDest
+      -- ** Messages
+    , setMessage
+    , setMessageI
+    , getMessage
+      -- * Helpers for specific content
+      -- ** Hamlet
+    , hamletToRepHtml
+    , giveUrlRenderer
+      -- ** Misc
+    , newIdent
+      -- * Lifting
+    , handlerToIO
+      -- * i18n
+    , getMessageRender
+      -- * Per-request caching
+    , cached
+    ) where
+
+import           Data.Time                     (UTCTime, addUTCTime,
+                                                getCurrentTime)
+import           Yesod.Core.Internal.Request   (langKey, mkFileInfoFile,
+                                                mkFileInfoLBS, mkFileInfoSource)
+
+import           Control.Applicative           ((<$>), (<|>))
+
+import           Control.Monad                 (liftM)
+import qualified Control.Monad.Trans.Writer    as Writer
+
+import           Control.Monad.IO.Class        (MonadIO, liftIO)
+import           Control.Monad.Trans.Resource  (MonadResource, liftResourceT)
+
+import qualified Network.HTTP.Types            as H
+import qualified Network.Wai                   as W
+import Control.Monad.Trans.Class (lift)
+import Data.Conduit (transPipe, Flush (Flush), yield, Producer)
+
+import qualified Data.Text                     as T
+import           Data.Text.Encoding            (decodeUtf8With, encodeUtf8)
+import           Data.Text.Encoding.Error      (lenientDecode)
+import qualified Data.Text.Lazy                as TL
+import qualified Text.Blaze.Html.Renderer.Text as RenderText
+import           Text.Hamlet                   (Html, HtmlUrl, hamlet)
+
+import qualified Data.ByteString               as S
+import qualified Data.ByteString.Lazy          as L
+import qualified Data.Map                      as Map
+
+import Data.Conduit (Source)
+import           Control.Arrow                 ((***))
+import qualified Data.ByteString.Char8         as S8
+import           Data.Maybe                    (mapMaybe)
+import           Data.Monoid                   (Endo (..), mappend, mempty)
+import           Data.Text                     (Text)
+import qualified Network.Wai.Parse             as NWP
+import           Text.Shakespeare.I18N         (RenderMessage (..))
+import           Web.Cookie                    (SetCookie (..))
+import           Yesod.Core.Content            (ToTypedContent (..), simpleContentType, contentTypeTypes, HasContentType (..), ToContent (..), ToFlushBuilder (..))
+import           Yesod.Core.Internal.Util      (formatRFC1123)
+import           Text.Blaze.Html               (preEscapedToMarkup, toHtml)
+
+import           Control.Monad.Trans.Resource  (ResourceT)
+import           Data.Dynamic                  (fromDynamic, toDyn)
+import qualified Data.IORef.Lifted             as I
+import           Data.Maybe                    (listToMaybe)
+import           Data.Typeable                 (Typeable, typeOf)
+import           Yesod.Core.Class.Handler
+import           Yesod.Core.Types
+import           Yesod.Routes.Class            (Route)
+import Control.Failure (failure)
+import Blaze.ByteString.Builder (Builder)
+import Safe (headMay)
+
+get :: MonadHandler m => m GHState
+get = liftHandlerT $ HandlerT $ I.readIORef . handlerState
+
+put :: MonadHandler m => GHState -> m ()
+put x = liftHandlerT $ HandlerT $ flip I.writeIORef x . handlerState
+
+modify :: MonadHandler m => (GHState -> GHState) -> m ()
+modify f = liftHandlerT $ HandlerT $ flip I.modifyIORef f . handlerState
+
+tell :: MonadHandler m => Endo [Header] -> m ()
+tell hs = modify $ \g -> g { ghsHeaders = ghsHeaders g `mappend` hs }
+
+handlerError :: MonadHandler m => HandlerContents -> m a
+handlerError = liftHandlerT . failure
+
+hcError :: MonadHandler m => ErrorResponse -> m a
+hcError = handlerError . HCError
+
+getRequest :: MonadHandler m => m YesodRequest
+getRequest = liftHandlerT $ HandlerT $ return . handlerRequest
+
+runRequestBody :: MonadHandler m => m RequestBodyContents
+runRequestBody = do
+    HandlerData
+        { handlerEnv = RunHandlerEnv {..}
+        , handlerRequest = req
+        } <- liftHandlerT $ HandlerT return
+    let len = W.requestBodyLength $ reqWaiRequest req
+        upload = rheUpload len
+    x <- get
+    case ghsRBC x of
+        Just rbc -> return rbc
+        Nothing -> do
+            rr <- waiRequest
+            rbc <- liftResourceT $ rbHelper upload rr
+            put x { ghsRBC = Just rbc }
+            return rbc
+
+rbHelper :: FileUpload -> W.Request -> ResourceT IO RequestBodyContents
+rbHelper upload =
+    case upload of
+        FileUploadMemory s -> rbHelper' s mkFileInfoLBS
+        FileUploadDisk s -> rbHelper' s mkFileInfoFile
+        FileUploadSource s -> rbHelper' s mkFileInfoSource
+
+rbHelper' :: NWP.BackEnd x
+          -> (Text -> Text -> x -> FileInfo)
+          -> W.Request
+          -> ResourceT IO ([(Text, Text)], [(Text, FileInfo)])
+rbHelper' backend mkFI req =
+    (map fix1 *** mapMaybe fix2) <$> (NWP.parseRequestBody backend req)
+  where
+    fix1 = go *** go
+    fix2 (x, NWP.FileInfo a' b c)
+        | S.null a = Nothing
+        | otherwise = Just (go x, mkFI (go a) (go b) c)
+      where
+        a
+            | S.length a' < 2 = a'
+            | S8.head a' == '"' && S8.last a' == '"' = S.tail $ S.init a'
+            | S8.head a' == '\'' && S8.last a' == '\'' = S.tail $ S.init a'
+            | otherwise = a'
+    go = decodeUtf8With lenientDecode
+
+askHandlerEnv :: MonadHandler m => m (RunHandlerEnv (HandlerSite m))
+askHandlerEnv = liftHandlerT $ HandlerT $ return . handlerEnv
+
+-- | Get the master site appliation argument.
+getYesod :: MonadHandler m => m (HandlerSite m)
+getYesod = rheSite `liftM` askHandlerEnv
+
+-- | Get the URL rendering function.
+getUrlRender :: MonadHandler m => m (Route (HandlerSite m) -> Text)
+getUrlRender = do
+    x <- rheRender `liftM` askHandlerEnv
+    return $ flip x []
+
+-- | The URL rendering function with query-string parameters.
+getUrlRenderParams
+    :: MonadHandler m
+    => m (Route (HandlerSite m) -> [(Text, Text)] -> Text)
+getUrlRenderParams = rheRender `liftM` askHandlerEnv
+
+-- | Get the route requested by the user. If this is a 404 response- where the
+-- user requested an invalid route- this function will return 'Nothing'.
+getCurrentRoute :: MonadHandler m => m (Maybe (Route (HandlerSite m)))
+getCurrentRoute = rheRoute `liftM` askHandlerEnv
+
+-- | Returns a function that runs 'HandlerT' actions inside @IO@.
+--
+-- Sometimes you want to run an inner 'HandlerT' action outside
+-- the control flow of an HTTP request (on the outer 'HandlerT'
+-- action).  For example, you may want to spawn a new thread:
+--
+-- @
+-- getFooR :: Handler RepHtml
+-- getFooR = do
+--   runInnerHandler <- handlerToIO
+--   liftIO $ forkIO $ runInnerHandler $ do
+--     /Code here runs inside GHandler but on a new thread./
+--     /This is the inner GHandler./
+--     ...
+--   /Code here runs inside the request's control flow./
+--   /This is the outer GHandler./
+--   ...
+-- @
+--
+-- Another use case for this function is creating a stream of
+-- server-sent events using 'GHandler' actions (see
+-- @yesod-eventsource@).
+--
+-- Most of the environment from the outer 'GHandler' is preserved
+-- on the inner 'GHandler', however:
+--
+--  * The request body is cleared (otherwise it would be very
+--  difficult to prevent huge memory leaks).
+--
+--  * The cache is cleared (see 'CacheKey').
+--
+-- Changes to the response made inside the inner 'GHandler' are
+-- ignored (e.g., session variables, cookies, response headers).
+-- This allows the inner 'GHandler' to outlive the outer
+-- 'GHandler' (e.g., on the @forkIO@ example above, a response
+-- may be sent to the client without killing the new thread).
+handlerToIO :: (MonadIO m1, MonadIO m2) => HandlerT site m1 (HandlerT site IO a -> m2 a)
+handlerToIO =
+  HandlerT $ \oldHandlerData -> do
+    -- Let go of the request body, cache and response headers.
+    let oldReq    = handlerRequest oldHandlerData
+        oldWaiReq = reqWaiRequest oldReq
+        newWaiReq = oldWaiReq { W.requestBody = mempty
+                              , W.requestBodyLength = W.KnownLength 0
+                              }
+        newReq    = oldReq { reqWaiRequest = newWaiReq }
+        clearedOldHandlerData =
+          oldHandlerData { handlerRequest = err "handlerRequest never here"
+                         , handlerState   = err "handlerState never here"
+                         , handlerToParent = const () }
+            where
+              err :: String -> a
+              err = error . ("handlerToIO: clearedOldHandlerData/" ++)
+    newState <- liftIO $ do
+      oldState <- I.readIORef (handlerState oldHandlerData)
+      return $ oldState { ghsRBC = Nothing
+                        , ghsIdent = 1
+                        , ghsCache = mempty
+                        , ghsHeaders = mempty }
+
+    -- Return GHandler running function.
+    return $ \(HandlerT f) -> liftIO $ do
+      -- The state IORef needs to be created here, otherwise it
+      -- will be shared by different invocations of this function.
+      newStateIORef <- I.newIORef newState
+      -- FIXME previously runResourceT was used here, but that could mean resources might vanish...
+      -- Check if this new behavior is correct.
+      f clearedOldHandlerData
+                         { handlerRequest = newReq
+                         , handlerState   = newStateIORef }
+
+
+-- | Redirect to the given route.
+-- HTTP status code 303 for HTTP 1.1 clients and 302 for HTTP 1.0
+-- This is the appropriate choice for a get-following-post
+-- technique, which should be the usual use case.
+--
+-- If you want direct control of the final status code, or need a different
+-- status code, please use 'redirectWith'.
+redirect :: (MonadHandler m, RedirectUrl (HandlerSite m) url)
+         => url -> m a
+redirect url = do
+    req <- waiRequest
+    let status =
+            if W.httpVersion req == H.http11
+                then H.status303
+                else H.status302
+    redirectWith status url
+
+-- | Redirect to the given URL with the specified status code.
+redirectWith :: (MonadHandler m, RedirectUrl (HandlerSite m) url)
+             => H.Status
+             -> url
+             -> m a
+redirectWith status url = do
+    urlText <- toTextUrl url
+    handlerError $ HCRedirect status urlText
+
+ultDestKey :: Text
+ultDestKey = "_ULT"
+
+-- | Sets the ultimate destination variable to the given route.
+--
+-- An ultimate destination is stored in the user session and can be loaded
+-- later by 'redirectUltDest'.
+setUltDest :: (MonadHandler m, RedirectUrl (HandlerSite m) url)
+           => url
+           -> m ()
+setUltDest url = do
+    urlText <- toTextUrl url
+    setSession ultDestKey urlText
+
+-- | Same as 'setUltDest', but uses the current page.
+--
+-- If this is a 404 handler, there is no current page, and then this call does
+-- nothing.
+setUltDestCurrent :: MonadHandler m => m ()
+setUltDestCurrent = do
+    route <- getCurrentRoute
+    case route of
+        Nothing -> return ()
+        Just r -> do
+            gets' <- reqGetParams `liftM` getRequest
+            setUltDest (r, gets')
+
+-- | Sets the ultimate destination to the referer request header, if present.
+--
+-- This function will not overwrite an existing ultdest.
+setUltDestReferer :: MonadHandler m => m ()
+setUltDestReferer = do
+    mdest <- lookupSession ultDestKey
+    maybe
+        (waiRequest >>= maybe (return ()) setUltDestBS . lookup "referer" . W.requestHeaders)
+        (const $ return ())
+        mdest
+  where
+    setUltDestBS = setUltDest . T.pack . S8.unpack
+
+-- | Redirect to the ultimate destination in the user's session. Clear the
+-- value from the session.
+--
+-- The ultimate destination is set with 'setUltDest'.
+--
+-- This function uses 'redirect', and thus will perform a temporary redirect to
+-- a GET request.
+redirectUltDest :: (RedirectUrl (HandlerSite m) url, MonadHandler m)
+                => url -- ^ default destination if nothing in session
+                -> m a
+redirectUltDest def = do
+    mdest <- lookupSession ultDestKey
+    deleteSession ultDestKey
+    maybe (redirect def) redirect mdest
+
+-- | Remove a previously set ultimate destination. See 'setUltDest'.
+clearUltDest :: MonadHandler m => m ()
+clearUltDest = deleteSession ultDestKey
+
+msgKey :: Text
+msgKey = "_MSG"
+
+-- | Sets a message in the user's session.
+--
+-- See 'getMessage'.
+setMessage :: MonadHandler m => Html -> m ()
+setMessage = setSession msgKey . T.concat . TL.toChunks . RenderText.renderHtml
+
+-- | Sets a message in the user's session.
+--
+-- See 'getMessage'.
+setMessageI :: (MonadHandler m, RenderMessage (HandlerSite m) msg)
+            => msg -> m ()
+setMessageI msg = do
+    mr <- getMessageRender
+    setMessage $ toHtml $ mr msg
+
+-- | Gets the message in the user's session, if available, and then clears the
+-- variable.
+--
+-- See 'setMessage'.
+getMessage :: MonadHandler m => m (Maybe Html)
+getMessage = do
+    mmsg <- liftM (fmap preEscapedToMarkup) $ lookupSession msgKey
+    deleteSession msgKey
+    return mmsg
+
+-- | Bypass remaining handler code and output the given file.
+--
+-- For some backends, this is more efficient than reading in the file to
+-- memory, since they can optimize file sending via a system call to sendfile.
+sendFile :: MonadHandler m => ContentType -> FilePath -> m a
+sendFile ct fp = handlerError $ HCSendFile ct fp Nothing
+
+-- | Same as 'sendFile', but only sends part of a file.
+sendFilePart :: MonadHandler m
+             => ContentType
+             -> FilePath
+             -> Integer -- ^ offset
+             -> Integer -- ^ count
+             -> m a
+sendFilePart ct fp off count =
+    handlerError $ HCSendFile ct fp $ Just $ W.FilePart off count
+
+-- | Bypass remaining handler code and output the given content with a 200
+-- status code.
+sendResponse :: (MonadHandler m, ToTypedContent c) => c -> m a
+sendResponse = handlerError . HCContent H.status200 . toTypedContent
+
+-- | Bypass remaining handler code and output the given content with the given
+-- status code.
+sendResponseStatus :: (MonadHandler m, ToTypedContent c) => H.Status -> c -> m a
+sendResponseStatus s = handlerError . HCContent s . toTypedContent
+
+-- | Send a 201 "Created" response with the given route as the Location
+-- response header.
+sendResponseCreated :: MonadHandler m => Route (HandlerSite m) -> m a
+sendResponseCreated url = do
+    r <- getUrlRender
+    handlerError $ HCCreated $ r url
+
+-- | Send a 'W.Response'. Please note: this function is rarely
+-- necessary, and will /disregard/ any changes to response headers and session
+-- that you have already specified. This function short-circuits. It should be
+-- considered only for very specific needs. If you are not sure if you need it,
+-- you don't.
+sendWaiResponse :: MonadHandler m => W.Response -> m b
+sendWaiResponse = handlerError . HCWai
+
+-- | Return a 404 not found page. Also denotes no handler available.
+notFound :: MonadHandler m => m a
+notFound = hcError NotFound
+
+-- | Return a 405 method not supported page.
+badMethod :: MonadHandler m => m a
+badMethod = do
+    w <- waiRequest
+    hcError $ BadMethod $ W.requestMethod w
+
+-- | Return a 401 status code
+notAuthenticated :: MonadHandler m => m a
+notAuthenticated = hcError NotAuthenticated
+
+-- | Return a 403 permission denied page.
+permissionDenied :: MonadHandler m => Text -> m a
+permissionDenied = hcError . PermissionDenied
+
+-- | Return a 403 permission denied page.
+permissionDeniedI :: (RenderMessage (HandlerSite m) msg, MonadHandler m)
+                  => msg
+                  -> m a
+permissionDeniedI msg = do
+    mr <- getMessageRender
+    permissionDenied $ mr msg
+
+-- | Return a 400 invalid arguments page.
+invalidArgs :: MonadHandler m => [Text] -> m a
+invalidArgs = hcError . InvalidArgs
+
+-- | Return a 400 invalid arguments page.
+invalidArgsI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => [msg] -> m a
+invalidArgsI msg = do
+    mr <- getMessageRender
+    invalidArgs $ map mr msg
+
+------- Headers
+-- | Set the cookie on the client.
+
+setCookie :: MonadHandler m => SetCookie -> m ()
+setCookie = addHeaderInternal . AddCookie
+
+-- | Helper function for setCookieExpires value
+getExpires :: MonadIO m
+           => Int -- ^ minutes
+           -> m UTCTime
+getExpires m = do
+    now <- liftIO getCurrentTime
+    return $ fromIntegral (m * 60) `addUTCTime` now
+
+
+-- | Unset the cookie on the client.
+--
+-- Note: although the value used for key and path is 'Text', you should only
+-- use ASCII values to be HTTP compliant.
+deleteCookie :: MonadHandler m
+             => Text -- ^ key
+             -> Text -- ^ path
+             -> m ()
+deleteCookie a = addHeaderInternal . DeleteCookie (encodeUtf8 a) . encodeUtf8
+
+
+-- | Set the language in the user session. Will show up in 'languages' on the
+-- next request.
+setLanguage :: MonadHandler m => Text -> m ()
+setLanguage = setSession langKey
+
+-- | Set an arbitrary response header.
+--
+-- Note that, while the data type used here is 'Text', you must provide only
+-- ASCII value to be HTTP compliant.
+--
+-- Since 1.2.0
+addHeader :: MonadHandler m => Text -> Text -> m ()
+addHeader a = addHeaderInternal . Header (encodeUtf8 a) . encodeUtf8
+
+-- | Deprecated synonym for addHeader.
+setHeader :: MonadHandler m => Text -> Text -> m ()
+setHeader = addHeader
+{-# DEPRECATED setHeader "Please use addHeader instead" #-}
+
+-- | Set the Cache-Control header to indicate this response should be cached
+-- for the given number of seconds.
+cacheSeconds :: MonadHandler m => Int -> m ()
+cacheSeconds i = setHeader "Cache-Control" $ T.concat
+    [ "max-age="
+    , T.pack $ show i
+    , ", public"
+    ]
+
+-- | Set the Expires header to some date in 2037. In other words, this content
+-- is never (realistically) expired.
+neverExpires :: MonadHandler m => m ()
+neverExpires = setHeader "Expires" "Thu, 31 Dec 2037 23:55:55 GMT"
+
+-- | Set an Expires header in the past, meaning this content should not be
+-- cached.
+alreadyExpired :: MonadHandler m => m ()
+alreadyExpired = setHeader "Expires" "Thu, 01 Jan 1970 05:05:05 GMT"
+
+-- | Set an Expires header to the given date.
+expiresAt :: MonadHandler m => UTCTime -> m ()
+expiresAt = setHeader "Expires" . formatRFC1123
+
+-- | Set a variable in the user's session.
+--
+-- The session is handled by the clientsession package: it sets an encrypted
+-- and hashed cookie on the client. This ensures that all data is secure and
+-- not tampered with.
+setSession :: MonadHandler m
+           => Text -- ^ key
+           -> Text -- ^ value
+           -> m ()
+setSession k = setSessionBS k . encodeUtf8
+
+-- | Same as 'setSession', but uses binary data for the value.
+setSessionBS :: MonadHandler m
+             => Text
+             -> S.ByteString
+             -> m ()
+setSessionBS k = modify . modSession . Map.insert k
+
+-- | Unsets a session variable. See 'setSession'.
+deleteSession :: MonadHandler m => Text -> m ()
+deleteSession = modify . modSession . Map.delete
+
+-- | Clear all session variables.
+--
+-- Since: 1.0.1
+clearSession :: MonadHandler m => m ()
+clearSession = modify $ \x -> x { ghsSession = Map.empty }
+
+modSession :: (SessionMap -> SessionMap) -> GHState -> GHState
+modSession f x = x { ghsSession = f $ ghsSession x }
+
+-- | Internal use only, not to be confused with 'setHeader'.
+addHeaderInternal :: MonadHandler m => Header -> m ()
+addHeaderInternal = tell . Endo . (:)
+
+-- | Some value which can be turned into a URL for redirects.
+class RedirectUrl master a where
+    -- | Converts the value to the URL and a list of query-string parameters.
+    toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => a -> m Text
+
+instance RedirectUrl master Text where
+    toTextUrl = return
+
+instance RedirectUrl master String where
+    toTextUrl = toTextUrl . T.pack
+
+instance RedirectUrl master (Route master) where
+    toTextUrl url = do
+        r <- getUrlRender
+        return $ r url
+
+instance (key ~ Text, val ~ Text) => RedirectUrl master (Route master, [(key, val)]) where
+    toTextUrl (url, params) = do
+        r <- getUrlRenderParams
+        return $ r url params
+
+instance (key ~ Text, val ~ Text) => RedirectUrl master (Route master, Map.Map key val) where
+    toTextUrl (url, params) = toTextUrl (url, Map.toList params)
+
+-- | Lookup for session data.
+lookupSession :: MonadHandler m => Text -> m (Maybe Text)
+lookupSession = (liftM . fmap) (decodeUtf8With lenientDecode) . lookupSessionBS
+
+-- | Lookup for session data in binary format.
+lookupSessionBS :: MonadHandler m => Text -> m (Maybe S.ByteString)
+lookupSessionBS n = do
+    m <- liftM ghsSession get
+    return $ Map.lookup n m
+
+-- | Get all session variables.
+getSession :: MonadHandler m => m SessionMap
+getSession = liftM ghsSession get
+
+-- | Get a unique identifier.
+newIdent :: MonadHandler m => m Text
+newIdent = do
+    x <- get
+    let i' = ghsIdent x + 1
+    put x { ghsIdent = i' }
+    return $ T.pack $ 'h' : show i'
+
+-- | Redirect to a POST resource.
+--
+-- This is not technically a redirect; instead, it returns an HTML page with a
+-- POST form, and some Javascript to automatically submit the form. This can be
+-- useful when you need to post a plain link somewhere that needs to cause
+-- changes on the server.
+redirectToPost :: (MonadHandler m, RedirectUrl (HandlerSite m) url)
+               => url
+               -> m a
+redirectToPost url = do
+    urlText <- toTextUrl url
+    hamletToRepHtml [hamlet|
+$newline never
+$doctype 5
+
+<html>
+    <head>
+        <title>Redirecting...
+    <body onload="document.getElementById('form').submit()">
+        <form id="form" method="post" action=#{urlText}>
+            <noscript>
+                <p>Javascript has been disabled; please click on the button below to be redirected.
+            <input type="submit" value="Continue">
+|] >>= sendResponse
+
+-- | Wraps the 'Content' generated by 'hamletToContent' in a 'RepHtml'.
+hamletToRepHtml :: MonadHandler m => HtmlUrl (Route (HandlerSite m)) -> m Html
+hamletToRepHtml = giveUrlRenderer
+
+-- | Provide a URL rendering function to the given function and return the
+-- result. Useful for processing Shakespearean templates.
+--
+-- Since 1.2.0
+giveUrlRenderer :: MonadHandler m
+                => ((Route (HandlerSite m) -> [(Text, Text)] -> Text) -> output)
+                -> m output
+giveUrlRenderer f = do
+    render <- getUrlRenderParams
+    return $ f render
+
+-- | Get the request\'s 'W.Request' value.
+waiRequest :: MonadHandler m => m W.Request
+waiRequest = reqWaiRequest `liftM` getRequest
+
+getMessageRender :: (MonadHandler m, RenderMessage (HandlerSite m) message)
+                 => m (message -> Text)
+getMessageRender = do
+    env <- askHandlerEnv
+    l <- reqLangs `liftM` getRequest
+    return $ renderMessage (rheSite env) l
+
+-- | Use a per-request cache to avoid performing the same action multiple
+-- times. Note that values are stored by their type. Therefore, you should use
+-- newtype wrappers to distinguish logically different types.
+--
+-- Since 1.2.0
+cached :: (MonadHandler m, Typeable a)
+       => m a
+       -> m a
+cached f = do
+    gs <- get
+    let cache = ghsCache gs
+    case clookup cache of
+        Just val -> return val
+        Nothing -> do
+            val <- f
+            put $ gs { ghsCache = cinsert val cache }
+            return val
+  where
+    clookup :: Typeable a => Cache -> Maybe a
+    clookup (Cache m) =
+        res
+      where
+        res = Map.lookup (typeOf $ fromJust res) m >>= fromDynamic
+        fromJust :: Maybe a -> a
+        fromJust = error "Yesod.Handler.cached.fromJust: Argument to typeOf was evaluated"
+
+    cinsert :: Typeable a => a -> Cache -> Cache
+    cinsert v (Cache m) = Cache (Map.insert (typeOf v) (toDyn v) m)
+
+-- | Get the list of supported languages supplied by the user.
+--
+-- Languages are determined based on the following three (in descending order
+-- of preference):
+--
+-- * The _LANG get parameter.
+--
+-- * The _LANG cookie.
+--
+-- * The _LANG user session variable.
+--
+-- * Accept-Language HTTP header.
+--
+-- Yesod will seek the first language from the returned list matched with languages supporting by your application. This language will be used to render i18n templates.
+-- If a matching language is not found the default language will be used.
+--
+-- This is handled by parseWaiRequest (not exposed).
+languages :: MonadHandler m => m [Text]
+languages = reqLangs `liftM` getRequest
+
+lookup' :: Eq a => a -> [(a, b)] -> [b]
+lookup' a = map snd . filter (\x -> a == fst x)
+
+-- | Lookup for GET parameters.
+lookupGetParams :: MonadHandler m => Text -> m [Text]
+lookupGetParams pn = do
+    rr <- getRequest
+    return $ lookup' pn $ reqGetParams rr
+
+-- | Lookup for GET parameters.
+lookupGetParam :: MonadHandler m => Text -> m (Maybe Text)
+lookupGetParam = liftM listToMaybe . lookupGetParams
+
+-- | Lookup for POST parameters.
+lookupPostParams :: (MonadResource m, MonadHandler m) => Text -> m [Text]
+lookupPostParams pn = do
+    (pp, _) <- runRequestBody
+    return $ lookup' pn pp
+
+lookupPostParam :: (MonadResource m, MonadHandler m)
+                => Text
+                -> m (Maybe Text)
+lookupPostParam = liftM listToMaybe . lookupPostParams
+
+-- | Lookup for POSTed files.
+lookupFile :: (MonadHandler m, MonadResource m)
+           => Text
+           -> m (Maybe FileInfo)
+lookupFile = liftM listToMaybe . lookupFiles
+
+-- | Lookup for POSTed files.
+lookupFiles :: (MonadHandler m, MonadResource m)
+            => Text
+            -> m [FileInfo]
+lookupFiles pn = do
+    (_, files) <- runRequestBody
+    return $ lookup' pn files
+
+-- | Lookup for cookie data.
+lookupCookie :: MonadHandler m => Text -> m (Maybe Text)
+lookupCookie = liftM listToMaybe . lookupCookies
+
+-- | Lookup for cookie data.
+lookupCookies :: MonadHandler m => Text -> m [Text]
+lookupCookies pn = do
+    rr <- getRequest
+    return $ lookup' pn $ reqCookies rr
+
+-- $representations
+--
+-- HTTP allows content negotation to determine what /representation/ of data
+-- you would like to use. The most common example of this is providing both a
+-- user-facing HTML page and an API facing JSON response from the same URL. The
+-- means of achieving this is the Accept HTTP header, which provides a list of
+-- content types the client will accept, sorted by preference.
+--
+-- By using 'selectRep' and 'provideRep', you can provide a number of different
+-- representations, e.g.:
+--
+-- > selectRep $ do
+-- >   provideRep typeHtml $ produceHtmlOutput
+-- >   provideRep typeJson $ produceJsonOutput
+--
+-- The first provided representation will be used if no matches are found.
+
+-- | Select a representation to send to the client based on the representations
+-- provided inside this do-block. Should be used together with 'provideRep'.
+--
+-- Since 1.2.0
+selectRep :: MonadHandler m
+          => Writer.Writer (Endo [ProvidedRep m]) ()
+          -> m TypedContent
+selectRep w = do
+    -- the content types are already sorted by q values
+    -- which have been stripped
+    cts <- liftM reqAccept getRequest
+
+    case mapMaybe tryAccept cts of
+        [] ->
+            case reps of
+                [] -> sendResponseStatus H.status500 ("No reps provided to selectRep" :: Text)
+                rep:_ ->
+                  if null cts
+                    then returnRep rep
+                    else sendResponseStatus H.status406 explainUnaccepted
+        rep:_ -> returnRep rep
+  where
+    explainUnaccepted :: Text
+    explainUnaccepted = "no match found for accept header"
+
+    returnRep (ProvidedRep ct mcontent) =
+        mcontent >>= return . TypedContent ct
+
+    reps = appEndo (Writer.execWriter w) []
+
+    repMap = Map.unions $ map (\v@(ProvidedRep k _) -> Map.fromList
+        [ (k, v)
+        , (noSpace k, v)
+        , (simpleContentType k, v)
+        ]) reps
+
+    -- match on the type for sub-type wildcards.
+    -- If the accept is text/* it should match a provided text/html
+    mainTypeMap = Map.fromList $ reverse $ map
+      (\v@(ProvidedRep ct _) -> (fst $ contentTypeTypes ct, v)) reps
+
+    tryAccept ct =
+        if subType == "*"
+          then if mainType == "*"
+                 then headMay reps
+                 else Map.lookup mainType mainTypeMap
+          else lookupAccept ct
+        where
+          (mainType, subType) = contentTypeTypes ct
+
+    lookupAccept ct = Map.lookup ct repMap <|>
+                      Map.lookup (noSpace ct) repMap <|>
+                      Map.lookup (simpleContentType ct) repMap
+
+    -- Mime types such as "text/html; charset=foo" get converted to
+    -- "text/html;charset=foo"
+    noSpace = S8.filter (/= ' ')
+
+-- | Internal representation of a single provided representation.
+--
+-- Since 1.2.0
+data ProvidedRep m = ProvidedRep !ContentType !(m Content)
+
+-- | Provide a single representation to be used, based on the request of the
+-- client. Should be used together with 'selectRep'.
+--
+-- Since 1.2.0
+provideRep :: (Monad m, HasContentType a)
+           => m a
+           -> Writer.Writer (Endo [ProvidedRep m]) ()
+provideRep handler = provideRepType (getContentType handler) handler
+
+-- | Same as 'provideRep', but instead of determining the content type from the
+-- type of the value itself, you provide the content type separately. This can
+-- be a convenience instead of creating newtype wrappers for uncommonly used
+-- content types.
+--
+-- > provideRepType "application/x-special-format" "This is the content"
+--
+-- Since 1.2.0
+provideRepType :: (Monad m, ToContent a)
+               => ContentType
+               -> m a
+               -> Writer.Writer (Endo [ProvidedRep m]) ()
+provideRepType ct handler =
+    Writer.tell $ Endo $ (ProvidedRep ct (liftM toContent handler):)
+
+-- | Stream in the raw request body without any parsing.
+--
+-- Since 1.2.0
+rawRequestBody :: MonadHandler m => Source m S.ByteString
+rawRequestBody = do
+    req <- lift waiRequest
+    transPipe liftResourceT $ W.requestBody req
+
+-- | Stream the data from the file. Since Yesod 1.2, this has been generalized
+-- to work in any @MonadResource@.
+fileSource :: MonadResource m => FileInfo -> Source m S.ByteString
+fileSource = transPipe liftResourceT . fileSourceRaw
+
+-- | Provide a pure value for the response body.
+--
+-- > respond ct = return . TypedContent ct . toContent
+--
+-- Since 1.2.0
+respond :: (Monad m, ToContent a) => ContentType -> a -> m TypedContent
+respond ct = return . TypedContent ct . toContent
+
+-- | Use a @Source@ for the response body.
+--
+-- Note that, for ease of use, the underlying monad is a @HandlerT@. This
+-- implies that you can run any @HandlerT@ action. However, since a streaming
+-- response occurs after the response headers have already been sent, some
+-- actions make no sense here. For example: short-circuit responses, setting
+-- headers, changing status codes, etc.
+--
+-- Since 1.2.0
+respondSource :: ContentType
+              -> Source (HandlerT site IO) (Flush Builder)
+              -> HandlerT site IO TypedContent
+respondSource ctype src = HandlerT $ \hd ->
+    -- Note that this implementation relies on the fact that the ResourceT
+    -- environment provided by the server is the same one used in HandlerT.
+    -- This is a safe assumption assuming the HandlerT is run correctly.
+    return $ TypedContent ctype $ ContentSource
+           $ transPipe (lift . flip unHandlerT hd) src
+
+-- | In a streaming response, send a single chunk of data. This function works
+-- on most datatypes, such as @ByteString@ and @Html@.
+--
+-- Since 1.2.0
+sendChunk :: Monad m => ToFlushBuilder a => a -> Producer m (Flush Builder)
+sendChunk = yield . toFlushBuilder
+
+-- | In a streaming response, send a flush command, causing all buffered data
+-- to be immediately sent to the client.
+--
+-- Since 1.2.0
+sendFlush :: Monad m => Producer m (Flush Builder)
+sendFlush = yield Flush
+
+-- | Type-specialized version of 'sendChunk' for strict @ByteString@s.
+--
+-- Since 1.2.0
+sendChunkBS :: Monad m => S.ByteString -> Producer m (Flush Builder)
+sendChunkBS = sendChunk
+
+-- | Type-specialized version of 'sendChunk' for lazy @ByteString@s.
+--
+-- Since 1.2.0
+sendChunkLBS :: Monad m => L.ByteString -> Producer m (Flush Builder)
+sendChunkLBS = sendChunk
+
+-- | Type-specialized version of 'sendChunk' for strict @Text@s.
+--
+-- Since 1.2.0
+sendChunkText :: Monad m => T.Text -> Producer m (Flush Builder)
+sendChunkText = sendChunk
+
+-- | Type-specialized version of 'sendChunk' for lazy @Text@s.
+--
+-- Since 1.2.0
+sendChunkLazyText :: Monad m => TL.Text -> Producer m (Flush Builder)
+sendChunkLazyText = sendChunk
+
+-- | Type-specialized version of 'sendChunk' for @Html@s.
+--
+-- Since 1.2.0
+sendChunkHtml :: Monad m => Html -> Producer m (Flush Builder)
+sendChunkHtml = sendChunk
diff --git a/yesod-core/Yesod/Core/Internal.hs b/yesod-core/Yesod/Core/Internal.hs
new file mode 100644
index 00000000..e60e4d6e
--- /dev/null
+++ b/yesod-core/Yesod/Core/Internal.hs
@@ -0,0 +1,7 @@
+-- | Exposed mostly for testing. These functions provide an unstable API and
+-- should not be relied upon.
+module Yesod.Core.Internal
+    ( module X
+    ) where
+
+import Yesod.Core.Internal.Request as X (randomString, parseWaiRequest)
diff --git a/yesod-core/Yesod/Core/Internal/LiteApp.hs b/yesod-core/Yesod/Core/Internal/LiteApp.hs
new file mode 100644
index 00000000..790f09a8
--- /dev/null
+++ b/yesod-core/Yesod/Core/Internal/LiteApp.hs
@@ -0,0 +1,82 @@
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE PatternGuards #-}
+module Yesod.Core.Internal.LiteApp where
+
+import Yesod.Routes.Class
+import Data.Monoid
+import Yesod.Core.Class.Yesod
+import Yesod.Core.Class.Dispatch
+import Yesod.Core.Types
+import Yesod.Core.Content
+import Data.Text (Text)
+import Web.PathPieces
+import Network.Wai
+import Yesod.Core.Handler
+import Yesod.Core.Internal.Run
+import Network.HTTP.Types (Method)
+import Data.Maybe (fromMaybe)
+import Control.Applicative ((<|>))
+import Control.Monad.Trans.Writer
+
+newtype LiteApp = LiteApp
+    { unLiteApp :: Method -> [Text] -> Maybe (LiteHandler TypedContent)
+    }
+
+instance Yesod LiteApp
+
+instance YesodDispatch LiteApp where
+    yesodDispatch yre req =
+        yesodRunner
+            (fromMaybe notFound $ f (requestMethod req) (pathInfo req))
+            yre
+            (Just $ LiteAppRoute $ pathInfo req)
+            req
+      where
+        LiteApp f = yreSite yre
+
+instance RenderRoute LiteApp where
+    data Route LiteApp = LiteAppRoute [Text]
+        deriving (Show, Eq, Read, Ord)
+    renderRoute (LiteAppRoute x) = (x, [])
+instance ParseRoute LiteApp where
+    parseRoute (x, _) = Just $ LiteAppRoute x
+
+instance Monoid LiteApp where
+    mempty = LiteApp $ \_ _ -> Nothing
+    mappend (LiteApp x) (LiteApp y) = LiteApp $ \m ps -> x m ps <|> y m ps
+
+type LiteHandler = HandlerT LiteApp IO
+type LiteWidget = WidgetT LiteApp IO
+
+liteApp :: Writer LiteApp () -> LiteApp
+liteApp = execWriter
+
+dispatchTo :: ToTypedContent a => LiteHandler a -> Writer LiteApp ()
+dispatchTo handler = tell $ LiteApp $ \_ ps ->
+    if null ps
+        then Just $ fmap toTypedContent handler
+        else Nothing
+
+onMethod :: Method -> Writer LiteApp () -> Writer LiteApp ()
+onMethod method f = tell $ LiteApp $ \m ps ->
+    if method == m
+        then unLiteApp (liteApp f) m ps
+        else Nothing
+
+onStatic :: Text -> Writer LiteApp () -> Writer LiteApp ()
+onStatic p0 f = tell $ LiteApp $ \m ps0 ->
+    case ps0 of
+        p:ps | p == p0 -> unLiteApp (liteApp f) m ps
+        _ -> Nothing
+
+withDynamic :: PathPiece p => (p -> Writer LiteApp ()) -> Writer LiteApp ()
+withDynamic f = tell $ LiteApp $ \m ps0 ->
+    case ps0 of
+        p:ps | Just v <- fromPathPiece p -> unLiteApp (liteApp $ f v) m ps
+        _ -> Nothing
+
+withDynamicMulti :: PathMultiPiece ps => (ps -> Writer LiteApp ()) -> Writer LiteApp ()
+withDynamicMulti f = tell $ LiteApp $ \m ps ->
+    case fromPathMultiPiece ps of
+        Nothing -> Nothing
+        Just v -> unLiteApp (liteApp $ f v) m []
diff --git a/yesod-core/Yesod/Internal/Request.hs b/yesod-core/Yesod/Core/Internal/Request.hs
similarity index 58%
rename from yesod-core/Yesod/Internal/Request.hs
rename to yesod-core/Yesod/Core/Internal/Request.hs
index 661456c8..0c740be8 100644
--- a/yesod-core/Yesod/Internal/Request.hs
+++ b/yesod-core/Yesod/Core/Internal/Request.hs
@@ -1,36 +1,34 @@
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE CPP #-}
-module Yesod.Internal.Request
+module Yesod.Core.Internal.Request
     ( parseWaiRequest
-    , Request (..)
     , RequestBodyContents
     , FileInfo
     , fileName
     , fileContentType
-    , fileSource
     , fileMove
     , mkFileInfoLBS
     , mkFileInfoFile
     , mkFileInfoSource
     , FileUpload (..)
     , tooLargeResponse
+    , tokenKey
+    , langKey
+    , textQueryString
     -- The below are exported for testing.
     , randomString
-    , parseWaiRequest'
     ) where
 
-import Control.Applicative ((<$>))
+import Data.String (IsString)
 import Control.Arrow (second)
 import qualified Network.Wai.Parse as NWP
-import Yesod.Internal
 import qualified Network.Wai as W
-import System.Random (RandomGen, newStdGen, randomRs)
+import System.Random (RandomGen, randomRs)
 import Web.Cookie (parseCookiesText)
 import Data.ByteString (ByteString)
 import qualified Data.ByteString.Char8 as S8
 import Data.Text (Text, pack)
 import Network.HTTP.Types (queryToQueryText, Status (Status))
-import Control.Monad (join)
 import Data.Maybe (fromMaybe, catMaybes)
 import qualified Data.ByteString.Lazy as L
 import qualified Data.Set as Set
@@ -43,31 +41,8 @@ import Data.Conduit.Binary (sourceFile, sinkFile)
 import Data.Word (Word64)
 import Control.Monad.IO.Class (liftIO)
 import Control.Exception (throwIO)
-
--- | The parsed request information.
-data Request = Request
-    { reqGetParams :: [(Text, Text)]
-    , reqCookies :: [(Text, Text)]
-    , reqWaiRequest :: W.Request
-      -- | Languages which the client supports.
-    , reqLangs :: [Text]
-      -- | A random, session-specific token used to prevent CSRF attacks.
-    , reqToken :: Maybe Text
-      -- | Size of the request body.
-      --
-      -- Note: in the presence of chunked request bodies, this value will be 0,
-      -- even though data is available.
-    , reqBodySize :: Word64 -- FIXME Consider in the future using a Maybe to represent chunked bodies
-    }
-
-parseWaiRequest :: W.Request
-                -> [(Text, ByteString)] -- ^ session
-                -> Bool
-                -> Word64 -- ^ actual length... might be meaningless, see 'reqBodySize'
-                -> Word64 -- ^ maximum allowed body size
-                -> IO Request
-parseWaiRequest env session' useToken bodySize maxBodySize =
-    parseWaiRequest' env session' useToken bodySize maxBodySize <$> newStdGen
+import Yesod.Core.Types
+import qualified Data.Map as Map
 
 -- | Impose a limit on the size of the request body.
 limitRequestBody :: Word64 -> W.Request -> W.Request
@@ -94,30 +69,44 @@ tooLargeResponse = W.responseLBS
     [("Content-Type", "text/plain")]
     "Request body too large to be processed."
 
-parseWaiRequest' :: RandomGen g
-                 => W.Request
-                 -> [(Text, ByteString)] -- ^ session
-                 -> Bool
-                 -> Word64
-                 -> Word64 -- ^ max body size
-                 -> g
-                 -> Request
-parseWaiRequest' env session' useToken bodySize maxBodySize gen =
-    Request gets'' cookies' (limitRequestBody maxBodySize env) langs'' token bodySize
+parseWaiRequest :: RandomGen g
+                => W.Request
+                -> SessionMap
+                -> Bool
+                -> Maybe Word64 -- ^ max body size
+                -> (Either YesodRequest (g -> YesodRequest))
+parseWaiRequest env session useToken mmaxBodySize =
+    -- In most cases, we won't need to generate any random values. Therefore,
+    -- we split our results: if we need a random generator, return a Right
+    -- value, otherwise return a Left and avoid the relatively costly generator
+    -- acquisition.
+    case etoken of
+        Left token -> Left $ mkRequest token
+        Right mkToken -> Right $ mkRequest . mkToken
   where
-    gets' = queryToQueryText $ W.queryString env
-    gets'' = map (second $ fromMaybe "") gets'
+    mkRequest token' = YesodRequest
+        { reqGetParams  = gets
+        , reqCookies    = cookies
+        , reqWaiRequest = maybe id limitRequestBody mmaxBodySize env
+        , reqLangs      = langs''
+        , reqToken      = token'
+        , reqSession    = if useToken
+                            then Map.delete tokenKey session
+                            else session
+        , reqAccept     = httpAccept env
+        }
+    gets = textQueryString env
     reqCookie = lookup "Cookie" $ W.requestHeaders env
-    cookies' = maybe [] parseCookiesText reqCookie
+    cookies = maybe [] parseCookiesText reqCookie
     acceptLang = lookup "Accept-Language" $ W.requestHeaders env
     langs = map (pack . S8.unpack) $ maybe [] NWP.parseHttpAccept acceptLang
 
-    lookupText k = fmap (decodeUtf8With lenientDecode) . lookup k
+    lookupText k = fmap (decodeUtf8With lenientDecode) . Map.lookup k
 
     -- The language preferences are prioritized as follows:
-    langs' = catMaybes [ join $ lookup langKey gets' -- Query _LANG
-                       , lookup langKey cookies'     -- Cookie _LANG
-                       , lookupText langKey session' -- Session _LANG
+    langs' = catMaybes [ lookup langKey gets -- Query _LANG
+                       , lookup langKey cookies     -- Cookie _LANG
+                       , lookupText langKey session -- Session _LANG
                        ] ++ langs                    -- Accept-Language(s)
 
     -- Github issue #195. We want to add an extra two-letter version of any
@@ -128,12 +117,27 @@ parseWaiRequest' env session' useToken bodySize maxBodySize gen =
     -- tokenKey present in the session is ignored). If sessions
     -- are enabled and a session has no tokenKey a new one is
     -- generated.
-    token = if not useToken
-              then Nothing
-              else Just $ maybe
-                            (pack $ randomString 10 gen)
-                            (decodeUtf8With lenientDecode)
-                            (lookup tokenKey session')
+    etoken
+        | useToken =
+            case Map.lookup tokenKey session of
+                -- Already have a token, use it.
+                Just bs -> Left $ Just $ decodeUtf8With lenientDecode bs
+                -- Don't have a token, get a random generator and make a new one.
+                Nothing -> Right $ Just . pack . randomString 10
+        | otherwise = Left Nothing
+
+textQueryString :: W.Request -> [(Text, Text)]
+textQueryString = map (second $ fromMaybe "") . queryToQueryText . W.queryString
+
+-- | Get the list of accepted content types from the WAI Request\'s Accept
+-- header.
+--
+-- Since 1.2.0
+httpAccept :: W.Request -> [ContentType]
+httpAccept = NWP.parseHttpAccept
+           . fromMaybe S8.empty
+           . lookup "Accept"
+           . W.requestHeaders
 
 addTwoLetters :: ([Text] -> [Text], Set.Set Text) -> [Text] -> [Text]
 addTwoLetters (toAdd, exist) [] =
@@ -156,19 +160,6 @@ randomString len = take len . map toChar . randomRs (0, 61)
         | i < 52 = toEnum $ i + fromEnum 'a' - 26
         | otherwise = toEnum $ i + fromEnum '0' - 52
 
--- | A tuple containing both the POST parameters and submitted files.
-type RequestBodyContents =
-    ( [(Text, Text)]
-    , [(Text, FileInfo)]
-    )
-
-data FileInfo = FileInfo
-    { fileName :: Text
-    , fileContentType :: Text
-    , fileSource :: Source (ResourceT IO) ByteString
-    , fileMove :: FilePath -> IO ()
-    }
-
 mkFileInfoLBS :: Text -> Text -> L.ByteString -> FileInfo
 mkFileInfoLBS name ct lbs = FileInfo name ct (sourceList $ L.toChunks lbs) (\fp -> L.writeFile fp lbs)
 
@@ -178,6 +169,8 @@ mkFileInfoFile name ct fp = FileInfo name ct (sourceFile fp) (\dst -> runResourc
 mkFileInfoSource :: Text -> Text -> Source (ResourceT IO) ByteString -> FileInfo
 mkFileInfoSource name ct src = FileInfo name ct src (\dst -> runResourceT $ src $$ sinkFile dst)
 
-data FileUpload = FileUploadMemory (NWP.BackEnd L.ByteString)
-                | FileUploadDisk (NWP.BackEnd FilePath)
-                | FileUploadSource (NWP.BackEnd (Source (ResourceT IO) ByteString))
+tokenKey :: IsString a => a
+tokenKey = "_TOKEN"
+
+langKey :: IsString a => a
+langKey = "_LANG"
diff --git a/yesod-core/Yesod/Core/Internal/Response.hs b/yesod-core/Yesod/Core/Internal/Response.hs
new file mode 100644
index 00000000..8e0870f5
--- /dev/null
+++ b/yesod-core/Yesod/Core/Internal/Response.hs
@@ -0,0 +1,85 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PatternGuards     #-}
+{-# LANGUAGE RankNTypes        #-}
+{-# LANGUAGE RecordWildCards   #-}
+{-# LANGUAGE TemplateHaskell   #-}
+module Yesod.Core.Internal.Response where
+
+import           Blaze.ByteString.Builder     (toByteString)
+import           Data.ByteString              (ByteString)
+import qualified Data.ByteString              as S
+import qualified Data.ByteString.Char8        as S8
+import           Data.CaseInsensitive         (CI)
+import qualified Data.CaseInsensitive         as CI
+import           Network.Wai
+import           Prelude                      hiding (catch)
+import           Web.Cookie                   (renderSetCookie)
+import           Yesod.Core.Content
+import           Yesod.Core.Types
+import qualified Network.HTTP.Types           as H
+import qualified Data.Text                    as T
+import           Control.Exception            (SomeException, handle)
+import           Blaze.ByteString.Builder     (fromLazyByteString,
+                                               toLazyByteString)
+import qualified Data.ByteString.Lazy         as L
+import qualified Data.Map                     as Map
+import           Yesod.Core.Internal.Request  (tokenKey)
+import           Data.Text.Encoding           (encodeUtf8)
+
+yarToResponse :: Monad m
+              => YesodResponse
+              -> (SessionMap -> m [Header]) -- ^ save session
+              -> YesodRequest
+              -> m Response
+yarToResponse (YRWai a) _ _ = return a
+yarToResponse (YRPlain s hs ct c newSess) saveSession yreq = do
+    extraHeaders <- do
+        let nsToken = maybe
+                newSess
+                (\n -> Map.insert tokenKey (encodeUtf8 n) newSess)
+                (reqToken yreq)
+        sessionHeaders <- saveSession nsToken
+        return $ ("Content-Type", ct) : map headerToPair sessionHeaders
+    let finalHeaders = extraHeaders ++ map headerToPair hs
+        finalHeaders' len = ("Content-Length", S8.pack $ show len)
+                          : finalHeaders
+    let go (ContentBuilder b mlen) =
+            let hs' = maybe finalHeaders finalHeaders' mlen
+             in ResponseBuilder s hs' b
+        go (ContentFile fp p) = ResponseFile s finalHeaders fp p
+        go (ContentSource body) = ResponseSource s finalHeaders body
+        go (ContentDontEvaluate c') = go c'
+    return $ go c
+
+-- | Convert Header to a key/value pair.
+headerToPair :: Header
+             -> (CI ByteString, ByteString)
+headerToPair (AddCookie sc) =
+    ("Set-Cookie", toByteString $ renderSetCookie $ sc)
+headerToPair (DeleteCookie key path) =
+    ( "Set-Cookie"
+    , S.concat
+        [ key
+        , "=; path="
+        , path
+        , "; expires=Thu, 01-Jan-1970 00:00:00 GMT"
+        ]
+    )
+headerToPair (Header key value) = (CI.mk key, value)
+
+evaluateContent :: Content -> IO (Either ErrorResponse Content)
+evaluateContent (ContentBuilder b mlen) = handle f $ do
+    let lbs = toLazyByteString b
+    L.length lbs `seq` return (Right $ ContentBuilder (fromLazyByteString lbs) mlen)
+  where
+    f :: SomeException -> IO (Either ErrorResponse Content)
+    f = return . Left . InternalError . T.pack . show
+evaluateContent c = return (Right c)
+
+getStatus :: ErrorResponse -> H.Status
+getStatus NotFound = H.status404
+getStatus (InternalError _) = H.status500
+getStatus (InvalidArgs _) = H.status400
+getStatus NotAuthenticated = H.status401
+getStatus (PermissionDenied _) = H.status403
+getStatus (BadMethod _) = H.status405
diff --git a/yesod-core/Yesod/Core/Internal/Run.hs b/yesod-core/Yesod/Core/Internal/Run.hs
new file mode 100644
index 00000000..38411b58
--- /dev/null
+++ b/yesod-core/Yesod/Core/Internal/Run.hs
@@ -0,0 +1,286 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PatternGuards     #-}
+{-# LANGUAGE RankNTypes        #-}
+{-# LANGUAGE RecordWildCards   #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE FlexibleContexts  #-}
+module Yesod.Core.Internal.Run where
+
+import Yesod.Core.Internal.Response
+import           Blaze.ByteString.Builder     (toByteString)
+import           Control.Applicative          ((<$>))
+import           Control.Exception            (fromException)
+import           Control.Exception.Lifted     (catch)
+import           Control.Monad.IO.Class       (MonadIO)
+import           Control.Monad.IO.Class       (liftIO)
+import           Control.Monad.Logger         (LogLevel (LevelError), LogSource,
+                                               liftLoc)
+import           Control.Monad.Trans.Resource (runResourceT, withInternalState, runInternalState)
+import qualified Data.ByteString              as S
+import qualified Data.ByteString.Char8        as S8
+import qualified Data.IORef                   as I
+import qualified Data.Map                     as Map
+import           Data.Maybe                   (isJust)
+import           Data.Maybe                   (fromMaybe)
+import           Data.Monoid                  (appEndo, mempty)
+import           Data.Text                    (Text)
+import qualified Data.Text                    as T
+import           Data.Text.Encoding           (encodeUtf8)
+import           Data.Text.Encoding           (decodeUtf8With)
+import           Data.Text.Encoding.Error     (lenientDecode)
+import           Language.Haskell.TH.Syntax   (Loc, qLocation)
+import qualified Network.HTTP.Types           as H
+import           Network.Wai
+import           Prelude                      hiding (catch)
+import           System.Log.FastLogger        (Logger)
+import           System.Log.FastLogger        (LogStr, toLogStr)
+import           System.Random                (newStdGen)
+import           Yesod.Core.Content
+import           Yesod.Core.Class.Yesod
+import           Yesod.Core.Types
+import           Yesod.Core.Internal.Request  (parseWaiRequest,
+                                               tooLargeResponse)
+import           Yesod.Routes.Class           (Route, renderRoute)
+
+-- | Function used internally by Yesod in the process of converting a
+-- 'HandlerT' into an 'Application'. Should not be needed by users.
+runHandler :: ToTypedContent c
+           => RunHandlerEnv site
+           -> HandlerT site IO c
+           -> YesodApp
+runHandler rhe@RunHandlerEnv {..} handler yreq = withInternalState $ \resState -> do
+    let toErrorHandler e =
+            case fromException e of
+                Just (HCError x) -> x
+                _ -> InternalError $ T.pack $ show e
+    istate <- liftIO $ I.newIORef GHState
+        { ghsSession = reqSession yreq
+        , ghsRBC = Nothing
+        , ghsIdent = 1
+        , ghsCache = mempty
+        , ghsHeaders = mempty
+        }
+    let hd = HandlerData
+            { handlerRequest = yreq
+            , handlerEnv     = rhe
+            , handlerState   = istate
+            , handlerToParent = const ()
+            , handlerResource = resState
+            }
+    contents' <- catch (fmap Right $ unHandlerT handler hd)
+        (\e -> return $ Left $ maybe (HCError $ toErrorHandler e) id
+                      $ fromException e)
+    state <- liftIO $ I.readIORef istate
+    let finalSession = ghsSession state
+    let headers = ghsHeaders state
+    let contents = either id (HCContent H.status200 . toTypedContent) contents'
+    let handleError e = flip runInternalState resState $ do
+            yar <- rheOnError e yreq
+                { reqSession = finalSession
+                }
+            case yar of
+                YRPlain _ hs ct c sess ->
+                    let hs' = appEndo headers hs
+                     in return $ YRPlain (getStatus e) hs' ct c sess
+                YRWai _ -> return yar
+    let sendFile' ct fp p =
+            return $ YRPlain H.status200 (appEndo headers []) ct (ContentFile fp p) finalSession
+    case contents of
+        HCContent status (TypedContent ct c) -> do
+            ec' <- liftIO $ evaluateContent c
+            case ec' of
+                Left e -> handleError e
+                Right c' -> return $ YRPlain status (appEndo headers []) ct c' finalSession
+        HCError e -> handleError e
+        HCRedirect status loc -> do
+            let disable_caching x =
+                      Header "Cache-Control" "no-cache, must-revalidate"
+                    : Header "Expires" "Thu, 01 Jan 1970 05:05:05 GMT"
+                    : x
+                hs = (if status /= H.movedPermanently301 then disable_caching else id)
+                      $ Header "Location" (encodeUtf8 loc) : appEndo headers []
+            return $ YRPlain
+                status hs typePlain emptyContent
+                finalSession
+        HCSendFile ct fp p -> catch
+            (sendFile' ct fp p)
+            (handleError . toErrorHandler)
+        HCCreated loc -> do
+            let hs = Header "Location" (encodeUtf8 loc) : appEndo headers []
+            return $ YRPlain
+                H.status201
+                hs
+                typePlain
+                emptyContent
+                finalSession
+        HCWai r -> return $ YRWai r
+
+safeEh :: (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
+       -> ErrorResponse
+       -> YesodApp
+safeEh log' er req = do
+    liftIO $ log' $(qLocation >>= liftLoc) "yesod-core" LevelError
+           $ toLogStr $ "Error handler errored out: " ++ show er
+    return $ YRPlain
+        H.status500
+        []
+        typePlain
+        (toContent ("Internal Server Error" :: S.ByteString))
+        (reqSession req)
+
+-- | Run a 'HandlerT' completely outside of Yesod.  This
+-- function comes with many caveats and you shouldn't use it
+-- unless you fully understand what it's doing and how it works.
+--
+-- As of now, there's only one reason to use this function at
+-- all: in order to run unit tests of functions inside 'HandlerT'
+-- but that aren't easily testable with a full HTTP request.
+-- Even so, it's better to use @wai-test@ or @yesod-test@ instead
+-- of using this function.
+--
+-- This function will create a fake HTTP request (both @wai@'s
+-- 'Request' and @yesod@'s 'Request') and feed it to the
+-- @HandlerT@.  The only useful information the @HandlerT@ may
+-- get from the request is the session map, which you must supply
+-- as argument to @runFakeHandler@.  All other fields contain
+-- fake information, which means that they can be accessed but
+-- won't have any useful information.  The response of the
+-- @HandlerT@ is completely ignored, including changes to the
+-- session, cookies or headers.  We only return you the
+-- @HandlerT@'s return value.
+runFakeHandler :: (Yesod site, MonadIO m) =>
+                  SessionMap
+               -> (site -> Logger)
+               -> site
+               -> HandlerT site IO a
+               -> m (Either ErrorResponse a)
+runFakeHandler fakeSessionMap logger site handler = liftIO $ do
+  ret <- I.newIORef (Left $ InternalError "runFakeHandler: no result")
+  let handler' = do liftIO . I.writeIORef ret . Right =<< handler
+                    return ()
+  let yapp = runHandler
+         RunHandlerEnv
+            { rheRender = yesodRender site $ resolveApproot site fakeWaiRequest
+            , rheRoute = Nothing
+            , rheSite = site
+            , rheUpload = fileUpload site
+            , rheLog = messageLoggerSource site $ logger site
+            , rheOnError = errHandler
+            }
+        handler'
+      errHandler err req = do
+          liftIO $ I.writeIORef ret (Left err)
+          return $ YRPlain
+                     H.status500
+                     []
+                     typePlain
+                     (toContent ("runFakeHandler: errHandler" :: S8.ByteString))
+                     (reqSession req)
+      fakeWaiRequest =
+        Request
+          { requestMethod  = "POST"
+          , httpVersion    = H.http11
+          , rawPathInfo    = "/runFakeHandler/pathInfo"
+          , rawQueryString = ""
+          , serverName     = "runFakeHandler-serverName"
+          , serverPort     = 80
+          , requestHeaders = []
+          , isSecure       = False
+          , remoteHost     = error "runFakeHandler-remoteHost"
+          , pathInfo       = ["runFakeHandler", "pathInfo"]
+          , queryString    = []
+          , requestBody    = mempty
+          , vault          = mempty
+          , requestBodyLength = KnownLength 0
+          }
+      fakeRequest =
+        YesodRequest
+          { reqGetParams  = []
+          , reqCookies    = []
+          , reqWaiRequest = fakeWaiRequest
+          , reqLangs      = []
+          , reqToken      = Just "NaN" -- not a nonce =)
+          , reqAccept     = []
+          , reqSession    = fakeSessionMap
+          }
+  _ <- runResourceT $ yapp fakeRequest
+  I.readIORef ret
+{-# WARNING runFakeHandler "Usually you should *not* use runFakeHandler unless you really understand how it works and why you need it." #-}
+
+yesodRunner :: (ToTypedContent res, Yesod site)
+            => HandlerT site IO res
+            -> YesodRunnerEnv site
+            -> Maybe (Route site)
+            -> Application
+yesodRunner handler' YesodRunnerEnv {..} route req
+  | Just maxLen <- mmaxLen, KnownLength len <- requestBodyLength req, maxLen < len = return tooLargeResponse
+  | otherwise = do
+    let dontSaveSession _ = return []
+    (session, saveSession) <- liftIO $ do
+        maybe (return (Map.empty, dontSaveSession)) (\sb -> sbLoadSession sb req) yreSessionBackend
+    let mkYesodReq = parseWaiRequest req session (isJust yreSessionBackend) mmaxLen
+    yreq <-
+        case mkYesodReq of
+            Left yreq -> return yreq
+            Right needGen -> liftIO $ needGen <$> newStdGen
+    let ra = resolveApproot yreSite req
+    let log' = messageLoggerSource yreSite yreLogger
+        -- We set up two environments: the first one has a "safe" error handler
+        -- which will never throw an exception. The second one uses the
+        -- user-provided errorHandler function. If that errorHandler function
+        -- errors out, it will use the safeEh below to recover.
+        rheSafe = RunHandlerEnv
+            { rheRender = yesodRender yreSite ra
+            , rheRoute = route
+            , rheSite = yreSite
+            , rheUpload = fileUpload yreSite
+            , rheLog = log'
+            , rheOnError = safeEh log'
+            }
+        rhe = rheSafe
+            { rheOnError = runHandler rheSafe . errorHandler
+            }
+    yar <- runHandler rhe handler yreq
+    liftIO $ yarToResponse yar saveSession yreq
+  where
+    mmaxLen = maximumContentLength yreSite route
+    handler = yesodMiddleware handler'
+
+yesodRender :: Yesod y
+            => y
+            -> ResolvedApproot
+            -> Route y
+            -> [(Text, Text)] -- ^ url query string
+            -> Text
+yesodRender y ar url params =
+    decodeUtf8With lenientDecode $ toByteString $
+    fromMaybe
+        (joinPath y ar ps
+          $ params ++ params')
+        (urlRenderOverride y url)
+  where
+    (ps, params') = renderRoute url
+
+resolveApproot :: Yesod master => master -> Request -> ResolvedApproot
+resolveApproot master req =
+    case approot of
+        ApprootRelative -> ""
+        ApprootStatic t -> t
+        ApprootMaster f -> f master
+        ApprootRequest f -> f master req
+
+stripHandlerT :: HandlerT child (HandlerT parent m) a
+              -> (parent -> child)
+              -> (Route child -> Route parent)
+              -> Maybe (Route child)
+              -> HandlerT parent m a
+stripHandlerT (HandlerT f) getSub toMaster newRoute = HandlerT $ \hd -> do
+    let env = handlerEnv hd
+    ($ hd) $ unHandlerT $ f hd
+        { handlerEnv = env
+            { rheSite = getSub $ rheSite env
+            , rheRoute = newRoute
+            , rheRender = \url params -> rheRender env (toMaster url) params
+            }
+        , handlerToParent = toMaster
+        }
diff --git a/yesod-core/Yesod/Core/Internal/Session.hs b/yesod-core/Yesod/Core/Internal/Session.hs
new file mode 100644
index 00000000..dd9ebc61
--- /dev/null
+++ b/yesod-core/Yesod/Core/Internal/Session.hs
@@ -0,0 +1,68 @@
+module Yesod.Core.Internal.Session
+    ( encodeClientSession
+    , decodeClientSession
+    , clientSessionDateCacher
+    , ClientSessionDateCache(..)
+    , SaveSession
+    , SessionBackend(..)
+    ) where
+
+import qualified Web.ClientSession as CS
+import Data.Serialize
+import Data.Time
+import Data.ByteString (ByteString)
+import Control.Concurrent (forkIO, killThread, threadDelay)
+import Control.Monad (forever, guard)
+import Yesod.Core.Types
+import Yesod.Core.Internal.Util
+import qualified Data.IORef as I
+
+encodeClientSession :: CS.Key
+                    -> CS.IV
+                    -> ClientSessionDateCache  -- ^ expire time
+                    -> ByteString -- ^ remote host
+                    -> SessionMap -- ^ session
+                    -> ByteString -- ^ cookie value
+encodeClientSession key iv date rhost session' =
+    CS.encrypt key iv $ encode $ SessionCookie expires rhost session'
+      where expires = Right (csdcExpiresSerialized date)
+
+decodeClientSession :: CS.Key
+                    -> ClientSessionDateCache  -- ^ current time
+                    -> ByteString -- ^ remote host field
+                    -> ByteString -- ^ cookie value
+                    -> Maybe SessionMap
+decodeClientSession key date rhost encrypted = do
+    decrypted <- CS.decrypt key encrypted
+    SessionCookie (Left expire) rhost' session' <-
+        either (const Nothing) Just $ decode decrypted
+    guard $ expire > csdcNow date
+    guard $ rhost' == rhost
+    return session'
+
+
+----------------------------------------------------------------------
+
+
+-- Mostly copied from Kazu's date-cache, but with modifications
+-- that better suit our needs.
+--
+-- The cached date is updated every 10s, we don't need second
+-- resolution for session expiration times.
+
+clientSessionDateCacher ::
+     NominalDiffTime -- ^ Inactive session valitity.
+  -> IO (IO ClientSessionDateCache, IO ())
+clientSessionDateCacher validity = do
+    ref <- getUpdated >>= I.newIORef
+    tid <- forkIO $ forever (doUpdate ref)
+    return $! (I.readIORef ref, killThread tid)
+  where
+    getUpdated = do
+      now <- getCurrentTime
+      let expires  = validity `addUTCTime` now
+          expiresS = runPut (putTime expires)
+      return $! ClientSessionDateCache now expires expiresS
+    doUpdate ref = do
+      threadDelay 10000000 -- 10s
+      I.writeIORef ref =<< getUpdated
diff --git a/yesod-core/Yesod/Core/Internal/TH.hs b/yesod-core/Yesod/Core/Internal/TH.hs
new file mode 100644
index 00000000..7e84c1cb
--- /dev/null
+++ b/yesod-core/Yesod/Core/Internal/TH.hs
@@ -0,0 +1,136 @@
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+module Yesod.Core.Internal.TH where
+
+import Prelude hiding (exp)
+import Yesod.Core.Handler
+
+import Language.Haskell.TH
+import Language.Haskell.TH.Syntax
+
+import qualified Network.Wai as W
+
+import Data.ByteString.Lazy.Char8 ()
+import Data.List (foldl')
+
+import Yesod.Routes.TH
+import Yesod.Routes.Parse
+import Yesod.Core.Types
+import Yesod.Core.Content
+import Yesod.Core.Class.Dispatch
+import Yesod.Core.Internal.Run
+
+-- | Generates URL datatype and site function for the given 'Resource's. This
+-- is used for creating sites, /not/ subsites. See 'mkYesodSub' for the latter.
+-- Use 'parseRoutes' to create the 'Resource's.
+mkYesod :: String -- ^ name of the argument datatype
+        -> [ResourceTree String]
+        -> Q [Dec]
+mkYesod name = fmap (uncurry (++)) . mkYesodGeneral name [] False
+
+-- | Sometimes, you will want to declare your routes in one file and define
+-- your handlers elsewhere. For example, this is the only way to break up a
+-- monolithic file into smaller parts. Use this function, paired with
+-- 'mkYesodDispatch', to do just that.
+mkYesodData :: String -> [ResourceTree String] -> Q [Dec]
+mkYesodData name res = mkYesodDataGeneral name False res
+
+mkYesodSubData :: String -> [ResourceTree String] -> Q [Dec]
+mkYesodSubData name res = mkYesodDataGeneral name True res
+
+mkYesodDataGeneral :: String -> Bool -> [ResourceTree String] -> Q [Dec]
+mkYesodDataGeneral name isSub res = do
+    let (name':rest) = words name
+    fmap fst $ mkYesodGeneral name' rest isSub res
+
+-- | See 'mkYesodData'.
+mkYesodDispatch :: String -> [ResourceTree String] -> Q [Dec]
+mkYesodDispatch name = fmap snd . mkYesodGeneral name [] False
+
+-- | Get the Handler and Widget type synonyms for the given site.
+masterTypeSyns :: Type -> [Dec]
+masterTypeSyns site =
+    [ TySynD (mkName "Handler") []
+      $ ConT ''HandlerT `AppT` site `AppT` ConT ''IO
+    , TySynD (mkName "Widget")  []
+      $ ConT ''WidgetT `AppT` site `AppT` ConT ''IO `AppT` ConT ''()
+    ]
+
+mkYesodGeneral :: String                   -- ^ foundation type
+               -> [String]                 -- ^ arguments for the type
+               -> Bool                     -- ^ it this a subsite
+               -> [ResourceTree String]
+               -> Q([Dec],[Dec])
+mkYesodGeneral name args isSub resS = do
+    renderRouteDec <- mkRenderRouteInstance site res
+    routeAttrsDec  <- mkRouteAttrsInstance site res
+    dispatchDec    <- mkDispatchInstance site res
+    parse <- mkParseRouteInstance site res
+    let rname = mkName $ "resources" ++ name
+    eres <- lift resS
+    let resourcesDec =
+            [ SigD rname $ ListT `AppT` (ConT ''ResourceTree `AppT` ConT ''String)
+            , FunD rname [Clause [] (NormalB eres) []]
+            ]
+    let dataDec = concat
+            [ [parse]
+            , renderRouteDec
+            , [routeAttrsDec]
+            , resourcesDec
+            , if isSub then [] else masterTypeSyns site
+            ]
+    return (dataDec, dispatchDec)
+  where site    = foldl' AppT (ConT $ mkName name) (map (VarT . mkName) args)
+        res     = map (fmap parseType) resS
+
+mkMDS :: Q Exp -> MkDispatchSettings
+mkMDS rh = MkDispatchSettings
+    { mdsRunHandler = rh
+    , mdsSubDispatcher =
+        [|\parentRunner getSub toParent env -> yesodSubDispatch
+                                 YesodSubRunnerEnv
+                                    { ysreParentRunner = parentRunner
+                                    , ysreGetSub = getSub
+                                    , ysreToParentRoute = toParent
+                                    , ysreParentEnv = env
+                                    }
+                              |]
+    , mdsGetPathInfo = [|W.pathInfo|]
+    , mdsSetPathInfo = [|\p r -> r { W.pathInfo = p }|]
+    , mdsMethod = [|W.requestMethod|]
+    , mds404 = [|notFound >> return ()|]
+    , mds405 = [|badMethod >> return ()|]
+    , mdsGetHandler = defaultGetHandler
+    }
+
+-- | If the generation of @'YesodDispatch'@ instance require finer
+-- control of the types, contexts etc. using this combinator. You will
+-- hardly need this generality. However, in certain situations, like
+-- when writing library/plugin for yesod, this combinator becomes
+-- handy.
+mkDispatchInstance :: Type                -- ^ The master site type
+                   -> [ResourceTree a]    -- ^ The resource
+                   -> DecsQ
+mkDispatchInstance master res = do
+    clause' <- mkDispatchClause (mkMDS [|yesodRunner|]) res
+    let thisDispatch = FunD 'yesodDispatch [clause']
+    return [InstanceD [] yDispatch [thisDispatch]]
+  where
+    yDispatch = ConT ''YesodDispatch `AppT` master
+
+mkYesodSubDispatch :: [ResourceTree a] -> Q Exp
+mkYesodSubDispatch res = do
+    clause' <- mkDispatchClause (mkMDS [|subHelper . fmap toTypedContent|]) res
+    inner <- newName "inner"
+    let innerFun = FunD inner [clause']
+    helper <- newName "helper"
+    let fun = FunD helper
+                [ Clause
+                    []
+                    (NormalB $ VarE inner)
+                    [innerFun]
+                ]
+    return $ LetE [fun] (VarE helper)
diff --git a/yesod-core/Yesod/Core/Internal/Util.hs b/yesod-core/Yesod/Core/Internal/Util.hs
new file mode 100644
index 00000000..1e705795
--- /dev/null
+++ b/yesod-core/Yesod/Core/Internal/Util.hs
@@ -0,0 +1,46 @@
+module Yesod.Core.Internal.Util
+    ( putTime
+    , getTime
+    , formatW3
+    , formatRFC1123
+    , formatRFC822
+    ) where
+
+import           Data.Int       (Int64)
+import           Data.Serialize (Get, Put, Serialize (..))
+import qualified Data.Text      as T
+import           Data.Time      (Day (ModifiedJulianDay, toModifiedJulianDay),
+                                 DiffTime, UTCTime (..), formatTime)
+import           System.Locale  (defaultTimeLocale)
+
+putTime :: UTCTime -> Put
+putTime (UTCTime d t) =
+  let d' = fromInteger  $ toModifiedJulianDay d
+      t' = fromIntegral $ fromEnum (t / diffTimeScale)
+  in put (d' * posixDayLength_int64 + min posixDayLength_int64 t')
+
+getTime :: Get UTCTime
+getTime = do
+  val <- get
+  let (d, t) = val `divMod` posixDayLength_int64
+      d' = ModifiedJulianDay $! fromIntegral d
+      t' = fromIntegral t
+  d' `seq` t' `seq` return (UTCTime d' t')
+
+posixDayLength_int64 :: Int64
+posixDayLength_int64 = 86400
+
+diffTimeScale :: DiffTime
+diffTimeScale = 1e12
+
+-- | Format a 'UTCTime' in W3 format.
+formatW3 :: UTCTime -> T.Text
+formatW3 = T.pack . formatTime defaultTimeLocale "%FT%X-00:00"
+
+-- | Format as per RFC 1123.
+formatRFC1123 :: UTCTime -> T.Text
+formatRFC1123 = T.pack . formatTime defaultTimeLocale "%a, %d %b %Y %X %Z"
+
+-- | Format as per RFC 822.
+formatRFC822 :: UTCTime -> T.Text
+formatRFC822 = T.pack . formatTime defaultTimeLocale "%a, %d %b %Y %H:%M:%S %z"
diff --git a/yesod-core/Yesod/Core/Json.hs b/yesod-core/Yesod/Core/Json.hs
new file mode 100644
index 00000000..94fcbcfb
--- /dev/null
+++ b/yesod-core/Yesod/Core/Json.hs
@@ -0,0 +1,112 @@
+{-# LANGUAGE TypeSynonymInstances, OverloadedStrings #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Yesod.Core.Json
+    ( -- * Convert from a JSON value
+      defaultLayoutJson
+    , jsonToRepJson
+
+      -- * Convert to a JSON value
+    , parseJsonBody
+    , parseJsonBody_
+
+      -- * Produce JSON values
+    , J.Value (..)
+    , J.ToJSON (..)
+    , J.FromJSON (..)
+    , array
+    , object
+    , (.=)
+    , (J..:)
+
+      -- * Convenience functions
+    , jsonOrRedirect
+    , acceptsJson
+    ) where
+
+import Yesod.Core.Handler (HandlerT, getRequest, invalidArgs, redirect, selectRep, provideRep, rawRequestBody)
+import Yesod.Core.Content (TypedContent)
+import Yesod.Core.Types (reqAccept)
+import Yesod.Core.Class.Yesod (defaultLayout, Yesod)
+import Yesod.Core.Class.Handler
+import Yesod.Core.Widget (WidgetT)
+import Yesod.Routes.Class
+import qualified Data.Aeson as J
+import qualified Data.Aeson.Parser as JP
+import Data.Aeson ((.=), object)
+import Data.Conduit.Attoparsec (sinkParser)
+import Data.Text (pack)
+import qualified Data.Vector as V
+import Data.Conduit
+import qualified Data.ByteString.Char8 as B8
+import Data.Maybe (listToMaybe)
+import Control.Monad (liftM)
+
+-- | Provide both an HTML and JSON representation for a piece of
+-- data, using the default layout for the HTML output
+-- ('defaultLayout').
+--
+-- /Since: 0.3.0/
+defaultLayoutJson :: (Yesod site, J.ToJSON a)
+                  => WidgetT site IO ()  -- ^ HTML
+                  -> HandlerT site IO a  -- ^ JSON
+                  -> HandlerT site IO TypedContent
+defaultLayoutJson w json = selectRep $ do
+    provideRep $ defaultLayout w
+    provideRep $ fmap J.toJSON json
+
+-- | Wraps a data type in a 'RepJson'.  The data type must
+-- support conversion to JSON via 'J.ToJSON'.
+--
+-- /Since: 0.3.0/
+jsonToRepJson :: (Monad m, J.ToJSON a) => a -> m J.Value
+jsonToRepJson = return . J.toJSON
+
+-- | Parse the request body to a data type as a JSON value.  The
+-- data type must support conversion from JSON via 'J.FromJSON'.
+-- If you want the raw JSON value, just ask for a @'J.Result'
+-- 'J.Value'@.
+--
+-- /Since: 0.3.0/
+parseJsonBody :: (MonadHandler m, J.FromJSON a) => m (J.Result a)
+parseJsonBody = do
+    eValue <- runExceptionT $ rawRequestBody $$ sinkParser JP.value'
+    return $ case eValue of
+        Left e -> J.Error $ show e
+        Right value -> J.fromJSON value
+
+-- | Same as 'parseJsonBody', but return an invalid args response on a parse
+-- error.
+parseJsonBody_ :: (MonadHandler m, J.FromJSON a) => m a
+parseJsonBody_ = do
+    ra <- parseJsonBody
+    case ra of
+        J.Error s -> invalidArgs [pack s]
+        J.Success a -> return a
+
+-- | Convert a list of values to an 'J.Array'.
+array :: J.ToJSON a => [a] -> J.Value
+array = J.Array . V.fromList . map J.toJSON
+
+-- | jsonOrRedirect simplifies the scenario where a POST handler sends a different
+-- response based on Accept headers:
+--
+--     1. 200 with JSON data if the client prefers
+--     @application\/json@ (e.g. AJAX, see 'acceptsJSON').
+--
+--     2. 3xx otherwise, following the PRG pattern.
+jsonOrRedirect :: (MonadHandler m, J.ToJSON a)
+               => Route (HandlerSite m) -- ^ Redirect target
+               -> a            -- ^ Data to send via JSON
+               -> m J.Value
+jsonOrRedirect r j = do
+    q <- acceptsJson
+    if q then return (J.toJSON j)
+         else redirect r
+
+-- | Returns @True@ if the client prefers @application\/json@ as
+-- indicated by the @Accept@ HTTP header.
+acceptsJson :: MonadHandler m => m Bool
+acceptsJson =  (maybe False ((== "application/json") . B8.takeWhile (/= ';'))
+            .  listToMaybe
+            .  reqAccept)
+           `liftM` getRequest
diff --git a/yesod-core/Yesod/Core/Types.hs b/yesod-core/Yesod/Core/Types.hs
new file mode 100644
index 00000000..fbe0e6bb
--- /dev/null
+++ b/yesod-core/Yesod/Core/Types.hs
@@ -0,0 +1,439 @@
+{-# LANGUAGE DeriveDataTypeable         #-}
+{-# LANGUAGE TupleSections #-}
+{-# LANGUAGE FlexibleInstances          #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses      #-}
+{-# LANGUAGE TypeFamilies               #-}
+{-# LANGUAGE UndecidableInstances #-}
+module Yesod.Core.Types where
+
+import qualified Blaze.ByteString.Builder           as BBuilder
+import qualified Blaze.ByteString.Builder.Char.Utf8
+import           Control.Applicative                (Applicative (..))
+import           Control.Applicative                ((<$>))
+import           Control.Arrow                      (first)
+import           Control.Exception                  (Exception)
+import           Control.Monad                      (liftM, ap)
+import           Control.Monad.Base                 (MonadBase (liftBase))
+import           Control.Monad.IO.Class             (MonadIO (liftIO))
+import           Control.Monad.Logger               (LogLevel, LogSource,
+                                                     MonadLogger (..))
+import           Control.Monad.Trans.Control        (MonadBaseControl (..))
+import           Control.Monad.Trans.Resource       (MonadResource (..), InternalState, runInternalState)
+import           Data.ByteString                    (ByteString)
+import qualified Data.ByteString.Lazy               as L
+import           Data.Conduit                       (Flush, MonadThrow (..),
+                                                     MonadUnsafeIO (..),
+                                                     ResourceT, Source)
+import           Data.Dynamic                       (Dynamic)
+import           Data.IORef                         (IORef)
+import           Data.Map                           (Map, unionWith)
+import qualified Data.Map                           as Map
+import           Data.Monoid                        (Endo (..), Last (..),
+                                                     Monoid (..))
+import           Data.Serialize                     (Serialize (..),
+                                                     putByteString)
+import           Data.String                        (IsString (fromString))
+import           Data.Text                          (Text)
+import qualified Data.Text                          as T
+import qualified Data.Text.Lazy.Builder             as TBuilder
+import           Data.Time                          (UTCTime)
+import           Data.Typeable                      (Typeable)
+import           Data.Typeable                      (TypeRep)
+import           Language.Haskell.TH.Syntax         (Loc)
+import qualified Network.HTTP.Types                 as H
+import           Network.Wai                        (FilePart,
+                                                     RequestBodyLength)
+import qualified Network.Wai                        as W
+import qualified Network.Wai.Parse                  as NWP
+import           System.Log.FastLogger              (LogStr, Logger, toLogStr)
+import           Text.Blaze.Html                    (Html)
+import           Text.Hamlet                        (HtmlUrl)
+import           Text.Julius                        (JavascriptUrl)
+import           Web.Cookie                         (SetCookie)
+import           Yesod.Core.Internal.Util           (getTime, putTime)
+import           Control.Monad.Trans.Class          (MonadTrans (..))
+import           Yesod.Routes.Class                 (RenderRoute (..), ParseRoute (..))
+
+-- Sessions
+type SessionMap = Map Text ByteString
+
+type SaveSession = SessionMap -- ^ The session contents after running the handler
+                -> IO [Header]
+
+newtype SessionBackend = SessionBackend
+    { sbLoadSession :: W.Request
+                    -> IO (SessionMap, SaveSession) -- ^ Return the session data and a function to save the session
+    }
+
+data SessionCookie = SessionCookie (Either UTCTime ByteString) ByteString SessionMap
+    deriving (Show, Read)
+instance Serialize SessionCookie where
+    put (SessionCookie a b c) = do
+        either putTime putByteString a
+        put b
+        put (map (first T.unpack) $ Map.toList c)
+
+    get = do
+        a <- getTime
+        b <- get
+        c <- map (first T.pack) <$> get
+        return $ SessionCookie (Left a) b (Map.fromList c)
+
+data ClientSessionDateCache =
+  ClientSessionDateCache {
+    csdcNow               :: !UTCTime
+  , csdcExpires           :: !UTCTime
+  , csdcExpiresSerialized :: !ByteString
+  } deriving (Eq, Show)
+
+-- | The parsed request information. This type augments the standard WAI
+-- 'W.Request' with additional information.
+data YesodRequest = YesodRequest
+    { reqGetParams  :: ![(Text, Text)]
+      -- ^ Same as 'W.queryString', but decoded to @Text@.
+    , reqCookies    :: ![(Text, Text)]
+    , reqWaiRequest :: !W.Request
+    , reqLangs      :: ![Text]
+      -- ^ Languages which the client supports. This is an ordered list by preference.
+    , reqToken      :: !(Maybe Text)
+      -- ^ A random, session-specific token used to prevent CSRF attacks.
+    , reqSession    :: !SessionMap
+      -- ^ Initial session sent from the client.
+      --
+      -- Since 1.2.0
+    , reqAccept     :: ![ContentType]
+      -- ^ An ordered list of the accepted content types.
+      --
+      -- Since 1.2.0
+    }
+
+-- | An augmented WAI 'W.Response'. This can either be a standard @Response@,
+-- or a higher-level data structure which Yesod will turn into a @Response@.
+data YesodResponse
+    = YRWai !W.Response
+    | YRPlain !H.Status ![Header] !ContentType !Content !SessionMap
+
+-- | A tuple containing both the POST parameters and submitted files.
+type RequestBodyContents =
+    ( [(Text, Text)]
+    , [(Text, FileInfo)]
+    )
+
+data FileInfo = FileInfo
+    { fileName        :: !Text
+    , fileContentType :: !Text
+    , fileSourceRaw   :: !(Source (ResourceT IO) ByteString)
+    , fileMove        :: !(FilePath -> IO ())
+    }
+
+data FileUpload = FileUploadMemory !(NWP.BackEnd L.ByteString)
+                | FileUploadDisk !(NWP.BackEnd FilePath)
+                | FileUploadSource !(NWP.BackEnd (Source (ResourceT IO) ByteString))
+
+-- | How to determine the root of the application for constructing URLs.
+--
+-- Note that future versions of Yesod may add new constructors without bumping
+-- the major version number. As a result, you should /not/ pattern match on
+-- @Approot@ values.
+data Approot master = ApprootRelative -- ^ No application root.
+                    | ApprootStatic !Text
+                    | ApprootMaster !(master -> Text)
+                    | ApprootRequest !(master -> W.Request -> Text)
+
+type ResolvedApproot = Text
+
+data AuthResult = Authorized | AuthenticationRequired | Unauthorized Text
+    deriving (Eq, Show, Read)
+
+data ScriptLoadPosition master
+    = BottomOfBody
+    | BottomOfHeadBlocking
+    | BottomOfHeadAsync (BottomOfHeadAsync master)
+
+type BottomOfHeadAsync master
+       = [Text] -- ^ urls to load asynchronously
+      -> Maybe (HtmlUrl (Route master)) -- ^ widget of js to run on async completion
+      -> (HtmlUrl (Route master)) -- ^ widget to insert at the bottom of <head>
+
+newtype Cache = Cache (Map TypeRep Dynamic)
+    deriving Monoid
+
+type Texts = [Text]
+
+-- | Wrap up a normal WAI application as a Yesod subsite.
+newtype WaiSubsite = WaiSubsite { runWaiSubsite :: W.Application }
+
+data RunHandlerEnv site = RunHandlerEnv
+    { rheRender   :: !(Route site -> [(Text, Text)] -> Text)
+    , rheRoute    :: !(Maybe (Route site))
+    , rheSite     :: !site
+    , rheUpload   :: !(RequestBodyLength -> FileUpload)
+    , rheLog      :: !(Loc -> LogSource -> LogLevel -> LogStr -> IO ())
+    , rheOnError  :: !(ErrorResponse -> YesodApp)
+      -- ^ How to respond when an error is thrown internally.
+      --
+      -- Since 1.2.0
+    }
+
+data HandlerData site parentRoute = HandlerData
+    { handlerRequest  :: !YesodRequest
+    , handlerEnv      :: !(RunHandlerEnv site)
+    , handlerState    :: !(IORef GHState)
+    , handlerToParent :: !(Route site -> parentRoute)
+    , handlerResource :: !InternalState
+    }
+
+data YesodRunnerEnv site = YesodRunnerEnv
+    { yreLogger         :: !Logger
+    , yreSite           :: !site
+    , yreSessionBackend :: !(Maybe SessionBackend)
+    }
+
+data YesodSubRunnerEnv sub parent parentMonad = YesodSubRunnerEnv
+    { ysreParentRunner  :: !(ParentRunner parent parentMonad)
+    , ysreGetSub        :: !(parent -> sub)
+    , ysreToParentRoute :: !(Route sub -> Route parent)
+    , ysreParentEnv     :: !(YesodRunnerEnv parent) -- FIXME maybe get rid of this and remove YesodRunnerEnv in ParentRunner?
+    }
+
+type ParentRunner parent m
+    = m TypedContent
+   -> YesodRunnerEnv parent
+   -> Maybe (Route parent)
+   -> W.Application
+
+-- | A generic handler monad, which can have a different subsite and master
+-- site. We define a newtype for better error message.
+newtype HandlerT site m a = HandlerT
+    { unHandlerT :: HandlerData site (MonadRoute m) -> m a
+    }
+
+type family MonadRoute (m :: * -> *)
+type instance MonadRoute IO = ()
+type instance MonadRoute (HandlerT site m) = (Route site)
+
+data GHState = GHState
+    { ghsSession :: SessionMap
+    , ghsRBC     :: Maybe RequestBodyContents
+    , ghsIdent   :: Int
+    , ghsCache   :: Cache
+    , ghsHeaders :: Endo [Header]
+    }
+
+-- | An extension of the basic WAI 'W.Application' datatype to provide extra
+-- features needed by Yesod. Users should never need to use this directly, as
+-- the 'HandlerT' monad and template haskell code should hide it away.
+type YesodApp = YesodRequest -> ResourceT IO YesodResponse
+
+-- | A generic widget, allowing specification of both the subsite and master
+-- site datatypes. While this is simply a @WriterT@, we define a newtype for
+-- better error messages.
+newtype WidgetT site m a = WidgetT
+    { unWidgetT :: HandlerData site (MonadRoute m) -> m (a, GWData (Route site))
+    }
+
+instance (a ~ (), Monad m) => Monoid (WidgetT site m a) where
+    mempty = return ()
+    mappend x y = x >> y
+
+type RY master = Route master -> [(Text, Text)] -> Text
+
+-- | Newtype wrapper allowing injection of arbitrary content into CSS.
+--
+-- Usage:
+--
+-- > toWidget $ CssBuilder "p { color: red }"
+--
+-- Since: 1.1.3
+newtype CssBuilder = CssBuilder { unCssBuilder :: TBuilder.Builder }
+
+-- | Content for a web page. By providing this datatype, we can easily create
+-- generic site templates, which would have the type signature:
+--
+-- > PageContent url -> HtmlUrl url
+data PageContent url = PageContent
+    { pageTitle :: Html
+    , pageHead  :: HtmlUrl url
+    , pageBody  :: HtmlUrl url
+    }
+
+data Content = ContentBuilder !BBuilder.Builder !(Maybe Int) -- ^ The content and optional content length.
+             | ContentSource !(Source (ResourceT IO) (Flush BBuilder.Builder))
+             | ContentFile !FilePath !(Maybe FilePart)
+             | ContentDontEvaluate !Content
+
+data TypedContent = TypedContent !ContentType !Content
+
+type RepHtml = Html
+newtype RepJson = RepJson Content
+newtype RepPlain = RepPlain Content
+newtype RepXml = RepXml Content
+
+type ContentType = ByteString -- FIXME Text?
+
+-- | Prevents a response body from being fully evaluated before sending the
+-- request.
+--
+-- Since 1.1.0
+newtype DontFullyEvaluate a = DontFullyEvaluate { unDontFullyEvaluate :: a }
+
+-- | Responses to indicate some form of an error occurred. These are different
+-- from 'SpecialResponse' in that they allow for custom error pages.
+data ErrorResponse =
+      NotFound
+    | InternalError Text
+    | InvalidArgs [Text]
+    | NotAuthenticated
+    | PermissionDenied Text
+    | BadMethod H.Method
+    deriving (Show, Eq, Typeable)
+
+----- header stuff
+-- | Headers to be added to a 'Result'.
+data Header =
+    AddCookie SetCookie
+    | DeleteCookie ByteString ByteString
+    | Header ByteString ByteString
+    deriving (Eq, Show)
+
+data Location url = Local url | Remote Text
+    deriving (Show, Eq)
+
+newtype UniqueList x = UniqueList ([x] -> [x])
+
+data Script url = Script { scriptLocation :: Location url, scriptAttributes :: [(Text, Text)] }
+    deriving (Show, Eq)
+data Stylesheet url = Stylesheet { styleLocation :: Location url, styleAttributes :: [(Text, Text)] }
+    deriving (Show, Eq)
+newtype Title = Title { unTitle :: Html }
+
+newtype Head url = Head (HtmlUrl url)
+    deriving Monoid
+newtype Body url = Body (HtmlUrl url)
+    deriving Monoid
+
+type CssBuilderUrl a = (a -> [(Text, Text)] -> Text) -> TBuilder.Builder
+
+data GWData a = GWData
+    { gwdBody        :: !(Body a)
+    , gwdTitle       :: !(Last Title)
+    , gwdScripts     :: !(UniqueList (Script a))
+    , gwdStylesheets :: !(UniqueList (Stylesheet a))
+    , gwdCss         :: !(Map (Maybe Text) (CssBuilderUrl a)) -- media type
+    , gwdJavascript  :: !(Maybe (JavascriptUrl a))
+    , gwdHead        :: !(Head a)
+    }
+instance Monoid (GWData a) where
+    mempty = GWData mempty mempty mempty mempty mempty mempty mempty
+    mappend (GWData a1 a2 a3 a4 a5 a6 a7)
+            (GWData b1 b2 b3 b4 b5 b6 b7) = GWData
+        (a1 `mappend` b1)
+        (a2 `mappend` b2)
+        (a3 `mappend` b3)
+        (a4 `mappend` b4)
+        (unionWith mappend a5 b5)
+        (a6 `mappend` b6)
+        (a7 `mappend` b7)
+
+data HandlerContents =
+      HCContent H.Status !TypedContent
+    | HCError ErrorResponse
+    | HCSendFile ContentType FilePath (Maybe FilePart)
+    | HCRedirect H.Status Text
+    | HCCreated Text
+    | HCWai W.Response
+    deriving Typeable
+
+instance Show HandlerContents where
+    show _ = "Cannot show a HandlerContents"
+instance Exception HandlerContents
+
+-- Instances for WidgetT
+instance Monad m => Functor (WidgetT site m) where
+    fmap = liftM
+instance Monad m => Applicative (WidgetT site m) where
+    pure = return
+    (<*>) = ap
+instance Monad m => Monad (WidgetT site m) where
+    return a = WidgetT $ const $ return (a, mempty)
+    WidgetT x >>= f = WidgetT $ \r -> do
+        (a, wa) <- x r
+        (b, wb) <- unWidgetT (f a) r
+        return (b, wa `mappend` wb)
+instance MonadIO m => MonadIO (WidgetT site m) where
+    liftIO = lift . liftIO
+instance MonadBase b m => MonadBase b (WidgetT site m) where
+    liftBase = WidgetT . const . liftBase . fmap (, mempty)
+instance MonadBaseControl b m => MonadBaseControl b (WidgetT site m) where
+    data StM (WidgetT site m) a = StW (StM m (a, GWData (Route site)))
+    liftBaseWith f = WidgetT $ \reader ->
+        liftBaseWith $ \runInBase ->
+            liftM (\x -> (x, mempty))
+            (f $ liftM StW . runInBase . flip unWidgetT reader)
+    restoreM (StW base) = WidgetT $ const $ restoreM base
+
+instance MonadTrans (WidgetT site) where
+    lift = WidgetT . const . liftM (, mempty)
+instance MonadThrow m => MonadThrow (WidgetT site m) where
+    monadThrow = lift . monadThrow
+instance (Applicative m, MonadIO m, MonadUnsafeIO m, MonadThrow m) => MonadResource (WidgetT site m) where
+    liftResourceT f = WidgetT $ \hd -> liftIO $ fmap (, mempty) $ runInternalState f (handlerResource hd)
+
+instance MonadIO m => MonadLogger (WidgetT site m) where
+    monadLoggerLog a b c d = WidgetT $ \hd ->
+        liftIO $ fmap (, mempty) $ rheLog (handlerEnv hd) a b c (toLogStr d)
+
+instance MonadTrans (HandlerT site) where
+    lift = HandlerT . const
+
+-- Instances for HandlerT
+instance Monad m => Functor (HandlerT site m) where
+    fmap = liftM
+instance Monad m => Applicative (HandlerT site m) where
+    pure = return
+    (<*>) = ap
+instance Monad m => Monad (HandlerT site m) where
+    return = HandlerT . const . return
+    HandlerT x >>= f = HandlerT $ \r -> x r >>= \x' -> unHandlerT (f x') r
+instance MonadIO m => MonadIO (HandlerT site m) where
+    liftIO = lift . liftIO
+instance MonadBase b m => MonadBase b (HandlerT site m) where
+    liftBase = lift . liftBase
+-- | Note: although we provide a @MonadBaseControl@ instance, @lifted-base@'s
+-- @fork@ function is incompatible with the underlying @ResourceT@ system.
+-- Instead, if you must fork a separate thread, you should use
+-- @resourceForkIO@.
+--
+-- Using fork usually leads to an exception that says
+-- \"Control.Monad.Trans.Resource.register\': The mutable state is being accessed
+-- after cleanup. Please contact the maintainers.\"
+instance MonadBaseControl b m => MonadBaseControl b (HandlerT site m) where
+    data StM (HandlerT site m) a = StH (StM m a)
+    liftBaseWith f = HandlerT $ \reader ->
+        liftBaseWith $ \runInBase ->
+            f $ liftM StH . runInBase . (\(HandlerT r) -> r reader)
+    restoreM (StH base) = HandlerT $ const $ restoreM base
+
+instance MonadThrow m => MonadThrow (HandlerT site m) where
+    monadThrow = lift . monadThrow
+instance (MonadIO m, MonadUnsafeIO m, MonadThrow m) => MonadResource (HandlerT site m) where
+    liftResourceT f = HandlerT $ \hd -> liftIO $ runInternalState f (handlerResource hd)
+
+instance MonadIO m => MonadLogger (HandlerT site m) where
+    monadLoggerLog a b c d = HandlerT $ \hd ->
+        liftIO $ rheLog (handlerEnv hd) a b c (toLogStr d)
+
+instance Monoid (UniqueList x) where
+    mempty = UniqueList id
+    UniqueList x `mappend` UniqueList y = UniqueList $ x . y
+
+instance IsString Content where
+    fromString = flip ContentBuilder Nothing . Blaze.ByteString.Builder.Char.Utf8.fromString
+
+instance RenderRoute WaiSubsite where
+    data Route WaiSubsite = WaiSubsiteRoute [Text] [(Text, Text)]
+        deriving (Show, Eq, Read, Ord)
+    renderRoute (WaiSubsiteRoute ps qs) = (ps, qs)
+instance ParseRoute WaiSubsite where
+    parseRoute (x, y) = Just $ WaiSubsiteRoute x y
diff --git a/yesod-core/Yesod/Core/Widget.hs b/yesod-core/Yesod/Core/Widget.hs
new file mode 100644
index 00000000..7aa43d84
--- /dev/null
+++ b/yesod-core/Yesod/Core/Widget.hs
@@ -0,0 +1,270 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE TupleSections #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE CPP #-}
+-- | Widgets combine HTML with JS and CSS dependencies with a unique identifier
+-- generator, allowing you to create truly modular HTML components.
+module Yesod.Core.Widget
+    ( -- * Datatype
+      WidgetT
+    , PageContent (..)
+      -- * Special Hamlet quasiquoter/TH for Widgets
+    , whamlet
+    , whamletFile
+    , ihamletToRepHtml
+      -- * Convert to Widget
+    , ToWidget (..)
+    , ToWidgetHead (..)
+    , ToWidgetBody (..)
+    , ToWidgetMedia (..)
+      -- * Creating
+      -- ** Head of page
+    , setTitle
+    , setTitleI
+      -- ** CSS
+    , addStylesheet
+    , addStylesheetAttrs
+    , addStylesheetRemote
+    , addStylesheetRemoteAttrs
+    , addStylesheetEither
+    , CssBuilder (..)
+      -- ** Javascript
+    , addScript
+    , addScriptAttrs
+    , addScriptRemote
+    , addScriptRemoteAttrs
+    , addScriptEither
+      -- * Subsites
+    , widgetToParentWidget
+    , handlerToWidget
+      -- * Internal
+    , whamletFileWithSettings
+    ) where
+
+import Data.Monoid
+import qualified Text.Blaze.Html5 as H
+import Text.Hamlet
+import Text.Cassius
+import Text.Julius
+import Yesod.Routes.Class
+import Yesod.Core.Handler (getMessageRender, getUrlRenderParams)
+import Control.Monad.IO.Class (MonadIO, liftIO)
+import Text.Shakespeare.I18N (RenderMessage)
+import Control.Monad (liftM)
+import Data.Text (Text)
+import qualified Data.Map as Map
+import Language.Haskell.TH.Quote (QuasiQuoter)
+import Language.Haskell.TH.Syntax (Q, Exp (InfixE, VarE, LamE, AppE), Pat (VarP), newName)
+
+import qualified Text.Hamlet as NP
+import Data.Text.Lazy.Builder (fromLazyText)
+import Text.Blaze.Html (toHtml, preEscapedToMarkup)
+import qualified Data.Text.Lazy as TL
+
+import Yesod.Core.Types
+import Yesod.Core.Class.Handler
+
+preEscapedLazyText :: TL.Text -> Html
+preEscapedLazyText = preEscapedToMarkup
+
+class ToWidget site a where
+    toWidget :: (MonadWidget m, HandlerSite m ~ site) => a -> m ()
+
+instance render ~ RY site => ToWidget site (render -> Html) where
+    toWidget x = tell $ GWData (Body x) mempty mempty mempty mempty mempty mempty
+instance render ~ RY site => ToWidget site (render -> Css) where
+    toWidget x = toWidget $ CssBuilder . fromLazyText . renderCss . x
+instance render ~ RY site => ToWidget site (render -> CssBuilder) where
+    toWidget x = tell $ GWData mempty mempty mempty mempty (Map.singleton Nothing $ unCssBuilder . x) mempty mempty
+instance render ~ RY site => ToWidget site (render -> Javascript) where
+    toWidget x = tell $ GWData mempty mempty mempty mempty mempty (Just x) mempty
+instance (site' ~ site, IO ~ m, a ~ ()) => ToWidget site' (WidgetT site m a) where
+    toWidget = liftWidgetT
+instance ToWidget site Html where
+    toWidget = toWidget . const
+
+-- | Allows adding some CSS to the page with a specific media type.
+--
+-- Since 1.2
+class ToWidgetMedia site a where
+    -- | Add the given content to the page, but only for the given media type.
+    --
+    -- Since 1.2
+    toWidgetMedia :: (MonadWidget m, HandlerSite m ~ site)
+                  => Text -- ^ media value
+                  -> a
+                  -> m ()
+instance render ~ RY site => ToWidgetMedia site (render -> Css) where
+    toWidgetMedia media x = toWidgetMedia media $ CssBuilder . fromLazyText . renderCss . x
+instance render ~ RY site => ToWidgetMedia site (render -> CssBuilder) where
+    toWidgetMedia media x = tell $ GWData mempty mempty mempty mempty (Map.singleton (Just media) $ unCssBuilder . x) mempty mempty
+
+class ToWidgetBody site a where
+    toWidgetBody :: (MonadWidget m, HandlerSite m ~ site) => a -> m ()
+
+instance render ~ RY site => ToWidgetBody site (render -> Html) where
+    toWidgetBody = toWidget
+instance render ~ RY site => ToWidgetBody site (render -> Javascript) where
+    toWidgetBody j = toWidget $ \r -> H.script $ preEscapedLazyText $ renderJavascriptUrl r j
+instance ToWidgetBody site Html where
+    toWidgetBody = toWidget
+
+class ToWidgetHead site a where
+    toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => a -> m ()
+
+instance render ~ RY site => ToWidgetHead site (render -> Html) where
+    toWidgetHead = tell . GWData mempty mempty mempty mempty mempty mempty . Head
+instance render ~ RY site => ToWidgetHead site (render -> Css) where
+    toWidgetHead = toWidget
+instance render ~ RY site => ToWidgetHead site (render -> CssBuilder) where
+    toWidgetHead = toWidget
+instance render ~ RY site => ToWidgetHead site (render -> Javascript) where
+    toWidgetHead j = toWidgetHead $ \r -> H.script $ preEscapedLazyText $ renderJavascriptUrl r j
+instance ToWidgetHead site Html where
+    toWidgetHead = toWidgetHead . const
+
+-- | Set the page title. Calling 'setTitle' multiple times overrides previously
+-- set values.
+setTitle :: MonadWidget m => Html -> m ()
+setTitle x = tell $ GWData mempty (Last $ Just $ Title x) mempty mempty mempty mempty mempty
+
+-- | Set the page title. Calling 'setTitle' multiple times overrides previously
+-- set values.
+setTitleI :: (MonadWidget m, RenderMessage (HandlerSite m) msg) => msg -> m ()
+setTitleI msg = do
+    mr <- getMessageRender
+    setTitle $ toHtml $ mr msg
+
+-- | Link to the specified local stylesheet.
+addStylesheet :: MonadWidget m => Route (HandlerSite m) -> m ()
+addStylesheet = flip addStylesheetAttrs []
+
+-- | Link to the specified local stylesheet.
+addStylesheetAttrs :: MonadWidget m
+                   => Route (HandlerSite m)
+                   -> [(Text, Text)]
+                   -> m ()
+addStylesheetAttrs x y = tell $ GWData mempty mempty mempty (toUnique $ Stylesheet (Local x) y) mempty mempty mempty
+
+-- | Link to the specified remote stylesheet.
+addStylesheetRemote :: MonadWidget m => Text -> m ()
+addStylesheetRemote = flip addStylesheetRemoteAttrs []
+
+-- | Link to the specified remote stylesheet.
+addStylesheetRemoteAttrs :: MonadWidget m => Text -> [(Text, Text)] -> m ()
+addStylesheetRemoteAttrs x y = tell $ GWData mempty mempty mempty (toUnique $ Stylesheet (Remote x) y) mempty mempty mempty
+
+addStylesheetEither :: MonadWidget m
+                    => Either (Route (HandlerSite m)) Text
+                    -> m ()
+addStylesheetEither = either addStylesheet addStylesheetRemote
+
+addScriptEither :: MonadWidget m
+                => Either (Route (HandlerSite m)) Text
+                -> m ()
+addScriptEither = either addScript addScriptRemote
+
+-- | Link to the specified local script.
+addScript :: MonadWidget m => Route (HandlerSite m) -> m ()
+addScript = flip addScriptAttrs []
+
+-- | Link to the specified local script.
+addScriptAttrs :: MonadWidget m => Route (HandlerSite m) -> [(Text, Text)] -> m ()
+addScriptAttrs x y = tell $ GWData mempty mempty (toUnique $ Script (Local x) y) mempty mempty mempty mempty
+
+-- | Link to the specified remote script.
+addScriptRemote :: MonadWidget m => Text -> m ()
+addScriptRemote = flip addScriptRemoteAttrs []
+
+-- | Link to the specified remote script.
+addScriptRemoteAttrs :: MonadWidget m => Text -> [(Text, Text)] -> m ()
+addScriptRemoteAttrs x y = tell $ GWData mempty mempty (toUnique $ Script (Remote x) y) mempty mempty mempty mempty
+
+whamlet :: QuasiQuoter
+whamlet = NP.hamletWithSettings rules NP.defaultHamletSettings
+
+whamletFile :: FilePath -> Q Exp
+whamletFile = NP.hamletFileWithSettings rules NP.defaultHamletSettings
+
+whamletFileWithSettings :: NP.HamletSettings -> FilePath -> Q Exp
+whamletFileWithSettings = NP.hamletFileWithSettings rules
+
+asWidgetT :: WidgetT site m () -> WidgetT site m ()
+asWidgetT = id
+
+rules :: Q NP.HamletRules
+rules = do
+    ah <- [|asWidgetT . toWidget|]
+    let helper qg f = do
+            x <- newName "urender"
+            e <- f $ VarE x
+            let e' = LamE [VarP x] e
+            g <- qg
+            bind <- [|(>>=)|]
+            return $ InfixE (Just g) bind (Just e')
+    let ur f = do
+            let env = NP.Env
+                    (Just $ helper [|getUrlRenderParams|])
+                    (Just $ helper [|liftM (toHtml .) getMessageRender|])
+            f env
+    return $ NP.HamletRules ah ur $ \_ b -> return $ ah `AppE` b
+
+-- | Wraps the 'Content' generated by 'hamletToContent' in a 'RepHtml'.
+ihamletToRepHtml :: (MonadHandler m, RenderMessage (HandlerSite m) message)
+                 => HtmlUrlI18n message (Route (HandlerSite m))
+                 -> m Html
+ihamletToRepHtml ih = do
+    urender <- getUrlRenderParams
+    mrender <- getMessageRender
+    return $ ih (toHtml . mrender) urender
+
+tell :: MonadWidget m => GWData (Route (HandlerSite m)) -> m ()
+tell w = liftWidgetT $ WidgetT $ const $ return ((), w)
+
+toUnique :: x -> UniqueList x
+toUnique = UniqueList . (:)
+
+handlerToWidget :: Monad m => HandlerT site m a -> WidgetT site m a
+handlerToWidget (HandlerT f) = WidgetT $ liftM (, mempty) . f
+
+widgetToParentWidget :: MonadIO m
+                     => WidgetT child IO a
+                     -> HandlerT child (HandlerT parent m) (WidgetT parent m a)
+widgetToParentWidget (WidgetT f) = HandlerT $ \hd -> do
+    (a, gwd) <- liftIO $ f hd { handlerToParent = const () }
+    return $ WidgetT $ const $ return (a, liftGWD (handlerToParent hd) gwd)
+
+liftGWD :: (child -> parent) -> GWData child -> GWData parent
+liftGWD tp gwd = GWData
+    { gwdBody = fixBody $ gwdBody gwd
+    , gwdTitle = gwdTitle gwd
+    , gwdScripts = fixUnique fixScript $ gwdScripts gwd
+    , gwdStylesheets = fixUnique fixStyle $ gwdStylesheets gwd
+    , gwdCss = fmap fixCss $ gwdCss gwd
+    , gwdJavascript = fmap fixJS $ gwdJavascript gwd
+    , gwdHead = fixHead $ gwdHead gwd
+    }
+  where
+    fixRender f route params = f (tp route) params
+
+    fixBody (Body h) = Body $ h . fixRender
+    fixHead (Head h) = Head $ h . fixRender
+
+    fixUnique go (UniqueList f) = UniqueList (map go (f []) ++)
+
+    fixScript (Script loc attrs) = Script (fixLoc loc) attrs
+    fixStyle (Stylesheet loc attrs) = Stylesheet (fixLoc loc) attrs
+
+    fixLoc (Local url) = Local $ tp url
+    fixLoc (Remote t) = Remote t
+
+    fixCss f = f . fixRender
+
+    fixJS f = f . fixRender
diff --git a/yesod-core/Yesod/Dispatch.hs b/yesod-core/Yesod/Dispatch.hs
deleted file mode 100644
index 1e193880..00000000
--- a/yesod-core/Yesod/Dispatch.hs
+++ /dev/null
@@ -1,223 +0,0 @@
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-module Yesod.Dispatch
-    ( -- * Quasi-quoted routing
-      parseRoutes
-    , parseRoutesNoCheck
-    , parseRoutesFile
-    , parseRoutesFileNoCheck
-    , mkYesod
-    , mkYesodSub
-      -- ** More fine-grained
-    , mkYesodData
-    , mkYesodSubData
-    , mkYesodDispatch
-    , mkYesodSubDispatch
-    , mkDispatchInstance
-      -- ** Path pieces
-    , PathPiece (..)
-    , PathMultiPiece (..)
-    , Texts
-      -- * Convert to WAI
-    , toWaiApp
-    , toWaiAppPlain
-      -- * WAI subsites
-    , WaiSubsite (..)
-    ) where
-
-import Control.Applicative ((<$>), (<*>))
-import Prelude hiding (exp)
-import Yesod.Internal.Core
-import Yesod.Handler hiding (lift)
-import Yesod.Widget (GWidget)
-
-import Web.PathPieces
-import Language.Haskell.TH
-import Language.Haskell.TH.Syntax
-
-import qualified Network.Wai as W
-import Network.Wai.Middleware.Gzip
-import Network.Wai.Middleware.Autohead
-
-import Data.ByteString.Lazy.Char8 ()
-
-import Data.Text (Text)
-import Data.Text.Encoding (decodeUtf8With)
-import Data.Text.Encoding.Error (lenientDecode)
-import Data.Monoid (mappend)
-import qualified Data.ByteString as S
-import qualified Blaze.ByteString.Builder
-import Network.HTTP.Types (status301)
-import Yesod.Routes.TH
-import Yesod.Content (chooseRep)
-import Yesod.Routes.Parse
-import System.Log.FastLogger (Logger)
-
-type Texts = [Text]
-
--- | Generates URL datatype and site function for the given 'Resource's. This
--- is used for creating sites, /not/ subsites. See 'mkYesodSub' for the latter.
--- Use 'parseRoutes' to create the 'Resource's.
-mkYesod :: String -- ^ name of the argument datatype
-        -> [ResourceTree String]
-        -> Q [Dec]
-mkYesod name = fmap (uncurry (++)) . mkYesodGeneral name [] [] False
-
--- | Generates URL datatype and site function for the given 'Resource's. This
--- is used for creating subsites, /not/ sites. See 'mkYesod' for the latter.
--- Use 'parseRoutes' to create the 'Resource's. In general, a subsite is not
--- executable by itself, but instead provides functionality to
--- be embedded in other sites.
-mkYesodSub :: String -- ^ name of the argument datatype
-           -> Cxt
-           -> [ResourceTree String]
-           -> Q [Dec]
-mkYesodSub name clazzes =
-    fmap (uncurry (++)) . mkYesodGeneral name' rest clazzes True
-  where
-    (name':rest) = words name
-
--- | Sometimes, you will want to declare your routes in one file and define
--- your handlers elsewhere. For example, this is the only way to break up a
--- monolithic file into smaller parts. Use this function, paired with
--- 'mkYesodDispatch', to do just that.
-mkYesodData :: String -> [ResourceTree String] -> Q [Dec]
-mkYesodData name res = mkYesodDataGeneral name [] False res
-
-mkYesodSubData :: String -> Cxt -> [ResourceTree String] -> Q [Dec]
-mkYesodSubData name clazzes res = mkYesodDataGeneral name clazzes True res
-
-mkYesodDataGeneral :: String -> Cxt -> Bool -> [ResourceTree String] -> Q [Dec]
-mkYesodDataGeneral name clazzes isSub res = do
-    let (name':rest) = words name
-    (x, _) <- mkYesodGeneral name' rest clazzes isSub res
-    let rname = mkName $ "resources" ++ name
-    eres <- lift res
-    let y = [ SigD rname $ ListT `AppT` (ConT ''ResourceTree `AppT` ConT ''String)
-            , FunD rname [Clause [] (NormalB eres) []]
-            ]
-    return $ x ++ y
-
--- | See 'mkYesodData'.
-mkYesodDispatch :: String -> [ResourceTree String] -> Q [Dec]
-mkYesodDispatch name = fmap snd . mkYesodGeneral name [] [] False
-
-mkYesodSubDispatch :: String -> Cxt -> [ResourceTree String] -> Q [Dec]
-mkYesodSubDispatch name clazzes = fmap snd . mkYesodGeneral name' rest clazzes True 
-  where (name':rest) = words name
-
-mkYesodGeneral :: String                   -- ^ foundation type
-               -> [String]                 -- ^ arguments for the type
-               -> Cxt                      -- ^ the type constraints
-               -> Bool                     -- ^ it this a subsite
-               -> [ResourceTree String]
-               -> Q([Dec],[Dec])
-mkYesodGeneral name args clazzes isSub resS = do
-     subsite        <- sub
-     masterTypeSyns <- if isSub then return   [] 
-                                else sequence [handler, widget]
-     renderRouteDec <- mkRenderRouteInstance subsite res
-     dispatchDec    <- mkDispatchInstance context sub master res
-     return (renderRouteDec ++ masterTypeSyns, dispatchDec)
-  where sub     = foldl appT subCons subArgs
-        master  = if isSub then (varT $ mkName "master") else sub
-        context = if isSub then cxt $ yesod : map return clazzes
-                           else return []
-        yesod   = classP ''Yesod [master]
-        handler = tySynD (mkName "Handler") [] [t| GHandler $master $master    |]
-        widget  = tySynD (mkName "Widget")  [] [t| GWidget  $master $master () |]
-        res     = map (fmap parseType) resS
-        subCons = conT $ mkName name
-        subArgs = map (varT. mkName) args
-        
--- | If the generation of @'YesodDispatch'@ instance require finer
--- control of the types, contexts etc. using this combinator. You will
--- hardly need this generality. However, in certain situations, like
--- when writing library/plugin for yesod, this combinator becomes
--- handy.
-mkDispatchInstance :: CxtQ                -- ^ The context
-                   -> TypeQ               -- ^ The subsite type
-                   -> TypeQ               -- ^ The master site type
-                   -> [ResourceTree a]    -- ^ The resource
-                   -> DecsQ
-mkDispatchInstance context sub master res = do
-  logger <- newName "logger"
-  let loggerE = varE logger
-      loggerP = VarP logger
-      yDispatch = conT ''YesodDispatch `appT` sub `appT` master
-      thisDispatch = do
-            Clause pat body decs <- mkDispatchClause
-                                    [|yesodRunner   $loggerE |]
-                                    [|yesodDispatch $loggerE |]
-                                    [|fmap chooseRep|]
-                                    res
-            return $ FunD 'yesodDispatch
-                         [ Clause (loggerP:pat)
-                                  body
-                                  decs
-                         ]
-      in sequence [instanceD context yDispatch [thisDispatch]]
-        
-
--- | Convert the given argument into a WAI application, executable with any WAI
--- handler. This is the same as 'toWaiAppPlain', except it includes two
--- middlewares: GZIP compression and autohead. This is the
--- recommended approach for most users.
-toWaiApp :: ( Yesod master
-            , YesodDispatch master master
-            ) => master -> IO W.Application
-toWaiApp y = gzip (gzipSettings y) . autohead <$> toWaiAppPlain y
-
--- | Convert the given argument into a WAI application, executable with any WAI
--- handler. This differs from 'toWaiApp' in that it uses no middlewares.
-toWaiAppPlain :: ( Yesod master
-                 , YesodDispatch master master
-                 ) => master -> IO W.Application
-toWaiAppPlain a = toWaiApp' a <$> getLogger a <*> makeSessionBackend a
-
-
-toWaiApp' :: ( Yesod master
-             , YesodDispatch master master
-             )
-          => master
-          -> Logger
-          -> Maybe (SessionBackend master)
-          -> W.Application
-toWaiApp' y logger sb env =
-    case cleanPath y $ W.pathInfo env of
-        Left pieces -> sendRedirect y pieces env
-        Right pieces ->
-            yesodDispatch logger y y id app404 handler405 method pieces sb env
-  where
-    app404 = yesodRunner logger notFound y y Nothing id
-    handler405 route = yesodRunner logger badMethod y y (Just route) id
-    method = decodeUtf8With lenientDecode $ W.requestMethod env
-
-sendRedirect :: Yesod master => master -> [Text] -> W.Application
-sendRedirect y segments' env =
-     return $ W.responseLBS status301
-            [ ("Content-Type", "text/plain")
-            , ("Location", Blaze.ByteString.Builder.toByteString dest')
-            ] "Redirecting"
-  where
-    dest = joinPath y (resolveApproot y env) segments' []
-    dest' =
-        if S.null (W.rawQueryString env)
-            then dest
-            else (dest `mappend`
-                 Blaze.ByteString.Builder.fromByteString (W.rawQueryString env))
-
--- | Wrap up a normal WAI application as a Yesod subsite.
-newtype WaiSubsite = WaiSubsite { runWaiSubsite :: W.Application }
-
-instance RenderRoute WaiSubsite where
-    data Route WaiSubsite = WaiSubsiteRoute [Text] [(Text, Text)]
-        deriving (Show, Eq, Read, Ord)
-    renderRoute (WaiSubsiteRoute ps qs) = (ps, qs)
-
-instance YesodDispatch WaiSubsite master where
-    yesodDispatch _logger _master (WaiSubsite app) _tomaster _404 _405 _method _pieces _session = app
diff --git a/yesod-core/Yesod/Handler.hs b/yesod-core/Yesod/Handler.hs
deleted file mode 100644
index 987a0ecc..00000000
--- a/yesod-core/Yesod/Handler.hs
+++ /dev/null
@@ -1,1071 +0,0 @@
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE DeriveDataTypeable #-}
----------------------------------------------------------
---
--- Module        : Yesod.Handler
--- Copyright     : Michael Snoyman
--- License       : BSD3
---
--- Maintainer    : Michael Snoyman <michael@snoyman.com>
--- Stability     : stable
--- Portability   : portable
---
--- Define Handler stuff.
---
----------------------------------------------------------
-module Yesod.Handler
-    ( -- * Type families
-      YesodSubRoute (..)
-      -- * Handler monad
-    , GHandler
-      -- ** Read information from handler
-    , getYesod
-    , getYesodSub
-    , getUrlRender
-    , getUrlRenderParams
-    , getCurrentRoute
-    , getRouteToMaster
-    , getRequest
-    , waiRequest
-    , runRequestBody
-      -- * Special responses
-      -- ** Redirecting
-    , RedirectUrl (..)
-    , redirect
-    , redirectWith
-    , redirectToPost
-      -- ** Errors
-    , notFound
-    , badMethod
-    , permissionDenied
-    , permissionDeniedI
-    , invalidArgs
-    , invalidArgsI
-      -- ** Short-circuit responses.
-    , sendFile
-    , sendFilePart
-    , sendResponse
-    , sendResponseStatus
-    , sendResponseCreated
-    , sendWaiResponse
-      -- * Setting headers
-    , setCookie
-    , getExpires
-    , deleteCookie
-    , setHeader
-    , setLanguage
-      -- ** Content caching and expiration
-    , cacheSeconds
-    , neverExpires
-    , alreadyExpired
-    , expiresAt
-      -- * Session
-    , SessionMap
-    , lookupSession
-    , lookupSessionBS
-    , getSession
-    , setSession
-    , setSessionBS
-    , deleteSession
-    , clearSession
-      -- ** Ultimate destination
-    , setUltDest
-    , setUltDestCurrent
-    , setUltDestReferer
-    , redirectUltDest
-    , clearUltDest
-      -- ** Messages
-    , setMessage
-    , setMessageI
-    , getMessage
-      -- * Helpers for specific content
-      -- ** Hamlet
-    , hamletToContent
-    , hamletToRepHtml
-      -- ** Misc
-    , newIdent
-      -- * Lifting
-    , MonadLift (..)
-    , handlerToIO
-      -- * i18n
-    , getMessageRender
-      -- * Per-request caching
-    , CacheKey
-    , mkCacheKey
-    , cacheLookup
-    , cacheInsert
-    , cacheDelete
-      -- * Internal Yesod
-    , runHandler
-    , YesodApp (..)
-    , runSubsiteGetter
-    , toMasterHandler
-    , toMasterHandlerDyn
-    , toMasterHandlerMaybe
-    , localNoCurrent
-    , HandlerData
-    , ErrorResponse (..)
-    , YesodAppResult (..)
-    , handlerToYAR
-    , yarToResponse
-    , headerToPair
-    ) where
-
-import Prelude hiding (catch)
-import Yesod.Internal.Request
-import Yesod.Internal
-import Data.Time (UTCTime, getCurrentTime, addUTCTime)
-
-import Control.Exception hiding (Handler, catch, finally)
-import Control.Applicative
-
-import Control.Monad (liftM)
-import Control.Failure (Failure (failure))
-
-import Control.Monad.IO.Class
-import Control.Monad.Trans.Class (MonadTrans)
-import qualified Control.Monad.Trans.Class
-
-import System.IO
-import qualified Network.Wai as W
-import qualified Network.HTTP.Types as H
-
-import Text.Hamlet
-import qualified Text.Blaze.Html.Renderer.Text as RenderText
-import qualified Data.Text as T
-import Data.Text.Encoding (encodeUtf8, decodeUtf8With)
-import Data.Text.Encoding.Error (lenientDecode)
-import qualified Data.Text.Lazy as TL
-
-import qualified Data.Map as Map
-import qualified Data.ByteString as S
-import qualified Data.ByteString.Lazy as L
-import Network.Wai.Parse (parseHttpAccept)
-
-import Yesod.Content
-import Data.Maybe (fromMaybe, mapMaybe)
-import Web.Cookie (SetCookie (..), renderSetCookie)
-import Control.Arrow ((***))
-import qualified Network.Wai.Parse as NWP
-import Data.Monoid (mappend, mempty, Endo (..))
-import qualified Data.ByteString.Char8 as S8
-import Data.ByteString (ByteString)
-import Data.CaseInsensitive (CI)
-import qualified Data.CaseInsensitive as CI
-import Blaze.ByteString.Builder (toByteString, toLazyByteString, fromLazyByteString)
-import Data.Text (Text)
-import Yesod.Message (RenderMessage (..))
-
-import Text.Blaze.Html (toHtml, preEscapedToMarkup)
-#define preEscapedText preEscapedToMarkup
-
-import System.Log.FastLogger
-import Control.Monad.Logger
-
-import qualified Yesod.Internal.Cache as Cache
-import Yesod.Internal.Cache (mkCacheKey, CacheKey)
-import qualified Data.IORef as I
-import Control.Exception.Lifted (catch)
-import Control.Monad.Trans.Control
-import Control.Monad.Trans.Resource
-import Control.Monad.Base
-import Yesod.Routes.Class
-import Data.Word (Word64)
-import Language.Haskell.TH.Syntax (Loc)
-
-class YesodSubRoute s y where
-    fromSubRoute :: s -> y -> Route s -> Route y
-
-data HandlerData sub master = HandlerData
-    { handlerRequest  :: Request
-    , handlerSub      :: sub
-    , handlerMaster   :: master
-    , handlerRoute    :: Maybe (Route sub)
-    , handlerRender   :: Route master -> [(Text, Text)] -> Text
-    , handlerToMaster :: Route sub -> Route master
-    , handlerState    :: I.IORef GHState
-    , handlerUpload   :: Word64 -> FileUpload
-    , handlerLog      :: Loc -> LogSource -> LogLevel -> LogStr -> IO ()
-    }
-
-handlerSubData :: (Route sub -> Route master)
-               -> (master -> sub)
-               -> Route sub
-               -> HandlerData oldSub master
-               -> HandlerData sub master
-handlerSubData tm ts = handlerSubDataMaybe tm ts . Just
-
-handlerSubDataMaybe :: (Route sub -> Route master)
-                    -> (master -> sub)
-                    -> Maybe (Route sub)
-                    -> HandlerData oldSub master
-                    -> HandlerData sub master
-handlerSubDataMaybe tm ts route hd = hd
-    { handlerSub = ts $ handlerMaster hd
-    , handlerToMaster = tm
-    , handlerRoute = route
-    }
-
-get :: GHandler sub master GHState
-get = do
-    hd <- ask
-    liftIO $ I.readIORef $ handlerState hd
-
-put :: GHState -> GHandler sub master ()
-put g = do
-    hd <- ask
-    liftIO $ I.writeIORef (handlerState hd) g
-
-modify :: (GHState -> GHState) -> GHandler sub master ()
-modify f = do
-    hd <- ask
-    liftIO $ I.atomicModifyIORef (handlerState hd) $ \g -> (f g, ())
-
-tell :: Endo [Header] -> GHandler sub master ()
-tell hs = modify $ \g -> g { ghsHeaders = ghsHeaders g `mappend` hs }
-
--- | Used internally for promoting subsite handler functions to master site
--- handler functions. Should not be needed by users.
-toMasterHandler :: (Route sub -> Route master)
-                -> (master -> sub)
-                -> Route sub
-                -> GHandler sub master a
-                -> GHandler sub' master a
-toMasterHandler tm ts route = local (handlerSubData tm ts route)
-
--- | FIXME do we need this?
-toMasterHandlerDyn :: (Route sub -> Route master)
-                   -> GHandler sub' master sub
-                   -> Route sub
-                   -> GHandler sub master a
-                   -> GHandler sub' master a
-toMasterHandlerDyn tm getSub route h = do
-    sub <- getSub
-    local (handlerSubData tm (const sub) route) h
-
-class SubsiteGetter g m s | g -> s where
-  runSubsiteGetter :: g -> m s
-
-instance (master ~ master'
-         ) => SubsiteGetter (master -> sub) (GHandler anySub master') sub where
-  runSubsiteGetter getter = getter <$> getYesod
-
-instance (anySub ~ anySub'
-         ,master ~ master'
-         ) => SubsiteGetter (GHandler anySub master sub) (GHandler anySub' master') sub where
-  runSubsiteGetter = id
-
-toMasterHandlerMaybe :: (Route sub -> Route master)
-                     -> (master -> sub)
-                     -> Maybe (Route sub)
-                     -> GHandler sub master a
-                     -> GHandler sub' master a
-toMasterHandlerMaybe tm ts route = local (handlerSubDataMaybe tm ts route)
-
--- | A generic handler monad, which can have a different subsite and master
--- site. We define a newtype for better error message.
-newtype GHandler sub master a = GHandler
-    { unGHandler :: HandlerData sub master -> ResourceT IO a
-    }
-
-data GHState = GHState
-    { ghsSession :: SessionMap
-    , ghsRBC :: Maybe RequestBodyContents
-    , ghsIdent :: Int
-    , ghsCache :: Cache.Cache
-    , ghsHeaders :: Endo [Header]
-    }
-
-type SessionMap = Map.Map Text S.ByteString
-
--- | An extension of the basic WAI 'W.Application' datatype to provide extra
--- features needed by Yesod. Users should never need to use this directly, as
--- the 'GHandler' monad and template haskell code should hide it away.
-newtype YesodApp = YesodApp
-    { unYesodApp
-    :: (ErrorResponse -> YesodApp)
-    -> Request
-    -> [ContentType]
-    -> SessionMap
-    -> ResourceT IO YesodAppResult
-    }
-
-data YesodAppResult
-    = YARWai W.Response
-    | YARPlain H.Status [Header] ContentType Content SessionMap
-
-getRequest :: GHandler s m Request
-getRequest = handlerRequest `liftM` ask
-
-hcError :: ErrorResponse -> GHandler sub master a
-hcError = liftIO . throwIO . HCError
-
-runRequestBody :: GHandler s m RequestBodyContents
-runRequestBody = do
-    hd <- ask
-    let getUpload = handlerUpload hd
-        len = reqBodySize $ handlerRequest hd
-        upload = getUpload len
-    x <- get
-    case ghsRBC x of
-        Just rbc -> return rbc
-        Nothing -> do
-            rr <- waiRequest
-            rbc <- lift $ rbHelper upload rr
-            put x { ghsRBC = Just rbc }
-            return rbc
-
-rbHelper :: FileUpload -> W.Request -> ResourceT IO RequestBodyContents
-rbHelper upload =
-    case upload of
-        FileUploadMemory s -> rbHelper' s mkFileInfoLBS
-        FileUploadDisk s -> rbHelper' s mkFileInfoFile
-        FileUploadSource s -> rbHelper' s mkFileInfoSource
-
-rbHelper' :: NWP.BackEnd x
-          -> (Text -> Text -> x -> FileInfo)
-          -> W.Request
-          -> ResourceT IO ([(Text, Text)], [(Text, FileInfo)])
-rbHelper' backend mkFI req =
-    (map fix1 *** mapMaybe fix2) <$> (NWP.parseRequestBody backend req)
-  where
-    fix1 = go *** go
-    fix2 (x, NWP.FileInfo a' b c)
-        | S.null a = Nothing
-        | otherwise = Just (go x, mkFI (go a) (go b) c)
-      where
-        a
-            | S.length a' < 2 = a'
-            | S8.head a' == '"' && S8.last a' == '"' = S.tail $ S.init a'
-            | S8.head a' == '\'' && S8.last a' == '\'' = S.tail $ S.init a'
-            | otherwise = a'
-    go = decodeUtf8With lenientDecode
-
--- | Get the sub application argument.
-getYesodSub :: GHandler sub master sub
-getYesodSub = handlerSub `liftM` ask
-
--- | Get the master site appliation argument.
-getYesod :: GHandler sub master master
-getYesod = handlerMaster `liftM` ask
-
--- | Get the URL rendering function.
-getUrlRender :: GHandler sub master (Route master -> Text)
-getUrlRender = do
-    x <- handlerRender `liftM` ask
-    return $ flip x []
-
--- | The URL rendering function with query-string parameters.
-getUrlRenderParams
-    :: GHandler sub master (Route master -> [(Text, Text)] -> Text)
-getUrlRenderParams = handlerRender `liftM` ask
-
--- | Get the route requested by the user. If this is a 404 response- where the
--- user requested an invalid route- this function will return 'Nothing'.
-getCurrentRoute :: GHandler sub master (Maybe (Route sub))
-getCurrentRoute = handlerRoute `liftM` ask
-
--- | Get the function to promote a route for a subsite to a route for the
--- master site.
-getRouteToMaster :: GHandler sub master (Route sub -> Route master)
-getRouteToMaster = handlerToMaster `liftM` ask
-
-
--- | Returns a function that runs 'GHandler' actions inside @IO@.
---
--- Sometimes you want to run an inner 'GHandler' action outside
--- the control flow of an HTTP request (on the outer 'GHandler'
--- action).  For example, you may want to spawn a new thread:
---
--- @
--- getFooR :: Handler RepHtml
--- getFooR = do
---   runInnerHandler <- handlerToIO
---   liftIO $ forkIO $ runInnerHandler $ do
---     /Code here runs inside GHandler but on a new thread./
---     /This is the inner GHandler./
---     ...
---   /Code here runs inside the request's control flow./
---   /This is the outer GHandler./
---   ...
--- @
---
--- Another use case for this function is creating a stream of
--- server-sent events using 'GHandler' actions (see
--- @yesod-eventsource@).
---
--- Most of the environment from the outer 'GHandler' is preserved
--- on the inner 'GHandler', however:
---
---  * The request body is cleared (otherwise it would be very
---  difficult to prevent huge memory leaks).
---
---  * The cache is cleared (see 'CacheKey').
---
--- Changes to the response made inside the inner 'GHandler' are
--- ignored (e.g., session variables, cookies, response headers).
--- This allows the inner 'GHandler' to outlive the outer
--- 'GHandler' (e.g., on the @forkIO@ example above, a response
--- may be sent to the client without killing the new thread).
-handlerToIO :: MonadIO m => GHandler sub master (GHandler sub master a -> m a)
-handlerToIO =
-  GHandler $ \oldHandlerData -> do
-    -- Let go of the request body, cache and response headers.
-    let oldReq    = handlerRequest oldHandlerData
-        oldWaiReq = reqWaiRequest oldReq
-        newWaiReq = oldWaiReq { W.requestBody = mempty }
-        newReq    = oldReq { reqWaiRequest = newWaiReq
-                           , reqBodySize   = 0 }
-        clearedOldHandlerData =
-          oldHandlerData { handlerRequest = err "handlerRequest never here"
-                         , handlerState   = err "handlerState never here" }
-            where
-              err :: String -> a
-              err = error . ("handlerToIO: clearedOldHandlerData/" ++)
-    newState <- liftIO $ do
-      oldState <- I.readIORef (handlerState oldHandlerData)
-      return $ oldState { ghsRBC = Nothing
-                        , ghsIdent = 1
-                        , ghsCache = mempty
-                        , ghsHeaders = mempty }
-
-    -- Return GHandler running function.
-    return $ \(GHandler f) -> liftIO $ do
-      -- The state IORef needs to be created here, otherwise it
-      -- will be shared by different invocations of this function.
-      newStateIORef <- I.newIORef newState
-      runResourceT $ f clearedOldHandlerData
-                         { handlerRequest = newReq
-                         , handlerState   = newStateIORef }
-
-
--- | Function used internally by Yesod in the process of converting a
--- 'GHandler' into an 'W.Application'. Should not be needed by users.
-runHandler :: HasReps c
-           => GHandler sub master c
-           -> (Route master -> [(Text, Text)] -> Text)
-           -> Maybe (Route sub)
-           -> (Route sub -> Route master)
-           -> master
-           -> sub
-           -> (Word64 -> FileUpload)
-           -> (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
-           -> YesodApp
-runHandler handler mrender sroute tomr master sub upload log' =
-  YesodApp $ \eh rr cts initSession -> do
-    let toErrorHandler e =
-            case fromException e of
-                Just x -> x
-                Nothing -> InternalError $ T.pack $ show e
-    istate <- liftIO $ I.newIORef GHState
-        { ghsSession = initSession
-        , ghsRBC = Nothing
-        , ghsIdent = 1
-        , ghsCache = mempty
-        , ghsHeaders = mempty
-        }
-    let hd = HandlerData
-            { handlerRequest = rr
-            , handlerSub = sub
-            , handlerMaster = master
-            , handlerRoute = sroute
-            , handlerRender = mrender
-            , handlerToMaster = tomr
-            , handlerState = istate
-            , handlerUpload = upload
-            , handlerLog = log'
-            }
-    contents' <- catch (fmap Right $ unGHandler handler hd)
-        (\e -> return $ Left $ maybe (HCError $ toErrorHandler e) id
-                      $ fromException e)
-    state <- liftIO $ I.readIORef istate
-    let finalSession = ghsSession state
-    let headers = ghsHeaders state
-    let contents = either id (HCContent H.status200 . chooseRep) contents'
-    let handleError e = do
-            yar <- unYesodApp (eh e) safeEh rr cts finalSession
-            case yar of
-                YARPlain _ hs ct c sess ->
-                    let hs' = appEndo headers hs
-                     in return $ YARPlain (getStatus e) hs' ct c sess
-                YARWai _ -> return yar
-    let sendFile' ct fp p =
-            return $ YARPlain H.status200 (appEndo headers []) ct (ContentFile fp p) finalSession
-    case contents of
-        HCContent status a -> do
-            (ct, c) <- liftIO $ a cts
-            ec' <- liftIO $ evaluateContent c
-            case ec' of
-                Left e -> handleError e
-                Right c' -> return $ YARPlain status (appEndo headers []) ct c' finalSession
-        HCError e -> handleError e
-        HCRedirect status loc -> do
-            let disable_caching x =
-                      Header "Cache-Control" "no-cache, must-revalidate"
-                    : Header "Expires" "Thu, 01 Jan 1970 05:05:05 GMT"
-                    : x
-                hs = (if status /= H.movedPermanently301 then disable_caching else id)
-                      $ Header "Location" (encodeUtf8 loc) : appEndo headers []
-            return $ YARPlain
-                status hs typePlain emptyContent
-                finalSession
-        HCSendFile ct fp p -> catch
-            (sendFile' ct fp p)
-            (handleError . toErrorHandler)
-        HCCreated loc -> do
-            let hs = Header "Location" (encodeUtf8 loc) : appEndo headers []
-            return $ YARPlain
-                H.status201
-                hs
-                typePlain
-                emptyContent
-                finalSession
-        HCWai r -> return $ YARWai r
-
-evaluateContent :: Content -> IO (Either ErrorResponse Content)
-evaluateContent (ContentBuilder b mlen) = Control.Exception.handle f $ do
-    let lbs = toLazyByteString b
-    L.length lbs `seq` return (Right $ ContentBuilder (fromLazyByteString lbs) mlen)
-  where
-    f :: SomeException -> IO (Either ErrorResponse Content)
-    f = return . Left . InternalError . T.pack . show
-evaluateContent c = return (Right c)
-
-safeEh :: ErrorResponse -> YesodApp
-safeEh er = YesodApp $ \_ _ _ session -> do
-    liftIO $ hPutStrLn stderr $ "Error handler errored out: " ++ show er
-    return $ YARPlain
-        H.status500
-        []
-        typePlain
-        (toContent ("Internal Server Error" :: S.ByteString))
-        session
-
--- | Redirect to the given route.
--- HTTP status code 303 for HTTP 1.1 clients and 302 for HTTP 1.0
--- This is the appropriate choice for a get-following-post
--- technique, which should be the usual use case.
---
--- If you want direct control of the final status code, or need a different
--- status code, please use 'redirectWith'.
-redirect :: RedirectUrl master url => url -> GHandler sub master a
-redirect url = do
-    req <- waiRequest
-    let status =
-            if W.httpVersion req == H.http11
-                then H.status303
-                else H.status302
-    redirectWith status url
-
--- | Redirect to the given URL with the specified status code.
-redirectWith :: RedirectUrl master url => H.Status -> url -> GHandler sub master a
-redirectWith status url = do
-    urlText <- toTextUrl url
-    liftIO $ throwIO $ HCRedirect status urlText
-
-ultDestKey :: Text
-ultDestKey = "_ULT"
-
--- | Sets the ultimate destination variable to the given route.
---
--- An ultimate destination is stored in the user session and can be loaded
--- later by 'redirectUltDest'.
-setUltDest :: RedirectUrl master url => url -> GHandler sub master ()
-setUltDest url = do
-    urlText <- toTextUrl url
-    setSession ultDestKey urlText
-
--- | Same as 'setUltDest', but uses the current page.
---
--- If this is a 404 handler, there is no current page, and then this call does
--- nothing.
-setUltDestCurrent :: GHandler sub master ()
-setUltDestCurrent = do
-    route <- getCurrentRoute
-    case route of
-        Nothing -> return ()
-        Just r -> do
-            tm <- getRouteToMaster
-            gets' <- reqGetParams `liftM` handlerRequest `liftM` ask
-            setUltDest (tm r, gets')
-
--- | Sets the ultimate destination to the referer request header, if present.
---
--- This function will not overwrite an existing ultdest.
-setUltDestReferer :: GHandler sub master ()
-setUltDestReferer = do
-    mdest <- lookupSession ultDestKey
-    maybe
-        (waiRequest >>= maybe (return ()) setUltDestBS . lookup "referer" . W.requestHeaders)
-        (const $ return ())
-        mdest
-  where
-    setUltDestBS = setUltDest . T.pack . S8.unpack
-
--- | Redirect to the ultimate destination in the user's session. Clear the
--- value from the session.
---
--- The ultimate destination is set with 'setUltDest'.
---
--- This function uses 'redirect', and thus will perform a temporary redirect to
--- a GET request.
-redirectUltDest :: RedirectUrl master url
-                => url -- ^ default destination if nothing in session
-                -> GHandler sub master a
-redirectUltDest def = do
-    mdest <- lookupSession ultDestKey
-    deleteSession ultDestKey
-    maybe (redirect def) redirect mdest
-
--- | Remove a previously set ultimate destination. See 'setUltDest'.
-clearUltDest :: GHandler sub master ()
-clearUltDest = deleteSession ultDestKey
-
-msgKey :: Text
-msgKey = "_MSG"
-
--- | Sets a message in the user's session.
---
--- See 'getMessage'.
-setMessage :: Html -> GHandler sub master ()
-setMessage = setSession msgKey . T.concat . TL.toChunks . RenderText.renderHtml
-
--- | Sets a message in the user's session.
---
--- See 'getMessage'.
-setMessageI :: (RenderMessage y msg) => msg -> GHandler sub y ()
-setMessageI msg = do
-    mr <- getMessageRender
-    setMessage $ toHtml $ mr msg
-
--- | Gets the message in the user's session, if available, and then clears the
--- variable.
---
--- See 'setMessage'.
-getMessage :: GHandler sub master (Maybe Html)
-getMessage = do
-    mmsg <- liftM (fmap preEscapedText) $ lookupSession msgKey
-    deleteSession msgKey
-    return mmsg
-
--- | Bypass remaining handler code and output the given file.
---
--- For some backends, this is more efficient than reading in the file to
--- memory, since they can optimize file sending via a system call to sendfile.
-sendFile :: ContentType -> FilePath -> GHandler sub master a
-sendFile ct fp = liftIO . throwIO $ HCSendFile ct fp Nothing
-
--- | Same as 'sendFile', but only sends part of a file.
-sendFilePart :: ContentType
-             -> FilePath
-             -> Integer -- ^ offset
-             -> Integer -- ^ count
-             -> GHandler sub master a
-sendFilePart ct fp off count =
-    liftIO . throwIO $ HCSendFile ct fp $ Just $ W.FilePart off count
-
--- | Bypass remaining handler code and output the given content with a 200
--- status code.
-sendResponse :: HasReps c => c -> GHandler sub master a
-sendResponse = liftIO . throwIO . HCContent H.status200
-             . chooseRep
-
--- | Bypass remaining handler code and output the given content with the given
--- status code.
-sendResponseStatus :: HasReps c => H.Status -> c -> GHandler s m a
-sendResponseStatus s = liftIO . throwIO . HCContent s
-                     . chooseRep
-
--- | Send a 201 "Created" response with the given route as the Location
--- response header.
-sendResponseCreated :: Route m -> GHandler s m a
-sendResponseCreated url = do
-    r <- getUrlRender
-    liftIO . throwIO $ HCCreated $ r url
-
--- | Send a 'W.Response'. Please note: this function is rarely
--- necessary, and will /disregard/ any changes to response headers and session
--- that you have already specified. This function short-circuits. It should be
--- considered only for very specific needs. If you are not sure if you need it,
--- you don't.
-sendWaiResponse :: W.Response -> GHandler s m b
-sendWaiResponse = liftIO . throwIO . HCWai
-
--- | Return a 404 not found page. Also denotes no handler available.
-notFound :: GHandler sub master a
-notFound = hcError NotFound
-
--- | Return a 405 method not supported page.
-badMethod :: GHandler sub master a
-badMethod = do
-    w <- waiRequest
-    hcError $ BadMethod $ W.requestMethod w
-
--- | Return a 403 permission denied page.
-permissionDenied :: Text -> GHandler sub master a
-permissionDenied = hcError . PermissionDenied
-
--- | Return a 403 permission denied page.
-permissionDeniedI :: RenderMessage master msg => msg -> GHandler sub master a
-permissionDeniedI msg = do
-    mr <- getMessageRender
-    permissionDenied $ mr msg
-
--- | Return a 400 invalid arguments page.
-invalidArgs :: [Text] -> GHandler sub master a
-invalidArgs = hcError . InvalidArgs
-
--- | Return a 400 invalid arguments page.
-invalidArgsI :: RenderMessage y msg => [msg] -> GHandler s y a
-invalidArgsI msg = do
-    mr <- getMessageRender
-    invalidArgs $ map mr msg
-
-------- Headers
--- | Set the cookie on the client.
-
-setCookie :: SetCookie
-          -> GHandler sub master ()
-setCookie = addHeader . AddCookie
-
--- | Helper function for setCookieExpires value
-getExpires :: Int -- ^ minutes
-          -> IO UTCTime
-getExpires m = do
-    now <- liftIO getCurrentTime
-    return $ fromIntegral (m * 60) `addUTCTime` now
-
-
--- | Unset the cookie on the client.
---
--- Note: although the value used for key and path is 'Text', you should only
--- use ASCII values to be HTTP compliant.
-deleteCookie :: Text -- ^ key
-             -> Text -- ^ path
-             -> GHandler sub master ()
-deleteCookie a = addHeader . DeleteCookie (encodeUtf8 a) . encodeUtf8
-
-
--- | Set the language in the user session. Will show up in 'languages' on the
--- next request.
-setLanguage :: Text -> GHandler sub master ()
-setLanguage = setSession langKey
-
--- | Set an arbitrary response header.
---
--- Note that, while the data type used here is 'Text', you must provide only
--- ASCII value to be HTTP compliant.
-setHeader :: Text -> Text -> GHandler sub master ()
-setHeader a = addHeader . Header (encodeUtf8 a) . encodeUtf8
-
--- | Set the Cache-Control header to indicate this response should be cached
--- for the given number of seconds.
-cacheSeconds :: Int -> GHandler s m ()
-cacheSeconds i = setHeader "Cache-Control" $ T.concat
-    [ "max-age="
-    , T.pack $ show i
-    , ", public"
-    ]
-
--- | Set the Expires header to some date in 2037. In other words, this content
--- is never (realistically) expired.
-neverExpires :: GHandler s m ()
-neverExpires = setHeader "Expires" "Thu, 31 Dec 2037 23:55:55 GMT"
-
--- | Set an Expires header in the past, meaning this content should not be
--- cached.
-alreadyExpired :: GHandler s m ()
-alreadyExpired = setHeader "Expires" "Thu, 01 Jan 1970 05:05:05 GMT"
-
--- | Set an Expires header to the given date.
-expiresAt :: UTCTime -> GHandler s m ()
-expiresAt = setHeader "Expires" . formatRFC1123
-
--- | Set a variable in the user's session.
---
--- The session is handled by the clientsession package: it sets an encrypted
--- and hashed cookie on the client. This ensures that all data is secure and
--- not tampered with.
-setSession :: Text -- ^ key
-           -> Text -- ^ value
-           -> GHandler sub master ()
-setSession k = setSessionBS k . encodeUtf8
-
--- | Same as 'setSession', but uses binary data for the value.
-setSessionBS :: Text
-             -> S.ByteString
-             -> GHandler sub master ()
-setSessionBS k = modify . modSession . Map.insert k
-
--- | Unsets a session variable. See 'setSession'.
-deleteSession :: Text -> GHandler sub master ()
-deleteSession = modify . modSession . Map.delete
-
--- | Clear all session variables.
---
--- Since: 1.0.1
-clearSession :: GHandler sub master ()
-clearSession = modify $ \x -> x { ghsSession = Map.empty }
-
-modSession :: (SessionMap -> SessionMap) -> GHState -> GHState
-modSession f x = x { ghsSession = f $ ghsSession x }
-
--- | Internal use only, not to be confused with 'setHeader'.
-addHeader :: Header -> GHandler sub master ()
-addHeader = tell . Endo . (:)
-
-getStatus :: ErrorResponse -> H.Status
-getStatus NotFound = H.status404
-getStatus (InternalError _) = H.status500
-getStatus (InvalidArgs _) = H.status400
-getStatus (PermissionDenied _) = H.status403
-getStatus (BadMethod _) = H.status405
-
--- | Some value which can be turned into a URL for redirects.
-class RedirectUrl master a where
-    -- | Converts the value to the URL and a list of query-string parameters.
-    toTextUrl :: a -> GHandler sub master Text
-
-instance RedirectUrl master Text where
-    toTextUrl = return
-
-instance RedirectUrl master String where
-    toTextUrl = toTextUrl . T.pack
-
-instance RedirectUrl master (Route master) where
-    toTextUrl url = do
-        r <- getUrlRender
-        return $ r url
-
-instance (key ~ Text, val ~ Text) => RedirectUrl master (Route master, [(key, val)]) where
-    toTextUrl (url, params) = do
-        r <- getUrlRenderParams
-        return $ r url params
-
-localNoCurrent :: GHandler s m a -> GHandler s m a
-localNoCurrent =
-    local (\hd -> hd { handlerRoute = Nothing })
-
--- | Lookup for session data.
-lookupSession :: Text -> GHandler s m (Maybe Text)
-lookupSession = (fmap . fmap) (decodeUtf8With lenientDecode) . lookupSessionBS
-
--- | Lookup for session data in binary format.
-lookupSessionBS :: Text -> GHandler s m (Maybe S.ByteString)
-lookupSessionBS n = do
-    m <- liftM ghsSession get
-    return $ Map.lookup n m
-
--- | Get all session variables.
-getSession :: GHandler sub master SessionMap
-getSession = liftM ghsSession get
-
-handlerToYAR :: (HasReps a, HasReps b)
-             => master -- ^ master site foundation
-             -> sub    -- ^ sub site foundation
-             -> (Word64 -> FileUpload)
-             -> (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
-             -> (Route sub -> Route master)
-             -> (Route master -> [(Text, Text)] -> Text) -- route renderer
-             -> (ErrorResponse -> GHandler sub master a)
-             -> Request
-             -> Maybe (Route sub)
-             -> SessionMap
-             -> GHandler sub master b
-             -> ResourceT IO YesodAppResult
-handlerToYAR y s upload log' toMasterRoute render errorHandler rr murl sessionMap h =
-    unYesodApp ya eh' rr types sessionMap
-  where
-    ya = runHandler h render murl toMasterRoute y s upload log'
-    eh' er = runHandler (errorHandler' er) render murl toMasterRoute y s upload log'
-    types = httpAccept $ reqWaiRequest rr
-    errorHandler' = localNoCurrent . errorHandler
-
-yarToResponse :: YesodAppResult -> [(CI ByteString, ByteString)] -> W.Response
-yarToResponse (YARWai a) _ = a
-yarToResponse (YARPlain s hs _ c _) extraHeaders =
-    go c
-  where
-    finalHeaders = extraHeaders ++ map headerToPair hs
-    finalHeaders' len = ("Content-Length", S8.pack $ show len)
-                      : finalHeaders
-
-    go (ContentBuilder b mlen) =
-        W.ResponseBuilder s hs' b
-      where
-        hs' = maybe finalHeaders finalHeaders' mlen
-    go (ContentFile fp p) = W.ResponseFile s finalHeaders fp p
-    go (ContentSource body) = W.ResponseSource s finalHeaders body
-    go (ContentDontEvaluate c') = go c'
-
-httpAccept :: W.Request -> [ContentType]
-httpAccept = parseHttpAccept
-           . fromMaybe mempty
-           . lookup "Accept"
-           . W.requestHeaders
-
--- | Convert Header to a key/value pair.
-headerToPair :: Header
-             -> (CI ByteString, ByteString)
-headerToPair (AddCookie sc) =
-    ("Set-Cookie", toByteString $ renderSetCookie $ sc)
-headerToPair (DeleteCookie key path) =
-    ( "Set-Cookie"
-    , S.concat
-        [ key
-        , "=; path="
-        , path
-        , "; expires=Thu, 01-Jan-1970 00:00:00 GMT"
-        ]
-    )
-headerToPair (Header key value) = (CI.mk key, value)
-
--- | Get a unique identifier.
-newIdent :: GHandler sub master Text
-newIdent = do
-    x <- get
-    let i' = ghsIdent x + 1
-    put x { ghsIdent = i' }
-    return $ T.pack $ 'h' : show i'
-
--- | Redirect to a POST resource.
---
--- This is not technically a redirect; instead, it returns an HTML page with a
--- POST form, and some Javascript to automatically submit the form. This can be
--- useful when you need to post a plain link somewhere that needs to cause
--- changes on the server.
-redirectToPost :: RedirectUrl master url => url -> GHandler sub master a
-redirectToPost url = do
-    urlText <- toTextUrl url
-    hamletToRepHtml [hamlet|
-$newline never
-$doctype 5
-
-<html>
-    <head>
-        <title>Redirecting...
-    <body onload="document.getElementById('form').submit()">
-        <form id="form" method="post" action=#{urlText}>
-            <noscript>
-                <p>Javascript has been disabled; please click on the button below to be redirected.
-            <input type="submit" value="Continue">
-|] >>= sendResponse
-
--- | Converts the given Hamlet template into 'Content', which can be used in a
--- Yesod 'Response'.
-hamletToContent :: HtmlUrl (Route master) -> GHandler sub master Content
-hamletToContent h = do
-    render <- getUrlRenderParams
-    return $ toContent $ h render
-
--- | Wraps the 'Content' generated by 'hamletToContent' in a 'RepHtml'.
-hamletToRepHtml :: HtmlUrl (Route master) -> GHandler sub master RepHtml
-hamletToRepHtml = liftM RepHtml . hamletToContent
-
--- | Get the request\'s 'W.Request' value.
-waiRequest :: GHandler sub master W.Request
-waiRequest = reqWaiRequest `liftM` getRequest
-
-getMessageRender :: RenderMessage master message => GHandler s master (message -> Text)
-getMessageRender = do
-    m <- getYesod
-    l <- reqLangs `liftM` getRequest
-    return $ renderMessage m l
-
-cacheLookup :: CacheKey a -> GHandler sub master (Maybe a)
-cacheLookup k = do
-    gs <- get
-    return $ Cache.lookup k $ ghsCache gs
-
-cacheInsert :: CacheKey a -> a -> GHandler sub master ()
-cacheInsert k v = modify $ \gs ->
-    gs { ghsCache = Cache.insert k v $ ghsCache gs }
-
-cacheDelete :: CacheKey a -> GHandler sub master ()
-cacheDelete k = modify $ \gs ->
-    gs { ghsCache = Cache.delete k $ ghsCache gs }
-
-ask :: GHandler sub master (HandlerData sub master)
-ask = GHandler return
-
-local :: (HandlerData sub' master' -> HandlerData sub master)
-      -> GHandler sub master a
-      -> GHandler sub' master' a
-local f (GHandler x) = GHandler $ \r -> x $ f r
-
--- | The standard @MonadTrans@ class only allows lifting for monad
--- transformers. While @GHandler@ and @GWidget@ should allow lifting, their
--- types do not express that they actually are transformers. This replacement
--- class accounts for this.
-class MonadLift base m | m -> base where
-    lift :: base a -> m a
-instance (Monad m, MonadTrans t) => MonadLift m (t m) where
-    lift = Control.Monad.Trans.Class.lift
-instance MonadLift (ResourceT IO) (GHandler sub master) where
-    lift = GHandler . const
-
--- Instances for GHandler
-instance Functor (GHandler sub master) where
-    fmap f (GHandler x) = GHandler $ \r -> fmap f (x r)
-instance Applicative (GHandler sub master) where
-    pure = GHandler . const . pure
-    GHandler f <*> GHandler x = GHandler $ \r -> f r <*> x r
-instance Monad (GHandler sub master) where
-    return = pure
-    GHandler x >>= f = GHandler $ \r -> x r >>= \x' -> unGHandler (f x') r
-instance MonadIO (GHandler sub master) where
-    liftIO = GHandler . const . lift
-instance MonadBase IO (GHandler sub master) where
-    liftBase = GHandler . const . lift
--- | Note: although we provide a @MonadBaseControl@ instance, @lifted-base@'s
--- @fork@ function is incompatible with the underlying @ResourceT@ system.
--- Instead, if you must fork a separate thread, you should use
--- @resourceForkIO@.
---
--- Using fork usually leads to an exception that says
--- \"Control.Monad.Trans.Resource.register\': The mutable state is being accessed
--- after cleanup. Please contact the maintainers.\"
-instance MonadBaseControl IO (GHandler sub master) where
-    data StM (GHandler sub master) a = StH (StM (ResourceT IO) a)
-    liftBaseWith f = GHandler $ \reader ->
-        liftBaseWith $ \runInBase ->
-            f $ liftM StH . runInBase . (\(GHandler r) -> r reader)
-    restoreM (StH base) = GHandler $ const $ restoreM base
-
-instance MonadUnsafeIO (GHandler sub master) where
-    unsafeLiftIO = liftIO
-instance MonadThrow (GHandler sub master) where
-    monadThrow = liftIO . throwIO
-instance MonadResource (GHandler sub master) where
-#if MIN_VERSION_resourcet(0,4,0)
-    liftResourceT = lift . liftResourceT
-#else
-    allocate a = lift . allocate a
-    register = lift . register
-    release = lift . release
-    resourceMask = lift . resourceMask
-#endif
-
-instance MonadLogger (GHandler sub master) where
-#if MIN_VERSION_monad_logger(0, 3, 0)
-    monadLoggerLog a b c d = do
-        hd <- ask
-        liftIO $ handlerLog hd a b c (toLogStr d)
-#else
-    monadLoggerLog a c d = monadLoggerLogSource a "" c d
-    monadLoggerLogSource a b c d = do
-        hd <- ask
-        liftIO $ handlerLog hd a b c (toLogStr d)
-#endif
-
-instance Exception e => Failure e (GHandler sub master) where
-    failure = liftIO . throwIO
diff --git a/yesod-core/Yesod/Internal.hs b/yesod-core/Yesod/Internal.hs
deleted file mode 100644
index d1560e30..00000000
--- a/yesod-core/Yesod/Internal.hs
+++ /dev/null
@@ -1,138 +0,0 @@
-{-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE DeriveDataTypeable #-}
--- | Normal users should never need access to these.
---
--- Note that no guarantees of API stability are provided on this module. Use at your own risk.
-module Yesod.Internal
-    ( -- * Error responses
-      ErrorResponse (..)
-    , HandlerContents (..)
-      -- * Header
-    , Header (..)
-      -- * Cookie names
-    , langKey
-      -- * Widgets
-    , GWData (..)
-    , Location (..)
-    , UniqueList (..)
-    , Script (..)
-    , Stylesheet (..)
-    , Title (..)
-    , Head (..)
-    , Body (..)
-    , locationToHtmlUrl
-    , runUniqueList
-    , toUnique
-      -- * Names
-    , tokenKey
-    ) where
-
-import Text.Hamlet (HtmlUrl, Html)
-import Text.Blaze.Html (toHtml)
-import Text.Julius (JavascriptUrl)
-import Data.Monoid (Monoid (..), Last)
-import Data.List (nub)
-
-import Data.Text (Text)
-
-import Data.Typeable (Typeable)
-import Control.Exception (Exception)
-
-import qualified Network.HTTP.Types as H
-import Data.String (IsString)
-import qualified Data.Map as Map
-import Data.Text.Lazy.Builder (Builder)
-import Web.Cookie (SetCookie (..))
-import Data.ByteString (ByteString)
-import qualified Network.Wai as W
-import Yesod.Content (ChooseRep, ContentType)
-
--- | Responses to indicate some form of an error occurred. These are different
--- from 'SpecialResponse' in that they allow for custom error pages.
-data ErrorResponse =
-      NotFound
-    | InternalError Text
-    | InvalidArgs [Text]
-    | PermissionDenied Text
-    | BadMethod H.Method
-    deriving (Show, Eq, Typeable)
-instance Exception ErrorResponse
-
------ header stuff
--- | Headers to be added to a 'Result'.
-data Header =
-    AddCookie SetCookie
-    | DeleteCookie ByteString ByteString
-    | Header ByteString ByteString
-    deriving (Eq, Show)
-
-langKey :: IsString a => a
-langKey = "_LANG"
-
-data Location url = Local url | Remote Text
-    deriving (Show, Eq)
-locationToHtmlUrl :: Location url -> HtmlUrl url
-locationToHtmlUrl (Local url) render = toHtml $ render url []
-locationToHtmlUrl (Remote s) _ = toHtml s
-
-newtype UniqueList x = UniqueList ([x] -> [x])
-instance Monoid (UniqueList x) where
-    mempty = UniqueList id
-    UniqueList x `mappend` UniqueList y = UniqueList $ x . y
-runUniqueList :: Eq x => UniqueList x -> [x]
-runUniqueList (UniqueList x) = nub $ x []
-toUnique :: x -> UniqueList x
-toUnique = UniqueList . (:)
-
-data Script url = Script { scriptLocation :: Location url, scriptAttributes :: [(Text, Text)] }
-    deriving (Show, Eq)
-data Stylesheet url = Stylesheet { styleLocation :: Location url, styleAttributes :: [(Text, Text)] }
-    deriving (Show, Eq)
-newtype Title = Title { unTitle :: Html }
-
-newtype Head url = Head (HtmlUrl url)
-    deriving Monoid
-newtype Body url = Body (HtmlUrl url)
-    deriving Monoid
-
-tokenKey :: IsString a => a
-tokenKey = "_TOKEN"
-
-type CssBuilderUrl a = (a -> [(Text, Text)] -> Text) -> Builder
-
-data GWData a = GWData
-    { gwdBody :: !(Body a)
-    , gwdTitle :: !(Last Title)
-    , gwdScripts :: !(UniqueList (Script a))
-    , gwdStylesheets :: !(UniqueList (Stylesheet a))
-    , gwdCss :: !(Map.Map (Maybe Text) (CssBuilderUrl a)) -- media type
-    , gwdJavascript :: !(Maybe (JavascriptUrl a))
-    , gwdHead :: !(Head a)
-    }
-instance Monoid (GWData a) where
-    mempty = GWData mempty mempty mempty mempty mempty mempty mempty
-    mappend (GWData a1 a2 a3 a4 a5 a6 a7)
-            (GWData b1 b2 b3 b4 b5 b6 b7) = GWData
-        (a1 `mappend` b1)
-        (a2 `mappend` b2)
-        (a3 `mappend` b3)
-        (a4 `mappend` b4)
-        (Map.unionWith mappend a5 b5)
-        (a6 `mappend` b6)
-        (a7 `mappend` b7)
-
-data HandlerContents =
-      HCContent H.Status ChooseRep
-    | HCError ErrorResponse
-    | HCSendFile ContentType FilePath (Maybe W.FilePart)
-    | HCRedirect H.Status Text
-    | HCCreated Text
-    | HCWai W.Response
-    deriving Typeable
-
-instance Show HandlerContents where
-    show _ = "Cannot show a HandlerContents"
-instance Exception HandlerContents
diff --git a/yesod-core/Yesod/Internal/Cache.hs b/yesod-core/Yesod/Internal/Cache.hs
deleted file mode 100644
index 4aec0d29..00000000
--- a/yesod-core/Yesod/Internal/Cache.hs
+++ /dev/null
@@ -1,38 +0,0 @@
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE TemplateHaskell #-}
-module Yesod.Internal.Cache
-    ( Cache
-    , CacheKey
-    , mkCacheKey
-    , lookup
-    , insert
-    , delete
-    ) where
-
-import Prelude hiding (lookup)
-import qualified Data.IntMap as Map
-import Language.Haskell.TH.Syntax (Q, Exp, runIO, Exp (LitE), Lit (IntegerL))
-import Language.Haskell.TH (appE)
-import Data.Unique (hashUnique, newUnique)
-import GHC.Exts (Any)
-import Unsafe.Coerce (unsafeCoerce)
-import Data.Monoid (Monoid)
-import Control.Applicative ((<$>))
-
-newtype Cache = Cache (Map.IntMap Any)
-    deriving Monoid
-
-newtype CacheKey a = CacheKey Int
-
--- | Generate a new 'CacheKey'. Be sure to give a full type signature.
-mkCacheKey :: Q Exp
-mkCacheKey = [|CacheKey|] `appE` (LitE . IntegerL . fromIntegral . hashUnique <$> runIO newUnique)
-
-lookup :: CacheKey a -> Cache -> Maybe a
-lookup (CacheKey i) (Cache m) = unsafeCoerce <$> Map.lookup i m
-
-insert :: CacheKey a -> a -> Cache -> Cache
-insert (CacheKey k) v (Cache m) = Cache (Map.insert k (unsafeCoerce v) m)
-
-delete :: CacheKey a -> Cache -> Cache
-delete (CacheKey k) (Cache m) = Cache (Map.delete k m)
diff --git a/yesod-core/Yesod/Internal/Core.hs b/yesod-core/Yesod/Internal/Core.hs
deleted file mode 100644
index cd3f0c02..00000000
--- a/yesod-core/Yesod/Internal/Core.hs
+++ /dev/null
@@ -1,928 +0,0 @@
-{-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE TemplateHaskell #-}
--- | The basic typeclass for a Yesod application.
-module Yesod.Internal.Core
-    ( -- * Type classes
-      Yesod (..)
-    , YesodDispatch (..)
-    , RenderRoute (..)
-      -- ** Breadcrumbs
-    , YesodBreadcrumbs (..)
-    , breadcrumbs
-      -- * Utitlities
-    , maybeAuthorized
-    , widgetToPageContent
-      -- * Defaults
-    , defaultErrorHandler
-      -- * Data types
-    , AuthResult (..)
-      -- * Sessions
-    , SessionBackend (..)
-    , defaultClientSessionBackend
-    , clientSessionBackend
-    , loadClientSession
-    , clientSessionBackend2
-    , loadClientSession2
-    , clientSessionDateCacher
-    , BackendSession
-      -- * jsLoader
-    , ScriptLoadPosition (..)
-    , BottomOfHeadAsync
-    , loadJsYepnope
-      -- * Misc
-    , yesodVersion
-    , yesodRender
-    , resolveApproot
-    , Approot (..)
-    , FileUpload (..)
-    , runFakeHandler
-    ) where
-
-import Yesod.Content
-import Yesod.Handler hiding (lift, getExpires)
-import Control.Monad.Logger (logErrorS)
-
-import Yesod.Routes.Class
-import Data.Time (UTCTime, addUTCTime, getCurrentTime)
-
-import Data.Word (Word64)
-import Control.Arrow ((***))
-import Control.Monad (forM)
-import Yesod.Widget
-import Yesod.Request
-import qualified Network.Wai as W
-import Yesod.Internal
-import Yesod.Internal.Session
-import Yesod.Internal.Request
-import qualified Web.ClientSession as CS
-import qualified Data.ByteString.Char8 as S8
-import qualified Data.ByteString.Lazy as L
-import qualified Data.IORef as I
-import Data.Monoid
-import Text.Hamlet
-import Text.Julius
-import Text.Blaze ((!), customAttribute, textTag, toValue, unsafeLazyByteString)
-import qualified Text.Blaze.Html5 as TBH
-import Data.Text.Lazy.Builder (toLazyText)
-import Data.Text.Lazy.Encoding (encodeUtf8)
-import Data.Maybe (fromMaybe, isJust)
-import Control.Monad.IO.Class (MonadIO (liftIO))
-import Control.Monad.Trans.Resource (runResourceT)
-import Web.Cookie (parseCookies)
-import qualified Data.Map as Map
-import Network.HTTP.Types (encodePath)
-import qualified Data.Text as T
-import Data.Text (Text)
-import qualified Data.Text.Encoding as TE
-import qualified Data.Text.Encoding.Error as TEE
-import Blaze.ByteString.Builder (Builder, toByteString)
-import Blaze.ByteString.Builder.Char.Utf8 (fromText)
-import Data.List (foldl')
-import qualified Network.HTTP.Types as H
-import Web.Cookie (SetCookie (..))
-import Language.Haskell.TH.Syntax (Loc (..))
-import Text.Blaze (preEscapedToMarkup)
-import Data.Aeson (Value (Array, String))
-import Data.Aeson.Encode (encode)
-import qualified Data.Vector as Vector
-import Network.Wai.Middleware.Gzip (GzipSettings, def)
-import Network.Wai.Parse (tempFileBackEnd, lbsBackEnd)
-import qualified Paths_yesod_core
-import Data.Version (showVersion)
-import System.Log.FastLogger (Logger, mkLogger, loggerDate, LogStr (..), loggerPutStr)
-import Control.Monad.Logger (LogLevel (LevelInfo, LevelOther), LogSource)
-import System.Log.FastLogger.Date (ZonedDate)
-import System.IO (stdout)
-
-yesodVersion :: String
-yesodVersion = showVersion Paths_yesod_core.version
-
--- | This class is automatically instantiated when you use the template haskell
--- mkYesod function. You should never need to deal with it directly.
-class YesodDispatch sub master where
-    yesodDispatch
-        :: Yesod master
-        => Logger
-        -> master
-        -> sub
-        -> (Route sub -> Route master)
-        -> (Maybe (SessionBackend master) -> W.Application) -- ^ 404 handler
-        -> (Route sub -> Maybe (SessionBackend master) -> W.Application) -- ^ 405 handler
-        -> Text -- ^ request method
-        -> [Text] -- ^ pieces
-        -> Maybe (SessionBackend master)
-        -> W.Application
-
-    yesodRunner :: Yesod master
-                => Logger
-                -> GHandler sub master ChooseRep
-                -> master
-                -> sub
-                -> Maybe (Route sub)
-                -> (Route sub -> Route master)
-                -> Maybe (SessionBackend master)
-                -> W.Application
-    yesodRunner = defaultYesodRunner
-
--- | How to determine the root of the application for constructing URLs.
---
--- Note that future versions of Yesod may add new constructors without bumping
--- the major version number. As a result, you should /not/ pattern match on
--- @Approot@ values.
-data Approot master = ApprootRelative -- ^ No application root.
-                    | ApprootStatic Text
-                    | ApprootMaster (master -> Text)
-                    | ApprootRequest (master -> W.Request -> Text)
-
-type ResolvedApproot = Text
-
--- | Define settings for a Yesod applications. All methods have intelligent
--- defaults, and therefore no implementation is required.
-class RenderRoute a => Yesod a where
-    -- | An absolute URL to the root of the application. Do not include
-    -- trailing slash.
-    --
-    -- Default value: 'ApprootRelative'. This is valid under the following
-    -- conditions:
-    --
-    -- * Your application is served from the root of the domain.
-    --
-    -- * You do not use any features that require absolute URLs, such as Atom
-    -- feeds and XML sitemaps.
-    --
-    -- If this is not true, you should override with a different
-    -- implementation.
-    approot :: Approot a
-    approot = ApprootRelative
-
-    -- | Output error response pages.
-    errorHandler :: ErrorResponse -> GHandler sub a ChooseRep
-    errorHandler = defaultErrorHandler
-
-    -- | Applies some form of layout to the contents of a page.
-    defaultLayout :: GWidget sub a () -> GHandler sub a RepHtml
-    defaultLayout w = do
-        p <- widgetToPageContent w
-        mmsg <- getMessage
-        hamletToRepHtml [hamlet|
-$newline never
-$doctype 5
-
-<html>
-    <head>
-        <title>#{pageTitle p}
-        ^{pageHead p}
-    <body>
-        $maybe msg <- mmsg
-            <p .message>#{msg}
-        ^{pageBody p}
-|]
-
-    -- | Override the rendering function for a particular URL. One use case for
-    -- this is to offload static hosting to a different domain name to avoid
-    -- sending cookies.
-    urlRenderOverride :: a -> Route a -> Maybe Builder
-    urlRenderOverride _ _ = Nothing
-
-    -- | Determine if a request is authorized or not.
-    --
-    -- Return 'Authorized' if the request is authorized,
-    -- 'Unauthorized' a message if unauthorized.
-    -- If authentication is required, return 'AuthenticationRequired'.
-    isAuthorized :: Route a
-                 -> Bool -- ^ is this a write request?
-                 -> GHandler s a AuthResult
-    isAuthorized _ _ = return Authorized
-
-    -- | Determines whether the current request is a write request. By default,
-    -- this assumes you are following RESTful principles, and determines this
-    -- from request method. In particular, all except the following request
-    -- methods are considered write: GET HEAD OPTIONS TRACE.
-    --
-    -- This function is used to determine if a request is authorized; see
-    -- 'isAuthorized'.
-    isWriteRequest :: Route a -> GHandler s a Bool
-    isWriteRequest _ = do
-        wai <- waiRequest
-        return $ W.requestMethod wai `notElem`
-            ["GET", "HEAD", "OPTIONS", "TRACE"]
-
-    -- | The default route for authentication.
-    --
-    -- Used in particular by 'isAuthorized', but library users can do whatever
-    -- they want with it.
-    authRoute :: a -> Maybe (Route a)
-    authRoute _ = Nothing
-
-    -- | A function used to clean up path segments. It returns 'Right' with a
-    -- clean path or 'Left' with a new set of pieces the user should be
-    -- redirected to. The default implementation enforces:
-    --
-    -- * No double slashes
-    --
-    -- * There is no trailing slash.
-    --
-    -- Note that versions of Yesod prior to 0.7 used a different set of rules
-    -- involing trailing slashes.
-    cleanPath :: a -> [Text] -> Either [Text] [Text]
-    cleanPath _ s =
-        if corrected == s
-            then Right $ map dropDash s
-            else Left corrected
-      where
-        corrected = filter (not . T.null) s
-        dropDash t
-            | T.all (== '-') t = T.drop 1 t
-            | otherwise = t
-
-    -- | Builds an absolute URL by concatenating the application root with the
-    -- pieces of a path and a query string, if any.
-    -- Note that the pieces of the path have been previously cleaned up by 'cleanPath'.
-    joinPath :: a
-             -> T.Text -- ^ application root
-             -> [T.Text] -- ^ path pieces
-             -> [(T.Text, T.Text)] -- ^ query string
-             -> Builder
-    joinPath _ ar pieces' qs' =
-        fromText ar `mappend` encodePath pieces qs
-      where
-        pieces = if null pieces' then [""] else map addDash pieces'
-        qs = map (TE.encodeUtf8 *** go) qs'
-        go "" = Nothing
-        go x = Just $ TE.encodeUtf8 x
-        addDash t
-            | T.all (== '-') t = T.cons '-' t
-            | otherwise = t
-
-    -- | This function is used to store some static content to be served as an
-    -- external file. The most common case of this is stashing CSS and
-    -- JavaScript content in an external file; the "Yesod.Widget" module uses
-    -- this feature.
-    --
-    -- The return value is 'Nothing' if no storing was performed; this is the
-    -- default implementation. A 'Just' 'Left' gives the absolute URL of the
-    -- file, whereas a 'Just' 'Right' gives the type-safe URL. The former is
-    -- necessary when you are serving the content outside the context of a
-    -- Yesod application, such as via memcached.
-    addStaticContent :: Text -- ^ filename extension
-                     -> Text -- ^ mime-type
-                     -> L.ByteString -- ^ content
-                     -> GHandler sub a (Maybe (Either Text (Route a, [(Text, Text)])))
-    addStaticContent _ _ _ = return Nothing
-
-    {- Temporarily disabled until we have a better interface.
-    -- | Whether or not to tie a session to a specific IP address. Defaults to
-    -- 'False'.
-    --
-    -- Note: This setting has two known problems: it does not work correctly
-    -- when behind a reverse proxy (including load balancers), and it may not
-    -- function correctly if the user is behind a proxy.
-    sessionIpAddress :: a -> Bool
-    sessionIpAddress _ = False
-    -}
-
-    -- | The path value to set for cookies. By default, uses \"\/\", meaning
-    -- cookies will be sent to every page on the current domain.
-    cookiePath :: a -> S8.ByteString
-    cookiePath _ = "/"
-
-    -- | The domain value to set for cookies. By default, the
-    -- domain is not set, meaning cookies will be sent only to
-    -- the current domain.
-    cookieDomain :: a -> Maybe S8.ByteString
-    cookieDomain _ = Nothing
-
-    -- | Maximum allowed length of the request body, in bytes.
-    --
-    -- Default: 2 megabytes.
-    maximumContentLength :: a -> Maybe (Route a) -> Word64
-    maximumContentLength _ _ = 2 * 1024 * 1024 -- 2 megabytes
-
-    -- | Returns a @Logger@ to use for log messages.
-    --
-    -- Default: Sends to stdout and automatically flushes on each write.
-    getLogger :: a -> IO Logger
-    getLogger _ = mkLogger True stdout
-
-    -- | Send a message to the @Logger@ provided by @getLogger@.
-    --
-    -- Note: This method is no longer used. Instead, you should override
-    -- 'messageLoggerSource'.
-    messageLogger :: a
-                  -> Logger
-                  -> Loc -- ^ position in source code
-                  -> LogLevel
-                  -> LogStr -- ^ message
-                  -> IO ()
-    messageLogger a logger loc = messageLoggerSource a logger loc ""
-
-    -- | Send a message to the @Logger@ provided by @getLogger@.
-    messageLoggerSource :: a
-                        -> Logger
-                        -> Loc -- ^ position in source code
-                        -> LogSource
-                        -> LogLevel
-                        -> LogStr -- ^ message
-                        -> IO ()
-    messageLoggerSource a logger loc source level msg =
-        if shouldLog a source level
-            then formatLogMessage (loggerDate logger) loc source level msg >>= loggerPutStr logger
-            else return ()
-
-    -- | The logging level in place for this application. Any messages below
-    -- this level will simply be ignored.
-    logLevel :: a -> LogLevel
-    logLevel _ = LevelInfo
-
-    -- | GZIP settings.
-    gzipSettings :: a -> GzipSettings
-    gzipSettings _ = def
-
-    -- | Where to Load sripts from. We recommend the default value,
-    -- 'BottomOfBody'.  Alternatively use the built in async yepnope loader:
-    --
-    -- > BottomOfHeadAsync $ loadJsYepnope $ Right $ StaticR js_modernizr_js
-    --
-    -- Or write your own async js loader: see 'loadJsYepnope'
-    jsLoader :: a -> ScriptLoadPosition a
-    jsLoader _ = BottomOfBody
-
-    -- | Create a session backend. Returning `Nothing' disables sessions.
-    --
-    -- Default: Uses clientsession with a 2 hour timeout.
-    makeSessionBackend :: a -> IO (Maybe (SessionBackend a))
-    makeSessionBackend _ = fmap Just defaultClientSessionBackend
-
-    -- | How to store uploaded files.
-    --
-    -- Default: When the request body is greater than 50kb, store in a temp
-    -- file. Otherwise, store in memory.
-    fileUpload :: a
-               -> Word64 -- ^ request body size
-               -> FileUpload
-    fileUpload _ size
-        | size > 50000 = FileUploadDisk tempFileBackEnd
-        | otherwise = FileUploadMemory lbsBackEnd
-
-    -- | Should we log the given log source/level combination.
-    --
-    -- Default: Logs everything at or above 'logLevel'
-    shouldLog :: a -> LogSource -> LogLevel -> Bool
-    shouldLog a _ level = level >= logLevel a
-
-    -- | A Yesod middleware, which will wrap every handler function. This
-    -- allows you to run code before and after a normal handler.
-    --
-    -- Default: Adds the response header \"Vary: Accept, Accept-Language\".
-    --
-    -- Since: 1.1.6
-    yesodMiddleware :: GHandler sub a res -> GHandler sub a res
-    yesodMiddleware handler = do
-        setHeader "Vary" "Accept, Accept-Language"
-        handler
-
-{-# DEPRECATED messageLogger "Please use messageLoggerSource (since yesod-core 1.1.2)" #-}
-
-formatLogMessage :: IO ZonedDate
-                 -> Loc
-                 -> LogSource
-                 -> LogLevel
-                 -> LogStr -- ^ message
-                 -> IO [LogStr]
-formatLogMessage getdate loc src level msg = do
-    now <- getdate
-    return
-        [ LB now
-        , LB " ["
-        , LS $
-            case level of
-                LevelOther t -> T.unpack t
-                _ -> drop 5 $ show level
-        , LS $
-            if T.null src
-                then ""
-                else "#" ++ T.unpack src
-        , LB "] "
-        , msg
-        , LB " @("
-        , LS $ fileLocationToString loc
-        , LB ")\n"
-        ]
-
--- taken from file-location package
--- turn the TH Loc loaction information into a human readable string
--- leaving out the loc_end parameter
-fileLocationToString :: Loc -> String
-fileLocationToString loc = (loc_package loc) ++ ':' : (loc_module loc) ++
-  ' ' : (loc_filename loc) ++ ':' : (line loc) ++ ':' : (char loc)
-  where
-    line = show . fst . loc_start
-    char = show . snd . loc_start
-
-defaultYesodRunner :: Yesod master
-                   => Logger
-                   -> GHandler sub master ChooseRep
-                   -> master
-                   -> sub
-                   -> Maybe (Route sub)
-                   -> (Route sub -> Route master)
-                   -> Maybe (SessionBackend master)
-                   -> W.Application
-defaultYesodRunner logger handler' master sub murl toMasterRoute msb req
-  | maxLen < len = return tooLargeResponse
-  | otherwise = do
-    let dontSaveSession _ _ = return []
-    now <- liftIO getCurrentTime -- FIXME remove in next major version bump
-    (session, saveSession) <- liftIO $ do
-        maybe (return ([], dontSaveSession)) (\sb -> sbLoadSession sb master req now) msb
-    rr <- liftIO $ parseWaiRequest req session (isJust msb) len maxLen
-    let h = {-# SCC "h" #-} do
-          case murl of
-            Nothing -> handler
-            Just url -> do
-                isWrite <- isWriteRequest $ toMasterRoute url
-                ar <- isAuthorized (toMasterRoute url) isWrite
-                case ar of
-                    Authorized -> return ()
-                    AuthenticationRequired ->
-                        case authRoute master of
-                            Nothing ->
-                                permissionDenied "Authentication required"
-                            Just url' -> do
-                                setUltDestCurrent
-                                redirect url'
-                    Unauthorized s' -> permissionDenied s'
-                handler
-    let sessionMap = Map.fromList . filter ((/=) tokenKey . fst) $ session
-    let ra = resolveApproot master req
-    let log' = messageLoggerSource master logger
-    yar <- handlerToYAR master sub (fileUpload master) log' toMasterRoute
-        (yesodRender master ra) errorHandler rr murl sessionMap h
-    extraHeaders <- case yar of
-        (YARPlain _ _ ct _ newSess) -> do
-            let nsToken = Map.toList $ maybe
-                    newSess
-                    (\n -> Map.insert tokenKey (TE.encodeUtf8 n) newSess)
-                    (reqToken rr)
-            sessionHeaders <- liftIO (saveSession nsToken now)
-            return $ ("Content-Type", ct) : map headerToPair sessionHeaders
-        _ -> return []
-    return $ yarToResponse yar extraHeaders
-  where
-    maxLen = maximumContentLength master $ fmap toMasterRoute murl
-    len = fromMaybe 0 $ lookup "content-length" (W.requestHeaders req) >>= readMay
-    readMay s =
-        case reads $ S8.unpack s of
-            [] -> Nothing
-            (x, _):_ -> Just x
-    handler = yesodMiddleware handler'
-
-data AuthResult = Authorized | AuthenticationRequired | Unauthorized Text
-    deriving (Eq, Show, Read)
-
--- | A type-safe, concise method of creating breadcrumbs for pages. For each
--- resource, you declare the title of the page and the parent resource (if
--- present).
-class YesodBreadcrumbs y where
-    -- | Returns the title and the parent resource, if available. If you return
-    -- a 'Nothing', then this is considered a top-level page.
-    breadcrumb :: Route y -> GHandler sub y (Text , Maybe (Route y))
-
--- | Gets the title of the current page and the hierarchy of parent pages,
--- along with their respective titles.
-breadcrumbs :: YesodBreadcrumbs y => GHandler sub y (Text, [(Route y, Text)])
-breadcrumbs = do
-    x' <- getCurrentRoute
-    tm <- getRouteToMaster
-    let x = fmap tm x'
-    case x of
-        Nothing -> return ("Not found", [])
-        Just y -> do
-            (title, next) <- breadcrumb y
-            z <- go [] next
-            return (title, z)
-  where
-    go back Nothing = return back
-    go back (Just this) = do
-        (title, next) <- breadcrumb this
-        go ((this, title) : back) next
-
-applyLayout' :: Yesod master
-             => Html -- ^ title
-             -> HtmlUrl (Route master) -- ^ body
-             -> GHandler sub master ChooseRep
-applyLayout' title body = fmap chooseRep $ defaultLayout $ do
-    setTitle title
-    toWidget body
-
--- | The default error handler for 'errorHandler'.
-defaultErrorHandler :: Yesod y => ErrorResponse -> GHandler sub y ChooseRep
-defaultErrorHandler NotFound = do
-    r <- waiRequest
-    let path' = TE.decodeUtf8With TEE.lenientDecode $ W.rawPathInfo r
-    applyLayout' "Not Found"
-        [hamlet|
-$newline never
-<h1>Not Found
-<p>#{path'}
-|]
-defaultErrorHandler (PermissionDenied msg) =
-    applyLayout' "Permission Denied"
-        [hamlet|
-$newline never
-<h1>Permission denied
-<p>#{msg}
-|]
-defaultErrorHandler (InvalidArgs ia) =
-    applyLayout' "Invalid Arguments"
-        [hamlet|
-$newline never
-<h1>Invalid Arguments
-<ul>
-    $forall msg <- ia
-        <li>#{msg}
-|]
-defaultErrorHandler (InternalError e) = do
-    $logErrorS "yesod-core" e
-    applyLayout' "Internal Server Error"
-        [hamlet|
-$newline never
-<h1>Internal Server Error
-<pre>#{e}
-|]
-defaultErrorHandler (BadMethod m) =
-    applyLayout' "Bad Method"
-        [hamlet|
-$newline never
-<h1>Method Not Supported
-<p>Method <code>#{S8.unpack m}</code> not supported
-|]
-
--- | Return the same URL if the user is authorized to see it.
---
--- Built on top of 'isAuthorized'. This is useful for building page that only
--- contain links to pages the user is allowed to see.
-maybeAuthorized :: Yesod a
-                => Route a
-                -> Bool -- ^ is this a write request?
-                -> GHandler s a (Maybe (Route a))
-maybeAuthorized r isWrite = do
-    x <- isAuthorized r isWrite
-    return $ if x == Authorized then Just r else Nothing
-
-jsToHtml :: Javascript -> Html
-jsToHtml (Javascript b) = preEscapedToMarkup $ toLazyText b
-
-jelper :: JavascriptUrl url -> HtmlUrl url
-jelper = fmap jsToHtml
-
--- | Convert a widget to a 'PageContent'.
-widgetToPageContent :: (Eq (Route master), Yesod master)
-                    => GWidget sub master ()
-                    -> GHandler sub master (PageContent (Route master))
-widgetToPageContent w = do
-    master <- getYesod
-    ((), GWData (Body body) (Last mTitle) scripts' stylesheets' style jscript (Head head')) <- unGWidget w
-    let title = maybe mempty unTitle mTitle
-        scripts = runUniqueList scripts'
-        stylesheets = runUniqueList stylesheets'
-
-    render <- getUrlRenderParams
-    let renderLoc x =
-            case x of
-                Nothing -> Nothing
-                Just (Left s) -> Just s
-                Just (Right (u, p)) -> Just $ render u p
-    css <- forM (Map.toList style) $ \(mmedia, content) -> do
-        let rendered = toLazyText $ content render
-        x <- addStaticContent "css" "text/css; charset=utf-8"
-           $ encodeUtf8 rendered
-        return (mmedia,
-            case x of
-                Nothing -> Left $ preEscapedToMarkup rendered
-                Just y -> Right $ either id (uncurry render) y)
-    jsLoc <-
-        case jscript of
-            Nothing -> return Nothing
-            Just s -> do
-                x <- addStaticContent "js" "text/javascript; charset=utf-8"
-                   $ encodeUtf8 $ renderJavascriptUrl render s
-                return $ renderLoc x
-
-    -- modernizr should be at the end of the <head> http://www.modernizr.com/docs/#installing
-    -- the asynchronous loader means your page doesn't have to wait for all the js to load
-    let (mcomplete, asyncScripts) = asyncHelper render scripts jscript jsLoc
-        regularScriptLoad = [hamlet|
-$newline never
-$forall s <- scripts
-    ^{mkScriptTag s}
-$maybe j <- jscript
-    $maybe s <- jsLoc
-        <script src="#{s}">
-    $nothing
-        <script>^{jelper j}
-|]
-
-        headAll = [hamlet|
-$newline never
-\^{head'}
-$forall s <- stylesheets
-    ^{mkLinkTag s}
-$forall s <- css
-    $maybe t <- right $ snd s
-        $maybe media <- fst s
-            <link rel=stylesheet media=#{media} href=#{t}>
-        $nothing
-            <link rel=stylesheet href=#{t}>
-    $maybe content <- left $ snd s
-        $maybe media <- fst s
-            <style media=#{media}>#{content}
-        $nothing
-            <style>#{content}
-$case jsLoader master
-  $of BottomOfBody
-  $of BottomOfHeadAsync asyncJsLoader
-      ^{asyncJsLoader asyncScripts mcomplete}
-  $of BottomOfHeadBlocking
-      ^{regularScriptLoad}
-|]
-    let bodyScript = [hamlet|
-$newline never
-^{body}
-^{regularScriptLoad}
-|]
-
-    return $ PageContent title headAll (case jsLoader master of
-      BottomOfBody -> bodyScript
-      _ -> body)
-  where
-    renderLoc' render' (Local url) = render' url []
-    renderLoc' _ (Remote s) = s
-
-    addAttr x (y, z) = x ! customAttribute (textTag y) (toValue z)
-    mkScriptTag (Script loc attrs) render' =
-        foldl' addAttr TBH.script (("src", renderLoc' render' loc) : attrs) $ return ()
-    mkLinkTag (Stylesheet loc attrs) render' =
-        foldl' addAttr TBH.link
-            ( ("rel", "stylesheet")
-            : ("href", renderLoc' render' loc)
-            : attrs
-            )
-
-data ScriptLoadPosition master
-    = BottomOfBody
-    | BottomOfHeadBlocking
-    | BottomOfHeadAsync (BottomOfHeadAsync master)
-
-type BottomOfHeadAsync master
-       = [Text] -- ^ urls to load asynchronously
-      -> Maybe (HtmlUrl (Route master)) -- ^ widget of js to run on async completion
-      -> (HtmlUrl (Route master)) -- ^ widget to insert at the bottom of <head>
-
-left :: Either a b -> Maybe a
-left (Left x) = Just x
-left _ = Nothing
-
-right :: Either a b -> Maybe b
-right (Right x) = Just x
-right _ = Nothing
-
-jsonArray :: [Text] -> Html
-jsonArray = unsafeLazyByteString . encode . Array . Vector.fromList . map String
-
--- | For use with setting 'jsLoader' to 'BottomOfHeadAsync'
-loadJsYepnope :: Yesod master => Either Text (Route master) -> [Text] -> Maybe (HtmlUrl (Route master)) -> (HtmlUrl (Route master))
-loadJsYepnope eyn scripts mcomplete =
-  [hamlet|
-$newline never
-    $maybe yn <- left eyn
-        <script src=#{yn}>
-    $maybe yn <- right eyn
-        <script src=@{yn}>
-    $maybe complete <- mcomplete
-        <script>yepnope({load:#{jsonArray scripts},complete:function(){^{complete}}});
-    $nothing
-        <script>yepnope({load:#{jsonArray scripts}});
-|]
-
-asyncHelper :: (url -> [x] -> Text)
-         -> [Script (url)]
-         -> Maybe (JavascriptUrl (url))
-         -> Maybe Text
-         -> (Maybe (HtmlUrl url), [Text])
-asyncHelper render scripts jscript jsLoc =
-    (mcomplete, scripts'')
-  where
-    scripts' = map goScript scripts
-    scripts'' =
-        case jsLoc of
-            Just s -> scripts' ++ [s]
-            Nothing -> scripts'
-    goScript (Script (Local url) _) = render url []
-    goScript (Script (Remote s) _) = s
-    mcomplete =
-        case jsLoc of
-            Just{} -> Nothing
-            Nothing ->
-                case jscript of
-                    Nothing -> Nothing
-                    Just j -> Just $ jelper j
-
-yesodRender :: Yesod y
-            => y
-            -> ResolvedApproot
-            -> Route y
-            -> [(Text, Text)] -- ^ url query string
-            -> Text
-yesodRender y ar url params =
-    TE.decodeUtf8 $ toByteString $
-    fromMaybe
-        (joinPath y ar ps
-          $ params ++ params')
-        (urlRenderOverride y url)
-  where
-    (ps, params') = renderRoute url
-
-resolveApproot :: Yesod master => master -> W.Request -> ResolvedApproot
-resolveApproot master req =
-    case approot of
-        ApprootRelative -> ""
-        ApprootStatic t -> t
-        ApprootMaster f -> f master
-        ApprootRequest f -> f master req
-
-defaultClientSessionBackend :: Yesod master => IO (SessionBackend master)
-defaultClientSessionBackend = do
-  key <- CS.getKey CS.defaultKeyFile
-  let timeout = fromIntegral (120 * 60 :: Int) -- 120 minutes
-  (getCachedDate, _closeDateCacher) <- clientSessionDateCacher timeout
-  return $ clientSessionBackend2 key getCachedDate
-
-
-clientSessionBackend :: Yesod master
-                     => CS.Key  -- ^ The encryption key
-                     -> Int -- ^ Inactive session valitity in minutes
-                     -> SessionBackend master
-clientSessionBackend key timeout = SessionBackend
-    { sbLoadSession = loadClientSession key timeout "_SESSION"
-    }
-{-# DEPRECATED clientSessionBackend "Please use clientSessionBackend2, which is more efficient." #-}
-
-loadClientSession :: Yesod master
-                  => CS.Key
-                  -> Int -- ^ timeout
-                  -> S8.ByteString -- ^ session name
-                  -> master
-                  -> W.Request
-                  -> UTCTime
-                  -> IO (BackendSession, SaveSession)
-loadClientSession key timeout sessionName master req now = return (sess, save)
-  where
-    sess = fromMaybe [] $ do
-      raw <- lookup "Cookie" $ W.requestHeaders req
-      val <- lookup sessionName $ parseCookies raw
-      let host = "" -- fixme, properly lock sessions to client address
-      decodeClientSessionOld key now host val
-    save sess' now' = do
-      -- We should never cache the IV!  Be careful!
-      iv <- liftIO CS.randomIV
-      return [AddCookie def
-          { setCookieName = sessionName
-          , setCookieValue = sessionVal iv
-          , setCookiePath = Just (cookiePath master)
-          , setCookieExpires = Just expires
-          , setCookieDomain = cookieDomain master
-          , setCookieHttpOnly = True
-          }]
-        where
-          host = "" -- fixme, properly lock sessions to client address
-          expires = fromIntegral (timeout * 60) `addUTCTime` now'
-          sessionVal iv = encodeClientSessionOld key iv expires host sess'
-{-# DEPRECATED loadClientSession "Please use loadClientSession2, which is more efficient." #-}
-
-clientSessionBackend2 :: Yesod master
-                     => CS.Key  -- ^ The encryption key
-                     -> IO ClientSessionDateCache -- ^ See 'clientSessionDateCacher'
-                     -> SessionBackend master
-clientSessionBackend2 key getCachedDate =
-  SessionBackend {
-    sbLoadSession = \master req -> const $ loadClientSession2 key getCachedDate "_SESSION" master req
-  }
-
-loadClientSession2 :: Yesod master
-                  => CS.Key
-                  -> IO ClientSessionDateCache -- ^ See 'clientSessionDateCacher'
-                  -> S8.ByteString -- ^ session name
-                  -> master
-                  -> W.Request
-                  -> IO (BackendSession, SaveSession)
-loadClientSession2 key getCachedDate sessionName master req = load
-  where
-    load = do
-      date <- getCachedDate
-      return (sess date, save date)
-    sess date = fromMaybe [] $ do
-      raw <- lookup "Cookie" $ W.requestHeaders req
-      val <- lookup sessionName $ parseCookies raw
-      let host = "" -- fixme, properly lock sessions to client address
-      decodeClientSession key date host val
-    save date sess' _ = do
-      -- We should never cache the IV!  Be careful!
-      iv <- liftIO CS.randomIV
-      return [AddCookie def
-          { setCookieName = sessionName
-          , setCookieValue = encodeClientSession key iv date host sess'
-          , setCookiePath = Just (cookiePath master)
-          , setCookieExpires = Just (csdcExpires date)
-          , setCookieDomain = cookieDomain master
-          , setCookieHttpOnly = True
-          }]
-        where
-          host = "" -- fixme, properly lock sessions to client address
-
-
--- | Run a 'GHandler' completely outside of Yesod.  This
--- function comes with many caveats and you shouldn't use it
--- unless you fully understand what it's doing and how it works.
---
--- As of now, there's only one reason to use this function at
--- all: in order to run unit tests of functions inside 'GHandler'
--- but that aren't easily testable with a full HTTP request.
--- Even so, it's better to use @wai-test@ or @yesod-test@ instead
--- of using this function.
---
--- This function will create a fake HTTP request (both @wai@'s
--- 'W.Request' and @yesod@'s 'Request') and feed it to the
--- @GHandler@.  The only useful information the @GHandler@ may
--- get from the request is the session map, which you must supply
--- as argument to @runFakeHandler@.  All other fields contain
--- fake information, which means that they can be accessed but
--- won't have any useful information.  The response of the
--- @GHandler@ is completely ignored, including changes to the
--- session, cookies or headers.  We only return you the
--- @GHandler@'s return value.
-runFakeHandler :: (Yesod master, MonadIO m) =>
-                  SessionMap
-               -> (master -> Logger)
-               -> master
-               -> GHandler master master a
-               -> m (Either ErrorResponse a)
-runFakeHandler fakeSessionMap logger master handler = liftIO $ do
-  ret <- I.newIORef (Left $ InternalError "runFakeHandler: no result")
-  let handler' = do liftIO . I.writeIORef ret . Right =<< handler
-                    return ()
-  let YesodApp yapp =
-        runHandler
-          handler'
-          (yesodRender master $ resolveApproot master fakeWaiRequest)
-          Nothing
-          id
-          master
-          master
-          (fileUpload master)
-          (messageLoggerSource master $ logger master)
-      errHandler err =
-        YesodApp $ \_ _ _ session -> do
-          liftIO $ I.writeIORef ret (Left err)
-          return $ YARPlain
-                     H.status500
-                     []
-                     typePlain
-                     (toContent ("runFakeHandler: errHandler" :: S8.ByteString))
-                     session
-      fakeWaiRequest =
-        W.Request
-          { W.requestMethod  = "POST"
-          , W.httpVersion    = H.http11
-          , W.rawPathInfo    = "/runFakeHandler/pathInfo"
-          , W.rawQueryString = ""
-          , W.serverName     = "runFakeHandler-serverName"
-          , W.serverPort     = 80
-          , W.requestHeaders = []
-          , W.isSecure       = False
-          , W.remoteHost     = error "runFakeHandler-remoteHost"
-          , W.pathInfo       = ["runFakeHandler", "pathInfo"]
-          , W.queryString    = []
-          , W.requestBody    = mempty
-          , W.vault          = mempty
-#if MIN_VERSION_wai(1, 4, 0)
-          , W.requestBodyLength = W.KnownLength 0
-#endif
-          }
-      fakeRequest =
-        Request
-          { reqGetParams  = []
-          , reqCookies    = []
-          , reqWaiRequest = fakeWaiRequest
-          , reqLangs      = []
-          , reqToken      = Just "NaN" -- not a nonce =)
-          , reqBodySize   = 0
-          }
-      fakeContentType = []
-  _ <- runResourceT $ yapp errHandler fakeRequest fakeContentType fakeSessionMap
-  I.readIORef ret
-{-# WARNING runFakeHandler "Usually you should *not* use runFakeHandler unless you really understand how it works and why you need it." #-}
diff --git a/yesod-core/Yesod/Internal/Session.hs b/yesod-core/Yesod/Internal/Session.hs
deleted file mode 100644
index ab17b698..00000000
--- a/yesod-core/Yesod/Internal/Session.hs
+++ /dev/null
@@ -1,161 +0,0 @@
-module Yesod.Internal.Session
-    ( encodeClientSession
-    , encodeClientSessionOld
-    , decodeClientSession
-    , decodeClientSessionOld
-    , clientSessionDateCacher
-    , ClientSessionDateCache(..)
-    , BackendSession
-    , SaveSession
-    , SaveSessionOld
-    , SessionBackend(..)
-    ) where
-
-import Yesod.Internal (Header(..))
-import qualified Web.ClientSession as CS
-import Data.Int (Int64)
-import Data.Serialize
-import Data.Time
-import Data.ByteString (ByteString)
-import Control.Concurrent (forkIO, killThread, threadDelay)
-import Control.Monad (forever, guard)
-import Data.Text (Text, pack, unpack)
-import Control.Arrow (first)
-import Control.Applicative ((<$>))
-
-import qualified Data.ByteString.Char8 as S8
-import qualified Data.IORef as I
-import qualified Network.Wai as W
-
-type BackendSession = [(Text, S8.ByteString)]
-
-type SaveSession = BackendSession    -- ^ The session contents after running the handler
-                -> UTCTime -- FIXME remove this in the next major version bump
-                -> IO [Header]
-
-type SaveSessionOld = BackendSession    -- ^ The session contents after running the handler
-                -> UTCTime
-                -> IO [Header]
-
-newtype SessionBackend master = SessionBackend
-    { sbLoadSession :: master
-                    -> W.Request
-                    -> UTCTime -- FIXME remove this in the next major version bump
-                    -> IO (BackendSession, SaveSession) -- ^ Return the session data and a function to save the session
-    }
-
-encodeClientSession :: CS.Key
-                    -> CS.IV
-                    -> ClientSessionDateCache  -- ^ expire time
-                    -> ByteString -- ^ remote host
-                    -> [(Text, ByteString)] -- ^ session
-                    -> ByteString -- ^ cookie value
-encodeClientSession key iv date rhost session' =
-    CS.encrypt key iv $ encode $ SessionCookie expires rhost session'
-      where expires = Right (csdcExpiresSerialized date)
-
-decodeClientSession :: CS.Key
-                    -> ClientSessionDateCache  -- ^ current time
-                    -> ByteString -- ^ remote host field
-                    -> ByteString -- ^ cookie value
-                    -> Maybe [(Text, ByteString)]
-decodeClientSession key date rhost encrypted = do
-    decrypted <- CS.decrypt key encrypted
-    SessionCookie (Left expire) rhost' session' <-
-        either (const Nothing) Just $ decode decrypted
-    guard $ expire > csdcNow date
-    guard $ rhost' == rhost
-    return session'
-
-data SessionCookie = SessionCookie (Either UTCTime ByteString) ByteString [(Text, ByteString)]
-    deriving (Show, Read)
-instance Serialize SessionCookie where
-    put (SessionCookie a b c) = do
-        either putTime putByteString a
-        put b
-        put (map (first unpack) c)
-    get = do
-        a <- getTime
-        b <- get
-        c <- map (first pack) <$> get
-        return $ SessionCookie (Left a) b c
-
-
-----------------------------------------------------------------------
-
-
--- Mostly copied from Kazu's date-cache, but with modifications
--- that better suit our needs.
---
--- The cached date is updated every 10s, we don't need second
--- resolution for session expiration times.
-
-data ClientSessionDateCache =
-  ClientSessionDateCache {
-    csdcNow               :: !UTCTime
-  , csdcExpires           :: !UTCTime
-  , csdcExpiresSerialized :: !ByteString
-  } deriving (Eq, Show)
-
-clientSessionDateCacher ::
-     NominalDiffTime -- ^ Inactive session valitity.
-  -> IO (IO ClientSessionDateCache, IO ())
-clientSessionDateCacher validity = do
-    ref <- getUpdated >>= I.newIORef
-    tid <- forkIO $ forever (doUpdate ref)
-    return $! (I.readIORef ref, killThread tid)
-  where
-    getUpdated = do
-      now <- getCurrentTime
-      let expires  = validity `addUTCTime` now
-          expiresS = runPut (putTime expires)
-      return $! ClientSessionDateCache now expires expiresS
-    doUpdate ref = do
-      threadDelay 10000000 -- 10s
-      I.writeIORef ref =<< getUpdated
-
-
-----------------------------------------------------------------------
-
-
-putTime :: Putter UTCTime
-putTime (UTCTime d t) =
-  let d' = fromInteger  $ toModifiedJulianDay d
-      t' = fromIntegral $ fromEnum (t / diffTimeScale)
-  in put (d' * posixDayLength_int64 + min posixDayLength_int64 t')
-
-getTime :: Get UTCTime
-getTime = do
-  val <- get
-  let (d, t) = val `divMod` posixDayLength_int64
-      d' = ModifiedJulianDay $! fromIntegral d
-      t' = fromIntegral t
-  d' `seq` t' `seq` return (UTCTime d' t')
-
-posixDayLength_int64 :: Int64
-posixDayLength_int64 = 86400
-
-diffTimeScale :: DiffTime
-diffTimeScale = 1e12
-
-encodeClientSessionOld :: CS.Key
-                    -> CS.IV
-                    -> UTCTime -- ^ expire time
-                    -> ByteString -- ^ remote host
-                    -> [(Text, ByteString)] -- ^ session
-                    -> ByteString -- ^ cookie value
-encodeClientSessionOld key iv expire rhost session' =
-    CS.encrypt key iv $ encode $ SessionCookie (Left expire) rhost session'
-
-decodeClientSessionOld :: CS.Key
-                    -> UTCTime -- ^ current time
-                    -> ByteString -- ^ remote host field
-                    -> ByteString -- ^ cookie value
-                    -> Maybe [(Text, ByteString)]
-decodeClientSessionOld key now rhost encrypted = do
-    decrypted <- CS.decrypt key encrypted
-    SessionCookie (Left expire) rhost' session' <-
-        either (const Nothing) Just $ decode decrypted
-    guard $ expire > now
-    guard $ rhost' == rhost
-    return session'
diff --git a/yesod-core/Yesod/Internal/TestApi.hs b/yesod-core/Yesod/Internal/TestApi.hs
deleted file mode 100644
index ffb1387e..00000000
--- a/yesod-core/Yesod/Internal/TestApi.hs
+++ /dev/null
@@ -1,11 +0,0 @@
---
--- | WARNING: This module exposes internal interfaces solely for the
--- purpose of facilitating cabal-driven testing of said interfaces.
--- This module is NOT part of the public Yesod API and should NOT be
--- imported by library users.
---
-module Yesod.Internal.TestApi
-  ( randomString, parseWaiRequest'
-  ) where
-
-import Yesod.Internal.Request (randomString, parseWaiRequest')
diff --git a/yesod-core/Yesod/Message.hs b/yesod-core/Yesod/Message.hs
deleted file mode 100644
index 1b76820e..00000000
--- a/yesod-core/Yesod/Message.hs
+++ /dev/null
@@ -1,6 +0,0 @@
--- | This module has moved to "Text.Shakespeare.I18N"
-module Yesod.Message
-    ( module Text.Shakespeare.I18N
-    ) where
-
-import Text.Shakespeare.I18N
diff --git a/yesod-core/Yesod/Request.hs b/yesod-core/Yesod/Request.hs
deleted file mode 100644
index ee8c25e9..00000000
--- a/yesod-core/Yesod/Request.hs
+++ /dev/null
@@ -1,108 +0,0 @@
----------------------------------------------------------
---
--- Module        : Yesod.Request
--- Copyright     : Michael Snoyman
--- License       : BSD3
---
--- Maintainer    : Michael Snoyman <michael@snoyman.com>
--- Stability     : Stable
--- Portability   : portable
---
--- | Provides a parsed version of the raw 'W.Request' data.
---
----------------------------------------------------------
-module Yesod.Request
-    (
-      -- * Request datatype
-      RequestBodyContents
-    , Request (..)
-    , FileInfo
-    , fileName
-    , fileContentType
-    , fileSource
-    , fileMove
-      -- * Convenience functions
-    , languages
-      -- * Lookup parameters
-    , lookupGetParam
-    , lookupPostParam
-    , lookupCookie
-    , lookupFile
-      -- ** Multi-lookup
-    , lookupGetParams
-    , lookupPostParams
-    , lookupCookies
-    , lookupFiles
-    ) where
-
-import Yesod.Internal.Request
-import Yesod.Handler
-import Control.Monad (liftM)
-import Control.Monad.Instances () -- I'm missing the instance Monad ((->) r
-import Data.Maybe (listToMaybe)
-import Data.Text (Text)
-
--- | Get the list of supported languages supplied by the user.
---
--- Languages are determined based on the following three (in descending order
--- of preference):
---
--- * The _LANG get parameter.
---
--- * The _LANG cookie.
---
--- * The _LANG user session variable.
---
--- * Accept-Language HTTP header.
---
--- Yesod will seek the first language from the returned list matched with languages supporting by your application. This language will be used to render i18n templates.
--- If a matching language is not found the default language will be used.
---
--- This is handled by parseWaiRequest (not exposed).
-languages :: GHandler s m [Text]
-languages = reqLangs `liftM` getRequest
-
-lookup' :: Eq a => a -> [(a, b)] -> [b]
-lookup' a = map snd . filter (\x -> a == fst x)
-
--- | Lookup for GET parameters.
-lookupGetParams :: Text -> GHandler s m [Text]
-lookupGetParams pn = do
-    rr <- getRequest
-    return $ lookup' pn $ reqGetParams rr
-
--- | Lookup for GET parameters.
-lookupGetParam :: Text -> GHandler s m (Maybe Text)
-lookupGetParam = liftM listToMaybe . lookupGetParams
-
--- | Lookup for POST parameters.
-lookupPostParams :: Text -> GHandler s m [Text]
-lookupPostParams pn = do
-    (pp, _) <- runRequestBody
-    return $ lookup' pn pp
-
-lookupPostParam :: Text
-                -> GHandler s m (Maybe Text)
-lookupPostParam = liftM listToMaybe . lookupPostParams
-
--- | Lookup for POSTed files.
-lookupFile :: Text
-           -> GHandler s m (Maybe FileInfo)
-lookupFile = liftM listToMaybe . lookupFiles
-
--- | Lookup for POSTed files.
-lookupFiles :: Text
-            -> GHandler s m [FileInfo]
-lookupFiles pn = do
-    (_, files) <- runRequestBody
-    return $ lookup' pn files
-
--- | Lookup for cookie data.
-lookupCookie :: Text -> GHandler s m (Maybe Text)
-lookupCookie = liftM listToMaybe . lookupCookies
-
--- | Lookup for cookie data.
-lookupCookies :: Text -> GHandler s m [Text]
-lookupCookies pn = do
-    rr <- getRequest
-    return $ lookup' pn $ reqCookies rr
diff --git a/yesod-core/Yesod/Widget.hs b/yesod-core/Yesod/Widget.hs
deleted file mode 100644
index 63ea210a..00000000
--- a/yesod-core/Yesod/Widget.hs
+++ /dev/null
@@ -1,369 +0,0 @@
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# LANGUAGE CPP #-}
--- FIXME Should we remove the older names here (addJulius, etc)?
-
--- | Widgets combine HTML with JS and CSS dependencies with a unique identifier
--- generator, allowing you to create truly modular HTML components.
-module Yesod.Widget
-    ( -- * Datatype
-      GWidget
-    , PageContent (..)
-      -- * Special Hamlet quasiquoter/TH for Widgets
-    , whamlet
-    , whamletFile
-    , ihamletToRepHtml
-      -- * Convert to Widget
-    , ToWidget (..)
-    , ToWidgetHead (..)
-    , ToWidgetBody (..)
-      -- * Creating
-      -- ** Head of page
-    , setTitle
-    , setTitleI
-    , addHamletHead
-    , addHtmlHead
-      -- ** Body
-    , addHamlet
-    , addHtml
-    , addWidget
-    , addSubWidget
-      -- ** CSS
-    , addCassius
-    , addCassiusMedia
-    , addLucius
-    , addLuciusMedia
-    , addStylesheet
-    , addStylesheetAttrs
-    , addStylesheetRemote
-    , addStylesheetRemoteAttrs
-    , addStylesheetEither
-    , CssBuilder (..)
-      -- ** Javascript
-    , addJulius
-    , addJuliusBody
-    , addScript
-    , addScriptAttrs
-    , addScriptRemote
-    , addScriptRemoteAttrs
-    , addScriptEither
-      -- * Internal
-    , unGWidget
-    , whamletFileWithSettings
-    ) where
-
-import Data.Monoid
-import qualified Text.Blaze.Html5 as H
-import Text.Hamlet
-import Text.Cassius
-import Text.Julius
-import Yesod.Routes.Class
-import Yesod.Handler
-    ( GHandler, YesodSubRoute(..), toMasterHandlerMaybe, getYesod
-    , getMessageRender, getUrlRenderParams, MonadLift (..)
-    )
-import Yesod.Message (RenderMessage)
-import Yesod.Content (RepHtml (..), toContent)
-import Control.Applicative (Applicative (..), (<$>))
-import Control.Monad.IO.Class (MonadIO (liftIO))
-import Yesod.Internal
-import Control.Monad (liftM)
-import Data.Text (Text)
-import qualified Data.Map as Map
-import Language.Haskell.TH.Quote (QuasiQuoter)
-import Language.Haskell.TH.Syntax (Q, Exp (InfixE, VarE, LamE, AppE), Pat (VarP), newName)
-
-import Control.Monad.Trans.Control (MonadBaseControl (..))
-import Control.Exception (throwIO)
-import qualified Text.Hamlet as NP
-import Data.Text.Lazy.Builder (fromLazyText, Builder)
-import Text.Blaze.Html (toHtml, preEscapedToMarkup)
-import qualified Data.Text.Lazy as TL
-import Control.Monad.Base (MonadBase (liftBase))
-import Control.Arrow (first)
-import Control.Monad.Trans.Resource
-
-import Control.Monad.Logger
-
-preEscapedLazyText :: TL.Text -> Html
-preEscapedLazyText = preEscapedToMarkup
-
--- | A generic widget, allowing specification of both the subsite and master
--- site datatypes. While this is simply a @WriterT@, we define a newtype for
--- better error messages.
-newtype GWidget sub master a = GWidget
-    { unGWidget :: GHandler sub master (a, GWData (Route master))
-    }
-
-instance (a ~ ()) => Monoid (GWidget sub master a) where
-    mempty = return ()
-    mappend x y = x >> y
-
-addSubWidget :: (YesodSubRoute sub master) => sub -> GWidget sub master a -> GWidget sub' master a
-addSubWidget sub (GWidget w) = do
-    master <- lift getYesod
-    let sr = fromSubRoute sub master
-    (a, w') <- lift $ toMasterHandlerMaybe sr (const sub) Nothing w
-    tell w'
-    return a
-
-class ToWidget sub master a where
-    toWidget :: a -> GWidget sub master ()
-
-type RY master = Route master -> [(Text, Text)] -> Text
-
--- | Newtype wrapper allowing injection of arbitrary content into CSS.
---
--- Usage:
---
--- > toWidget $ CssBuilder "p { color: red }"
---
--- Since: 1.1.3
-newtype CssBuilder = CssBuilder { unCssBuilder :: Builder }
-
-instance render ~ RY master => ToWidget sub master (render -> Html) where
-    toWidget x = tell $ GWData (Body x) mempty mempty mempty mempty mempty mempty
-instance render ~ RY master => ToWidget sub master (render -> Css) where
-    toWidget x = toWidget $ CssBuilder . fromLazyText . renderCss . x
-instance render ~ RY master => ToWidget sub master (render -> CssBuilder) where
-    toWidget x = tell $ GWData mempty mempty mempty mempty (Map.singleton Nothing $ unCssBuilder . x) mempty mempty
-instance render ~ RY master => ToWidget sub master (render -> Javascript) where
-    toWidget x = tell $ GWData mempty mempty mempty mempty mempty (Just x) mempty
-instance (sub' ~ sub, master' ~ master) => ToWidget sub' master' (GWidget sub master ()) where
-    toWidget = id
-instance ToWidget sub master Html where
-    toWidget = toWidget . const
-
-class ToWidgetBody sub master a where
-    toWidgetBody :: a -> GWidget sub master ()
-
-instance render ~ RY master => ToWidgetBody sub master (render -> Html) where
-    toWidgetBody = toWidget
-instance render ~ RY master => ToWidgetBody sub master (render -> Javascript) where
-    toWidgetBody j = toWidget $ \r -> H.script $ preEscapedLazyText $ renderJavascriptUrl r j
-instance ToWidgetBody sub master Html where
-    toWidgetBody = toWidget
-
-class ToWidgetHead sub master a where
-    toWidgetHead :: a -> GWidget sub master ()
-
-instance render ~ RY master => ToWidgetHead sub master (render -> Html) where
-    toWidgetHead = tell . GWData mempty mempty mempty mempty mempty mempty . Head
-instance render ~ RY master => ToWidgetHead sub master (render -> Css) where
-    toWidgetHead = toWidget
-instance render ~ RY master => ToWidgetHead sub master (render -> CssBuilder) where
-    toWidgetHead = toWidget
-instance render ~ RY master => ToWidgetHead sub master (render -> Javascript) where
-    toWidgetHead j = toWidgetHead $ \r -> H.script $ preEscapedLazyText $ renderJavascriptUrl r j
-instance ToWidgetHead sub master Html where
-    toWidgetHead = toWidgetHead . const
-
--- | Set the page title. Calling 'setTitle' multiple times overrides previously
--- set values.
-setTitle :: Html -> GWidget sub master ()
-setTitle x = tell $ GWData mempty (Last $ Just $ Title x) mempty mempty mempty mempty mempty
-
--- | Set the page title. Calling 'setTitle' multiple times overrides previously
--- set values.
-setTitleI :: RenderMessage master msg => msg -> GWidget sub master ()
-setTitleI msg = do
-    mr <- lift getMessageRender
-    setTitle $ toHtml $ mr msg
-
-{-# DEPRECATED addHamletHead, addHtmlHead "Use toWidgetHead instead" #-}
-{-# DEPRECATED addHamlet, addHtml, addCassius, addLucius, addJulius "Use toWidget instead" #-}
-{-# DEPRECATED addJuliusBody "Use toWidgetBody instead" #-}
-{-# DEPRECATED addWidget "addWidget can be omitted" #-}
-
--- | Add a 'Hamlet' to the head tag.
-addHamletHead :: HtmlUrl (Route master) -> GWidget sub master ()
-addHamletHead = toWidgetHead
-
--- | Add a 'Html' to the head tag.
-addHtmlHead :: Html -> GWidget sub master ()
-addHtmlHead = toWidgetHead . const
-
--- | Add a 'Hamlet' to the body tag.
-addHamlet :: HtmlUrl (Route master) -> GWidget sub master ()
-addHamlet = toWidget
-
--- | Add a 'Html' to the body tag.
-addHtml :: Html -> GWidget sub master ()
-addHtml = toWidget
-
--- | Add another widget. This is defined as 'id', by can help with types, and
--- makes widget blocks look more consistent.
-addWidget :: GWidget sub master () -> GWidget sub master ()
-addWidget = id
-
--- | Add some raw CSS to the style tag. Applies to all media types.
-addCassius :: CssUrl (Route master) -> GWidget sub master ()
-addCassius = toWidget
-
--- | Identical to 'addCassius'.
-addLucius :: CssUrl (Route master) -> GWidget sub master ()
-addLucius = toWidget
-
--- | Add some raw CSS to the style tag, for a specific media type.
-addCassiusMedia :: Text -> CssUrl (Route master) -> GWidget sub master ()
-addCassiusMedia m x = tell $ GWData mempty mempty mempty mempty (Map.singleton (Just m) $ \r -> fromLazyText $ renderCss $ x r) mempty mempty
-
--- | Identical to 'addCassiusMedia'.
-addLuciusMedia :: Text -> CssUrl (Route master) -> GWidget sub master ()
-addLuciusMedia = addCassiusMedia
-
--- | Link to the specified local stylesheet.
-addStylesheet :: Route master -> GWidget sub master ()
-addStylesheet = flip addStylesheetAttrs []
-
--- | Link to the specified local stylesheet.
-addStylesheetAttrs :: Route master -> [(Text, Text)] -> GWidget sub master ()
-addStylesheetAttrs x y = tell $ GWData mempty mempty mempty (toUnique $ Stylesheet (Local x) y) mempty mempty mempty
-
--- | Link to the specified remote stylesheet.
-addStylesheetRemote :: Text -> GWidget sub master ()
-addStylesheetRemote = flip addStylesheetRemoteAttrs []
-
--- | Link to the specified remote stylesheet.
-addStylesheetRemoteAttrs :: Text -> [(Text, Text)] -> GWidget sub master ()
-addStylesheetRemoteAttrs x y = tell $ GWData mempty mempty mempty (toUnique $ Stylesheet (Remote x) y) mempty mempty mempty
-
-addStylesheetEither :: Either (Route master) Text -> GWidget sub master ()
-addStylesheetEither = either addStylesheet addStylesheetRemote
-
-addScriptEither :: Either (Route master) Text -> GWidget sub master ()
-addScriptEither = either addScript addScriptRemote
-
--- | Link to the specified local script.
-addScript :: Route master -> GWidget sub master ()
-addScript = flip addScriptAttrs []
-
--- | Link to the specified local script.
-addScriptAttrs :: Route master -> [(Text, Text)] -> GWidget sub master ()
-addScriptAttrs x y = tell $ GWData mempty mempty (toUnique $ Script (Local x) y) mempty mempty mempty mempty
-
--- | Link to the specified remote script.
-addScriptRemote :: Text -> GWidget sub master ()
-addScriptRemote = flip addScriptRemoteAttrs []
-
--- | Link to the specified remote script.
-addScriptRemoteAttrs :: Text -> [(Text, Text)] -> GWidget sub master ()
-addScriptRemoteAttrs x y = tell $ GWData mempty mempty (toUnique $ Script (Remote x) y) mempty mempty mempty mempty
-
--- | Include raw Javascript in the page's script tag.
-addJulius :: JavascriptUrl (Route master) -> GWidget sub master ()
-addJulius = toWidget
-
--- | Add a new script tag to the body with the contents of this 'Julius'
--- template.
-addJuliusBody :: JavascriptUrl (Route master) -> GWidget sub master ()
-addJuliusBody = toWidgetBody
-
--- | Content for a web page. By providing this datatype, we can easily create
--- generic site templates, which would have the type signature:
---
--- > PageContent url -> HtmlUrl url
-data PageContent url = PageContent
-    { pageTitle :: Html
-    , pageHead :: HtmlUrl url
-    , pageBody :: HtmlUrl url
-    }
-
-whamlet :: QuasiQuoter
-whamlet = NP.hamletWithSettings rules NP.defaultHamletSettings
-
-whamletFile :: FilePath -> Q Exp
-whamletFile = NP.hamletFileWithSettings rules NP.defaultHamletSettings
-
-whamletFileWithSettings :: NP.HamletSettings -> FilePath -> Q Exp
-whamletFileWithSettings = NP.hamletFileWithSettings rules
-
-rules :: Q NP.HamletRules
-rules = do
-    ah <- [|toWidget|]
-    let helper qg f = do
-            x <- newName "urender"
-            e <- f $ VarE x
-            let e' = LamE [VarP x] e
-            g <- qg
-            bind <- [|(>>=)|]
-            return $ InfixE (Just g) bind (Just e')
-    let ur f = do
-            let env = NP.Env
-                    (Just $ helper [|liftW getUrlRenderParams|])
-                    (Just $ helper [|liftM (toHtml .) $ liftW getMessageRender|])
-            f env
-    return $ NP.HamletRules ah ur $ \_ b -> return $ ah `AppE` b
-
--- | Wraps the 'Content' generated by 'hamletToContent' in a 'RepHtml'.
-ihamletToRepHtml :: RenderMessage master message
-                 => HtmlUrlI18n message (Route master)
-                 -> GHandler sub master RepHtml
-ihamletToRepHtml ih = do
-    urender <- getUrlRenderParams
-    mrender <- getMessageRender
-    return $ RepHtml $ toContent $ ih (toHtml . mrender) urender
-
-tell :: GWData (Route master) -> GWidget sub master ()
-tell w = GWidget $ return ((), w)
-
-instance MonadLift (GHandler sub master) (GWidget sub master) where
-    lift = GWidget . fmap (\x -> (x, mempty))
-
--- | Type-restricted version of @lift@
-liftW :: GHandler sub master a -> GWidget sub master a
-liftW = lift
-
--- Instances for GWidget
-instance Functor (GWidget sub master) where
-    fmap f (GWidget x) = GWidget (fmap (first f) x)
-instance Applicative (GWidget sub master) where
-    pure a = GWidget $ pure (a, mempty)
-    GWidget f <*> GWidget v =
-        GWidget $ k <$> f <*> v
-      where
-        k (a, wa) (b, wb) = (a b, wa `mappend` wb)
-instance Monad (GWidget sub master) where
-    return = pure
-    GWidget x >>= f = GWidget $ do
-        (a, wa) <- x
-        (b, wb) <- unGWidget (f a)
-        return (b, wa `mappend` wb)
-instance MonadIO (GWidget sub master) where
-    liftIO = GWidget . fmap (\a -> (a, mempty)) . liftIO
-instance MonadBase IO (GWidget sub master) where
-    liftBase = GWidget . fmap (\a -> (a, mempty)) . liftBase
-instance MonadBaseControl IO (GWidget sub master) where
-    data StM (GWidget sub master) a =
-        StW (StM (GHandler sub master) (a, GWData (Route master)))
-    liftBaseWith f = GWidget $ liftBaseWith $ \runInBase ->
-        liftM (\x -> (x, mempty))
-        (f $ liftM StW . runInBase . unGWidget)
-    restoreM (StW base) = GWidget $ restoreM base
-
-instance MonadUnsafeIO (GWidget sub master) where
-    unsafeLiftIO = liftIO
-instance MonadThrow (GWidget sub master) where
-    monadThrow = liftIO . throwIO
-instance MonadResource (GWidget sub master) where
-#if MIN_VERSION_resourcet(0,4,0)
-    liftResourceT = lift . liftResourceT
-#else
-    allocate a = lift . allocate a
-    register = lift . register
-    release = lift . release
-    resourceMask = lift . resourceMask
-#endif
-
-instance MonadLogger (GWidget sub master) where
-#if MIN_VERSION_monad_logger(0, 3, 0)
-    monadLoggerLog a b c = lift . monadLoggerLog a b c
-#else
-    monadLoggerLog a b = lift . monadLoggerLog a b
-    monadLoggerLogSource a b c = lift . monadLoggerLogSource a b c
-#endif
diff --git a/yesod-core/attic/pong.hs b/yesod-core/attic/pong.hs
new file mode 100644
index 00000000..0423e49b
--- /dev/null
+++ b/yesod-core/attic/pong.hs
@@ -0,0 +1,15 @@
+{-# LANGUAGE TemplateHaskell, QuasiQuotes, TypeFamilies #-}
+import Yesod.Core
+import Network.Wai.Handler.Warp
+
+data Pong = Pong
+
+mkYesod "Pong" [parseRoutes|
+/ HomeR GET
+|]
+
+instance Yesod Pong
+
+getHomeR = liftHandlerT $ return "PONG"
+
+main = warp 3000 Pong
diff --git a/yesod-core/helloworld.hs b/yesod-core/helloworld.hs
index c36abfbf..8ccba74d 100644
--- a/yesod-core/helloworld.hs
+++ b/yesod-core/helloworld.hs
@@ -17,17 +17,16 @@ mkYesodSub "Subsite" [] [parseRoutes|
 /multi/*Strings SubMultiR
 |]
 
-getSubRootR :: Yesod m => GHandler Subsite m RepPlain
+getSubRootR :: Yesod master => HandlerT Subsite (HandlerT master IO) RepPlain
 getSubRootR = do
-    Subsite s <- getYesodSub
-    tm <- getRouteToMaster
+    Subsite s <- getYesod
     render <- getUrlRender
     $logDebug "I'm in SubRootR"
-    return $ RepPlain $ toContent $ "Hello Sub World: " ++ s ++ ". " ++ unpack (render (tm SubRootR))
+    return $ RepPlain $ toContent $ "Hello Sub World: " ++ s ++ ". " ++ unpack (render SubRootR)
 
-handleSubMultiR :: Yesod m => Strings -> GHandler Subsite m RepPlain
+handleSubMultiR :: Yesod master => Strings -> HandlerT Subsite (HandlerT master IO) RepPlain
 handleSubMultiR x = do
-    Subsite y <- getYesodSub
+    Subsite y <- getYesod
     $logInfo "In SubMultiR"
     return . RepPlain . toContent . show $ (x, y)
 
diff --git a/yesod-core/test/YesodCoreTest.hs b/yesod-core/test/YesodCoreTest.hs
index 13c5e20e..60a1cb2e 100644
--- a/yesod-core/test/YesodCoreTest.hs
+++ b/yesod-core/test/YesodCoreTest.hs
@@ -13,6 +13,11 @@ import qualified YesodCoreTest.WaiSubsite as WaiSubsite
 import qualified YesodCoreTest.Redirect as Redirect
 import qualified YesodCoreTest.JsLoader as JsLoader
 import qualified YesodCoreTest.RequestBodySize as RequestBodySize
+import qualified YesodCoreTest.Json as Json
+import qualified YesodCoreTest.Streaming as Streaming
+import qualified YesodCoreTest.Reps as Reps
+import qualified YesodCoreTest.Auth as Auth
+import qualified YesodCoreTest.LiteApp as LiteApp
 
 import Test.Hspec
 
@@ -31,3 +36,8 @@ specs = do
       Redirect.specs
       JsLoader.specs
       RequestBodySize.specs
+      Json.specs
+      Streaming.specs
+      Reps.specs
+      Auth.specs
+      LiteApp.specs
diff --git a/yesod-core/test/YesodCoreTest/Auth.hs b/yesod-core/test/YesodCoreTest/Auth.hs
new file mode 100644
index 00000000..c8aad922
--- /dev/null
+++ b/yesod-core/test/YesodCoreTest/Auth.hs
@@ -0,0 +1,68 @@
+{-# LANGUAGE OverloadedStrings, TemplateHaskell, QuasiQuotes, TypeFamilies, MultiParamTypeClasses #-}
+module YesodCoreTest.Auth (specs, Widget) where
+
+import Yesod.Core
+import Test.Hspec
+import Network.Wai.Test
+import Network.Wai
+import qualified Data.ByteString.Char8 as S8
+import qualified Data.Text as T
+import Data.List (isSuffixOf)
+
+data App = App
+
+mkYesod "App" [parseRoutes|
+/no-auth NoAuthR
+/needs-login-json NeedsLoginJsonR
+/needs-login-html NeedsLoginHtmlR
+/read-only ReadOnlyR
+/forbidden ForbiddenR
+|]
+
+instance Yesod App where
+    isAuthorized NoAuthR _ = return Authorized
+    isAuthorized NeedsLoginJsonR _ = return AuthenticationRequired
+    isAuthorized NeedsLoginHtmlR _ = return AuthenticationRequired
+    isAuthorized ReadOnlyR False = return Authorized
+    isAuthorized ReadOnlyR True = return $ Unauthorized "Read only"
+    isAuthorized ForbiddenR _ = return $ Unauthorized "Forbidden"
+    authRoute _ = Just NoAuthR
+
+handleNoAuthR, handleReadOnlyR, handleForbiddenR :: Handler ()
+handleNoAuthR     = return ()
+handleReadOnlyR   = return ()
+handleForbiddenR  = return ()
+
+handleNeedsLoginJsonR :: Handler RepJson
+handleNeedsLoginJsonR = return $ repJson $ object []
+handleNeedsLoginHtmlR :: Handler RepHtml
+handleNeedsLoginHtmlR = return ""
+
+test :: String -- ^ method
+     -> String -- ^ path
+     -> (SResponse -> Session ())
+     -> Spec
+test method path f = it (method ++ " " ++ path) $ do
+    app <- toWaiApp App
+    flip runSession app $ do
+        sres <- request defaultRequest
+            { requestMethod = S8.pack method
+            , pathInfo = [T.pack path]
+            , requestHeaders =
+                if not $ isSuffixOf "json" path then [] else
+                  [("Accept", S8.pack "application/json")]
+            }
+        f sres
+
+specs :: Spec
+specs = describe "Auth" $ do
+    test "GET" "no-auth" $ \sres -> assertStatus 200 sres
+    test "POST" "no-auth" $ \sres -> assertStatus 200 sres
+    test "GET" "needs-login-html" $ \sres -> assertStatus 303 sres
+    test "POST" "needs-login-html" $ \sres -> assertStatus 303 sres
+    test "GET" "needs-login-json" $ \sres -> assertStatus 401 sres
+    test "POST" "needs-login-json" $ \sres -> assertStatus 401 sres
+    test "GET" "read-only" $ \sres -> assertStatus 200 sres
+    test "POST" "read-only" $ \sres -> assertStatus 403 sres
+    test "GET" "forbidden" $ \sres -> assertStatus 403 sres
+    test "POST" "forbidden" $ \sres -> assertStatus 403 sres
diff --git a/yesod-core/test/YesodCoreTest/Cache.hs b/yesod-core/test/YesodCoreTest/Cache.hs
index d12d0cc1..45df7615 100644
--- a/yesod-core/test/YesodCoreTest/Cache.hs
+++ b/yesod-core/test/YesodCoreTest/Cache.hs
@@ -1,38 +1,40 @@
 {-# LANGUAGE QuasiQuotes, TypeFamilies, TemplateHaskell, MultiParamTypeClasses #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE DeriveDataTypeable #-}
 module YesodCoreTest.Cache (cacheTest, Widget) where
 
 import Test.Hspec
 
-import Network.Wai
 import Network.Wai.Test
 
 import Yesod.Core
+import Data.IORef.Lifted
+import Data.Typeable (Typeable)
+import qualified Data.ByteString.Lazy.Char8 as L8
 
 data C = C
 
-key :: CacheKey Int
-key = $(mkCacheKey)
+newtype V1 = V1 Int
+    deriving Typeable
 
-key2 :: CacheKey Int
-key2 = $(mkCacheKey)
+newtype V2 = V2 Int
+    deriving Typeable
 
 mkYesod "C" [parseRoutes|/ RootR GET|]
 
 instance Yesod C
 
-getRootR :: Handler ()
+getRootR :: Handler RepPlain
 getRootR = do
-    Nothing <- cacheLookup key
-    cacheInsert key 5
-    Just 5 <- cacheLookup key
-    cacheInsert key 7
-    Just 7 <- cacheLookup key
-    Nothing <- cacheLookup key2
-    cacheDelete key
-    Nothing <- cacheLookup key
-    return ()
+    ref <- newIORef 0
+    V1 v1a <- cached $ atomicModifyIORef ref $ \i -> (i + 1, V1 $ i + 1)
+    V1 v1b <- cached $ atomicModifyIORef ref $ \i -> (i + 1, V1 $ i + 1)
+
+    V2 v2a <- cached $ atomicModifyIORef ref $ \i -> (i + 1, V2 $ i + 1)
+    V2 v2b <- cached $ atomicModifyIORef ref $ \i -> (i + 1, V2 $ i + 1)
+
+    return $ RepPlain $ toContent $ show [v1a, v1b, v2a, v2b]
 
 cacheTest :: Spec
 cacheTest =
@@ -44,5 +46,6 @@ runner f = toWaiApp C >>= runSession f
 
 works :: IO ()
 works = runner $ do
-    res <- request defaultRequest { pathInfo = [] }
+    res <- request defaultRequest
     assertStatus 200 res
+    assertBody (L8.pack $ show [1, 1, 2, 2 :: Int]) res
diff --git a/yesod-core/test/YesodCoreTest/CleanPath.hs b/yesod-core/test/YesodCoreTest/CleanPath.hs
index eb99ebd6..451c26d2 100644
--- a/yesod-core/test/YesodCoreTest/CleanPath.hs
+++ b/yesod-core/test/YesodCoreTest/CleanPath.hs
@@ -5,7 +5,7 @@ module YesodCoreTest.CleanPath (cleanPathTest, Widget) where
 
 import Test.Hspec
 
-import Yesod.Core hiding (Request)
+import Yesod.Core
 
 import Network.Wai
 import Network.Wai.Test
@@ -28,12 +28,14 @@ instance RenderRoute Subsite where
     data Route Subsite = SubsiteRoute [TS.Text]
         deriving (Eq, Show, Read)
     renderRoute (SubsiteRoute x) = (x, [])
+instance ParseRoute Subsite where
+    parseRoute (x, _) = Just $ SubsiteRoute x
 
-instance YesodDispatch Subsite master where
-    yesodDispatch _ _ _ _ _ _ _ pieces _ _ = return $ responseLBS
+instance YesodSubDispatch Subsite master where
+    yesodSubDispatch _ req = return $ responseLBS
         status200
         [ ("Content-Type", "SUBSITE")
-        ] $ L8.pack $ show pieces
+        ] $ L8.pack $ show (pathInfo req)
 
 data Y = Y
 mkYesod "Y" [parseRoutes|
@@ -84,6 +86,11 @@ cleanPathTest =
       it "/foo/something" fooSomething
       it "subsite dispatch" subsiteDispatch
       it "redirect with query string" redQueryString
+      it "parsing" $ do
+        parseRoute (["foo"], []) `shouldBe` Just FooR
+        parseRoute (["foo", "bar"], []) `shouldBe` Just (FooStringR "bar")
+        parseRoute (["subsite", "some", "path"], []) `shouldBe` Just (SubsiteR $ SubsiteRoute ["some", "path"])
+        parseRoute (["ignore", "me"], []) `shouldBe` (Nothing :: Maybe (Route Y))
 
 runner :: Session () -> IO ()
 runner f = toWaiApp Y >>= runSession f
diff --git a/yesod-core/test/YesodCoreTest/Exceptions.hs b/yesod-core/test/YesodCoreTest/Exceptions.hs
index f0942350..7c2711d9 100644
--- a/yesod-core/test/YesodCoreTest/Exceptions.hs
+++ b/yesod-core/test/YesodCoreTest/Exceptions.hs
@@ -5,7 +5,7 @@ module YesodCoreTest.Exceptions (exceptionsTest, Widget) where
 
 import Test.Hspec
 
-import Yesod.Core hiding (Request)
+import Yesod.Core
 import Network.Wai
 import Network.Wai.Test
 import Network.HTTP.Types (status301)
@@ -18,7 +18,7 @@ mkYesod "Y" [parseRoutes|
 
 instance Yesod Y where
     approot = ApprootStatic "http://test"
-    errorHandler (InternalError e) = return $ chooseRep $ RepPlain $ toContent e
+    errorHandler (InternalError e) = return $ toTypedContent e
     errorHandler x = defaultErrorHandler x
 
 getRootR :: Handler ()
@@ -26,7 +26,7 @@ getRootR = error "FOOBAR" >> return ()
 
 getRedirR :: Handler ()
 getRedirR = do
-    setHeader "foo" "bar"
+    addHeader "foo" "bar"
     redirectWith status301 RootR
 
 exceptionsTest :: Spec
diff --git a/yesod-core/test/YesodCoreTest/InternalRequest.hs b/yesod-core/test/YesodCoreTest/InternalRequest.hs
index 38194886..792b484f 100644
--- a/yesod-core/test/YesodCoreTest/InternalRequest.hs
+++ b/yesod-core/test/YesodCoreTest/InternalRequest.hs
@@ -6,9 +6,12 @@ import System.Random (StdGen, mkStdGen)
 
 import Network.Wai as W
 import Network.Wai.Test
-import Yesod.Internal.TestApi (randomString, parseWaiRequest')
-import Yesod.Request (Request (..))
+import Yesod.Core.Internal (randomString, parseWaiRequest)
 import Test.Hspec
+import Data.Monoid (mempty)
+import Data.Map (singleton)
+import Yesod.Core
+import Data.Word (Word64)
 
 randomStringSpecs :: Spec
 randomStringSpecs = describe "Yesod.Internal.Request.randomString" $ do
@@ -28,6 +31,15 @@ noRepeat len n = length (nub $ map (randomString len . mkStdGen) [1..n]) == n
 g :: StdGen
 g = error "test/YesodCoreTest/InternalRequest.g"
 
+parseWaiRequest' :: Request
+                 -> SessionMap
+                 -> Bool
+                 -> Word64
+                 -> YesodRequest
+parseWaiRequest' a b c d =
+    case parseWaiRequest a b c (Just d) of
+        Left yreq -> yreq
+        Right needGen -> needGen g
 
 tokenSpecs :: Spec
 tokenSpecs = describe "Yesod.Internal.Request.parseWaiRequest (reqToken)" $ do
@@ -38,19 +50,19 @@ tokenSpecs = describe "Yesod.Internal.Request.parseWaiRequest (reqToken)" $ do
 
 noDisabledToken :: Bool
 noDisabledToken = reqToken r == Nothing where
-  r = parseWaiRequest' defaultRequest [] False 0 1000 g
+  r = parseWaiRequest' defaultRequest mempty False 1000
 
 ignoreDisabledToken :: Bool
 ignoreDisabledToken = reqToken r == Nothing where
-  r = parseWaiRequest' defaultRequest [("_TOKEN", "old")] False 0 1000 g
+  r = parseWaiRequest' defaultRequest (singleton "_TOKEN" "old") False 1000
 
 useOldToken :: Bool
 useOldToken = reqToken r == Just "old" where
-  r = parseWaiRequest' defaultRequest [("_TOKEN", "old")] True 0 1000 g
+  r = parseWaiRequest' defaultRequest (singleton "_TOKEN" "old") True 1000
 
 generateToken :: Bool
 generateToken = reqToken r /= Nothing where
-  r = parseWaiRequest' defaultRequest [("_TOKEN", "old")] True 0 1000 g
+  r = parseWaiRequest' defaultRequest (singleton "_TOKEN" "old") True 1000
 
 
 langSpecs :: Spec
@@ -64,21 +76,21 @@ langSpecs = describe "Yesod.Internal.Request.parseWaiRequest (reqLangs)" $ do
 respectAcceptLangs :: Bool
 respectAcceptLangs = reqLangs r == ["en-US", "es", "en"] where
   r = parseWaiRequest' defaultRequest
-        { requestHeaders = [("Accept-Language", "en-US, es")] } [] False 0 1000 g
+        { requestHeaders = [("Accept-Language", "en-US, es")] } mempty False 1000
 
 respectSessionLang :: Bool
 respectSessionLang = reqLangs r == ["en"] where
-  r = parseWaiRequest' defaultRequest [("_LANG", "en")] False 0 1000 g
+  r = parseWaiRequest' defaultRequest (singleton "_LANG" "en") False 1000
 
 respectCookieLang :: Bool
 respectCookieLang = reqLangs r == ["en"] where
   r = parseWaiRequest' defaultRequest
         { requestHeaders = [("Cookie", "_LANG=en")]
-        } [] False 0 1000 g
+        } mempty False 1000
 
 respectQueryLang :: Bool
 respectQueryLang = reqLangs r == ["en-US", "en"] where
-  r = parseWaiRequest' defaultRequest { queryString = [("_LANG", Just "en-US")] } [] False 0 1000 g
+  r = parseWaiRequest' defaultRequest { queryString = [("_LANG", Just "en-US")] } mempty False 1000
 
 prioritizeLangs :: Bool
 prioritizeLangs = reqLangs r == ["en-QUERY", "en-COOKIE", "en-SESSION", "en", "es"] where
@@ -87,8 +99,7 @@ prioritizeLangs = reqLangs r == ["en-QUERY", "en-COOKIE", "en-SESSION", "en", "e
                            , ("Cookie", "_LANG=en-COOKIE")
                            ]
         , queryString = [("_LANG", Just "en-QUERY")]
-        } [("_LANG", "en-SESSION")] False 0 10000 g
-
+        } (singleton "_LANG" "en-SESSION") False 10000
 
 internalRequestTest :: Spec
 internalRequestTest = describe "Test.InternalRequestTest" $ do
diff --git a/yesod-core/test/YesodCoreTest/JsLoader.hs b/yesod-core/test/YesodCoreTest/JsLoader.hs
index 1849d5b1..c084536a 100644
--- a/yesod-core/test/YesodCoreTest/JsLoader.hs
+++ b/yesod-core/test/YesodCoreTest/JsLoader.hs
@@ -3,12 +3,11 @@
 {-# LANGUAGE FlexibleInstances #-}
 module YesodCoreTest.JsLoader (specs, Widget) where
 
-import YesodCoreTest.JsLoaderSites.HeadAsync (HA(..))
 import YesodCoreTest.JsLoaderSites.Bottom (B(..))
 
 import Test.Hspec
 
-import Yesod.Core hiding (Request)
+import Yesod.Core
 import Network.Wai.Test
 
 data H = H
@@ -27,13 +26,9 @@ specs = describe "Test.JsLoader" $ do
       res <- request defaultRequest
       assertBody "<!DOCTYPE html>\n<html><head><title></title><script src=\"load.js\"></script></head><body></body></html>" res
 
-    it "link from head async" $ runner HA $ do
-      res <- request defaultRequest
-      assertBody "<!DOCTYPE html>\n<html><head><title></title><script src=\"yepnope.js\"></script><script>yepnope({load:[\"load.js\"]});</script></head><body></body></html>" res
-
     it "link from bottom" $ runner B $ do
       res <- request defaultRequest
       assertBody "<!DOCTYPE html>\n<html><head><title></title></head><body><script src=\"load.js\"></script></body></html>" res
 
-runner :: (YesodDispatch master master, Yesod master) => master -> Session () -> IO ()
+runner :: YesodDispatch master => master -> Session () -> IO ()
 runner app f = toWaiApp app >>= runSession f
diff --git a/yesod-core/test/YesodCoreTest/JsLoaderSites/HeadAsync.hs b/yesod-core/test/YesodCoreTest/JsLoaderSites/HeadAsync.hs
deleted file mode 100644
index a7b4dceb..00000000
--- a/yesod-core/test/YesodCoreTest/JsLoaderSites/HeadAsync.hs
+++ /dev/null
@@ -1,16 +0,0 @@
-{-# LANGUAGE QuasiQuotes, TypeFamilies, TemplateHaskell, MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleInstances #-}
-module YesodCoreTest.JsLoaderSites.HeadAsync (HA(..), Widget) where
-
-import Yesod.Core
-
-data HA = HA
-mkYesod "HA" [parseRoutes|
-/ HeadAsyncR GET
-|]
-instance Yesod HA where
-  jsLoader _ = BottomOfHeadAsync $ loadJsYepnope $ Left "yepnope.js"
-
-getHeadAsyncR :: Handler RepHtml
-getHeadAsyncR = defaultLayout $ addScriptRemote "load.js"
diff --git a/yesod-core/test/YesodCoreTest/Json.hs b/yesod-core/test/YesodCoreTest/Json.hs
new file mode 100644
index 00000000..09050ac7
--- /dev/null
+++ b/yesod-core/test/YesodCoreTest/Json.hs
@@ -0,0 +1,52 @@
+{-# LANGUAGE OverloadedStrings, TemplateHaskell, QuasiQuotes, TypeFamilies, MultiParamTypeClasses #-}
+module YesodCoreTest.Json (specs, Widget) where
+
+import Yesod.Core
+import Test.Hspec
+import qualified Data.Map as Map
+import Network.Wai.Test
+import Data.Text (Text)
+import Data.ByteString.Lazy (ByteString)
+
+data App = App
+
+mkYesod "App" [parseRoutes|
+/ HomeR GET
+/has-multiple-pieces/#Int/#Int MultiplePiecesR GET
+|]
+
+instance Yesod App
+
+getHomeR :: Handler RepPlain
+getHomeR = do
+    val <- parseJsonBody_
+    case Map.lookup ("foo" :: Text) val of
+        Nothing -> invalidArgs ["foo not found"]
+        Just foo -> return $ RepPlain $ toContent (foo :: Text)
+
+getMultiplePiecesR :: Int -> Int -> Handler ()
+getMultiplePiecesR _ _ = return ()
+
+test :: String
+     -> ByteString
+     -> (SResponse -> Session ())
+     -> Spec
+test name rbody f = it name $ do
+    app <- toWaiApp App
+    flip runSession app $ do
+        sres <- srequest SRequest
+            { simpleRequest = defaultRequest
+            , simpleRequestBody = rbody
+            }
+        f sres
+
+specs :: Spec
+specs = describe "Yesod.Json" $ do
+    test "parses valid content" "{\"foo\":\"bar\"}" $ \sres -> do
+        assertStatus 200 sres
+        assertBody "bar" sres
+    test "400 for bad JSON" "{\"foo\":\"bar\"" $ \sres -> do
+        assertStatus 400 sres
+    test "400 for bad structure" "{\"foo2\":\"bar\"}" $ \sres -> do
+        assertStatus 400 sres
+        assertBodyContains "foo not found" sres
diff --git a/yesod-core/test/YesodCoreTest/Links.hs b/yesod-core/test/YesodCoreTest/Links.hs
index 188cfe97..6dbe9ca7 100644
--- a/yesod-core/test/YesodCoreTest/Links.hs
+++ b/yesod-core/test/YesodCoreTest/Links.hs
@@ -5,12 +5,11 @@ module YesodCoreTest.Links (linksTest, Widget) where
 
 import Test.Hspec
 
-import Yesod.Core hiding (Request)
+import Yesod.Core
 import Text.Hamlet
 import Network.Wai
 import Network.Wai.Test
 import Data.Text (Text)
-import Control.Monad.IO.Class (liftIO)
 import Blaze.ByteString.Builder (toByteString)
 
 data Y = Y
@@ -18,8 +17,23 @@ mkYesod "Y" [parseRoutes|
 / RootR GET
 /single/#Text TextR GET
 /multi/*Texts TextsR GET
+
+/route-test-1/+[Text] RT1 GET
+/route-test-2/*Vector-String RT2 GET
+/route-test-3/*Vector-(Maybe-Int) RT3 GET
+/route-test-4/#(Foo-Int-Int) RT4 GET
 |]
 
+data Vector a = Vector
+    deriving (Show, Read, Eq)
+
+instance PathMultiPiece (Vector a)
+
+data Foo x y = Foo
+    deriving (Show, Read, Eq)
+
+instance PathPiece (Foo x y)
+
 instance Yesod Y
 
 getRootR :: Handler RepHtml
@@ -31,6 +45,18 @@ getTextR foo = defaultLayout $ toWidget [hamlet|%#{foo}%|]
 getTextsR :: [Text] -> Handler RepHtml
 getTextsR foos = defaultLayout $ toWidget [hamlet|%#{show foos}%|]
 
+getRT1 :: [Text] -> Handler ()
+getRT1 _ = return ()
+
+getRT2 :: Vector String -> Handler ()
+getRT2 _ = return ()
+
+getRT3 :: Vector (Maybe Int) -> Handler ()
+getRT3 _ = return ()
+
+getRT4 :: Foo Int Int -> Handler ()
+getRT4 _ = return ()
+
 linksTest :: Spec
 linksTest = describe "Test.Links" $ do
       it "linkToHome" case_linkToHome
diff --git a/yesod-core/test/YesodCoreTest/LiteApp.hs b/yesod-core/test/YesodCoreTest/LiteApp.hs
new file mode 100644
index 00000000..60de5095
--- /dev/null
+++ b/yesod-core/test/YesodCoreTest/LiteApp.hs
@@ -0,0 +1,42 @@
+module YesodCoreTest.LiteApp (specs) where
+
+import Yesod.Core
+import Test.Hspec
+import Network.Wai.Test
+import Network.Wai
+import qualified Data.ByteString.Char8 as S8
+import qualified Data.Text as T
+import qualified Data.ByteString.Lazy.Char8 as L8
+
+iapp :: IO Application
+iapp = toWaiApp $ liteApp $ do
+    onMethod (S8.pack "GET") (dispatchTo $ return "GetHomepage")
+    onMethod (S8.pack "POST") (dispatchTo $ return "PostHomepage")
+    onStatic (T.pack "string") (withDynamic (\t -> dispatchTo $ return (t :: T.Text)))
+    onStatic (T.pack "multi") (withDynamicMulti (\[_, y] -> dispatchTo $ return (y :: T.Text)))
+
+test :: String -- ^ method
+     -> [String] -- ^ path
+     -> (Either Int String) -- ^ status code or body
+     -> Spec
+test method path expected = it (method ++ " " ++ show path) $ do
+    app <- iapp
+    flip runSession app $ do
+        sres <- request defaultRequest
+            { requestMethod = S8.pack method
+            , pathInfo = map T.pack path
+            }
+        case expected of
+            Left i -> assertStatus i sres
+            Right b -> assertBody (L8.pack b) sres
+
+specs :: Spec
+specs = describe "LiteApp" $ do
+    test "GET" [] $ Right "GetHomepage"
+    test "POST" [] $ Right "PostHomepage"
+    -- test "PUT" [] $ Left 405
+    test "GET" ["string", "foo"] $ Right "foo"
+    test "DELETE" ["string", "bar"] $ Right "bar"
+    test "GET" ["string!", "foo"] $ Left 404
+    test "GET" ["multi", "foo", "bar"] $ Right "bar"
+    test "GET" ["multi", "foo", "bar", "baz"] $ Left 500
diff --git a/yesod-core/test/YesodCoreTest/Media.hs b/yesod-core/test/YesodCoreTest/Media.hs
index 490b6bdb..1dc52dca 100644
--- a/yesod-core/test/YesodCoreTest/Media.hs
+++ b/yesod-core/test/YesodCoreTest/Media.hs
@@ -5,7 +5,7 @@
 module YesodCoreTest.Media (mediaTest, Widget) where
 
 import Test.Hspec
-import Yesod.Core hiding (Request)
+import Yesod.Core
 import Network.Wai
 import Network.Wai.Test
 import Text.Lucius
@@ -15,9 +15,8 @@ mkYesodDispatch "Y" resourcesY
 
 instance Yesod Y where
     addStaticContent _ _ content = do
-        tm <- getRouteToMaster
         route <- getCurrentRoute
-        case fmap tm route of
+        case route of
             Just StaticR -> return $ Just $ Left $
                         if content == "foo2{bar:baz}"
                             then "screen.css"
@@ -27,7 +26,7 @@ instance Yesod Y where
 getRootR :: Handler RepHtml
 getRootR = defaultLayout $ do
     toWidget [lucius|foo1{bar:baz}|]
-    addCassiusMedia "screen" [lucius|foo2{bar:baz}|]
+    toWidgetMedia "screen" [lucius|foo2{bar:baz}|]
     toWidget [lucius|foo3{bar:baz}|]
 
 getStaticR :: Handler RepHtml
diff --git a/yesod-core/test/YesodCoreTest/MediaData.hs b/yesod-core/test/YesodCoreTest/MediaData.hs
index 6a33fab3..9036d41f 100644
--- a/yesod-core/test/YesodCoreTest/MediaData.hs
+++ b/yesod-core/test/YesodCoreTest/MediaData.hs
@@ -8,5 +8,5 @@ import Yesod.Core
 data Y = Y
 mkYesodData "Y" [parseRoutes|
 / RootR GET
-/static StaticR GET
+/static StaticR !IGNORED GET !alsoIgnored
 |]
diff --git a/yesod-core/test/YesodCoreTest/NoOverloadedStrings.hs b/yesod-core/test/YesodCoreTest/NoOverloadedStrings.hs
index d68707cd..7e344f5e 100644
--- a/yesod-core/test/YesodCoreTest/NoOverloadedStrings.hs
+++ b/yesod-core/test/YesodCoreTest/NoOverloadedStrings.hs
@@ -3,22 +3,40 @@
 module YesodCoreTest.NoOverloadedStrings (noOverloadedTest, Widget) where
 
 import Test.Hspec
+import YesodCoreTest.NoOverloadedStringsSub
 
-import Yesod.Core hiding (Request)
+import Yesod.Core
+import Network.Wai
 import Network.Wai.Test
 import Data.Monoid (mempty)
-
-data Subsite = Subsite
+import qualified Data.Text as T
+import qualified Data.ByteString.Lazy.Char8 as L8
 
 getSubsite :: a -> Subsite
-getSubsite = const Subsite
+getSubsite _ = Subsite $(mkYesodSubDispatch resourcesSubsite)
 
-mkYesodSub "Subsite" [] [parseRoutes|
-/bar BarR GET
-|]
+getBarR :: Monad m => m T.Text
+getBarR = return $ T.pack "BarR"
 
-getBarR :: GHandler Subsite m ()
-getBarR = return ()
+getBazR :: Yesod master => HandlerT Subsite (HandlerT master IO) RepHtml
+getBazR = lift $ defaultLayout [whamlet|Used Default Layout|]
+
+getBinR :: Yesod master => HandlerT Subsite (HandlerT master IO) RepHtml
+getBinR = do
+    widget <- widgetToParentWidget [whamlet|
+        <p>Used defaultLayoutT
+        <a href=@{BazR}>Baz
+    |]
+    lift $ defaultLayout widget
+
+getOnePiecesR :: Monad m => Int -> m ()
+getOnePiecesR _ = return ()
+
+getTwoPiecesR :: Monad m => Int -> Int -> m ()
+getTwoPiecesR _ _ = return ()
+
+getThreePiecesR :: Monad m => Int -> Int -> Int -> m ()
+getThreePiecesR _ _ _ = return ()
 
 data Y = Y
 mkYesod "Y" [parseRoutes|
@@ -43,6 +61,33 @@ case_sanity = runner $ do
     res <- request defaultRequest
     assertBody mempty res
 
+case_subsite :: IO ()
+case_subsite = runner $ do
+    res <- request defaultRequest
+        { pathInfo = map T.pack ["subsite", "bar"]
+        }
+    assertBody (L8.pack "BarR") res
+    assertStatus 200 res
+
+case_deflayout :: IO ()
+case_deflayout = runner $ do
+    res <- request defaultRequest
+        { pathInfo = map T.pack ["subsite", "baz"]
+        }
+    assertBodyContains (L8.pack "Used Default Layout") res
+    assertStatus 200 res
+
+case_deflayoutT :: IO ()
+case_deflayoutT = runner $ do
+    res <- request defaultRequest
+        { pathInfo = map T.pack ["subsite", "bin"]
+        }
+    assertBodyContains (L8.pack "Used defaultLayoutT") res
+    assertStatus 200 res
+
 noOverloadedTest :: Spec
 noOverloadedTest = describe "Test.NoOverloadedStrings" $ do
       it "sanity" case_sanity
+      it "subsite" case_subsite
+      it "deflayout" case_deflayout
+      it "deflayoutT" case_deflayoutT
diff --git a/yesod-core/test/YesodCoreTest/NoOverloadedStringsSub.hs b/yesod-core/test/YesodCoreTest/NoOverloadedStringsSub.hs
new file mode 100644
index 00000000..aa5d7c0e
--- /dev/null
+++ b/yesod-core/test/YesodCoreTest/NoOverloadedStringsSub.hs
@@ -0,0 +1,25 @@
+{-# LANGUAGE QuasiQuotes, TypeFamilies, TemplateHaskell, MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE RankNTypes #-}
+module YesodCoreTest.NoOverloadedStringsSub where
+
+import Yesod.Core
+import Network.Wai
+import Yesod.Core.Types
+
+data Subsite = Subsite (forall master. Yesod master => YesodSubRunnerEnv Subsite master (HandlerT master IO) -> Application)
+
+mkYesodSubData "Subsite" [parseRoutes|
+/bar BarR GET
+/baz BazR GET
+/bin BinR GET
+/has-one-piece/#Int OnePiecesR GET
+/has-two-pieces/#Int/#Int TwoPiecesR GET
+/has-three-pieces/#Int/#Int/#Int ThreePiecesR GET
+|]
+
+instance Yesod master => YesodSubDispatch Subsite (HandlerT master IO) where
+    yesodSubDispatch ysre =
+        f ysre
+      where
+        Subsite f = ysreGetSub ysre $ yreSite $ ysreParentEnv ysre
diff --git a/yesod-core/test/YesodCoreTest/Redirect.hs b/yesod-core/test/YesodCoreTest/Redirect.hs
index 63d28759..da6f9725 100644
--- a/yesod-core/test/YesodCoreTest/Redirect.hs
+++ b/yesod-core/test/YesodCoreTest/Redirect.hs
@@ -2,7 +2,7 @@
 module YesodCoreTest.Redirect (specs, Widget) where
 
 import YesodCoreTest.YesodTest
-import Yesod.Handler (redirectWith)
+import Yesod.Core.Handler (redirectWith)
 import qualified Network.HTTP.Types as H
 
 data Y = Y
diff --git a/yesod-core/test/YesodCoreTest/Reps.hs b/yesod-core/test/YesodCoreTest/Reps.hs
new file mode 100644
index 00000000..c1576797
--- /dev/null
+++ b/yesod-core/test/YesodCoreTest/Reps.hs
@@ -0,0 +1,90 @@
+{-# LANGUAGE OverloadedStrings, TemplateHaskell, QuasiQuotes, TypeFamilies, MultiParamTypeClasses #-}
+module YesodCoreTest.Reps (specs, Widget) where
+
+import Yesod.Core
+import Test.Hspec
+import Network.Wai
+import Network.Wai.Test
+import Data.ByteString.Lazy (ByteString)
+import qualified Data.ByteString.Char8 as S8
+import Data.String (IsString)
+import Data.Text (Text)
+import Data.Maybe (fromJust)
+import Data.Monoid (Endo (..))
+import qualified Control.Monad.Trans.Writer    as Writer
+import qualified Data.Set as Set
+
+data App = App
+
+mkYesod "App" [parseRoutes|
+/     HomeR GET !home
+/json JsonR GET
+/parent/#Int ParentR:
+    /#Text/child ChildR !child
+|]
+
+instance Yesod App
+
+specialHtml :: IsString a => a
+specialHtml = "text/html; charset=special"
+
+getHomeR :: Handler TypedContent
+getHomeR = selectRep $ do
+    rep typeHtml "HTML"
+    rep specialHtml "HTMLSPECIAL"
+    rep typeXml "XML"
+    rep typeJson "JSON"
+
+rep :: Monad m => ContentType -> Text -> Writer.Writer (Data.Monoid.Endo [ProvidedRep m]) ()
+rep ct t = provideRepType ct $ return (t :: Text)
+
+getJsonR :: Handler TypedContent
+getJsonR = selectRep $ do
+  rep typeHtml "HTML"
+  provideRep $ return $ object ["message" .= ("Invalid Login" :: Text)]
+
+handleChildR :: Int -> Text -> Handler ()
+handleChildR _ _ = return ()
+
+testRequest :: Int -- ^ http status code
+            -> Request
+            -> ByteString -- ^ expected body
+            -> Spec
+testRequest status req expected = it (S8.unpack $ fromJust $ lookup "Accept" $ requestHeaders req) $ do
+    app <- toWaiApp App
+    flip runSession app $ do
+        sres <- request req
+        assertStatus status sres
+        assertBody expected sres
+
+test :: String -- ^ accept header
+     -> ByteString -- ^ expected body
+     -> Spec
+test accept expected =
+    testRequest 200 (acceptRequest accept) expected
+
+acceptRequest :: String -> Request
+acceptRequest accept = defaultRequest
+            { requestHeaders = [("Accept", S8.pack accept)]
+            }
+
+specs :: Spec
+specs = do
+  describe "selectRep" $ do
+    test "application/json" "JSON"
+    test (S8.unpack typeJson) "JSON"
+    test "text/xml" "XML"
+    test (S8.unpack typeXml) "XML"
+    test "text/xml,application/json" "XML"
+    test "text/xml;q=0.9,application/json;q=1.0" "JSON"
+    test (S8.unpack typeHtml) "HTML"
+    test "text/html" "HTML"
+    test specialHtml "HTMLSPECIAL"
+    testRequest 200 (acceptRequest "application/json") { pathInfo = ["json"] } "{\"message\":\"Invalid Login\"}"
+    testRequest 406 (acceptRequest "text/foo") "no match found for accept header"
+    test "text/*" "HTML"
+    test "*/*" "HTML"
+  describe "routeAttrs" $ do
+    it "HomeR" $ routeAttrs HomeR `shouldBe` Set.singleton "home"
+    it "JsonR" $ routeAttrs JsonR `shouldBe` Set.empty
+    it "ChildR" $ routeAttrs (ParentR 5 $ ChildR "ignored") `shouldBe` Set.singleton "child"
diff --git a/yesod-core/test/YesodCoreTest/RequestBodySize.hs b/yesod-core/test/YesodCoreTest/RequestBodySize.hs
index 937b887a..514559ac 100644
--- a/yesod-core/test/YesodCoreTest/RequestBodySize.hs
+++ b/yesod-core/test/YesodCoreTest/RequestBodySize.hs
@@ -5,7 +5,7 @@ module YesodCoreTest.RequestBodySize (specs, Widget) where
 
 import Test.Hspec
 
-import Yesod.Core hiding (Request)
+import Yesod.Core
 
 import Network.Wai
 import Network.Wai.Test
@@ -29,7 +29,7 @@ mkYesod "Y" [parseRoutes|
 |]
 
 instance Yesod Y where
-    maximumContentLength _ _ = 10
+    maximumContentLength _ _ = Just 10
 
 postPostR, postConsumeR, postPartialConsumeR, postUnusedR :: Handler RepPlain
 
@@ -38,13 +38,11 @@ postPostR = do
     return $ RepPlain $ toContent $ T.concat val
 
 postConsumeR = do
-    req <- waiRequest
-    body <- lift $ requestBody req $$ consume
+    body <- rawRequestBody $$ consume
     return $ RepPlain $ toContent $ S.concat body
 
 postPartialConsumeR = do
-    req <- waiRequest
-    body <- lift $ requestBody req $$ isolate 5 =$ consume
+    body <- rawRequestBody $$ isolate 5 =$ consume
     return $ RepPlain $ toContent $ S.concat body
 
 postUnusedR = return $ RepPlain ""
@@ -75,6 +73,10 @@ caseHelper name path body statusChunked statusNonChunked = describe name $ do
                 then [("content-length", S8.pack $ show $ S.length body)]
                 else []
         , requestMethod = "POST"
+        , requestBodyLength =
+            if includeLength
+                then KnownLength $ fromIntegral $ S.length body
+                else ChunkedBody
         } $ L.fromChunks $ map S.singleton $ S.unpack body
 
 specs :: Spec
diff --git a/yesod-core/test/YesodCoreTest/Streaming.hs b/yesod-core/test/YesodCoreTest/Streaming.hs
new file mode 100644
index 00000000..1b2fde72
--- /dev/null
+++ b/yesod-core/test/YesodCoreTest/Streaming.hs
@@ -0,0 +1,30 @@
+{-# LANGUAGE OverloadedStrings #-}
+module YesodCoreTest.Streaming (specs) where
+
+import Yesod.Core
+import Test.Hspec
+import Network.Wai.Test
+import Data.Text (Text)
+import Data.ByteString (ByteString)
+
+app :: LiteApp
+app = liteApp $ dispatchTo $ respondSource typeHtml $ do
+    sendChunk ("Hello " :: String)
+    sendChunk ("World" :: ByteString)
+    sendChunk ("!\n" :: Text)
+    sendChunkHtml "<&>"
+
+test :: String
+     -> (SResponse -> Session ())
+     -> Spec
+test name f = it name $ do
+    wapp <- toWaiApp app
+    flip runSession wapp $ do
+        sres <- request defaultRequest
+        f sres
+
+specs :: Spec
+specs = describe "Streaming" $ do
+    test "works" $ \sres -> do
+        assertStatus 200 sres
+        assertBody "Hello World!\n&lt;&amp;&gt;" sres
diff --git a/yesod-core/test/YesodCoreTest/Widget.hs b/yesod-core/test/YesodCoreTest/Widget.hs
index 9b14ee35..c05a3f27 100644
--- a/yesod-core/test/YesodCoreTest/Widget.hs
+++ b/yesod-core/test/YesodCoreTest/Widget.hs
@@ -5,7 +5,7 @@ module YesodCoreTest.Widget (widgetTest) where
 
 import Test.Hspec
 
-import Yesod.Core hiding (Request)
+import Yesod.Core
 import Text.Julius
 import Text.Lucius
 import Text.Hamlet
@@ -61,18 +61,18 @@ getTowidgetR = defaultLayout $ do
 
 getWhamletR :: Handler RepHtml
 getWhamletR = defaultLayout [whamlet|
-$newline never
-<h1>Test
-<h2>@{WhamletR}
-<h3>_{Goodbye}
-<h3>_{MsgAnother}
-^{embed}
-|]
+                    $newline never
+                    <h1>Test
+                    <h2>@{WhamletR}
+                    <h3>_{Goodbye}
+                    <h3>_{MsgAnother}
+                    ^{embed}
+                |]
   where
     embed = [whamlet|
-$newline never
-<h4>Embed
-|]
+                $newline never
+                <h4>Embed
+                |]
 
 getAutoR :: Handler RepHtml
 getAutoR = defaultLayout [whamlet|
diff --git a/yesod-core/test/YesodCoreTest/YesodTest.hs b/yesod-core/test/YesodCoreTest/YesodTest.hs
index 4cea7409..f0b7b69b 100644
--- a/yesod-core/test/YesodCoreTest/YesodTest.hs
+++ b/yesod-core/test/YesodCoreTest/YesodTest.hs
@@ -9,10 +9,10 @@ module YesodCoreTest.YesodTest
   , module Test.Hspec
 ) where
 
-import Yesod.Core hiding (Request)
+import Yesod.Core
 import Network.Wai.Test
 import Network.Wai
 import Test.Hspec
 
-yesod :: (YesodDispatch y y, Yesod y) => y -> Session a -> IO a
+yesod :: YesodDispatch y => y -> Session a -> IO a
 yesod app f = toWaiApp app >>= runSession f
diff --git a/yesod-core/yesod-core.cabal b/yesod-core/yesod-core.cabal
index f8717d70..988ce01d 100644
--- a/yesod-core/yesod-core.cabal
+++ b/yesod-core/yesod-core.cabal
@@ -1,5 +1,5 @@
 name:            yesod-core
-version:         1.1.8.3
+version:         1.2.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -22,9 +22,9 @@ extra-source-files:
   test/YesodCoreTest/ErrorHandling.hs
   test/YesodCoreTest/Exceptions.hs
   test/YesodCoreTest/InternalRequest.hs
+  test/YesodCoreTest/Json.hs
   test/YesodCoreTest/JsLoader.hs
   test/YesodCoreTest/JsLoaderSites/Bottom.hs
-  test/YesodCoreTest/JsLoaderSites/HeadAsync.hs
   test/YesodCoreTest/Links.hs
   test/YesodCoreTest/Media.hs
   test/YesodCoreTest/MediaData.hs
@@ -34,23 +34,16 @@ extra-source-files:
   test/YesodCoreTest/WaiSubsite.hs
   test/YesodCoreTest/Widget.hs
   test/YesodCoreTest/YesodTest.hs
+  test/YesodCoreTest/Auth.hs
+  test/YesodCoreTest/LiteApp.hs
   test/en.msg
   test/test.hs
 
-flag test
-  description: Build the executable to run unit tests
-  default: False
-
 library
-    -- Work around a bug in cabal. Without this, wai-test doesn't get built and
-    -- we have a missing dependency during --enable-tests builds.
-    if flag(test)
-        build-depends: wai-test
-
     build-depends:   base                  >= 4.3      && < 5
                    , time                  >= 1.1.4
-                   , yesod-routes          >= 1.1      && < 1.2
-                   , wai                   >= 1.3      && < 1.5
+                   , yesod-routes          >= 1.2      && < 1.3
+                   , wai                   >= 1.4      && < 1.5
                    , wai-extra             >= 1.3      && < 1.4
                    , bytestring            >= 0.9.1.4
                    , text                  >= 0.7      && < 0.12
@@ -63,7 +56,7 @@ library
                    , shakespeare-i18n      >= 1.0      && < 1.1
                    , blaze-builder         >= 0.2.1.4  && < 0.4
                    , transformers          >= 0.2.2    && < 0.4
-                   , clientsession         >= 0.8
+                   , clientsession         >= 0.9      && < 0.10
                    , random                >= 1.0.0.2  && < 1.1
                    , cereal                >= 0.3      && < 0.4
                    , old-locale            >= 1.0.0.2  && < 1.1
@@ -79,26 +72,36 @@ library
                    , vector                >= 0.9      && < 0.11
                    , aeson                 >= 0.5
                    , fast-logger           >= 0.2
-                   , monad-logger          >= 0.2.1    && < 0.4
+                   , monad-logger          >= 0.3.1    && < 0.4
                    , conduit               >= 0.5
-                   , resourcet             >= 0.3      && < 0.5
+                   , resourcet             >= 0.4.6    && < 0.5
                    , lifted-base           >= 0.1
+                   , attoparsec-conduit
                    , blaze-html            >= 0.5
                    , blaze-markup          >= 0.5.1
+                   , data-default
+                   , safe
+                   , warp                  >= 1.3.8
 
-    exposed-modules: Yesod.Content
-                     Yesod.Core
-                     Yesod.Dispatch
-                     Yesod.Handler
-                     Yesod.Request
-                     Yesod.Widget
-                     Yesod.Message
-                     Yesod.Internal.TestApi
-    other-modules:   Yesod.Internal
-                     Yesod.Internal.Cache
-                     Yesod.Internal.Core
-                     Yesod.Internal.Session
-                     Yesod.Internal.Request
+    exposed-modules: Yesod.Core
+                     Yesod.Core.Content
+                     Yesod.Core.Dispatch
+                     Yesod.Core.Handler
+                     Yesod.Core.Json
+                     Yesod.Core.Widget
+                     Yesod.Core.Internal
+                     Yesod.Core.Types
+    other-modules:   Yesod.Core.Internal.Session
+                     Yesod.Core.Internal.Request
+                     Yesod.Core.Class.Handler
+                     Yesod.Core.Internal.Util
+                     Yesod.Core.Internal.Response
+                     Yesod.Core.Internal.Run
+                     Yesod.Core.Internal.TH
+                     Yesod.Core.Internal.LiteApp
+                     Yesod.Core.Class.Yesod
+                     Yesod.Core.Class.Dispatch
+                     Yesod.Core.Class.Breadcrumbs
                      Paths_yesod_core
     ghc-options:     -Wall
 
@@ -110,7 +113,7 @@ test-suite tests
     cpp-options:   -DTEST
     build-depends: base
                   ,hspec >= 1.3
-                  ,wai-test
+                  ,wai-test >= 1.3.0.5
                   ,wai
                   ,yesod-core
                   ,bytestring
@@ -125,6 +128,9 @@ test-suite tests
                   ,QuickCheck >= 2 && < 3
                   ,transformers
                   , conduit
+                  , containers
+                  , lifted-base
+                  , resourcet
     ghc-options:     -Wall
 
 source-repository head
diff --git a/yesod-default/README b/yesod-default/README
deleted file mode 100644
index e69de29b..00000000
diff --git a/yesod-default/yesod-default.cabal b/yesod-default/yesod-default.cabal
deleted file mode 100644
index 130c7ba4..00000000
--- a/yesod-default/yesod-default.cabal
+++ /dev/null
@@ -1,51 +0,0 @@
-name:            yesod-default
-version:         1.1.3.2
-license:         MIT
-license-file:    LICENSE
-author:          Patrick Brisbin
-maintainer:      Patrick Brisbin <pbrisbin@gmail.com>
-synopsis:        Default config and main functions for your yesod application
-category:        Web, Yesod
-stability:       Stable
-cabal-version:   >= 1.6
-build-type:      Simple
-homepage:        http://www.yesodweb.com/
-description:     Convenient wrappers for your the configuration and
-                 execution of your yesod application
-
-library
-    if os(windows)
-        cpp-options: -DWINDOWS
-
-    build-depends:   base                  >= 4       && < 5
-                   , yesod-core            >= 1.1     && < 1.2
-                   , warp                  >= 1.3     && < 1.4
-                   , wai                   >= 1.3     && < 1.5
-                   , wai-extra             >= 1.3     && < 1.4
-                   , bytestring            >= 0.9.1.4
-                   , transformers          >= 0.2.2   && < 0.4
-                   , text                  >= 0.9
-                   , directory             >= 1.0
-                   , shakespeare-css       >= 1.0     && < 1.1
-                   , shakespeare-js        >= 1.0     && < 1.2
-                   , template-haskell
-                   , yaml                  >= 0.8     && < 0.9
-                   , network-conduit       >= 0.5
-                   , unordered-containers
-                   , hamlet                >= 1.1     && < 1.2
-                   , data-default
-                   , safe
-
-    if !os(windows)
-         build-depends: unix
-
-    exposed-modules: Yesod.Default.Config
-                   , Yesod.Default.Main
-                   , Yesod.Default.Util
-                   , Yesod.Default.Handlers
-
-    ghc-options:     -Wall
-
-source-repository head
-  type:     git
-  location: https://github.com/yesodweb/yesod
diff --git a/yesod-examples/.gitignore b/yesod-examples/.gitignore
deleted file mode 100644
index 1cd91990..00000000
--- a/yesod-examples/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-client_session_key.aes
-dist
-cabal-dev/
diff --git a/yesod-examples/LICENSE b/yesod-examples/LICENSE
deleted file mode 100644
index d9f04179..00000000
--- a/yesod-examples/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2012 Michael Snoyman, http://www.yesodweb.com/
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/yesod-examples/README b/yesod-examples/README
deleted file mode 100644
index e69de29b..00000000
diff --git a/yesod-examples/Setup.hs b/yesod-examples/Setup.hs
deleted file mode 100644
index cd7dc327..00000000
--- a/yesod-examples/Setup.hs
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/usr/bin/env runhaskell
-import Distribution.Simple
-main = defaultMain
diff --git a/yesod-examples/src/MkToForm2.hs b/yesod-examples/src/MkToForm2.hs
deleted file mode 100644
index 1cedbeb5..00000000
--- a/yesod-examples/src/MkToForm2.hs
+++ /dev/null
@@ -1,15 +0,0 @@
-{-# LANGUAGE TypeFamilies, QuasiQuotes, GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-module MkToForm2 where
-
-import Yesod
-import Data.Time (Day)
-
-mkPersist [$persist|
-Entry
-    title String
-    day Day Desc toFormField=YesodJquery.jqueryDayField'
-    content Html toFormField=YesodNic.nicHtmlField
-    deriving
-|]
diff --git a/yesod-examples/src/ajax.lhs b/yesod-examples/src/ajax.lhs
deleted file mode 100644
index 9396aef1..00000000
--- a/yesod-examples/src/ajax.lhs
+++ /dev/null
@@ -1,116 +0,0 @@
-<p>We're going to write a very simple AJAX application. It will be a simple site with a few pages and a navbar; when you have Javascript, clicking on the links will load the pages via AJAX. Otherwise, it will use static HTML.</p>
-
-<p>We're going to use jQuery for the Javascript, though anything would work just fine. Also, the AJAX responses will be served as JSON. Let's get started.</p>
-
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-}
-> import Yesod
-> import Yesod.Static
-> import Data.Text (Text, unpack)
-
-Like the blog example, we'll define some data first.
-
-> data Page = Page
->   { pageName :: Text
->   , pageSlug :: Text
->   , pageContent :: Text
->   }
-
-> loadPages :: IO [Page]
-> loadPages = return
->   [ Page "Page 1" "page-1" "My first page"
->   , Page "Page 2" "page-2" "My second page"
->   , Page "Page 3" "page-3" "My third page"
->   ]
-
-> data Ajax = Ajax
->   { ajaxPages :: [Page]
->   , ajaxStatic :: Static
->   }
-
-Next we'll generate a function for each file in our static folder. This way, we get a compiler warning when trying to using a file which does not exist.
-
-> staticFiles "static/yesod/ajax"
-
-Now the routes; we'll have a homepage, a pattern for the pages, and use a static subsite for the Javascript and CSS files.
-
-> mkYesod "Ajax" [parseRoutes|
-> /                  HomeR   GET
-> /page/#Text        PageR   GET
-> /static            StaticR Static ajaxStatic
-> |]
-
-<p>That third line there is the syntax for a subsite: Static is the datatype for the subsite argument; siteStatic returns the site itself (parse, render and dispatch functions); and ajaxStatic gets the subsite argument from the master argument.</p>
-
-<p>Now, we'll define the Yesod instance. We'll still use a dummy approot value, but we're also going to define a default layout.</p>
-
-> instance Yesod Ajax where
->   approot _ = ""
->   defaultLayout widget = do
->   Ajax pages _ <- getYesod
->   content <- widgetToPageContent widget
->   hamletToRepHtml [hamlet|
-> \<!DOCTYPE html>
-> 
-> <html>
->   <head>
->     <title>#{pageTitle content}
->     <link rel="stylesheet" href="@{StaticR style_css}">
->     <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js">
->     <script src="@{StaticR script_js}">
->     \^{pageHead content}
->   <body>
->     <ul id="navbar">
->       $forall page <- pages
->         <li>
->           <a href="@{PageR (pageSlug page)}">#{pageName page}
->     <div id="content">
->       \^{pageBody content}
-> |]
-
-<p>The Hamlet template refers to style_css and style_js; these were generated by the call to staticFiles above.  There's nothing Yesod-specific about the <a href="/static/yesod/ajax/style.css">style.css</a> and <a href="/static/yesod/ajax/script.js">script.js</a> files, so I won't describe them here.</p>
-
-<p>Now we need our handler functions. We'll have the homepage simply redirect to the first page, so:</p>
-
-> getHomeR :: Handler ()
-> getHomeR = do
->   Ajax pages _ <- getYesod
->   let first = head pages
->   redirect RedirectTemporary $ PageR $ pageSlug first
-
-And now the cool part: a handler that returns either HTML or JSON data, depending on the request headers.
-
-> getPageR :: Text -> Handler RepHtmlJson
-> getPageR slug = do
->   Ajax pages _ <- getYesod
->   case filter (\e -> pageSlug e == slug) pages of
->       [] -> notFound
->       page:_ -> defaultLayoutJson (do
->           setTitle $ toHtml $ pageName page
->           addHamlet $ html page
->           ) (json page)
->  where
->   html page = [hamlet|
-> <h1>#{pageName page}
-> <article>#{pageContent page}
-> |]
->   json page = jsonMap
->       [ ("name", jsonScalar $ unpack $ pageName page)
->       , ("content", jsonScalar $ unpack $ pageContent page)
->       ]
-
-<p>We first try and find the appropriate Page, returning a 404 if it's not there. We then use the applyLayoutJson function, which is really the heart of this example. It allows you an easy way to create responses that will be either HTML or JSON, and which use the default layout in the HTML responses. It takes four arguments: 1) the title of the HTML page, 2) some value, 3) a function from that value to a Hamlet value, and 4) a function from that value to a Json value.</p>
-
-<p>Under the scenes, the Json monad is really just using the Hamlet monad, so it gets all of the benefits thereof, namely interleaved IO and enumerator output. It is pretty straight-forward to generate JSON output by using the three functions jsonMap, jsonList and jsonMap. One thing to note: the input to jsonScalar must be HtmlContent; this helps avoid cross-site scripting attacks, by ensuring that any HTML entities will be escaped.</p>
-
-<p>And now our typical main function. We need two parameters to build our Ajax value: the pages, and the static loader. We'll load up from a local directory.</p>
-
-> main :: IO ()
-> main = do
->   pages <- loadPages
->   s <- static "static/yesod/ajax"
->   warpDebug 3000 $ Ajax pages s
-
-And just to avoid some warnings...
-
-> _ignored :: Widget
-> _ignored = undefined ajaxPages
diff --git a/yesod-examples/src/blog.lhs b/yesod-examples/src/blog.lhs
deleted file mode 100644
index 8e59cdd9..00000000
--- a/yesod-examples/src/blog.lhs
+++ /dev/null
@@ -1,120 +0,0 @@
-<p>Well, just about every web framework I've seen starts with a blog tutorial- so here's mine! Actually, you'll see that this is actually a much less featureful blog than most, but gives a good introduction to Yesod basics. I recommend you start by <a href="/book/basics">reading the basics chapter</a>.</p>
-
-<p>This file is literate Haskell, so we'll start off with our language pragmas and import statements. Basically every Yesod application will start off like this:</p>
-
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-}
-> import Yesod
-
-Next, we'll define the blog entry information. Usually, we would want to store the data in a database and allow users to modify them, but we'll simplify for the moment.
-
-> data Entry = Entry
->       { entryTitle :: String
->       , entrySlug :: String -- ^ used in the URL
->       , entryContent :: String
->       }
-
-Since normally you'll need to perform an IO action to load up your entries from a database, we'll define the loadEntries function to be in the IO monad.
-
-> loadEntries :: IO [Entry]
-> loadEntries = return
->   [ Entry "Entry 1" "entry-1" "My first entry"
->   , Entry "Entry 2" "entry-2" "My second entry"
->   , Entry "Entry 3" "entry-3" "My third entry"
->   ]
-
-Each Yesod application needs to define the site argument. You can use this for storing anything that should be loaded before running your application. For example, you might store a database connection there. In our case, we'll store our list of entries.
-
-> data Blog = Blog { blogEntries :: [Entry] }
-
-Now we use the first "magical" Yesod set of functions: mkYesod and parseRoutes. If you want to see *exactly* what they do, look at their Haddock docs. For now, we'll try to keep this tutorial simple:
-
-> mkYesod "Blog" [parseRoutes|
-> /               HomeR   GET
-> /entry/#String  EntryR  GET
-> |]
-
-Usually, the next thing you want to do after a call to mkYesod is to create an instance of Yesod. Every Yesod app needs this; it is a centralized place to define some settings. All settings but approot have sensible defaults. In general, you should put in a valid, fully-qualified URL for your approot, but you can sometimes get away with just doing this:
-
-> instance Yesod Blog where approot _ = ""
-
-This only works if you application is being served from the root of your webserver, and if you never use features like sitemaps and atom feeds that need absolute URLs.
-
-We defined two resource patterns for our blog: the homepage, and the page for each entry. For each of these, we are allowing only the GET request method. For the homepage, we want to simply redirect to the most recent entry, so we'll use:
-
-> getHomeR :: Handler ()
-> getHomeR = do
->   Blog entries <- getYesod
->   let newest = last entries
->   redirect RedirectTemporary $ EntryR $ entrySlug newest
-
-We go ahead and send a 302 redirect request to the entry resource. Notice how we at no point need to construct a String to redirect to; this is the beauty of type-safe URLs.
-
-Next we'll define a template for entry pages. Normally, I tend to just define them within the handler function, but it's easier to follow if they're separate. Also for clarity, I'll define a datatype for the template arguments. It would also be possible to simply use the Entry datatype with some filter functions, but I'll save that for a later tutorial.
-
-> data TemplateArgs = TemplateArgs
->   { templateTitle :: Html
->   , templateContent :: Html
->   , templateNavbar :: [Nav]
->   }
-
-The Nav datatype will contain navigation information (ie, the URL and title) of each entry.
-
-> data Nav = Nav
->   { navUrl :: Route Blog
->   , navTitle :: Html
->   }
-
-And now the template itself:
-
-> entryTemplate :: TemplateArgs -> HtmlUrl (Route Blog)
-> entryTemplate args = [hamlet|
->   !!!
->   <html>
->       <head>
->           <title>#{templateTitle args}
->       <body>
->           <h1>Yesod Sample Blog
->           <h2>#{templateTitle args}
->           <ul id="nav">
->               $forall nav <- templateNavbar args
->                   <li>
->                       <a href="@{navUrl nav}">#{navTitle nav}
->           <div id="content">
->               \#{templateContent args}
->   |]
-
-Hopefully, that is fairly easy to follow; if not, please review the Hamlet documentation. Just remember that dollar signs mean Html variables, and at signs mean URLs.
-
-Finally, the entry route handler:
-
-> getEntryR :: String -> Handler RepHtml
-> getEntryR slug = do
->   Blog entries <- getYesod
->   case filter (\e -> entrySlug e == slug) entries of
->       [] -> notFound
->       (entry:_) -> do
->           let nav = reverse $ map toNav entries
->           let tempArgs = TemplateArgs
->                   { templateTitle = toHtml $ entryTitle entry
->                   , templateContent = toHtml $ entryContent entry
->                   , templateNavbar = nav
->                   }
->           hamletToRepHtml $ entryTemplate tempArgs
->  where
->    toNav :: Entry -> Nav
->    toNav e = Nav
->       { navUrl = EntryR $ entrySlug e
->       , navTitle = toHtml $ entryTitle e
->       }
-
-All that's left now is the main function. Yesod is built on top of WAI, so you can use any WAI handler you wish. For the tutorials, we'll use the basicHandler that comes built-in with Yesod: it serves content via CGI if the appropriate environment variables are available, otherwise with simpleserver.
-
-> main :: IO ()
-> main = do
->   entries <- loadEntries
->   warpDebug 3000 $ Blog entries
-
-And this is just to avoid some warnings...
-
-> _ignored :: Widget
-> _ignored = undefined blogEntries
diff --git a/yesod-examples/src/chat.hs b/yesod-examples/src/chat.hs
deleted file mode 100644
index eb138906..00000000
--- a/yesod-examples/src/chat.hs
+++ /dev/null
@@ -1,122 +0,0 @@
-{-# LANGUAGE TemplateHaskell, QuasiQuotes, TypeFamilies #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-
-module Main where
-
-import Yesod
-import Yesod.Static
-
-import Control.Concurrent.STM
-
-import Control.Arrow ((***))
-import Data.Text (Text, unpack)
-
--- speaker and content
-data Message = Message Text Text
-
--- all those TChans are dupes, so writing to any one writes to them all, but reading is separate
-data Chat = Chat
-  { chatClients    :: TVar [(Int, TChan Message)]
-  , nextClient     :: TVar Int
-  , chatStatic     :: Static
-  }
-
-staticFiles "static"
-
-mkYesod "Chat" [parseRoutes|
-/          HomeR   GET
-/check     CheckR  GET
-/post      PostR   GET
-/static    StaticR Static chatStatic
-|]
-
-instance Yesod Chat where
-  approot _ = ""
-  defaultLayout widget = do
-    content <- widgetToPageContent widget
-    hamletToRepHtml [hamlet|
-!!!
-
-<html>
-    <head>
-        <title>#{pageTitle content}
-        <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js">
-        <script src="@{StaticR chat_js}">
-        ^{pageHead content}
-    <body>
-        ^{pageBody content}
-|]
-
-getHomeR :: Handler RepHtml
-getHomeR = do
-  Chat clients next _ <- getYesod
-  client <- liftIO . atomically $ do
-    c <- readTVar next
-    writeTVar next (c+1)
-    cs <- readTVar clients
-    chan <- case cs of
-             []      -> newTChan
-             (_,x):_ -> dupTChan x
-    writeTVar clients ((c,chan) : cs)
-    return c
-  defaultLayout $ do
-    setTitle "Chat Page"
-    toWidget [hamlet|
-!!!
-
-<h1>Chat Example
-<form>
-    <textarea cols="80" rows="20" name="chat">
-    <p>
-        <input type="text" size="15" name="name" id="name">
-        <input type="text" size="60" name="send" id="send">
-        <input type="submit" value="Send">
-<script>var clientNumber = #{show client}
-|]
-
-getCheckR :: Handler RepJson
-getCheckR = do
-  liftIO $ putStrLn "Check"
-  Chat clients _ _ <- getYesod
-  client <- do
-    c <- lookupGetParam "client"
-    case c of
-      Nothing -> invalidArgs ["No client value in Check request"]
-      Just c' -> return $ read $ unpack c'
-  cs <- liftIO . atomically $ readTVar clients
-  chan <- case lookup client cs of
-            Nothing -> invalidArgs ["Bad client value"]
-            Just ch -> return ch
-  -- block until there's something there
-  first <- liftIO . atomically $ readTChan chan
-  let Message s c = first
-  jsonToRepJson $ zipJson ["sender", "content"] [s,c]
-
-zipJson :: [Text] -> [Text] -> Json
-zipJson x y = jsonMap $ map (unpack *** jsonScalar . unpack) $ zip x y
-
-getPostR :: Handler RepJson
-getPostR = do
-  liftIO $ putStrLn "Post"
-  Chat clients _ _ <- getYesod
-  (sender,content) <- do
-    s <- lookupGetParam "name"
-    c <- lookupGetParam "send"
-    case (s,c) of
-      (Just s', Just c') -> return (s', c')
-      _                  -> invalidArgs ["Either name or send not provided."]
-  liftIO . atomically $ do
-    cs <- readTVar clients
-    let chan = snd . head $ cs -- doesn't matter which one we use, they're all duplicates
-    writeTChan chan (Message sender content)
-
-  jsonToRepJson $ jsonScalar "success"
-
-main :: IO ()
-main = do
-  clients <- newTVarIO []
-  next <- newTVarIO 0
-  s <- static "static"
-  warpDebug 3000 $ Chat clients next s
diff --git a/yesod-examples/src/file-echo.lhs b/yesod-examples/src/file-echo.lhs
deleted file mode 100644
index ed86a365..00000000
--- a/yesod-examples/src/file-echo.lhs
+++ /dev/null
@@ -1,37 +0,0 @@
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-}
-
-> import Yesod
-> import qualified Data.ByteString.Char8 as S8
-> import qualified Data.Text as T
-
-> data Echo = Echo
-
-> mkYesod "Echo" [parseRoutes|
-> / Homepage GET POST
-> |]
-
-> instance Yesod Echo where approot _ = ""
-
-> getHomepage :: Handler RepHtml
-> getHomepage = defaultLayout $ do
->   setTitle "Upload a file"
->   addHamlet [hamlet|
-> <form method=post action=. enctype=multipart/form-data>
->   File name:
->   <input type=file name=file
->   <input type=submit
-> |]
-
-> postHomepage :: Handler [(ContentType, Content)]
-> postHomepage = do
->   (_, files) <- runRequestBody
->   fi <- maybe notFound return $ lookup "file" files
->   return [(S8.pack $ T.unpack $ fileContentType fi, toContent $ fileContent fi)]
-
-> main :: IO ()
-> main = warpDebug 3000 Echo
-
-To avoid warnings
-
-> _ignored :: Widget
-> _ignored = undefined
diff --git a/yesod-examples/src/form.lhs b/yesod-examples/src/form.lhs
deleted file mode 100644
index 927fb6fa..00000000
--- a/yesod-examples/src/form.lhs
+++ /dev/null
@@ -1,55 +0,0 @@
-<p>Forms can be a tedious part of web development since they require synchronization of code in many different areas: the HTML form declaration, parsing of the form and reconstructing a datatype from the raw values. The Yesod form library simplifies things greatly. We'll start off with a basic application.</p>
-
-
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, OverloadedStrings, MultiParamTypeClasses, TemplateHaskell #-}
-> import Yesod hiding (Form)
-> import Control.Applicative
-> import Data.Text (Text)
-
-> data FormExample = FormExample
-> mkYesod "FormExample" [parseRoutes|
-> / RootR GET
-> |]
-> type Form a = Html -> MForm FormExample FormExample (FormResult a, Widget)
-> type Formlet a = Maybe a -> Form a
-> instance Yesod FormExample where approot _ = ""
-> instance RenderMessage FormExample FormMessage where
->    renderMessage _ _ = defaultFormMessage
-
-Next, we'll declare a Person datatype with a name and age. After that, we'll create a formlet. A formlet is a declarative approach to forms. It takes a Maybe value and constructs either a blank form, a form based on the original value, or a form based on the values submitted by the user. It also attempts to construct a datatype, failing on validation errors.
-
-> data Person = Person { name :: Text, age :: Int }
->     deriving Show
-> personFormlet :: Formlet Person
-> personFormlet p = renderTable $ Person
->     <$> areq textField "Name" (fmap name p)
->     <*> areq intField "Age" (fmap age p)
-
-We use an applicative approach and stay mostly declarative. The "fmap name p" bit is just a way to get the name from within a value of type "Maybe Person".
-
-> getRootR :: Handler RepHtml
-> getRootR = do
->     ((res, wform), enctype) <- runFormGet $ personFormlet Nothing
-
-<p>We use runFormGet to bind to GET (query-string) parameters; we could also use runFormPost. The "Nothing" is the initial value of the form. You could also supply a "Just Person" value if you like. There is a three-tuple returned, containing the parsed value, the HTML form as a widget and the encoding type for the form.</p>
-
-<p>We use a widget for the form since it allows embedding CSS and Javascript code in forms directly. This allows unobtrusive adding of rich Javascript controls like date pickers.</p>
-
->     defaultLayout $ do
->         setTitle "Form Example"
->         form <- extractBody wform
-
-<p>extractBody returns the HTML of a widget and "passes" all of the other declarations (the CSS, Javascript, etc) up to the parent widget. The rest of this is just standard Hamlet code and our main function.</p>
-
->         addHamlet [hamlet|
-> <p>Last result: #{show res}
-> <form enctype="#{enctype}">
->     <table>
->         ^{form}
->         <tr>
->             <td colspan="2">
->                 <input type="submit">
-> |]
-> 
-> main :: IO ()
-> main = warpDebug 3000 FormExample
diff --git a/yesod-examples/src/i18n.lhs b/yesod-examples/src/i18n.lhs
deleted file mode 100644
index 99eb47a6..00000000
--- a/yesod-examples/src/i18n.lhs
+++ /dev/null
@@ -1,56 +0,0 @@
-> {-# LANGUAGE QuasiQuotes #-}
-> {-# LANGUAGE TemplateHaskell #-}
-> {-# LANGUAGE TypeFamilies #-}
-> {-# LANGUAGE MultiParamTypeClasses #-}
-> {-# LANGUAGE OverloadedStrings #-}
-> {-# LANGUAGE CPP #-}
-
-> import Yesod
-> import Data.Text (Text)
-
-> data I18N = I18N
-
-> mkYesod "I18N" [parseRoutes|
-> /            HomepageR GET
-> /set/#Text SetLangR  GET
-> |]
-
-> instance Yesod I18N where
->     approot _ = "http://localhost:3000"
-
-> getHomepageR :: Handler RepHtml
-> getHomepageR = do
->     ls <- languages
->     let hello = chooseHello ls
->     let choices =
->             [ ("en", "English") :: (Text, Text)
->             , ("es", "Español")
->             , ("he", "עִבְרִית")
->             ]
->     defaultLayout $ do
->       setTitle "I18N Homepage"
->       addHamlet [hamlet|
-> <h1>#{hello}
-> <p>In other languages:
-> <ul>
->     $forall choice <- choices
->         <li>
->             <a href="@{SetLangR (fst choice)}">#{snd choice}
-> |]
-
-> chooseHello :: [Text] -> Text
-> chooseHello [] = "Hello"
-> chooseHello ("he":_) = "שלום"
-> chooseHello ("es":_) = "¡Hola!"
-> chooseHello (_:rest) = chooseHello rest
-
-> getSetLangR :: Text -> Handler ()
-> getSetLangR lang = do
->     setLanguage lang
->     redirect RedirectTemporary HomepageR
-
-> main :: IO ()
-> main = warpDebug 3000 I18N
-
-> _ignored :: Widget
-> _ignored = undefined
diff --git a/yesod-examples/src/pretty-yaml.lhs b/yesod-examples/src/pretty-yaml.lhs
deleted file mode 100644
index f8786553..00000000
--- a/yesod-examples/src/pretty-yaml.lhs
+++ /dev/null
@@ -1,66 +0,0 @@
-<p>This example uses the <a href="http://hackage.haskell.org/package/data-object-yaml">data-object-yaml package</a> to display YAML files as cleaned-up HTML. If you've read through the other tutorials, this one should be easy to follow.</p>
-
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-}
-
-> import Yesod
-> import Data.Object
-> import Data.Object.Yaml
-> import qualified Data.ByteString as B
-> import qualified Data.ByteString.Lazy as L
-
-> data PY = PY
-
-> mkYesod "PY" [parseRoutes|
-> / Homepage GET POST
-> |]
-
-> instance Yesod PY where approot _ = ""
-
-> template :: Maybe (HtmlUrl url) -> HtmlUrl url
-> template myaml = [hamlet|
-> !!!
-> 
-> <html>
->     <head>
->         <meta charset="utf-8">
->         <title>Pretty YAML
->     <body>
->         <form method="post" action="" enctype="multipart/form-data" .>
->             \File name:
->             <input type="file" name="yaml">
->             <input type="submit">
->         $maybe yaml <- myaml
->             <div>^{yaml}
-> |]
-
-> getHomepage :: Handler RepHtml
-> getHomepage = hamletToRepHtml $ template Nothing
-
-> postHomepage :: Handler RepHtml
-> postHomepage = do
->     (_, files) <- runRequestBody
->     fi <- case lookup "yaml" files of
->             Nothing -> invalidArgs ["yaml: Missing input"]
->             Just x -> return x
->     so <- liftIO $ decode $ B.concat $ L.toChunks $ fileContent fi
->     hamletToRepHtml $ template $ Just $ objToHamlet so
-
-> objToHamlet :: StringObject -> HtmlUrl url
-> objToHamlet (Scalar s) = [hamlet|#{s}|]
-> objToHamlet (Sequence list) = [hamlet|
-> <ul
->     $forall o <- list
->         <li>^{objToHamlet o}
-> |]
-> objToHamlet (Mapping pairs) = [hamlet|
-> <dl
->     $forall pair <- pairs
->         <dt>#{fst pair}
->         <dd>^{objToHamlet $ snd pair}
-> |]
-
-> main :: IO ()
-> main = warpDebug 3000 PY
-
-> _ignored :: Widget
-> _ignored = undefined
diff --git a/yesod-examples/src/session.lhs b/yesod-examples/src/session.lhs
deleted file mode 100644
index 083783c7..00000000
--- a/yesod-examples/src/session.lhs
+++ /dev/null
@@ -1,39 +0,0 @@
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, TemplateHaskell, MultiParamTypeClasses, OverloadedStrings #-}
-> import Yesod
-> import Control.Applicative ((<$>), (<*>))
-> 
-> data Session = Session
-> mkYesod "Session" [parseRoutes|
-> / Root GET POST
-> |]
-> 
-> instance Yesod Session where
->     approot _ = ""
->     clientSessionDuration _ = 1
->
-> instance RenderMessage Session FormMessage where
->    renderMessage _ _ = defaultFormMessage
->
-> getRoot :: Handler RepHtml
-> getRoot = do
->     sess <- getSession
->     hamletToRepHtml [hamlet|
-> <form method=post
->     <input type=text name=key
->     <input type=text name=val
->     <input type=submit
-> <h1>#{show sess}
-> |]
-> 
-> postRoot :: Handler ()
-> postRoot = do
->       (key, val) <- runInputPost $ (,) <$> ireq textField "key" <*> ireq textField "val"
->       setSession key val
->       liftIO $ print (key, val)
->       redirect RedirectTemporary Root
->
-> main :: IO ()
-> main = warpDebug 3000 Session
-
-> _ignored :: Widget
-> _ignored = undefined
diff --git a/yesod-examples/src/tmp.hamlet b/yesod-examples/src/tmp.hamlet
deleted file mode 100644
index e69de29b..00000000
diff --git a/yesod-examples/src/widgets.lhs b/yesod-examples/src/widgets.lhs
deleted file mode 100644
index afa28ca0..00000000
--- a/yesod-examples/src/widgets.lhs
+++ /dev/null
@@ -1,92 +0,0 @@
-> {-# LANGUAGE TypeFamilies, QuasiQuotes, OverloadedStrings, MultiParamTypeClasses, TemplateHaskell #-}
-> import Yesod
-> import Yesod.Static
-> import Yesod.Form.Jquery
-> import Yesod.Form.Nic
-> import Control.Applicative
-> import Data.Text (unpack)
-> import Text.Blaze (string)
-> 
-> data HW = HW { hwStatic :: Static }
-> mkYesod "HW" [$parseRoutes|
-> / RootR GET
-> /form FormR
-> /static StaticR Static hwStatic
-> /autocomplete AutoCompleteR GET
-> |]
-> instance Yesod HW where approot _ = ""
-> instance YesodJquery HW
-> instance YesodNic HW
-> wrapper h = [hamlet|
-> <#wrapper>^{h}
-> <footer>Brought to you by Yesod Widgets&trade;
-> |]
-> instance RenderMessage HW FormMessage where
->    renderMessage _ _ = defaultFormMessage
->
-> getRootR = defaultLayout $ wrapper $ do
->     i <- lift newIdent
->     setTitle $ string "Hello Widgets"
->     addCassius [$cassius|
->   #$i$
->       color: red|]
->     addStylesheet $ StaticR $ StaticRoute ["style.css"] []
->     addStylesheetRemote "http://localhost:3000/static/style2.css"
->     addScriptRemote "http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"
->     addScript $ StaticR $ StaticRoute ["script.js"] []
->     addHamlet [$hamlet|
-> <h1 ##{i}>Welcome to my first widget!!!
-> <p
->     <a href=@RootR@>Recursive link.
-> <p
->     <a href=@FormR@>Check out the form.
-> <p .noscript>Your script did not load. :(
-> |]
->     addHtmlHead [$hamlet|<meta keywords=haskell|]
-> 
-> handleFormR = do
->     (res, form, enctype, nonce) <- runFormPost $ renderTable $ (,,,,,,,,)
->         <$> aopt textField "My Field" Nothing
->         <*> aopt textField "Another field" (Just "some default text")
->         <*> aopt intField "A number field" (Just 5)
->         <*> aopt jqueryDayField "A day field" Nothing
->         <*> aopt timeField "A time field" Nothing
->         <*> aopt boolField "A checkbox" (Just False)
->         <*> aopt jqueryAutocompleteField AutoCompleteR "Autocomplete" Nothing
->         <*> aopt nicHtmlField "HTML"
->                 (Just $ string "You can put <rich text> here")
->         <*> aopt emailField "An e-mail addres" Nothing
->     let mhtml = case res of
->                     FormSuccess (_, _, _, _, _, _, _, x, _) -> Just x
->                     _ -> Nothing
->     defaultLayout $ do
->         addCassius [$cassius|
-> .tooltip
->     color: #666
->     font-style: italic
-> textarea.html
->     width: 300px
->     height: 150px|]
->         addWidget [$hamlet|
-> <form method="post" enctype="#{enctype}">
->     <table>
->         \^{form}
->         <tr>
->             <td colspan="2">
->                 \#{nonce}
->                 <input type="submit">
->     $maybe html <- mhtml
->         \#{html}
-> |]
->         setTitle $ string "Form"
-> 
-> main = static "static" >>= (warpDebug 3000 . HW)
-> 
-> getAutoCompleteR :: Handler RepJson
-> getAutoCompleteR = do
->     term <- runInputGet $ ireq textField "term"
->     jsonToRepJson $ jsonList
->         [ jsonScalar $ unpack term ++ "foo"
->         , jsonScalar $ unpack term ++ "bar"
->         , jsonScalar $ unpack term ++ "baz"
->         ]
diff --git a/yesod-examples/static/chat.js b/yesod-examples/static/chat.js
deleted file mode 100644
index 3959f93c..00000000
--- a/yesod-examples/static/chat.js
+++ /dev/null
@@ -1,21 +0,0 @@
-$(document).ready(function () {
-    $("form").submit(function (e) {
-        e.preventDefault();
-        $.getJSON("/post", { name: $("#name").attr("value"), send: $("#send").attr("value") }, function(o) { });
-        $("#send").attr("value", "");
-    });
-
-    checkIn();
-
-});
-
-function checkIn () {
-    $.getJSON("/check", { client: clientNumber }, function(o) {
-        //alert("response: " + o);
-        var ta = $("textarea");
-        ta.html(ta.html() + o.sender + ": " + o.content + "\n");
-        ta.scrollTop(10000);
-
-        checkIn();
-    });
-}
diff --git a/yesod-examples/static/yesod/ajax/script.js b/yesod-examples/static/yesod/ajax/script.js
deleted file mode 100644
index 2ddfba79..00000000
--- a/yesod-examples/static/yesod/ajax/script.js
+++ /dev/null
@@ -1,9 +0,0 @@
-$(function(){
-  $("#navbar a").click(function(){
-    $.getJSON($(this).attr("href"), {}, function(o){
-      $("h1").html(o.name);
-      $("article").html(o.content);
-    });
-    return false;
-  });
-});
diff --git a/yesod-examples/static/yesod/ajax/style.css b/yesod-examples/static/yesod/ajax/style.css
deleted file mode 100644
index 6c780186..00000000
--- a/yesod-examples/static/yesod/ajax/style.css
+++ /dev/null
@@ -1,11 +0,0 @@
-#navbar {
-  width: 100px;
-  float: left;
-  background: #eee;
-  padding: 1em;
-  list-style: none;
-}
-
-#content {
-  margin-left: 230px;
-}
diff --git a/yesod-examples/synopsis/hamlet.lhs b/yesod-examples/synopsis/hamlet.lhs
deleted file mode 100644
index c885ccbc..00000000
--- a/yesod-examples/synopsis/hamlet.lhs
+++ /dev/null
@@ -1,74 +0,0 @@
-\begin{code}
-{-# LANGUAGE QuasiQuotes, OverloadedStrings #-}
-
-import Text.Hamlet
-import Data.Text (Text, cons)
-import qualified Data.Text.Lazy.IO as L
-import Text.Blaze.Renderer.Text (renderHtml)
-
-
-data Person = Person
-    { name :: String
-    , age :: String
-    , page :: PersonUrls
-    , isMarried :: Bool
-    , children :: [String]
-    }
-data PersonUrls = Homepage | PersonPage Text
-
-renderUrls :: PersonUrls -> [(Text, Text)] -> Text
-renderUrls Homepage _ = "/"
-renderUrls (PersonPage name') _ = '/' `cons` name'
-
-footer :: HtmlUrl url
-footer = [hamlet|
-<div id="footer">Thank you, come again
-|]
-
-template :: Person -> HtmlUrl PersonUrls
-template person = [hamlet|
-!!!
-
-<html>
-    <head>
-        <title>Hamlet Demo
-    <body>
-        <h1>Information on #{name person}
-        <p>#{name person} is #{age person} years old.
-        <h2>
-            $if isMarried person
-                \Married
-            $else
-                \Not married
-        <ul>
-            $forall child <- children person
-                <li>#{child}
-        <p>
-            <a href="@{page person}">See the page.
-        \^{footer}
-|]
-
-main :: IO ()
-main = do
-    let person = Person
-            { name = "Michael"
-            , age = "twenty five & a half"
-            , page = PersonPage "michael"
-            , isMarried = True
-            , children = ["Adam", "Ben", "Chris"]
-            }
-    L.putStrLn $ renderHtml $ (template person) renderUrls 
-\end{code}
-
-Outputs (new lines added for readability):
-<code><pre>
-    &lt;!DOCTYPE html&gt;
-    &lt;html&gt;&lt;head&gt;&lt;title&gt;Hamlet Demo&lt;/title&gt;&lt;/head&gt;&lt;body&gt;
-    &lt;h1&gt;Information on Michael&lt;/h1&gt;
-    &lt;p&gt;Michael is twenty five &amp; a half years old.&lt;/p&gt;
-    &lt;h2&gt;Married&lt;/h2&gt;
-    &lt;ul&gt;&lt;li&gt;Adam&lt;/li&gt;&lt;li&gt;Ben&lt;/li&gt;&lt;li&gt;Chris&lt;/li&gt;&lt;/ul&gt;
-    &lt;p&gt;&lt;a href="/michael"&gt;See the page.&lt;/a&gt;&lt;/p&gt;
-    &lt;div id="footer"&gt;Thank you, come again&lt;/div&gt;
-    &lt;/body&gt;&lt;/html&gt;
-</pre></code>
diff --git a/yesod-examples/synopsis/persistent.lhs b/yesod-examples/synopsis/persistent.lhs
deleted file mode 100644
index 095a01c6..00000000
--- a/yesod-examples/synopsis/persistent.lhs
+++ /dev/null
@@ -1,42 +0,0 @@
-This example uses the sqlite backend for Persistent, since it can run in-memory and has no external dependencies.
-
-> {-# LANGUAGE GADTs, TypeFamilies, GeneralizedNewtypeDeriving, QuasiQuotes, TemplateHaskell, OverloadedStrings #-}
->
-> import Database.Persist.Sqlite
-> import Database.Persist.TH
-> import Control.Monad.IO.Class (liftIO)
->
-> mkPersist sqlSettings [persist|Person
->     name String Eq
->     age Int Update
-> |]
->
-> main :: IO ()
-> main = withSqliteConn ":memory:" $ runSqlConn go
->
-> go :: SqlPersist IO ()
-> go = do
->   runMigration $ migrate (undefined :: Person)
->   key <- insert $ Person "Michael" 25
->   liftIO $ print key
->   p1 <- get key
->   liftIO $ print p1
->   update key [PersonAge =. 26]
->   p2 <- get key
->   liftIO $ print p2
->   p3 <- selectList [PersonName ==. "Michael"] []
->   liftIO $ print p3
->   delete key
->   p4 <- selectList [PersonName ==. "Michael"] []
->   liftIO $ print p4
-
-The output of the above is:
-
-<code><pre>PersonId 1
-Just (Person {personName = "Michael", personAge = 25})
-Just (Person {personName = "Michael", personAge = 26})
-[(PersonId 1,Person {personName = "Michael", personAge = 26})]
-[]</pre></code>
-
-> _ignored :: PersonId
-> _ignored = undefined personName personAge
diff --git a/yesod-examples/yesod-examples.cabal b/yesod-examples/yesod-examples.cabal
deleted file mode 100644
index a72bc5e5..00000000
--- a/yesod-examples/yesod-examples.cabal
+++ /dev/null
@@ -1,75 +0,0 @@
-Name:                yesod-examples
-Version:             0.9.0
-Synopsis:            Example programs using the Yesod Web Framework.
-Description:         These are the same examples and tutorials found on the documentation site.
-Homepage:            http://www.yesodweb.com/
-License:             BSD3
-License-file:        LICENSE
-Author:              Michael Snoyman
-Maintainer:          michael@snoyman.com
-Stability:           Experimental
-Category:            Web, Yesod
-Build-type:          Simple
-Cabal-version:       >=1.6
-extra-source-files:  static/yesod/ajax/script.js,
-                     static/yesod/ajax/style.css,
-                     static/chat.js
-
-flag ghc7
-
-Executable yesod-blog
-  Main-is:             src/blog.lhs
-  Build-depends:       base >= 4 && < 5,
-                       yesod >= 0.9
-
-Executable yesod-ajax
-  Main-is:             src/ajax.lhs
-  Build-depends:       yesod-static,
-                       blaze-html  >= 0.4.1.3  && < 0.5,
-                       yesod >= 0.9
-
-Executable yesod-file-echo
-  Main-is:             src/file-echo.lhs
-  Build-depends:       text              >= 0.9   && < 0.12,
-                       yesod >= 0.9
-
-Executable yesod-pretty-yaml
-  Main-is:             src/pretty-yaml.lhs
-  Build-depends:       data-object-yaml >= 0.3.0 && < 0.4,
-                       data-object >= 0.3.1 && < 0.4,
-                       bytestring                >= 0.9.1.4  && < 0.10,
-                       yesod >= 0.9
-
-Executable yesod-i18n
-  Main-is:             src/i18n.lhs
-  if flag(ghc7)
-      cpp-options:     -DGHC7
-
-Executable yesod-session
-  Main-is:             src/session.lhs
-
--- Executable yesod-widgets
---  Main-is:             src/widgets.lhs
---  Build-depends:       yesod-form
-
-Executable yesod-form
-  Main-is:             src/form.lhs
-
-Executable yesod-persistent-synopsis
-  Main-is:             synopsis/persistent.lhs
-  Build-depends:       transformers >= 0.2.2 && < 0.3,
-                       persistent-sqlite   >= 0.6 && < 0.7,
-                       persistent-template >= 0.6 && < 0.7
-  extra-libraries:     sqlite3
-
-Executable yesod-hamlet-synopsis
-  Main-is:             synopsis/hamlet.lhs
-  Build-depends:       hamlet, yesod-core
-
-Executable yesod-chat
-  Main-is:             src/chat.hs
-  Build-depends:       stm
-
-source-repository head
-  type:     git
-  location: https://github.com/yesodweb/yesod
diff --git a/yesod-form/Yesod/Form.hs b/yesod-form/Yesod/Form.hs
index e2f09afc..ae096f51 100644
--- a/yesod-form/Yesod/Form.hs
+++ b/yesod-form/Yesod/Form.hs
@@ -3,12 +3,10 @@ module Yesod.Form
     ( module Yesod.Form.Types
     , module Yesod.Form.Functions
     , module Yesod.Form.Fields
-    , module Yesod.Form.Class
     , module Yesod.Form.Input
     ) where
 
 import Yesod.Form.Types
 import Yesod.Form.Functions
 import Yesod.Form.Fields hiding (FormMessage (..))
-import Yesod.Form.Class
 import Yesod.Form.Input
diff --git a/yesod-form/Yesod/Form/Class.hs b/yesod-form/Yesod/Form/Class.hs
deleted file mode 100644
index 629a93ca..00000000
--- a/yesod-form/Yesod/Form/Class.hs
+++ /dev/null
@@ -1,78 +0,0 @@
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE FlexibleContexts #-}
-module Yesod.Form.Class
-    ( {- FIXME ToForm (..)
-    , -} ToField (..)
-    ) where
-
-import Text.Hamlet
-import Yesod.Form.Fields
-import Yesod.Form.Types
-import Yesod.Form.Functions (areq, aopt)
-import Data.Int (Int64)
-import Data.Time (Day, TimeOfDay)
-import Data.Text (Text)
-import Yesod.Message (RenderMessage)
-
-{-
-class ToForm a where
-    toForm :: AForm sub master a
--}
-
-class ToField a master where
-    toField :: RenderMessage master FormMessage
-            => FieldSettings master -> Maybe a -> AForm sub master a
-
-{- FIXME
-instance ToFormField String y where
-    toFormField = stringField
-instance ToFormField (Maybe String) y where
-    toFormField = maybeStringField
--}
-
-instance ToField Text master where
-    toField = areq textField
-instance ToField (Maybe Text) master where
-    toField = aopt textField
-
-instance ToField Int master where
-    toField = areq intField
-instance ToField (Maybe Int) master where
-    toField = aopt intField
-
-instance ToField Int64 master where
-    toField = areq intField
-instance ToField (Maybe Int64) master where
-    toField = aopt intField
-
-instance ToField Double master where
-    toField = areq doubleField
-instance ToField (Maybe Double) master where
-    toField = aopt doubleField
-
-instance ToField Day master where
-    toField = areq dayField
-instance ToField (Maybe Day) master where
-    toField = aopt dayField
-
-instance ToField TimeOfDay master where
-    toField = areq timeField
-instance ToField (Maybe TimeOfDay) master where
-    toField = aopt timeField
-
-instance ToField Html master where
-    toField = areq htmlField
-instance ToField (Maybe Html) master where
-    toField = aopt htmlField
-
-instance ToField Textarea master where
-    toField = areq textareaField
-instance ToField (Maybe Textarea) master where
-    toField = aopt textareaField
-
-{- FIXME
-instance ToFormField Bool y where
-    toFormField = boolField
--}
diff --git a/yesod-form/Yesod/Form/Fields.hs b/yesod-form/Yesod/Form/Fields.hs
index adc59deb..bd675b56 100644
--- a/yesod-form/Yesod/Form/Fields.hs
+++ b/yesod-form/Yesod/Form/Fields.hs
@@ -49,24 +49,20 @@ module Yesod.Form.Fields
 import Yesod.Form.Types
 import Yesod.Form.I18n.English
 import Yesod.Form.Functions (parseHelper)
-import Yesod.Handler (getMessageRender)
-import Yesod.Widget (toWidget, whamlet, GWidget)
-import Yesod.Message (RenderMessage (renderMessage), SomeMessage (..))
+import Yesod.Core
 import Text.Hamlet
-import Text.Blaze (ToMarkup (toMarkup), preEscapedToMarkup, unsafeByteString)
+import Text.Blaze (ToMarkup (toMarkup), unsafeByteString)
 #define ToHtml ToMarkup
 #define toHtml toMarkup
 #define preEscapedText preEscapedToMarkup
 import Text.Cassius
 import Data.Time (Day, TimeOfDay(..))
 import qualified Text.Email.Validate as Email
-#if MIN_VERSION_email_validate(1, 0, 0)
 import Data.Text.Encoding (encodeUtf8, decodeUtf8With)
 import Data.Text.Encoding.Error (lenientDecode)
-#endif
 import Network.URI (parseURI)
-import Database.Persist (PersistField)
-import Database.Persist.Store (Entity (..))
+import Database.Persist.Sql (PersistField, PersistFieldSql)
+import Database.Persist (Entity (..))
 import Text.HTML.SanitizeXSS (sanitizeBalance)
 import Control.Monad (when, unless)
 import Data.Maybe (listToMaybe, fromMaybe)
@@ -74,10 +70,7 @@ import Data.Maybe (listToMaybe, fromMaybe)
 import qualified Blaze.ByteString.Builder.Html.Utf8 as B
 import Blaze.ByteString.Builder (writeByteString, toLazyByteString)
 import Blaze.ByteString.Builder.Internal.Write (fromWriteList)
-import Database.Persist.Store (PersistEntityBackend)
-#if MIN_VERSION_persistent(1, 1, 0)
-import Database.Persist.Store (PersistMonadBackend)
-#endif
+import Database.Persist (PersistMonadBackend, PersistEntityBackend)
 
 import Text.Blaze.Html.Renderer.String (renderHtml)
 import qualified Data.ByteString as S
@@ -86,11 +79,7 @@ import Data.Text (Text, unpack, pack)
 import qualified Data.Text.Read
 
 import qualified Data.Map as Map
-import Yesod.Handler (newIdent, lift)
-import Yesod.Request (FileInfo)
-
-import Yesod.Core (toPathPiece, GHandler, PathPiece, fromPathPiece)
-import Yesod.Persist (selectList, runDB, Filter, SelectOpt, YesodPersistBackend, Key, YesodPersist, PersistEntity, PersistQuery)
+import Yesod.Persist (selectList, runDB, Filter, SelectOpt, Key, YesodPersist, PersistEntity, PersistQuery, YesodDB)
 import Control.Arrow ((&&&))
 
 import Control.Applicative ((<$>), (<|>))
@@ -101,7 +90,7 @@ defaultFormMessage :: FormMessage -> Text
 defaultFormMessage = englishFormMessage
 
 
-intField :: (Integral i, RenderMessage master FormMessage) => Field sub master i
+intField :: (Monad m, Integral i, RenderMessage (HandlerSite m) FormMessage) => Field m i
 intField = Field
     { fieldParse = parseHelper $ \s ->
         case Data.Text.Read.signed Data.Text.Read.decimal s of
@@ -118,7 +107,7 @@ $newline never
     showVal = either id (pack . showI)
     showI x = show (fromIntegral x :: Integer)
 
-doubleField :: RenderMessage master FormMessage => Field sub master Double
+doubleField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Double
 doubleField = Field
     { fieldParse = parseHelper $ \s ->
         case Data.Text.Read.double s of
@@ -133,7 +122,7 @@ $newline never
     }
   where showVal = either id (pack . show)
 
-dayField :: RenderMessage master FormMessage => Field sub master Day
+dayField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Day
 dayField = Field
     { fieldParse = parseHelper $ parseDate . unpack
     , fieldView = \theId name attrs val isReq -> toWidget [hamlet|
@@ -144,7 +133,7 @@ $newline never
     }
   where showVal = either id (pack . show)
 
-timeField :: RenderMessage master FormMessage => Field sub master TimeOfDay
+timeField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m TimeOfDay
 timeField = Field
     { fieldParse = parseHelper parseTime
     , fieldView = \theId name attrs val isReq -> toWidget [hamlet|
@@ -160,7 +149,7 @@ $newline never
       where
         fullSec = fromInteger $ floor $ todSec tod
 
-htmlField :: RenderMessage master FormMessage => Field sub master Html
+htmlField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Html
 htmlField = Field
     { fieldParse = parseHelper $ Right . preEscapedText . sanitizeBalance
     , fieldView = \theId name attrs val _isReq -> toWidget [hamlet|
@@ -174,7 +163,7 @@ $newline never
 -- | A newtype wrapper around a 'Text' that converts newlines to HTML
 -- br-tags.
 newtype Textarea = Textarea { unTextarea :: Text }
-    deriving (Show, Read, Eq, PersistField, Ord)
+    deriving (Show, Read, Eq, PersistField, PersistFieldSql, Ord)
 instance ToHtml Textarea where
     toHtml =
         unsafeByteString
@@ -189,7 +178,7 @@ instance ToHtml Textarea where
         writeHtmlEscapedChar '\n' = writeByteString "<br>"
         writeHtmlEscapedChar c    = B.writeHtmlEscapedChar c
 
-textareaField :: RenderMessage master FormMessage => Field sub master Textarea
+textareaField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Textarea
 textareaField = Field
     { fieldParse = parseHelper $ Right . Textarea
     , fieldView = \theId name attrs val _isReq -> toWidget [hamlet|
@@ -199,8 +188,8 @@ $newline never
     , fieldEnctype = UrlEncoded
     }
 
-hiddenField :: (PathPiece p, RenderMessage master FormMessage)
-            => Field sub master p
+hiddenField :: (Monad m, PathPiece p, RenderMessage (HandlerSite m) FormMessage)
+            => Field m p
 hiddenField = Field
     { fieldParse = parseHelper $ maybe (Left MsgValueRequired) Right . fromPathPiece
     , fieldView = \theId name attrs val _isReq -> toWidget [hamlet|
@@ -210,7 +199,7 @@ $newline never
     , fieldEnctype = UrlEncoded
     }
 
-textField :: RenderMessage master FormMessage => Field sub master Text
+textField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Text
 textField = Field
     { fieldParse = parseHelper $ Right
     , fieldView = \theId name attrs val isReq ->
@@ -221,7 +210,7 @@ $newline never
     , fieldEnctype = UrlEncoded
     }
 
-passwordField :: RenderMessage master FormMessage => Field sub master Text
+passwordField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Text
 passwordField = Field
     { fieldParse = parseHelper $ Right
     , fieldView = \theId name attrs val isReq -> toWidget [hamlet|
@@ -292,19 +281,13 @@ timeParser = do
             then fail $ show $ msg $ pack xy
             else return $ fromIntegral (i :: Int)
 
-emailField :: RenderMessage master FormMessage => Field sub master Text
+emailField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Text
 emailField = Field
     { fieldParse = parseHelper $
-#if MIN_VERSION_email_validate(1, 0, 0)
         \s ->
             case Email.canonicalizeEmail $ encodeUtf8 s of
                 Just e -> Right $ decodeUtf8With lenientDecode e
                 Nothing -> Left $ MsgInvalidEmail s
-#else
-        \s -> if Email.isValid (unpack s)
-                then Right s
-                else Left $ MsgInvalidEmail s
-#endif
     , fieldView = \theId name attrs val isReq -> toWidget [hamlet|
 $newline never
 <input id="#{theId}" name="#{name}" *{attrs} type="email" :isReq:required="" value="#{either id id val}">
@@ -313,7 +296,7 @@ $newline never
     }
 
 type AutoFocus = Bool
-searchField :: RenderMessage master FormMessage => AutoFocus -> Field sub master Text
+searchField :: Monad m => RenderMessage (HandlerSite m) FormMessage => AutoFocus -> Field m Text
 searchField autoFocus = Field
     { fieldParse = parseHelper Right
     , fieldView = \theId name attrs val isReq -> do
@@ -334,24 +317,25 @@ $newline never
     , fieldEnctype = UrlEncoded
     }
 
-urlField :: RenderMessage master FormMessage => Field sub master Text
+urlField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Text
 urlField = Field
     { fieldParse = parseHelper $ \s ->
         case parseURI $ unpack s of
             Nothing -> Left $ MsgInvalidUrl s
             Just _ -> Right s
     , fieldView = \theId name attrs val isReq ->
-        [whamlet|
-$newline never
-<input ##{theId} name=#{name} *{attrs} type=url :isReq:required value=#{either id id val}>
-|]
+        [whamlet|<input ##{theId} name=#{name} *{attrs} type=url :isReq:required value=#{either id id val}>|]
     , fieldEnctype = UrlEncoded
     }
 
-selectFieldList :: (Eq a, RenderMessage master FormMessage, RenderMessage master msg) => [(msg, a)] -> Field sub master a
+selectFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg)
+                => [(msg, a)]
+                -> Field (HandlerT site IO) a
 selectFieldList = selectField . optionsPairs
 
-selectField :: (Eq a, RenderMessage master FormMessage) => GHandler sub master (OptionList a) -> Field sub master a
+selectField :: (Eq a, RenderMessage site FormMessage)
+            => HandlerT site IO (OptionList a)
+            -> Field (HandlerT site IO) a
 selectField = selectFieldHelper
     (\theId name attrs inside -> [whamlet|
 $newline never
@@ -366,12 +350,14 @@ $newline never
 <option value=#{value} :isSel:selected>#{text}
 |]) -- inside
 
-multiSelectFieldList :: (Eq a, RenderMessage master FormMessage, RenderMessage master msg) => [(msg, a)] -> Field sub master [a]
+multiSelectFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg)
+                     => [(msg, a)]
+                     -> Field (HandlerT site IO) [a]
 multiSelectFieldList = multiSelectField . optionsPairs
 
-multiSelectField :: (Eq a, RenderMessage master FormMessage)
-                 => GHandler sub master (OptionList a)
-                 -> Field sub master [a]
+multiSelectField :: (Eq a, RenderMessage site FormMessage)
+                 => HandlerT site IO (OptionList a)
+                 -> Field (HandlerT site IO) [a]
 multiSelectField ioptlist =
     Field parse view UrlEncoded
   where
@@ -383,10 +369,9 @@ multiSelectField ioptlist =
              Just res -> return $ Right $ Just res
 
     view theId name attrs val isReq = do
-        opts <- fmap olOptions $ lift ioptlist
+        opts <- fmap olOptions $ handlerToWidget ioptlist
         let selOpts = map (id &&& (optselected val)) opts
         [whamlet|
-$newline never
             <select ##{theId} name=#{name} :isReq:required multiple *{attrs}>
                 $forall (opt, optsel) <- selOpts
                     <option value=#{optionExternalValue opt} :optsel:selected>#{optionDisplay opt}
@@ -395,10 +380,14 @@ $newline never
             optselected (Left _) _ = False
             optselected (Right vals) opt = (optionInternalValue opt) `elem` vals
 
-radioFieldList :: (Eq a, RenderMessage master FormMessage, RenderMessage master msg) => [(msg, a)] -> Field sub master a
+radioFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg)
+               => [(msg, a)]
+               -> Field (HandlerT site IO) a
 radioFieldList = radioField . optionsPairs
 
-radioField :: (Eq a, RenderMessage master FormMessage) => GHandler sub master (OptionList a) -> Field sub master a
+radioField :: (Eq a, RenderMessage site FormMessage)
+           => HandlerT site IO (OptionList a)
+           -> Field (HandlerT site IO) a
 radioField = selectFieldHelper
     (\theId _name _attrs inside -> [whamlet|
 $newline never
@@ -419,7 +408,7 @@ $newline never
         \#{text}
 |])
 
-boolField :: RenderMessage master FormMessage => Field sub master Bool
+boolField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Bool
 boolField = Field
       { fieldParse = \e _ -> return $ boolParser e
       , fieldView = \theId name attrs val isReq -> [whamlet|
@@ -455,7 +444,7 @@ $newline never
 --
 --   Note that this makes the field always optional.
 --
-checkBoxField :: RenderMessage m FormMessage => Field s m Bool
+checkBoxField :: Monad m => RenderMessage (HandlerSite m) FormMessage => Field m Bool
 checkBoxField = Field
     { fieldParse = \e _ -> return $ checkBoxParser e
     , fieldView  = \theId name attrs val _ -> [whamlet|
@@ -491,7 +480,8 @@ data Option a = Option
     , optionExternalValue :: Text
     }
 
-optionsPairs :: RenderMessage master msg => [(msg, a)] -> GHandler sub master (OptionList a)
+optionsPairs :: (MonadHandler m, RenderMessage (HandlerSite m) msg)
+             => [(msg, a)] -> m (OptionList a)
 optionsPairs opts = do
   mr <- getMessageRender
   let mkOption external (display, internal) =
@@ -501,22 +491,19 @@ optionsPairs opts = do
                  }
   return $ mkOptionList (zipWith mkOption [1 :: Int ..] opts)
 
-optionsEnum :: (Show a, Enum a, Bounded a) => GHandler sub master (OptionList a)
+optionsEnum :: (MonadHandler m, Show a, Enum a, Bounded a) => m (OptionList a)
 optionsEnum = optionsPairs $ map (\x -> (pack $ show x, x)) [minBound..maxBound]
 
-optionsPersist :: ( YesodPersist master, PersistEntity a
-#if MIN_VERSION_persistent(1, 1, 0)
-                  , PersistQuery (YesodPersistBackend master (GHandler sub master))
+optionsPersist :: ( YesodPersist site, PersistEntity a
+                  , PersistQuery (YesodDB site)
                   , PathPiece (Key a)
-                  , PersistEntityBackend a ~ PersistMonadBackend (YesodPersistBackend master (GHandler sub master))
-#else
-                  , PersistQuery (YesodPersistBackend master) (GHandler sub master)
-                  , PathPiece (Key (YesodPersistBackend master) a)
-                  , PersistEntityBackend a ~ YesodPersistBackend master
-#endif
-                  , RenderMessage master msg
+                  , PersistEntityBackend a ~ PersistMonadBackend (YesodDB site)
+                  , RenderMessage site msg
                   )
-               => [Filter a] -> [SelectOpt a] -> (a -> msg) -> GHandler sub master (OptionList (Entity a))
+               => [Filter a]
+               -> [SelectOpt a]
+               -> (a -> msg)
+               -> HandlerT site IO (OptionList (Entity a))
 optionsPersist filts ords toDisplay = fmap mkOptionList $ do
     mr <- getMessageRender
     pairs <- runDB $ selectList filts ords
@@ -527,17 +514,18 @@ optionsPersist filts ords toDisplay = fmap mkOptionList $ do
         }) pairs
 
 selectFieldHelper
-        :: (Eq a, RenderMessage master FormMessage)
-        => (Text -> Text -> [(Text, Text)] -> GWidget sub master () -> GWidget sub master ())
-        -> (Text -> Text -> Bool -> GWidget sub master ())
-        -> (Text -> Text -> [(Text, Text)] -> Text -> Bool -> Text -> GWidget sub master ())
-        -> GHandler sub master (OptionList a) -> Field sub master a
+        :: (Eq a, RenderMessage site FormMessage)
+        => (Text -> Text -> [(Text, Text)] -> WidgetT site IO () -> WidgetT site IO ())
+        -> (Text -> Text -> Bool -> WidgetT site IO ())
+        -> (Text -> Text -> [(Text, Text)] -> Text -> Bool -> Text -> WidgetT site IO ())
+        -> HandlerT site IO (OptionList a)
+        -> Field (HandlerT site IO) a
 selectFieldHelper outside onOpt inside opts' = Field
     { fieldParse = \x _ -> do
         opts <- opts'
         return $ selectParser opts x
     , fieldView = \theId name attrs val isReq -> do
-        opts <- fmap olOptions $ lift opts'
+        opts <- fmap olOptions $ handlerToWidget opts'
         outside theId name attrs $ do
             unless isReq $ onOpt theId name $ not $ render opts val `elem` map optionExternalValue opts
             flip mapM_ opts $ \opt -> inside
@@ -560,7 +548,8 @@ selectFieldHelper outside onOpt inside opts' = Field
                     Nothing -> Left $ SomeMessage $ MsgInvalidEntry x
                     Just y -> Right $ Just y
 
-fileField :: RenderMessage master FormMessage => Field sub master FileInfo
+fileField :: (Monad m, RenderMessage (HandlerSite m) FormMessage)
+          => Field m FileInfo
 fileField = Field
     { fieldParse = \_ files -> return $
         case files of
@@ -572,8 +561,9 @@ fileField = Field
     , fieldEnctype = Multipart
     }
 
-fileAFormReq :: RenderMessage master FormMessage => FieldSettings master -> AForm sub master FileInfo
-fileAFormReq fs = AForm $ \(master, langs) menvs ints -> do
+fileAFormReq :: (MonadHandler m, RenderMessage (HandlerSite m) FormMessage)
+             => FieldSettings (HandlerSite m) -> AForm m FileInfo
+fileAFormReq fs = AForm $ \(site, langs) menvs ints -> do
     let (name, ints') =
             case fsName fs of
                 Just x -> (x, ints)
@@ -588,11 +578,11 @@ fileAFormReq fs = AForm $ \(master, langs) menvs ints -> do
                     case Map.lookup name fenv of
                         Just (fi:_) -> (FormSuccess fi, Nothing)
                         _ ->
-                            let t = renderMessage master langs MsgValueRequired
+                            let t = renderMessage site langs MsgValueRequired
                              in (FormFailure [t], Just $ toHtml t)
     let fv = FieldView
-            { fvLabel = toHtml $ renderMessage master langs $ fsLabel fs
-            , fvTooltip = fmap (toHtml . renderMessage master langs) $ fsTooltip fs
+            { fvLabel = toHtml $ renderMessage site langs $ fsLabel fs
+            , fvTooltip = fmap (toHtml . renderMessage site langs) $ fsTooltip fs
             , fvId = id'
             , fvInput = [whamlet|
 $newline never
@@ -603,7 +593,10 @@ $newline never
             }
     return (res, (fv :), ints', Multipart)
 
-fileAFormOpt :: RenderMessage master FormMessage => FieldSettings master -> AForm sub master (Maybe FileInfo)
+fileAFormOpt :: MonadHandler m
+             => RenderMessage (HandlerSite m) FormMessage
+             => FieldSettings (HandlerSite m)
+             -> AForm m (Maybe FileInfo)
 fileAFormOpt fs = AForm $ \(master, langs) menvs ints -> do
     let (name, ints') =
             case fsName fs of
diff --git a/yesod-form/Yesod/Form/Functions.hs b/yesod-form/Yesod/Form/Functions.hs
index db3e4933..82641317 100644
--- a/yesod-form/Yesod/Form/Functions.hs
+++ b/yesod-form/Yesod/Form/Functions.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE FlexibleContexts #-}
@@ -27,18 +28,16 @@ module Yesod.Form.Functions
     , FormRender
     , renderTable
     , renderDivs
-    , renderDivsNoLabels 
+    , renderDivsNoLabels
     , renderBootstrap
       -- * Validation
     , check
     , checkBool
     , checkM
     , checkMMap
-    , checkMMod
     , customErrorMessage
       -- * Utilities
     , fieldSettingsLabel
-    , aformM
     , parseHelper
     ) where
 
@@ -46,29 +45,23 @@ import Yesod.Form.Types
 import Data.Text (Text, pack)
 import Control.Arrow (second)
 import Control.Monad.Trans.RWS (ask, get, put, runRWST, tell, evalRWST)
-import Control.Monad.Trans.Class (lift)
+import Control.Monad.Trans.Class
 import Control.Monad (liftM, join)
 import Crypto.Classes (constTimeEq)
 import Text.Blaze (Markup, toMarkup)
 #define Html Markup
 #define toHtml toMarkup
-import Yesod.Handler (GHandler, getRequest, runRequestBody, newIdent, getYesod)
-import Yesod.Core (RenderMessage, SomeMessage (..))
-import Yesod.Widget (GWidget, whamlet)
-import Yesod.Request (reqToken, reqWaiRequest, reqGetParams, languages)
+import Yesod.Core
 import Network.Wai (requestMethod)
 import Text.Hamlet (shamlet)
 import Data.Monoid (mempty)
 import Data.Maybe (listToMaybe, fromMaybe)
-import Yesod.Message (RenderMessage (..))
 import qualified Data.Map as Map
 import qualified Data.Text.Encoding as TE
-import Control.Applicative ((<$>))
 import Control.Arrow (first)
-import Yesod.Request (FileInfo)
 
 -- | Get a unique identifier.
-newFormIdent :: MForm sub master Text
+newFormIdent :: Monad m => MForm m Text
 newFormIdent = do
     i <- get
     let i' = incrInts i
@@ -78,54 +71,64 @@ newFormIdent = do
     incrInts (IntSingle i) = IntSingle $ i + 1
     incrInts (IntCons i is) = (i + 1) `IntCons` is
 
-formToAForm :: MForm sub master (FormResult a, [FieldView sub master]) -> AForm sub master a
-formToAForm form = AForm $ \(master, langs) env ints -> do
-    ((a, xmls), ints', enc) <- runRWST form (env, master, langs) ints
+formToAForm :: (HandlerSite m ~ site, Monad m)
+            => MForm m (FormResult a, [FieldView site])
+            -> AForm m a
+formToAForm form = AForm $ \(site, langs) env ints -> do
+    ((a, xmls), ints', enc) <- runRWST form (env, site, langs) ints
     return (a, (++) xmls, ints', enc)
 
-aFormToForm :: AForm sub master a -> MForm sub master (FormResult a, [FieldView sub master] -> [FieldView sub master])
+aFormToForm :: (Monad m, HandlerSite m ~ site)
+            => AForm m a
+            -> MForm m (FormResult a, [FieldView site] -> [FieldView site])
 aFormToForm (AForm aform) = do
     ints <- get
-    (env, master, langs) <- ask
-    (a, xml, ints', enc) <- lift $ aform (master, langs) env ints
+    (env, site, langs) <- ask
+    (a, xml, ints', enc) <- lift $ aform (site, langs) env ints
     put ints'
     tell enc
     return (a, xml)
 
-askParams :: MForm sub master (Maybe Env)
+askParams :: Monad m => MForm m (Maybe Env)
 askParams = do
     (x, _, _) <- ask
     return $ liftM fst x
 
-askFiles :: MForm sub master (Maybe FileEnv)
+askFiles :: Monad m => MForm m (Maybe FileEnv)
 askFiles = do
     (x, _, _) <- ask
     return $ liftM snd x
 
-mreq :: RenderMessage master FormMessage
-     => Field sub master a -> FieldSettings master -> Maybe a
-     -> MForm sub master (FormResult a, FieldView sub master)
+mreq :: (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m)
+     => Field m a
+     -> FieldSettings site
+     -> Maybe a
+     -> MForm m (FormResult a, FieldView site)
 mreq field fs mdef = mhelper field fs mdef (\m l -> FormFailure [renderMessage m l MsgValueRequired]) FormSuccess True
 
-mopt :: Field sub master a -> FieldSettings master -> Maybe (Maybe a)
-     -> MForm sub master (FormResult (Maybe a), FieldView sub master)
+mopt :: (site ~ HandlerSite m, MonadHandler m)
+     => Field m a
+     -> FieldSettings site
+     -> Maybe (Maybe a)
+     -> MForm m (FormResult (Maybe a), FieldView site)
 mopt field fs mdef = mhelper field fs (join mdef) (const $ const $ FormSuccess Nothing) (FormSuccess . Just) False
 
-mhelper :: Field sub master a
-        -> FieldSettings master
+mhelper :: (site ~ HandlerSite m, MonadHandler m)
+        => Field m a
+        -> FieldSettings site
         -> Maybe a
-        -> (master -> [Text] -> FormResult b) -- ^ on missing
+        -> (site -> [Text] -> FormResult b) -- ^ on missing
         -> (a -> FormResult b) -- ^ on success
         -> Bool -- ^ is it required?
-        -> MForm sub master (FormResult b, FieldView sub master)
+        -> MForm m (FormResult b, FieldView site)
 
 mhelper Field {..} FieldSettings {..} mdef onMissing onFound isReq = do
     tell fieldEnctype
     mp <- askParams
     name <- maybe newFormIdent return fsName
     theId <- lift $ maybe newIdent return fsId
-    (_, master, langs) <- ask
-    let mr2 = renderMessage master langs
+    (_, site, langs) <- ask
+    let mr2 = renderMessage site langs
     (res, val) <-
         case mp of
             Nothing -> return (FormMissing, maybe (Left "") Right mdef)
@@ -135,10 +138,10 @@ mhelper Field {..} FieldSettings {..} mdef onMissing onFound isReq = do
                     files = fromMaybe [] $ mfs >>= Map.lookup name
                 emx <- lift $ fieldParse mvals files
                 return $ case emx of
-                    Left (SomeMessage e) -> (FormFailure [renderMessage master langs e], maybe (Left "") Left (listToMaybe mvals))
+                    Left (SomeMessage e) -> (FormFailure [renderMessage site langs e], maybe (Left "") Left (listToMaybe mvals))
                     Right mx ->
                         case mx of
-                            Nothing -> (onMissing master langs, Left "")
+                            Nothing -> (onMissing site langs, Left "")
                             Just x -> (onFound x, Right x)
     return (res, FieldView
         { fvLabel = toHtml $ mr2 fsLabel
@@ -152,19 +155,27 @@ mhelper Field {..} FieldSettings {..} mdef onMissing onFound isReq = do
         , fvRequired = isReq
         })
 
-areq :: RenderMessage master FormMessage
-     => Field sub master a -> FieldSettings master -> Maybe a
-     -> AForm sub master a
-areq a b = formToAForm . fmap (second return) . mreq a b
+areq :: (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m)
+     => Field m a
+     -> FieldSettings site
+     -> Maybe a
+     -> AForm m a
+areq a b = formToAForm . liftM (second return) . mreq a b
 
-aopt :: Field sub master a
-     -> FieldSettings master
+aopt :: MonadHandler m
+     => Field m a
+     -> FieldSettings (HandlerSite m)
      -> Maybe (Maybe a)
-     -> AForm sub master (Maybe a)
-aopt a b = formToAForm . fmap (second return) . mopt a b
+     -> AForm m (Maybe a)
+aopt a b = formToAForm . liftM (second return) . mopt a b
 
-runFormGeneric :: MForm sub master a -> master -> [Text] -> Maybe (Env, FileEnv) -> GHandler sub master (a, Enctype)
-runFormGeneric form master langs env = evalRWST form (env, master, langs) (IntSingle 1)
+runFormGeneric :: Monad m
+               => MForm m a
+               -> HandlerSite m
+               -> [Text]
+               -> Maybe (Env, FileEnv)
+               -> m (a, Enctype)
+runFormGeneric form site langs env = evalRWST form (env, site, langs) (IntSingle 1)
 
 -- | This function is used to both initially render a form and to later extract
 -- results from it. Note that, due to CSRF protection and a few other issues,
@@ -175,27 +186,24 @@ runFormGeneric form master langs env = evalRWST form (env, master, langs) (IntSi
 -- For example, a common case is displaying a form on a GET request and having
 -- the form submit to a POST page. In such a case, both the GET and POST
 -- handlers should use 'runFormPost'.
-runFormPost :: RenderMessage master FormMessage
-            => (Html -> MForm sub master (FormResult a, xml))
-            -> GHandler sub master ((FormResult a, xml), Enctype)
+runFormPost :: (RenderMessage (HandlerSite m) FormMessage, MonadResource m, MonadHandler m)
+            => (Html -> MForm m (FormResult a, xml))
+            -> m ((FormResult a, xml), Enctype)
 runFormPost form = do
     env <- postEnv
     postHelper form env
 
-postHelper  :: RenderMessage master FormMessage
-            => (Html -> MForm sub master (FormResult a, xml))
+postHelper  :: (MonadHandler m, RenderMessage (HandlerSite m) FormMessage)
+            => (Html -> MForm m (FormResult a, xml))
             -> Maybe (Env, FileEnv)
-            -> GHandler sub master ((FormResult a, xml), Enctype)
+            -> m ((FormResult a, xml), Enctype)
 postHelper form env = do
     req <- getRequest
     let tokenKey = "_token"
     let token =
             case reqToken req of
                 Nothing -> mempty
-                Just n -> [shamlet|
-$newline never
-<input type=hidden name=#{tokenKey} value=#{n}>
-|]
+                Just n -> [shamlet|<input type=hidden name=#{tokenKey} value=#{n}>|]
     m <- getYesod
     langs <- languages
     ((res, xml), enctype) <- runFormGeneric (form token) m langs env
@@ -215,12 +223,13 @@ $newline never
 -- page will both receive and incoming form and produce a new, blank form. For
 -- general usage, you can stick with @runFormPost@.
 generateFormPost
-    :: RenderMessage master FormMessage
-    => (Html -> MForm sub master (FormResult a, xml))
-    -> GHandler sub master (xml, Enctype)
-generateFormPost form = first snd <$> postHelper form Nothing
+    :: (RenderMessage (HandlerSite m) FormMessage, MonadHandler m)
+    => (Html -> MForm m (FormResult a, xml))
+    -> m (xml, Enctype)
+generateFormPost form = first snd `liftM` postHelper form Nothing
 
-postEnv :: GHandler sub master (Maybe (Env, FileEnv))
+postEnv :: (MonadHandler m, MonadResource m)
+        => m (Maybe (Env, FileEnv))
 postEnv = do
     req <- getRequest
     if requestMethod (reqWaiRequest req) == "GET"
@@ -230,14 +239,18 @@ postEnv = do
             let p' = Map.unionsWith (++) $ map (\(x, y) -> Map.singleton x [y]) p
             return $ Just (p', Map.unionsWith (++) $ map (\(k, v) -> Map.singleton k [v]) f)
 
-runFormPostNoToken :: (Html -> MForm sub master (FormResult a, xml)) -> GHandler sub master ((FormResult a, xml), Enctype)
+runFormPostNoToken :: MonadHandler m
+                   => (Html -> MForm m (FormResult a, xml))
+                   -> m ((FormResult a, xml), Enctype)
 runFormPostNoToken form = do
     langs <- languages
     m <- getYesod
     env <- postEnv
     runFormGeneric (form mempty) m langs env
 
-runFormGet :: (Html -> MForm sub master a) -> GHandler sub master (a, Enctype)
+runFormGet :: MonadHandler m
+           => (Html -> MForm m a)
+           -> m (a, Enctype)
 runFormGet form = do
     gets <- liftM reqGetParams getRequest
     let env =
@@ -246,28 +259,30 @@ runFormGet form = do
                 Just _ -> Just (Map.unionsWith (++) $ map (\(x, y) -> Map.singleton x [y]) gets, Map.empty)
     getHelper form env
 
-generateFormGet :: (Html -> MForm sub master a) -> GHandler sub master (a, Enctype)
+generateFormGet :: MonadHandler m
+                => (Html -> MForm m a)
+                -> m (a, Enctype)
 generateFormGet form = getHelper form Nothing
 
 getKey :: Text
 getKey = "_hasdata"
 
-getHelper :: (Html -> MForm sub master a) -> Maybe (Env, FileEnv) -> GHandler sub master (a, Enctype)
+getHelper :: MonadHandler m
+          => (Html -> MForm m a)
+          -> Maybe (Env, FileEnv)
+          -> m (a, Enctype)
 getHelper form env = do
-    let fragment = [shamlet|
-$newline never
-<input type=hidden name=#{getKey}>
-|]
+    let fragment = [shamlet|<input type=hidden name=#{getKey}>|]
     langs <- languages
     m <- getYesod
     runFormGeneric (form fragment) m langs env
 
-type FormRender sub master a =
-       AForm sub master a
+type FormRender m a =
+       AForm m a
     -> Html
-    -> MForm sub master (FormResult a, GWidget sub master ())
+    -> MForm m (FormResult a, WidgetT (HandlerSite m) IO ())
 
-renderTable, renderDivs, renderDivsNoLabels :: FormRender sub master a
+renderTable, renderDivs, renderDivsNoLabels :: Monad m => FormRender m a
 renderTable aform fragment = do
     (res, views') <- aFormToForm aform
     let views = views' []
@@ -292,7 +307,7 @@ renderDivs = renderDivsMaybeLabels True
 -- | render a field inside a div, not displaying any label
 renderDivsNoLabels = renderDivsMaybeLabels False
 
-renderDivsMaybeLabels :: Bool -> FormRender sub master a
+renderDivsMaybeLabels :: Monad m => Bool -> FormRender m a
 renderDivsMaybeLabels withLabels aform fragment = do
     (res, views') <- aFormToForm aform
     let views = views' []
@@ -326,40 +341,42 @@ $forall view <- views
 -- >      ^{formWidget}
 -- >      <div .form-actions>
 -- >        <input .btn .primary type=submit value=_{MsgSubmit}>
-renderBootstrap :: FormRender sub master a
+renderBootstrap :: Monad m => FormRender m a
 renderBootstrap aform fragment = do
     (res, views') <- aFormToForm aform
     let views = views' []
         has (Just _) = True
         has Nothing  = False
     let widget = [whamlet|
-$newline never
-\#{fragment}
-$forall view <- views
-    <div .control-group .clearfix :fvRequired view:.required :not $ fvRequired view:.optional :has $ fvErrors view:.error>
-        <label .control-label for=#{fvId view}>#{fvLabel view}
-        <div .controls .input>
-            ^{fvInput view}
-            $maybe tt <- fvTooltip view
-                <span .help-block>#{tt}
-            $maybe err <- fvErrors view
-                <span .help-block>#{err}
-|]
+                $newline never
+                \#{fragment}
+                $forall view <- views
+                    <div .control-group .clearfix :fvRequired view:.required :not $ fvRequired view:.optional :has $ fvErrors view:.error>
+                        <label .control-label for=#{fvId view}>#{fvLabel view}
+                        <div .controls .input>
+                            ^{fvInput view}
+                            $maybe tt <- fvTooltip view
+                                <span .help-block>#{tt}
+                            $maybe err <- fvErrors view
+                                <span .help-block>#{err}
+                |]
     return (res, widget)
 
-check :: RenderMessage master msg
-      => (a -> Either msg a) -> Field sub master a -> Field sub master a
+check :: (Monad m, RenderMessage (HandlerSite m) msg)
+      => (a -> Either msg a)
+      -> Field m a
+      -> Field m a
 check f = checkM $ return . f
 
 -- | Return the given error message if the predicate is false.
-checkBool :: RenderMessage master msg
-          => (a -> Bool) -> msg -> Field sub master a -> Field sub master a
+checkBool :: (Monad m, RenderMessage (HandlerSite m) msg)
+          => (a -> Bool) -> msg -> Field m a -> Field m a
 checkBool b s = check $ \x -> if b x then Right x else Left s
 
-checkM :: RenderMessage master msg
-       => (a -> GHandler sub master (Either msg a))
-       -> Field sub master a
-       -> Field sub master a
+checkM :: (Monad m, RenderMessage (HandlerSite m) msg)
+       => (a -> m (Either msg a))
+       -> Field m a
+       -> Field m a
 checkM f = checkMMap f id
 
 -- | Same as 'checkM', but modifies the datatype.
@@ -368,56 +385,42 @@ checkM f = checkMMap f id
 -- the new datatype to the old one (the second argument to this function).
 --
 -- Since 1.1.2
-checkMMap :: RenderMessage master msg
-          => (a -> GHandler sub master (Either msg b))
+checkMMap :: (Monad m, RenderMessage (HandlerSite m) msg)
+          => (a -> m (Either msg b))
           -> (b -> a)
-          -> Field sub master a
-          -> Field sub master b
+          -> Field m a
+          -> Field m b
 checkMMap f inv field = field
     { fieldParse = \ts fs -> do
         e1 <- fieldParse field ts fs
         case e1 of
             Left msg -> return $ Left msg
             Right Nothing -> return $ Right Nothing
-            Right (Just a) -> fmap (either (Left . SomeMessage) (Right . Just)) $ f a
+            Right (Just a) -> liftM (either (Left . SomeMessage) (Right . Just)) $ f a
     , fieldView = \i n a eres req -> fieldView field i n a (fmap inv eres) req
     }
 
--- | Deprecated synonym for 'checkMMap'.
---
--- Since 1.1.1
-checkMMod :: RenderMessage master msg
-          => (a -> GHandler sub master (Either msg b))
-          -> (b -> a)
-          -> Field sub master a
-          -> Field sub master b
-checkMMod = checkMMap
-{-# DEPRECATED checkMMod "Please use checkMMap instead" #-}
-
 -- | Allows you to overwrite the error message on parse error.
-customErrorMessage :: SomeMessage master -> Field sub master a -> Field sub master a
-customErrorMessage msg field = field { fieldParse = \ts fs -> fmap (either
-(const $ Left msg) Right) $ fieldParse field ts fs }
+customErrorMessage :: Monad m => SomeMessage (HandlerSite m) -> Field m a -> Field m a
+customErrorMessage msg field = field
+    { fieldParse = \ts fs ->
+        liftM (either (const $ Left msg) Right)
+      $ fieldParse field ts fs
+    }
 
 -- | Generate a 'FieldSettings' from the given label.
-fieldSettingsLabel :: RenderMessage master msg => msg -> FieldSettings master
+fieldSettingsLabel :: RenderMessage site msg => msg -> FieldSettings site
 fieldSettingsLabel msg = FieldSettings (SomeMessage msg) Nothing Nothing Nothing []
 
--- | Generate an 'AForm' that gets its value from the given action.
-aformM :: GHandler sub master a -> AForm sub master a
-aformM action = AForm $ \_ _ ints -> do
-    value <- action
-    return (FormSuccess value, id, ints, mempty)
-
 -- | A helper function for creating custom fields.
 --
 -- This is intended to help with the common case where a single input value is
 -- required, such as when parsing a text field.
 --
 -- Since 1.1
-parseHelper :: (Monad m, RenderMessage master FormMessage)
+parseHelper :: (Monad m, RenderMessage site FormMessage)
             => (Text -> Either FormMessage a)
-            -> [Text] -> [FileInfo] -> m (Either (SomeMessage master) (Maybe a))
+            -> [Text] -> [FileInfo] -> m (Either (SomeMessage site) (Maybe a))
 parseHelper _ [] _ = return $ Right Nothing
 parseHelper _ ("":_) _ = return $ Right Nothing
 parseHelper f (x:_) _ = return $ either (Left . SomeMessage) (Right . Just) $ f x
diff --git a/yesod-form/Yesod/Form/Input.hs b/yesod-form/Yesod/Form/Input.hs
index 0c23677d..6cbe8dd0 100644
--- a/yesod-form/Yesod/Form/Input.hs
+++ b/yesod-form/Yesod/Form/Input.hs
@@ -11,19 +11,17 @@ module Yesod.Form.Input
 import Yesod.Form.Types
 import Data.Text (Text)
 import Control.Applicative (Applicative (..))
-import Yesod.Handler (GHandler, invalidArgs, runRequestBody, getRequest, getYesod)
-import Yesod.Request (reqGetParams, languages)
+import Yesod.Core
 import Control.Monad (liftM)
-import Yesod.Message (RenderMessage (..), SomeMessage (..))
 import qualified Data.Map as Map
 import Data.Maybe (fromMaybe)
 import Control.Arrow ((***))
 
 type DText = [Text] -> [Text]
-newtype FormInput sub master a = FormInput { unFormInput :: master -> [Text] -> Env -> FileEnv -> GHandler sub master (Either DText a) }
-instance Functor (FormInput sub master) where
-    fmap a (FormInput f) = FormInput $ \c d e e' -> fmap (either Left (Right . a)) $ f c d e e'
-instance Applicative (FormInput sub master) where
+newtype FormInput m a = FormInput { unFormInput :: HandlerSite m -> [Text] -> Env -> FileEnv -> m (Either DText a) }
+instance Monad m => Functor (FormInput m) where
+    fmap a (FormInput f) = FormInput $ \c d e e' -> liftM (either Left (Right . a)) $ f c d e e'
+instance Monad m => Applicative (FormInput m) where
     pure = FormInput . const . const . const . const . return . Right
     (FormInput f) <*> (FormInput x) = FormInput $ \c d e e' -> do
         res1 <- f c d e e'
@@ -34,7 +32,8 @@ instance Applicative (FormInput sub master) where
             (_, Left b) -> Left b
             (Right a, Right b) -> Right $ a b
 
-ireq :: (RenderMessage master FormMessage) => Field sub master a -> Text -> FormInput sub master a
+ireq :: (Monad m, RenderMessage (HandlerSite m) FormMessage)
+     => Field m a -> Text -> FormInput m a
 ireq field name = FormInput $ \m l env fenv -> do
       let filteredEnv = fromMaybe [] $ Map.lookup name env
           filteredFEnv = fromMaybe [] $ Map.lookup name fenv
@@ -44,7 +43,7 @@ ireq field name = FormInput $ \m l env fenv -> do
           Right Nothing -> Left $ (:) $ renderMessage m l $ MsgInputNotFound name
           Right (Just a) -> Right a
 
-iopt :: Field sub master a -> Text -> FormInput sub master (Maybe a)
+iopt :: Monad m => Field m a -> Text -> FormInput m (Maybe a)
 iopt field name = FormInput $ \m l env fenv -> do
       let filteredEnv = fromMaybe [] $ Map.lookup name env
           filteredFEnv = fromMaybe [] $ Map.lookup name fenv
@@ -53,7 +52,7 @@ iopt field name = FormInput $ \m l env fenv -> do
         Left (SomeMessage e) -> Left $ (:) $ renderMessage m l e
         Right x -> Right x
 
-runInputGet :: FormInput sub master a -> GHandler sub master a
+runInputGet :: MonadHandler m => FormInput m a -> m a
 runInputGet (FormInput f) = do
     env <- liftM (toMap . reqGetParams) getRequest
     m <- getYesod
@@ -66,7 +65,7 @@ runInputGet (FormInput f) = do
 toMap :: [(Text, a)] -> Map.Map Text [a]
 toMap = Map.unionsWith (++) . map (\(x, y) -> Map.singleton x [y])
 
-runInputPost :: FormInput sub master a -> GHandler sub master a
+runInputPost :: MonadHandler m => FormInput m a -> m a
 runInputPost (FormInput f) = do
     (env, fenv) <- liftM (toMap *** toMap) runRequestBody
     m <- getYesod
diff --git a/yesod-form/Yesod/Form/Jquery.hs b/yesod-form/Yesod/Form/Jquery.hs
index 85a0c769..7ddeff47 100644
--- a/yesod-form/Yesod/Form/Jquery.hs
+++ b/yesod-form/Yesod/Form/Jquery.hs
@@ -12,18 +12,14 @@ module Yesod.Form.Jquery
     , Default (..)
     ) where
 
-import Yesod.Handler
-import Yesod.Core (Route)
+import Yesod.Core
 import Yesod.Form
-import Yesod.Widget
 import Data.Time (Day)
 import Data.Default
 import Text.Hamlet (shamlet)
 import Text.Julius (julius, rawJS)
 import Data.Text (Text, pack, unpack)
 import Data.Monoid (mconcat)
-import Yesod.Core (RenderMessage)
-import Data.Aeson (toJSON)
 
 -- | Gets the Google hosted jQuery UI 1.8 CSS file with the given theme.
 googleHostedJqueryUiCss :: Text -> Text
@@ -56,7 +52,7 @@ class YesodJquery a where
     urlJqueryUiDateTimePicker :: a -> Either (Route a) Text
     urlJqueryUiDateTimePicker _ = Right "http://github.com/gregwebs/jquery.ui.datetimepicker/raw/master/jquery.ui.datetimepicker.js"
 
-jqueryDayField :: (RenderMessage master FormMessage, YesodJquery master) => JqueryDaySettings -> Field sub master Day
+jqueryDayField :: (RenderMessage site FormMessage, YesodJquery site) => JqueryDaySettings -> Field (HandlerT site IO) Day
 jqueryDayField jds = Field
     { fieldParse = parseHelper $ maybe
                   (Left MsgInvalidDay)
@@ -100,8 +96,8 @@ $(function(){
         , "]"
         ]
 
-jqueryAutocompleteField :: (RenderMessage master FormMessage, YesodJquery master)
-                        => Route master -> Field sub master Text
+jqueryAutocompleteField :: (RenderMessage site FormMessage, YesodJquery site)
+                        => Route site -> Field (HandlerT site IO) Text
 jqueryAutocompleteField src = Field
     { fieldParse = parseHelper $ Right
     , fieldView = \theId name attrs val isReq -> do
@@ -118,14 +114,16 @@ $(function(){$("##{rawJS theId}").autocomplete({source:"@{src}",minLength:2})});
     , fieldEnctype = UrlEncoded
     }
 
-addScript' :: (master -> Either (Route master) Text) -> GWidget sub master ()
+addScript' :: (HandlerSite m ~ site, MonadWidget m) => (site -> Either (Route site) Text) -> m ()
 addScript' f = do
-    y <- lift getYesod
+    y <- getYesod
     addScriptEither $ f y
 
-addStylesheet' :: (y -> Either (Route y) Text) -> GWidget sub y ()
+addStylesheet' :: (MonadWidget m, HandlerSite m ~ site)
+               => (site -> Either (Route site) Text)
+               -> m ()
 addStylesheet' f = do
-    y <- lift getYesod
+    y <- getYesod
     addStylesheetEither $ f y
 
 readMay :: Read a => String -> Maybe a
diff --git a/yesod-form/Yesod/Form/MassInput.hs b/yesod-form/Yesod/Form/MassInput.hs
index 62e89d68..332eb660 100644
--- a/yesod-form/Yesod/Form/MassInput.hs
+++ b/yesod-form/Yesod/Form/MassInput.hs
@@ -12,11 +12,7 @@ module Yesod.Form.MassInput
 import Yesod.Form.Types
 import Yesod.Form.Functions
 import Yesod.Form.Fields (boolField)
-import Yesod.Widget (GWidget, whamlet)
-import Yesod.Message (RenderMessage)
-import Yesod.Handler (newIdent, GHandler)
-import Text.Blaze.Html (Html)
-import Control.Monad.Trans.Class (lift)
+import Yesod.Core
 import Control.Monad.Trans.RWS (get, put, ask)
 import Data.Maybe (fromMaybe)
 import Data.Text.Read (decimal)
@@ -25,9 +21,8 @@ import Data.Either (partitionEithers)
 import Data.Traversable (sequenceA)
 import qualified Data.Map as Map
 import Data.Maybe (listToMaybe)
-import Yesod.Core (SomeMessage (SomeMessage))
 
-down :: Int -> MForm sub master ()
+down :: Monad m => Int -> MForm m ()
 down 0 = return ()
 down i | i < 0 = error "called down with a negative number"
 down i = do
@@ -35,7 +30,7 @@ down i = do
     put $ IntCons 0 is
     down $ i - 1
 
-up :: Int -> MForm sub master ()
+up :: Monad m => Int -> MForm m ()
 up 0 = return ()
 up i | i < 0 = error "called down with a negative number"
 up i = do
@@ -45,11 +40,11 @@ up i = do
         IntCons _ is' -> put is' >> newFormIdent >> return ()
     up $ i - 1
 
-inputList :: (m ~ GHandler sub master, xml ~ GWidget sub master (), RenderMessage master FormMessage)
+inputList :: (m ~ HandlerT site IO, xml ~ WidgetT site IO (), RenderMessage site FormMessage)
           => Html
-          -> ([[FieldView sub master]] -> xml)
-          -> (Maybe a -> AForm sub master a)
-          -> (Maybe [a] -> AForm sub master [a])
+          -> ([[FieldView site]] -> xml)
+          -> (Maybe a -> AForm (HandlerT site IO) a)
+          -> (Maybe [a] -> AForm (HandlerT site IO) [a])
 inputList label fixXml single mdef = formToAForm $ do
     theId <- lift newIdent
     down 1
@@ -89,9 +84,9 @@ $newline never
         , fvRequired = False
         }])
 
-withDelete :: (xml ~ GWidget sub master (), RenderMessage master FormMessage)
-           => AForm sub master a
-           -> MForm sub master (Either xml (FormResult a, [FieldView sub master]))
+withDelete :: (xml ~ WidgetT site IO (), RenderMessage site FormMessage)
+           => AForm (HandlerT site IO) a
+           -> MForm (HandlerT site IO) (Either xml (FormResult a, [FieldView site]))
 withDelete af = do
     down 1
     deleteName <- newFormIdent
@@ -114,9 +109,9 @@ $newline never
     up 1
     return res
 
-fixme :: (xml ~ GWidget sub master ())
-      => [Either xml (FormResult a, [FieldView sub master])]
-      -> (FormResult [a], [xml], [[FieldView sub master]])
+fixme :: (xml ~ WidgetT site IO ())
+      => [Either xml (FormResult a, [FieldView site])]
+      -> (FormResult [a], [xml], [[FieldView site]])
 fixme eithers =
     (res, xmls, map snd rest)
   where
@@ -124,8 +119,8 @@ fixme eithers =
     res = sequenceA $ map fst rest
 
 massDivs, massTable
-         :: [[FieldView sub master]]
-         -> GWidget sub master ()
+         :: [[FieldView site]]
+         -> WidgetT site IO ()
 massDivs viewss = [whamlet|
 $newline never
 $forall views <- viewss
diff --git a/yesod-form/Yesod/Form/Nic.hs b/yesod-form/Yesod/Form/Nic.hs
index 7c65ce44..28626789 100644
--- a/yesod-form/Yesod/Form/Nic.hs
+++ b/yesod-form/Yesod/Form/Nic.hs
@@ -9,21 +9,12 @@ module Yesod.Form.Nic
     , nicHtmlField
     ) where
 
-import Yesod.Handler
-import Yesod.Core (Route, ScriptLoadPosition(..), jsLoader, Yesod)
+import Yesod.Core
 import Yesod.Form
-import Yesod.Widget
 import Text.HTML.SanitizeXSS (sanitizeBalance)
-import Text.Hamlet (Html, shamlet)
+import Text.Hamlet (shamlet)
 import Text.Julius (julius, rawJS)
-#if MIN_VERSION_blaze_html(0, 5, 0)
-import Text.Blaze (preEscapedToMarkup)
 import Text.Blaze.Html.Renderer.String (renderHtml)
-#define preEscapedText preEscapedToMarkup
-#else
-import Text.Blaze (preEscapedText)
-import Text.Blaze.Renderer.String (renderHtml)
-#endif
 import Data.Text (Text, pack)
 import Data.Maybe (listToMaybe)
 
@@ -32,16 +23,16 @@ class Yesod a => YesodNic a where
     urlNicEdit :: a -> Either (Route a) Text
     urlNicEdit _ = Right "http://js.nicedit.com/nicEdit-latest.js"
 
-nicHtmlField :: YesodNic master => Field sub master Html
+nicHtmlField :: YesodNic site => Field (HandlerT site IO) Html
 nicHtmlField = Field
-    { fieldParse = \e _ -> return . Right . fmap (preEscapedText . sanitizeBalance) . listToMaybe $ e
+    { fieldParse = \e _ -> return . Right . fmap (preEscapedToMarkup . sanitizeBalance) . listToMaybe $ e
     , fieldView = \theId name attrs val _isReq -> do
         toWidget [shamlet|
 $newline never
     <textarea id="#{theId}" *{attrs} name="#{name}" .html>#{showVal val}
 |]
         addScript' urlNicEdit
-        master <- lift getYesod
+        master <- getYesod
         toWidget $
           case jsLoader master of
             BottomOfHeadBlocking -> [julius|
@@ -55,7 +46,9 @@ bkLib.onDomLoaded(function(){new nicEditor({fullPanel:true}).panelInstance("#{ra
   where
     showVal = either id (pack . renderHtml)
 
-addScript' :: (y -> Either (Route y) Text) -> GWidget sub y ()
+addScript' :: (MonadWidget m, HandlerSite m ~ site)
+           => (site -> Either (Route site) Text)
+           -> m ()
 addScript' f = do
-    y <- lift getYesod
+    y <- getYesod
     addScriptEither $ f y
diff --git a/yesod-form/Yesod/Form/Types.hs b/yesod-form/Yesod/Form/Types.hs
index fc157b70..5dc79657 100644
--- a/yesod-form/Yesod/Form/Types.hs
+++ b/yesod-form/Yesod/Form/Types.hs
@@ -22,7 +22,6 @@ module Yesod.Form.Types
     ) where
 
 import Control.Monad.Trans.RWS (RWST)
-import Yesod.Request (FileInfo)
 import Data.Text (Text)
 import Data.Monoid (Monoid (..))
 import Text.Blaze (Markup, ToMarkup (toMarkup))
@@ -31,8 +30,9 @@ import Text.Blaze (Markup, ToMarkup (toMarkup))
 #define toHtml toMarkup
 import Control.Applicative ((<$>), Applicative (..))
 import Control.Monad (liftM)
+import Control.Monad.Trans.Class
 import Data.String (IsString (..))
-import Yesod.Core (GHandler, GWidget, SomeMessage, MonadLift (..))
+import Yesod.Core
 import qualified Data.Map as Map
 
 -- | A form can produce three different results: there was no data available,
@@ -79,27 +79,35 @@ instance Show Ints where
 type Env = Map.Map Text [Text]
 type FileEnv = Map.Map Text [FileInfo]
 
-type Lang = Text
-type MForm sub master a = RWST (Maybe (Env, FileEnv), master, [Lang]) Enctype Ints (GHandler sub master) a
+type MForm m a = RWST
+    (Maybe (Env, FileEnv), HandlerSite m, [Lang])
+    Enctype
+    Ints
+    m
+    a
 
-newtype AForm sub master a = AForm
-    { unAForm :: (master, [Text]) -> Maybe (Env, FileEnv) -> Ints -> GHandler sub master (FormResult a, [FieldView sub master] -> [FieldView sub master], Ints, Enctype)
+newtype AForm m a = AForm
+    { unAForm :: (HandlerSite m, [Text])
+              -> Maybe (Env, FileEnv)
+              -> Ints
+              -> m (FormResult a, [FieldView (HandlerSite m)] -> [FieldView (HandlerSite m)], Ints, Enctype)
     }
-instance Functor (AForm sub master) where
+instance Monad m => Functor (AForm m) where
     fmap f (AForm a) =
         AForm $ \x y z -> liftM go $ a x y z
       where
         go (w, x, y, z) = (fmap f w, x, y, z)
-instance Applicative (AForm sub master) where
+instance Monad m => Applicative (AForm m) where
     pure x = AForm $ const $ const $ \ints -> return (FormSuccess x, mempty, ints, mempty)
     (AForm f) <*> (AForm g) = AForm $ \mr env ints -> do
         (a, b, ints', c) <- f mr env ints
         (x, y, ints'', z) <- g mr env ints'
         return (a <*> x, b `mappend` y, ints'', c `mappend` z)
-instance Monoid a => Monoid (AForm sub master a) where
+instance (Monad m, Monoid a) => Monoid (AForm m a) where
     mempty = pure mempty
     mappend a b = mappend <$> a <*> b
-instance MonadLift (GHandler sub master) (AForm sub master) where
+
+instance MonadTrans AForm where
     lift f = AForm $ \_ _ ints -> do
         x <- f
         return (FormSuccess x, id, ints, mempty)
@@ -115,26 +123,26 @@ data FieldSettings master = FieldSettings
 instance IsString (FieldSettings a) where
     fromString s = FieldSettings (fromString s) Nothing Nothing Nothing []
 
-data FieldView sub master = FieldView
+data FieldView site = FieldView
     { fvLabel :: Html
     , fvTooltip :: Maybe Html
     , fvId :: Text
-    , fvInput :: GWidget sub master ()
+    , fvInput :: WidgetT site IO ()
     , fvErrors :: Maybe Html
     , fvRequired :: Bool
     }
 
-type FieldViewFunc sub master a
+type FieldViewFunc m a
     = Text -- ^ ID
    -> Text -- ^ Name
    -> [(Text, Text)] -- ^ Attributes
    -> Either Text a -- ^ Either (invalid text) or (legitimate result)
    -> Bool -- ^ Required?
-   -> GWidget sub master ()
+   -> WidgetT (HandlerSite m) IO ()
 
-data Field sub master a = Field
-    { fieldParse :: [Text] -> [FileInfo] -> GHandler sub master (Either (SomeMessage master) (Maybe a))
-    , fieldView :: FieldViewFunc sub master a
+data Field m a = Field
+    { fieldParse :: [Text] -> [FileInfo] -> m (Either (SomeMessage (HandlerSite m)) (Maybe a))
+    , fieldView :: FieldViewFunc m a
     , fieldEnctype :: Enctype
     }
 
diff --git a/yesod-form/yesod-form.cabal b/yesod-form/yesod-form.cabal
index b0ac64e2..b54a438d 100644
--- a/yesod-form/yesod-form.cabal
+++ b/yesod-form/yesod-form.cabal
@@ -1,5 +1,5 @@
 name:            yesod-form
-version:         1.2.1.3
+version:         1.3.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -14,20 +14,20 @@ description:     Form handling support for Yesod Web Framework
 
 library
     build-depends:   base                  >= 4        && < 5
-                   , yesod-core            >= 1.1      && < 1.2
-                   , yesod-persistent      >= 1.1      && < 1.2
+                   , yesod-core            >= 1.2      && < 1.3
+                   , yesod-persistent      >= 1.2      && < 1.3
                    , time                  >= 1.1.4
                    , hamlet                >= 1.1      && < 1.2
                    , shakespeare-css       >= 1.0      && < 1.1
                    , shakespeare-js        >= 1.0.2    && < 1.2
-                   , persistent            >= 1.0      && < 1.2
+                   , persistent            >= 1.2      && < 1.3
                    , template-haskell
                    , transformers          >= 0.2.2
                    , data-default
                    , xss-sanitize          >= 0.3.0.1
                    , blaze-builder         >= 0.2.1.4
                    , network               >= 2.2
-                   , email-validate        >= 0.2.6
+                   , email-validate        >= 1.0
                    , bytestring            >= 0.9.1.4
                    , text                  >= 0.9
                    , wai                   >= 1.3
@@ -37,9 +37,9 @@ library
                    , attoparsec            >= 0.10
                    , crypto-api            >= 0.8
                    , aeson
+                   , resourcet
 
     exposed-modules: Yesod.Form
-                     Yesod.Form.Class
                      Yesod.Form.Types
                      Yesod.Form.Functions
                      Yesod.Form.Input
diff --git a/yesod-json/LICENSE b/yesod-json/LICENSE
deleted file mode 100644
index d9f04179..00000000
--- a/yesod-json/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2012 Michael Snoyman, http://www.yesodweb.com/
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/yesod-json/README b/yesod-json/README
deleted file mode 100644
index e69de29b..00000000
diff --git a/yesod-json/Setup.lhs b/yesod-json/Setup.lhs
deleted file mode 100755
index 06e2708f..00000000
--- a/yesod-json/Setup.lhs
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env runhaskell
-
-> module Main where
-> import Distribution.Simple
-
-> main :: IO ()
-> main = defaultMain
diff --git a/yesod-json/Yesod/Json.hs b/yesod-json/Yesod/Json.hs
deleted file mode 100644
index dcc4dce8..00000000
--- a/yesod-json/Yesod/Json.hs
+++ /dev/null
@@ -1,144 +0,0 @@
-{-# LANGUAGE TypeSynonymInstances, OverloadedStrings #-}
-{-# LANGUAGE CPP #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Yesod.Json
-    ( -- * Convert from a JSON value
-      defaultLayoutJson
-    , jsonToRepJson
-
-      -- * Convert to a JSON value
-    , parseJsonBody
-    , parseJsonBody_
-
-      -- * Produce JSON values
-    , J.Value (..)
-    , object
-    , array
-    , (.=)
-
-      -- * Convenience functions
-    , jsonOrRedirect
-    , acceptsJson
-    ) where
-
-import Yesod.Handler (GHandler, waiRequest, lift, invalidArgs, redirect)
-import Yesod.Content
-    ( ToContent (toContent), RepHtmlJson (RepHtmlJson), RepHtml (RepHtml)
-    , RepJson (RepJson), Content (ContentBuilder)
-    )
-import Yesod.Core (defaultLayout, Yesod)
-import Yesod.Widget (GWidget)
-import Yesod.Routes.Class
-import Control.Arrow (second)
-import Control.Applicative ((<$>))
-import Control.Monad (join)
-import qualified Data.Aeson as J
-import qualified Data.Aeson.Parser as JP
-import Data.Aeson ((.=))
-import qualified Data.Aeson.Encode as JE
-import Data.Aeson.Encode (fromValue)
-import Data.Conduit.Attoparsec (sinkParser)
-import Data.Text (Text, pack)
-import qualified Data.Vector as V
-import Text.Julius (ToJavascript (..))
-import Data.Text.Lazy.Builder (fromLazyText)
-import Data.Text.Lazy.Encoding (decodeUtf8)
-import Data.Text.Lazy.Builder (toLazyText)
-import qualified Blaze.ByteString.Builder.Char.Utf8 as Blaze
-import Data.Conduit
-import Network.Wai (requestBody, requestHeaders)
-import Network.Wai.Parse (parseHttpAccept)
-import qualified Data.ByteString.Char8 as B8
-import Safe (headMay)
-
-#if !MIN_VERSION_yesod_core(1, 1, 5)
-instance ToContent J.Value where
-    toContent = flip ContentBuilder Nothing
-              . Blaze.fromLazyText
-              . toLazyText
-              . fromValue
-#endif
-
--- | Provide both an HTML and JSON representation for a piece of
--- data, using the default layout for the HTML output
--- ('defaultLayout').
---
--- /Since: 0.3.0/
-defaultLayoutJson :: (Yesod master, J.ToJSON a)
-                  => GWidget sub master ()  -- ^ HTML
-                  -> a                      -- ^ JSON
-                  -> GHandler sub master RepHtmlJson
-defaultLayoutJson w json = do
-    RepHtml html' <- defaultLayout w
-    return $ RepHtmlJson html' $ toContent (J.toJSON json)
-
--- | Wraps a data type in a 'RepJson'.  The data type must
--- support conversion to JSON via 'J.ToJSON'.
---
--- /Since: 0.3.0/
-jsonToRepJson :: J.ToJSON a => a -> GHandler sub master RepJson
-jsonToRepJson = return . RepJson . toContent . J.toJSON
-
--- | Parse the request body to a data type as a JSON value.  The
--- data type must support conversion from JSON via 'J.FromJSON'.
--- If you want the raw JSON value, just ask for a @'J.Result'
--- 'J.Value'@.
---
--- /Since: 0.3.0/
-parseJsonBody :: J.FromJSON a => GHandler sub master (J.Result a)
-parseJsonBody = do
-    req <- waiRequest
-    eValue <- lift
-            $ runExceptionT
-            $ transPipe lift (requestBody req)
-           $$ sinkParser JP.value'
-    return $ case eValue of
-        Left e -> J.Error $ show e
-        Right value -> J.fromJSON value
-
--- | Same as 'parseJsonBody', but return an invalid args response on a parse
--- error.
-parseJsonBody_ :: J.FromJSON a => GHandler sub master a
-parseJsonBody_ = do
-    ra <- parseJsonBody
-    case ra of
-        J.Error s -> invalidArgs [pack s]
-        J.Success a -> return a
-
-#if !MIN_VERSION_shakespeare_js(1, 0, 2)
-instance ToJavascript J.Value where
-    toJavascript = fromLazyText . decodeUtf8 . JE.encode
-#endif
-
--- | Convert a list of pairs to an 'J.Object'.
-object :: J.ToJSON a => [(Text, a)] -> J.Value
-object = J.object . map (second J.toJSON)
-
--- | Convert a list of values to an 'J.Array'.
-array :: J.ToJSON a => [a] -> J.Value
-array = J.Array . V.fromList . map J.toJSON
-
--- | jsonOrRedirect simplifies the scenario where a POST handler sends a different
--- response based on Accept headers:
---
---     1. 200 with JSON data if the client prefers
---     @application\/json@ (e.g. AJAX, see 'acceptsJSON').
---
---     2. 3xx otherwise, following the PRG pattern.
-jsonOrRedirect :: (Yesod master, J.ToJSON a)
-               => Route master -- ^ Redirect target
-               -> a            -- ^ Data to send via JSON
-               -> GHandler sub master RepJson
-jsonOrRedirect r j = do
-    q <- acceptsJson
-    if q then jsonToRepJson (J.toJSON j)
-         else redirect r
-
--- | Returns @True@ if the client prefers @application\/json@ as
--- indicated by the @Accept@ HTTP header.
-acceptsJson :: Yesod master => GHandler sub master Bool
-acceptsJson =  maybe False ((== "application/json") . B8.takeWhile (/= ';'))
-            .  join
-            .  fmap (headMay . parseHttpAccept)
-            .  lookup "Accept" . requestHeaders
-           <$> waiRequest
diff --git a/yesod-json/test/Spec.hs b/yesod-json/test/Spec.hs
deleted file mode 100644
index 7ed8c3dd..00000000
--- a/yesod-json/test/Spec.hs
+++ /dev/null
@@ -1,47 +0,0 @@
-{-# LANGUAGE OverloadedStrings, TemplateHaskell, QuasiQuotes, TypeFamilies, MultiParamTypeClasses #-}
-import Yesod.Core
-import Yesod.Json
-import Test.Hspec
-import qualified Data.Map as Map
-import Network.Wai.Test
-import Data.Text (Text)
-
-data App = App
-
-mkYesod "App" [parseRoutes|
-/ HomeR GET
-|]
-
-instance Yesod App
-
-getHomeR :: Handler RepPlain
-getHomeR = do
-    val <- parseJsonBody_
-    case Map.lookup ("foo" :: Text) val of
-        Nothing -> invalidArgs ["foo not found"]
-        Just foo -> return $ RepPlain $ toContent (foo :: Text)
-
-main :: IO ()
-main = do
-    app <- toWaiApp App
-    hspec $ describe "Yesod.Json" $ do
-        it "parses valid content" $ flip runSession app $ do
-            sres <- srequest SRequest
-                { simpleRequest = defaultRequest
-                , simpleRequestBody = "{\"foo\":\"bar\"}"
-                }
-            assertStatus 200 sres
-            assertBody "bar" sres
-        it "400 for bad JSON" $ flip runSession app $ do
-            sres <- srequest SRequest
-                { simpleRequest = defaultRequest
-                , simpleRequestBody = "{\"foo\":\"bar\""
-                }
-            assertStatus 400 sres
-        it "400 for bad structure" $ flip runSession app $ do
-            sres <- srequest SRequest
-                { simpleRequest = defaultRequest
-                , simpleRequestBody = "{\"foo2\":\"bar\"}"
-                }
-            assertStatus 400 sres
-            assertBodyContains "foo not found" sres
diff --git a/yesod-json/yesod-json.cabal b/yesod-json/yesod-json.cabal
deleted file mode 100644
index 42610e8c..00000000
--- a/yesod-json/yesod-json.cabal
+++ /dev/null
@@ -1,49 +0,0 @@
-name:            yesod-json
-version:         1.1.2.2
-license:         MIT
-license-file:    LICENSE
-author:          Michael Snoyman <michael@snoyman.com>
-maintainer:      Michael Snoyman <michael@snoyman.com>
-synopsis:        Generate content for Yesod using the aeson package.
-category:        Web, Yesod
-stability:       Stable
-cabal-version:   >= 1.8
-build-type:      Simple
-homepage:        http://www.yesodweb.com/
-description:     Generate content for Yesod using the aeson package.
-
-library
-    build-depends:   base                  >= 4        && < 5
-                   , yesod-core            >= 1.1
-                   , yesod-routes          >= 1.1
-                   , aeson                 >= 0.5
-                   , text                  >= 0.8
-                   , shakespeare-js        >= 1.0
-                   , vector                >= 0.9
-                   , containers            >= 0.2
-                   , blaze-builder
-                   , attoparsec-conduit    >= 0.5
-                   , conduit               >= 0.5
-                   , transformers          >= 0.2.2
-                   , wai                   >= 1.3
-                   , wai-extra             >= 1.3
-                   , bytestring            >= 0.9
-                   , safe                  >= 0.2
-    exposed-modules: Yesod.Json
-    ghc-options:     -Wall
-
-test-suite tests
-    type: exitcode-stdio-1.0
-    main-is: Spec.hs
-    hs-source-dirs: test
-    build-depends: base
-                 , wai-test
-                 , hspec
-                 , yesod-json
-                 , yesod-core
-                 , text
-                 , containers
-
-source-repository head
-  type:     git
-  location: https://github.com/yesodweb/yesod
diff --git a/yesod-newsfeed/Yesod/AtomFeed.hs b/yesod-newsfeed/Yesod/AtomFeed.hs
index b5ae4e59..a9c0d257 100644
--- a/yesod-newsfeed/Yesod/AtomFeed.hs
+++ b/yesod-newsfeed/Yesod/AtomFeed.hs
@@ -2,6 +2,7 @@
 {-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 ---------------------------------------------------------
 --
 -- Module        : Yesod.AtomFeed
@@ -35,10 +36,13 @@ import Text.Blaze.Html.Renderer.Text (renderHtml)
 import qualified Data.Map as Map
 
 newtype RepAtom = RepAtom Content
-instance HasReps RepAtom where
-    chooseRep (RepAtom c) _ = return (typeAtom, c)
+    deriving ToContent
+instance HasContentType RepAtom where
+    getContentType _ = typeAtom
+instance ToTypedContent RepAtom where
+    toTypedContent = TypedContent typeAtom . toContent
 
-atomFeed :: Feed (Route master) -> GHandler sub master RepAtom
+atomFeed :: MonadHandler m => Feed (Route (HandlerSite m)) -> m RepAtom
 atomFeed feed = do
     render <- getUrlRender
     return $ RepAtom $ toContent $ renderLBS def $ template feed render
@@ -71,10 +75,10 @@ entryTemplate FeedEntry {..} render = Element "entry" Map.empty $ map NodeElemen
     ]
 
 -- | Generates a link tag in the head of a widget.
-atomLink :: Route m
+atomLink :: MonadWidget m
+         => Route (HandlerSite m)
          -> Text -- ^ title
-         -> GWidget s m ()
+         -> m ()
 atomLink r title = toWidgetHead [hamlet|
-$newline never
-<link href=@{r} type=#{S8.unpack typeAtom} rel="alternate" title=#{title}>
-|]
+    <link href=@{r} type=#{S8.unpack typeAtom} rel="alternate" title=#{title}>
+    |]
diff --git a/yesod-newsfeed/Yesod/Feed.hs b/yesod-newsfeed/Yesod/Feed.hs
index 58673f8d..0dcd2b09 100644
--- a/yesod-newsfeed/Yesod/Feed.hs
+++ b/yesod-newsfeed/Yesod/Feed.hs
@@ -17,24 +17,15 @@
 -------------------------------------------------------------------------------
 module Yesod.Feed
     ( newsFeed
-    , RepAtomRss (..)
     , module Yesod.FeedTypes
     ) where
 
 import Yesod.FeedTypes
 import Yesod.AtomFeed
 import Yesod.RssFeed
-import Yesod.Content (HasReps (chooseRep), typeAtom, typeRss)
-import Yesod.Core (Route, GHandler)
+import Yesod.Core
 
-data RepAtomRss = RepAtomRss RepAtom RepRss
-instance HasReps RepAtomRss where
-    chooseRep (RepAtomRss (RepAtom a) (RepRss r)) = chooseRep
-        [ (typeAtom, a)
-        , (typeRss, r)
-        ]
-newsFeed :: Feed (Route master) -> GHandler sub master RepAtomRss
-newsFeed f = do
-    a <- atomFeed f
-    r <- rssFeed f
-    return $ RepAtomRss a r
+newsFeed :: MonadHandler m => Feed (Route (HandlerSite m)) -> m TypedContent
+newsFeed f = selectRep $ do
+    provideRep $ atomFeed f
+    provideRep $ rssFeed f
diff --git a/yesod-newsfeed/Yesod/RssFeed.hs b/yesod-newsfeed/Yesod/RssFeed.hs
index 4a8d5029..8243b4a1 100644
--- a/yesod-newsfeed/Yesod/RssFeed.hs
+++ b/yesod-newsfeed/Yesod/RssFeed.hs
@@ -2,6 +2,7 @@
 {-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 -------------------------------------------------------------------------------
 --
 -- Module        : Yesod.RssFeed
@@ -31,11 +32,14 @@ import Text.Blaze.Html.Renderer.Text (renderHtml)
 import qualified Data.Map as Map
 
 newtype RepRss = RepRss Content
-instance HasReps RepRss where
-    chooseRep (RepRss c) _ = return (typeRss, c)
+    deriving ToContent
+instance HasContentType RepRss where
+    getContentType _ = typeRss
+instance ToTypedContent RepRss where
+    toTypedContent = TypedContent typeRss . toContent
 
 -- | Generate the feed
-rssFeed :: Feed (Route master) -> GHandler sub master RepRss
+rssFeed :: MonadHandler m => Feed (Route (HandlerSite m)) -> m RepRss
 rssFeed feed = do
     render <- getUrlRender
     return $ RepRss $ toContent $ renderLBS def $ template feed render
@@ -67,10 +71,10 @@ entryTemplate FeedEntry {..} render = Element "item" Map.empty $ map NodeElement
     ]
 
 -- | Generates a link tag in the head of a widget.
-rssLink :: Route m
+rssLink :: MonadWidget m
+        => Route (HandlerSite m)
         -> Text -- ^ title
-        -> GWidget s m ()
+        -> m ()
 rssLink r title = toWidgetHead [hamlet|
-$newline never
     <link href=@{r} type=#{S8.unpack typeRss} rel="alternate" title=#{title}>
     |]
diff --git a/yesod-newsfeed/yesod-newsfeed.cabal b/yesod-newsfeed/yesod-newsfeed.cabal
index f6ce8cda..cdca81ab 100644
--- a/yesod-newsfeed/yesod-newsfeed.cabal
+++ b/yesod-newsfeed/yesod-newsfeed.cabal
@@ -1,5 +1,5 @@
 name:            yesod-newsfeed
-version:         1.1.0.1
+version:         1.2.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman, Patrick Brisbin
@@ -14,7 +14,7 @@ description:     Helper functions and data types for producing News feeds.
 
 library
     build-depends:   base                 >= 4        && < 5
-                   , yesod-core           >= 1.1      && < 1.2
+                   , yesod-core           >= 1.2      && < 1.3
                    , time                 >= 1.1.4
                    , hamlet               >= 1.1      && < 1.2
                    , bytestring           >= 0.9.1.4
diff --git a/yesod-persistent/Yesod/Persist.hs b/yesod-persistent/Yesod/Persist.hs
index 06461520..b8b24d27 100644
--- a/yesod-persistent/Yesod/Persist.hs
+++ b/yesod-persistent/Yesod/Persist.hs
@@ -1,8 +1,15 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE RankNTypes #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
 module Yesod.Persist
     ( YesodPersist (..)
+    , defaultRunDB
+    , YesodPersistRunner (..)
+    , defaultGetDBRunner
+    , DBRunner (..)
+    , runDBSource
+    , respondSourceDB
     , YesodDB
     , get404
     , getBy404
@@ -12,35 +19,116 @@ module Yesod.Persist
 
 import Database.Persist
 import Database.Persist.TH
-import Control.Monad.Trans.Class (MonadTrans)
+import Database.Persist.Sql (SqlPersistT, unSqlPersistT)
+import Control.Monad.Trans.Reader (runReaderT)
 
-import Yesod.Handler
+import Yesod.Core
+import Data.Conduit
+import Blaze.ByteString.Builder (Builder)
+import Data.IORef.Lifted
+import Data.Conduit.Pool
+import Control.Monad.Trans.Resource
+import qualified Database.Persist.Sql as SQL
 
-type YesodDB sub master = YesodPersistBackend master (GHandler sub master)
+type YesodDB site = YesodPersistBackend site (HandlerT site IO)
 
-class YesodPersist master where
-    type YesodPersistBackend master :: (* -> *) -> * -> *
-    runDB :: YesodDB sub master a -> GHandler sub master a
+class Monad (YesodPersistBackend site (HandlerT site IO)) => YesodPersist site where
+    type YesodPersistBackend site :: (* -> *) -> * -> *
+    runDB :: YesodDB site a -> HandlerT site IO a
+
+-- | Helper for creating 'runDB'.
+--
+-- Since 1.2.0
+defaultRunDB :: PersistConfig c
+             => (site -> c)
+             -> (site -> PersistConfigPool c)
+             -> PersistConfigBackend c (HandlerT site IO) a
+             -> HandlerT site IO a
+defaultRunDB getConfig getPool f = do
+    master <- getYesod
+    Database.Persist.runPool
+        (getConfig master)
+        f
+        (getPool master)
+
+-- |
+--
+-- Since 1.2.0
+class YesodPersist site => YesodPersistRunner site where
+    -- | This function differs from 'runDB' in that it returns a database
+    -- runner function, as opposed to simply running a single action. This will
+    -- usually mean that a connection is taken from a pool and then reused for
+    -- each invocation. This can be useful for creating streaming responses;
+    -- see 'runDBSource'.
+    --
+    -- It additionally returns a cleanup function to free the connection.  If
+    -- your code finishes successfully, you /must/ call this cleanup to
+    -- indicate changes should be committed. Otherwise, for SQL backends at
+    -- least, a rollback will be used instead.
+    --
+    -- Since 1.2.0
+    getDBRunner :: HandlerT site IO (DBRunner site, HandlerT site IO ())
+
+newtype DBRunner site = DBRunner
+    { runDBRunner :: forall a. YesodDB site a -> HandlerT site IO a
+    }
+
+-- | Helper for implementing 'getDBRunner'.
+--
+-- Since 1.2.0
+defaultGetDBRunner :: YesodPersistBackend site ~ SqlPersistT
+                   => (site -> Pool SQL.Connection)
+                   -> HandlerT site IO (DBRunner site, HandlerT site IO ())
+defaultGetDBRunner getPool = do
+    ididSucceed <- newIORef False
+
+    pool <- fmap getPool getYesod
+    managedConn <- takeResource pool
+    let conn = mrValue managedConn
+
+    let withPrep f = f conn (SQL.connPrepare conn)
+    (finishTransaction, ()) <- allocate (withPrep SQL.connBegin) $ \() -> do
+        didSucceed <- readIORef ididSucceed
+        withPrep $ if didSucceed
+            then SQL.connCommit
+            else SQL.connRollback
+
+    let cleanup = do
+            writeIORef ididSucceed True
+            release finishTransaction
+            mrReuse managedConn True
+            mrRelease managedConn
+
+    return (DBRunner $ \x -> runReaderT (unSqlPersistT x) conn, cleanup)
+
+-- | Like 'runDB', but transforms a @Source@. See 'respondSourceDB' for an
+-- example, practical use case.
+--
+-- Since 1.2.0
+runDBSource :: YesodPersistRunner site
+            => Source (YesodDB site) a
+            -> Source (HandlerT site IO) a
+runDBSource src = do
+    (dbrunner, cleanup) <- lift getDBRunner
+    transPipe (runDBRunner dbrunner) src
+    lift cleanup
+
+-- | Extends 'respondSource' to create a streaming database response body.
+respondSourceDB :: YesodPersistRunner site
+                => ContentType
+                -> Source (YesodDB site) (Flush Builder)
+                -> HandlerT site IO TypedContent
+respondSourceDB ctype = respondSource ctype . runDBSource
 
 -- | Get the given entity by ID, or return a 404 not found if it doesn't exist.
-#if MIN_VERSION_persistent(1, 1, 0)
 get404 :: ( PersistStore (t m)
           , PersistEntity val
           , Monad (t m)
-          , m ~ GHandler sub master
+          , m ~ HandlerT site IO
           , MonadTrans t
           , PersistMonadBackend (t m) ~ PersistEntityBackend val
           )
        => Key val -> t m val
-#else
-get404 :: ( PersistStore b m
-          , PersistEntity val
-          , Monad (b m)
-          , m ~ GHandler sub master
-          , MonadTrans b
-          )
-       => Key b val -> b m val
-#endif
 get404 key = do
     mres <- get key
     case mres of
@@ -49,27 +137,22 @@ get404 key = do
 
 -- | Get the given entity by unique key, or return a 404 not found if it doesn't
 --   exist.
-#if MIN_VERSION_persistent(1, 1, 0)
 getBy404 :: ( PersistUnique (t m)
             , PersistEntity val
-            , m ~ GHandler sub master
+            , m ~ HandlerT site IO
             , Monad (t m)
             , MonadTrans t
             , PersistEntityBackend val ~ PersistMonadBackend (t m)
             )
          => Unique val -> t m (Entity val)
-#else
-getBy404 :: ( PersistUnique b m
-            , PersistEntity val
-            , m ~ GHandler sub master
-            , Monad (b m)
-            , MonadTrans b
-            , PersistEntityBackend val ~ b
-            )
-         => Unique val b -> b m (Entity val)
-#endif
 getBy404 key = do
     mres <- getBy key
     case mres of
         Nothing -> lift notFound
         Just res -> return res
+
+instance MonadHandler m => MonadHandler (SqlPersistT m) where
+    type HandlerSite (SqlPersistT m) = HandlerSite m
+    liftHandlerT = lift . liftHandlerT
+instance MonadWidget m => MonadWidget (SqlPersistT m) where
+    liftWidgetT = lift . liftWidgetT
diff --git a/yesod-persistent/test/Spec.hs b/yesod-persistent/test/Spec.hs
new file mode 100644
index 00000000..a824f8c3
--- /dev/null
+++ b/yesod-persistent/test/Spec.hs
@@ -0,0 +1 @@
+{-# OPTIONS_GHC -F -pgmF hspec-discover #-}
diff --git a/yesod-persistent/test/Yesod/PersistSpec.hs b/yesod-persistent/test/Yesod/PersistSpec.hs
new file mode 100644
index 00000000..bf29910c
--- /dev/null
+++ b/yesod-persistent/test/Yesod/PersistSpec.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE OverloadedStrings, TemplateHaskell, QuasiQuotes, TypeFamilies #-}
+{-# LANGUAGE EmptyDataDecls, FlexibleContexts, GADTs #-}
+module Yesod.PersistSpec where
+
+import Test.Hspec
+import Database.Persist.Sqlite
+import Network.Wai.Test
+import Yesod.Core
+import Data.Conduit
+import Blaze.ByteString.Builder.Char.Utf8 (fromText)
+import Yesod.Persist
+import Data.Text (Text)
+
+share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
+Person
+    name Text
+|]
+
+data App = App
+    { appConfig :: SqliteConf
+    , appPool   :: ConnectionPool
+    }
+
+mkYesod "App" [parseRoutes|
+/ HomeR GET
+|]
+
+instance Yesod App
+instance YesodPersist App where
+    type YesodPersistBackend App = SqlPersistT
+    runDB = defaultRunDB appConfig appPool
+instance YesodPersistRunner App where
+    getDBRunner = defaultGetDBRunner appPool
+
+getHomeR :: Handler TypedContent
+getHomeR = do
+    runDB $ do
+        runMigration migrateAll
+        deleteWhere ([] :: [Filter Person])
+        insert_ $ Person "Charlie"
+        insert_ $ Person "Alice"
+        insert_ $ Person "Bob"
+    respondSourceDB typePlain $ selectSource [] [Asc PersonName] $= awaitForever toBuilder
+  where
+    toBuilder (Entity _ (Person name)) = do
+        yield $ Chunk $ fromText name
+        yield $ Chunk $ fromText "\n"
+        yield Flush
+
+test :: String -> Session () -> Spec
+test name session = it name $ do
+    let config = SqliteConf ":memory:" 1
+    pool <- createPoolConfig config
+    app <- toWaiApp $ App config pool
+    runSession session app
+
+spec :: Spec
+spec = test "streaming" $ do
+    sres <- request defaultRequest
+    assertBody "Alice\nBob\nCharlie\n" sres
+    assertStatus 200 sres
diff --git a/yesod-persistent/yesod-persistent.cabal b/yesod-persistent/yesod-persistent.cabal
index 111c1b9a..2298c040 100644
--- a/yesod-persistent/yesod-persistent.cabal
+++ b/yesod-persistent/yesod-persistent.cabal
@@ -1,5 +1,5 @@
 name:            yesod-persistent
-version:         1.1.0.1
+version:         1.2.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -7,20 +7,41 @@ maintainer:      Michael Snoyman <michael@snoyman.com>
 synopsis:        Some helpers for using Persistent from Yesod.
 category:        Web, Yesod, Database
 stability:       Stable
-cabal-version:   >= 1.6
+cabal-version:   >= 1.8
 build-type:      Simple
 homepage:        http://www.yesodweb.com/
 description:     Some helpers for using Persistent from Yesod.
 
 library
     build-depends:   base                      >= 4        && < 5
-                   , yesod-core                >= 1.1      && < 1.2
-                   , persistent                >= 1.0      && < 1.2
-                   , persistent-template       >= 1.0      && < 1.2
+                   , yesod-core                >= 1.2      && < 1.3
+                   , persistent                >= 1.2      && < 1.3
+                   , persistent-template       >= 1.2      && < 1.3
                    , transformers              >= 0.2.2    && < 0.4
+                   , blaze-builder
+                   , conduit
+                   , lifted-base
+                   , pool-conduit
+                   , resourcet
     exposed-modules: Yesod.Persist
     ghc-options:     -Wall
 
+test-suite test
+    type: exitcode-stdio-1.0
+    main-is: Spec.hs
+    hs-source-dirs: test
+    other-modules: Yesod.PersistSpec
+    build-depends: base
+                 , hspec
+                 , wai-test
+                 , yesod-core
+                 , persistent-sqlite
+                 , yesod-persistent
+                 , conduit
+                 , blaze-builder
+                 , persistent
+                 , text
+
 source-repository head
   type:     git
   location: https://github.com/yesodweb/yesod
diff --git a/yesod-platform/make-cabal.sh b/yesod-platform/make-cabal.sh
index 3525dd94..7ba1d387 100755
--- a/yesod-platform/make-cabal.sh
+++ b/yesod-platform/make-cabal.sh
@@ -7,4 +7,4 @@ then
     cabal install cabal-nirvana -fgenerate
 fi
 
-cabal-nirvana-generate yesod yesod-static yesod-default hjsmin blaze-html yesod-test | runghc to-cabal.hs > yesod-platform.cabal
+cabal-nirvana-generate yesod yesod-static yesod-default yesod-bin hjsmin blaze-html yesod-test | runghc to-cabal.hs > yesod-platform.cabal
diff --git a/yesod-routes/Yesod/Routes/Class.hs b/yesod-routes/Yesod/Routes/Class.hs
index 92024165..9a9e8a41 100644
--- a/yesod-routes/Yesod/Routes/Class.hs
+++ b/yesod-routes/Yesod/Routes/Class.hs
@@ -2,11 +2,20 @@
 {-# LANGUAGE FlexibleContexts #-}
 module Yesod.Routes.Class
     ( RenderRoute (..)
+    , ParseRoute (..)
+    , RouteAttrs (..)
     ) where
 
 import Data.Text (Text)
+import Data.Set (Set)
 
 class Eq (Route a) => RenderRoute a where
     -- | The type-safe URLs associated with a site argument.
     data Route a
     renderRoute :: Route a -> ([Text], [(Text, Text)])
+
+class RenderRoute a => ParseRoute a where
+    parseRoute :: ([Text], [(Text, Text)]) -> Maybe (Route a)
+
+class RenderRoute a => RouteAttrs a where
+    routeAttrs :: Route a -> Set Text
diff --git a/yesod-routes/Yesod/Routes/Dispatch.lhs b/yesod-routes/Yesod/Routes/Dispatch.lhs
index 181906a4..f12665a6 100644
--- a/yesod-routes/Yesod/Routes/Dispatch.lhs
+++ b/yesod-routes/Yesod/Routes/Dispatch.lhs
@@ -1,4 +1,4 @@
-Title: Experimental, optimized route dispatch code
+Title: Optimized route dispatch code
 
 Let's start with our module declaration and imports.
 
diff --git a/yesod-routes/Yesod/Routes/Parse.hs b/yesod-routes/Yesod/Routes/Parse.hs
index fc16eef3..9d8c01fb 100644
--- a/yesod-routes/Yesod/Routes/Parse.hs
+++ b/yesod-routes/Yesod/Routes/Parse.hs
@@ -7,6 +7,8 @@ module Yesod.Routes.Parse
     , parseRoutesNoCheck
     , parseRoutesFileNoCheck
     , parseType
+    , parseTypeTree
+    , TypeTree (..)
     ) where
 
 import Language.Haskell.TH.Syntax
@@ -15,6 +17,7 @@ import Language.Haskell.TH.Quote
 import qualified System.IO as SIO
 import Yesod.Routes.TH
 import Yesod.Routes.Overlap (findOverlapNames)
+import Data.List (foldl')
 
 -- | A quasi-quoter to parse a string into a list of 'Resource's. Checks for
 -- overlapping routes, failing if present; use 'parseRoutesNoCheck' to skip the
@@ -73,11 +76,22 @@ resourcesFromString =
                      in ((ResourceParent (init constr) pieces children :), otherLines'')
                 (pattern:constr:rest) ->
                     let (pieces, mmulti) = piecesFromString $ drop1Slash pattern
-                        disp = dispatchFromString rest mmulti
-                     in ((ResourceLeaf (Resource constr pieces disp):), otherLines)
+                        (attrs, rest') = takeAttrs rest
+                        disp = dispatchFromString rest' mmulti
+                     in ((ResourceLeaf (Resource constr pieces disp attrs):), otherLines)
                 [] -> (id, otherLines)
                 _ -> error $ "Invalid resource line: " ++ thisLine
 
+-- | Take attributes out of the list and put them in the first slot in the
+-- result tuple.
+takeAttrs :: [String] -> ([String], [String])
+takeAttrs =
+    go id id
+  where
+    go x y [] = (x [], y [])
+    go x y (('!':attr):rest) = go (x . (attr:)) y rest
+    go x y (z:rest) = go x (y . (z:)) rest
+
 dispatchFromString :: [String] -> Maybe String -> Dispatch String
 dispatchFromString rest mmulti
     | null rest = Methods mmulti []
@@ -105,11 +119,72 @@ piecesFromString x =
     rest = piecesFromString $ drop 1 z
 
 parseType :: String -> Type
-parseType = ConT . mkName -- FIXME handle more complicated stuff
+parseType orig =
+    maybe (error $ "Invalid type: " ++ show orig) ttToType $ parseTypeTree orig
+
+parseTypeTree :: String -> Maybe TypeTree
+parseTypeTree orig =
+    toTypeTree pieces
+  where
+    pieces = filter (not . null) $ splitOn '-' $ addDashes orig
+    addDashes [] = []
+    addDashes (x:xs) =
+        front $ addDashes xs
+      where
+        front rest
+            | x `elem` "()[]" = '-' : x : '-' : rest
+            | otherwise = x : rest
+    splitOn c s =
+        case y' of
+            _:y -> x : splitOn c y
+            [] -> [x]
+      where
+        (x, y') = break (== c) s
+
+data TypeTree = TTTerm String
+              | TTApp TypeTree TypeTree
+              | TTList TypeTree
+    deriving (Show, Eq)
+
+toTypeTree :: [String] -> Maybe TypeTree
+toTypeTree orig = do
+    (x, []) <- gos orig
+    return x
+  where
+    go [] = Nothing
+    go ("(":xs) = do
+        (x, rest) <- gos xs
+        case rest of
+            ")":rest' -> Just (x, rest')
+            _ -> Nothing
+    go ("[":xs) = do
+        (x, rest) <- gos xs
+        case rest of
+            "]":rest' -> Just (TTList x, rest')
+            _ -> Nothing
+    go (x:xs) = Just (TTTerm x, xs)
+
+    gos xs1 = do
+        (t, xs2) <- go xs1
+        (ts, xs3) <- gos' id xs2
+        Just (foldl' TTApp t ts, xs3)
+
+    gos' front [] = Just (front [], [])
+    gos' front (x:xs)
+        | x `elem` words ") ]" = Just (front [], x:xs)
+        | otherwise = do
+            (t, xs') <- go $ x:xs
+            gos' (front . (t:)) xs'
+
+ttToType :: TypeTree -> Type
+ttToType (TTTerm s) = ConT $ mkName s
+ttToType (TTApp x y) = ttToType x `AppT` ttToType y
+ttToType (TTList t) = ListT `AppT` ttToType t
 
 pieceFromString :: String -> Either String (CheckOverlap, Piece String)
 pieceFromString ('#':'!':x) = Right $ (False, Dynamic x)
 pieceFromString ('#':x) = Right $ (True, Dynamic x)
 pieceFromString ('*':x) = Left x
+pieceFromString ('+':x) = Left x
 pieceFromString ('!':x) = Right $ (False, Static x)
 pieceFromString x = Right $ (True, Static x)
diff --git a/yesod-routes/Yesod/Routes/TH.hs b/yesod-routes/Yesod/Routes/TH.hs
index 41045b3c..7b2e50b7 100644
--- a/yesod-routes/Yesod/Routes/TH.hs
+++ b/yesod-routes/Yesod/Routes/TH.hs
@@ -3,10 +3,14 @@ module Yesod.Routes.TH
     ( module Yesod.Routes.TH.Types
       -- * Functions
     , module Yesod.Routes.TH.RenderRoute
+    , module Yesod.Routes.TH.ParseRoute
+    , module Yesod.Routes.TH.RouteAttrs
       -- ** Dispatch
     , module Yesod.Routes.TH.Dispatch
     ) where
 
 import Yesod.Routes.TH.Types
 import Yesod.Routes.TH.RenderRoute
+import Yesod.Routes.TH.ParseRoute
+import Yesod.Routes.TH.RouteAttrs
 import Yesod.Routes.TH.Dispatch
diff --git a/yesod-routes/Yesod/Routes/TH/Dispatch.hs b/yesod-routes/Yesod/Routes/TH/Dispatch.hs
index a52f69ad..9770875a 100644
--- a/yesod-routes/Yesod/Routes/TH/Dispatch.hs
+++ b/yesod-routes/Yesod/Routes/TH/Dispatch.hs
@@ -2,6 +2,8 @@
 module Yesod.Routes.TH.Dispatch
     ( -- ** Dispatch
       mkDispatchClause
+    , MkDispatchSettings (..)
+    , defaultGetHandler
     ) where
 
 import Prelude hiding (exp)
@@ -16,16 +18,22 @@ import Data.Char (toLower)
 import Web.PathPieces (PathPiece (..), PathMultiPiece (..))
 import Control.Applicative ((<$>))
 import Data.List (foldl')
+import Data.Text.Encoding (encodeUtf8)
 
-data FlatResource a = FlatResource [(String, [(CheckOverlap, Piece a)])] String [(CheckOverlap, Piece a)] (Dispatch a)
+data MkDispatchSettings = MkDispatchSettings
+    { mdsRunHandler :: Q Exp
+    , mdsSubDispatcher :: Q Exp
+    , mdsGetPathInfo :: Q Exp
+    , mdsSetPathInfo :: Q Exp
+    , mdsMethod :: Q Exp
+    , mds404 :: Q Exp
+    , mds405 :: Q Exp
+    , mdsGetHandler :: Maybe String -> String -> Q Exp
+    }
 
-flatten :: [ResourceTree a] -> [FlatResource a]
-flatten =
-    concatMap (go id)
-  where
-    go front (ResourceLeaf (Resource a b c)) = [FlatResource (front []) a b c]
-    go front (ResourceParent name pieces children) =
-        concatMap (go (front . ((name, pieces):))) children
+defaultGetHandler :: Maybe String -> String -> Q Exp
+defaultGetHandler Nothing s = return $ VarE $ mkName $ "handle" ++ s
+defaultGetHandler (Just method) s = return $ VarE $ mkName $ map toLower method ++ s
 
 -- |
 --
@@ -90,12 +98,10 @@ flatten =
 -- @'yesodRunner'@ for the first, @'yesodDispatch'@ for the second and
 -- @fmap 'chooseRep'@.
 
-mkDispatchClause :: Q Exp -- ^ runHandler function
-                 -> Q Exp -- ^ dispatcher function
-                 -> Q Exp -- ^ fixHandler function
+mkDispatchClause :: MkDispatchSettings
                  -> [ResourceTree a]
                  -> Q Clause
-mkDispatchClause runHandler dispatcher fixHandler ress' = do
+mkDispatchClause mds ress' = do
     -- Allocate the names to be used. Start off with the names passed to the
     -- function itself (with a 0 suffix).
     --
@@ -103,41 +109,42 @@ mkDispatchClause runHandler dispatcher fixHandler ress' = do
     -- with -Wall). Additionally, we want to ensure that none of the code
     -- passed to toDispatch uses variables from the closure to prevent the
     -- dispatch data structure from being rebuilt on each run.
-    master0 <- newName "master0"
-    sub0 <- newName "sub0"
-    toMaster0 <- newName "toMaster0"
-    app4040 <- newName "app4040"
-    handler4050 <- newName "handler4050"
-    method0 <- newName "method0"
-    pieces0 <- newName "pieces0"
+    getEnv0 <- newName "yesod_dispatch_env0"
+    req0 <- newName "req0"
+    pieces <- [|$(mdsGetPathInfo mds) $(return $ VarE req0)|]
 
     -- Name of the dispatch function
     dispatch <- newName "dispatch"
 
     -- Dispatch function applied to the pieces
-    let dispatched = VarE dispatch `AppE` VarE pieces0
+    let dispatched = VarE dispatch `AppE` pieces
 
     -- The 'D.Route's used in the dispatch function
-    routes <- mapM (buildRoute runHandler dispatcher fixHandler) ress
+    routes <- mapM (buildRoute mds) ress
 
     -- The dispatch function itself
     toDispatch <- [|D.toDispatch|]
-    let dispatchFun = FunD dispatch [Clause [] (NormalB $ toDispatch `AppE` ListE routes) []]
+    let dispatchFun = FunD dispatch
+            [Clause
+                []
+                (NormalB $ toDispatch `AppE` ListE routes)
+                []
+            ]
 
     -- The input to the clause.
-    let pats = map VarP [master0, sub0, toMaster0, app4040, handler4050, method0, pieces0]
+    let pats = map VarP [getEnv0, req0]
 
     -- For each resource that dispatches based on methods, build up a map for handling the dispatching.
-    methodMaps <- catMaybes <$> mapM (buildMethodMap fixHandler) ress
+    methodMaps <- catMaybes <$> mapM (buildMethodMap mds) ress
 
     u <- [|case $(return dispatched) of
-            Just f -> f $(return $ VarE master0)
-                        $(return $ VarE sub0)
-                        $(return $ VarE toMaster0)
-                        $(return $ VarE app4040)
-                        $(return $ VarE handler4050)
-                        $(return $ VarE method0)
-            Nothing -> $(return $ VarE app4040)
+            Just f -> f $(return $ VarE getEnv0)
+                        $(return $ VarE req0)
+            Nothing -> $(mdsRunHandler mds)
+                            $(mds404 mds)
+                            $(return $ VarE getEnv0)
+                            Nothing
+                            $(return $ VarE req0)
           |]
     return $ Clause pats (NormalB u) $ dispatchFun : methodMaps
   where
@@ -147,11 +154,11 @@ mkDispatchClause runHandler dispatcher fixHandler ress' = do
 methodMapName :: String -> Name
 methodMapName s = mkName $ "methods" ++ s
 
-buildMethodMap :: Q Exp -- ^ fixHandler
+buildMethodMap :: MkDispatchSettings
                -> FlatResource a
                -> Q (Maybe Dec)
 buildMethodMap _ (FlatResource _ _ _ (Methods _ [])) = return Nothing -- single handle function
-buildMethodMap fixHandler (FlatResource parents name pieces' (Methods mmulti methods)) = do
+buildMethodMap mds (FlatResource parents name pieces' (Methods mmulti methods)) = do
     fromList <- [|Map.fromList|]
     methods' <- mapM go methods
     let exp = fromList `AppE` ListE methods'
@@ -160,20 +167,27 @@ buildMethodMap fixHandler (FlatResource parents name pieces' (Methods mmulti met
   where
     pieces = concat $ map snd parents ++ [pieces']
     go method = do
-        fh <- fixHandler
-        let func = VarE $ mkName $ map toLower method ++ name
-        pack' <- [|pack|]
+        func <- mdsGetHandler mds (Just method) name
+        pack' <- [|encodeUtf8 . pack|]
         let isDynamic Dynamic{} = True
             isDynamic _ = False
         let argCount = length (filter (isDynamic . snd) pieces) + maybe 0 (const 1) mmulti
         xs <- replicateM argCount $ newName "arg"
-        let rhs = LamE (map VarP xs) $ fh `AppE` (foldl' AppE func $ map VarE xs)
-        return $ TupE [pack' `AppE` LitE (StringL method), rhs]
+        runHandler <- mdsRunHandler mds
+        let rhs
+                | null xs = runHandler `AppE` func
+                | otherwise =
+                    LamE (map VarP xs) $
+                    runHandler `AppE` (foldl' AppE func $ map VarE xs)
+        return $ TupE
+            [ pack' `AppE` LitE (StringL method)
+            , rhs
+            ]
 buildMethodMap _ (FlatResource _ _ _ Subsite{}) = return Nothing
 
 -- | Build a single 'D.Route' expression.
-buildRoute :: Q Exp -> Q Exp -> Q Exp -> FlatResource a -> Q Exp
-buildRoute runHandler dispatcher fixHandler (FlatResource parents name resPieces resDisp) = do
+buildRoute :: MkDispatchSettings -> FlatResource a -> Q Exp
+buildRoute mds (FlatResource parents name resPieces resDisp) = do
     -- First two arguments to D.Route
     routePieces <- ListE <$> mapM (convertPiece . snd) allPieces
     isMulti <-
@@ -181,19 +195,26 @@ buildRoute runHandler dispatcher fixHandler (FlatResource parents name resPieces
             Methods Nothing _ -> [|False|]
             _ -> [|True|]
 
-    [|D.Route $(return routePieces) $(return isMulti) $(routeArg3 runHandler dispatcher fixHandler parents name (map snd allPieces) resDisp)|]
+    [|D.Route
+        $(return routePieces)
+        $(return isMulti)
+        $(routeArg3
+            mds
+            parents
+            name
+            (map snd allPieces)
+            resDisp)
+        |]
   where
     allPieces = concat $ map snd parents ++ [resPieces]
 
-routeArg3 :: Q Exp -- ^ runHandler
-          -> Q Exp -- ^ dispatcher
-          -> Q Exp -- ^ fixHandler
+routeArg3 :: MkDispatchSettings
           -> [(String, [(CheckOverlap, Piece a)])]
           -> String -- ^ name of resource
           -> [Piece a]
           -> Dispatch a
           -> Q Exp
-routeArg3 runHandler dispatcher fixHandler parents name resPieces resDisp = do
+routeArg3 mds parents name resPieces resDisp = do
     pieces <- newName "pieces"
 
     -- Allocate input piece variables (xs) and variables that have been
@@ -235,7 +256,7 @@ routeArg3 runHandler dispatcher fixHandler parents name resPieces resDisp = do
             _ -> return ([], [])
 
     -- The final expression that actually uses the values we've computed
-    caller <- buildCaller runHandler dispatcher fixHandler xrest parents name resDisp $ map snd ys ++ yrest'
+    caller <- buildCaller mds xrest parents name resDisp $ map snd ys ++ yrest'
 
     -- Put together all the statements
     just <- [|Just|]
@@ -254,24 +275,20 @@ routeArg3 runHandler dispatcher fixHandler parents name resPieces resDisp = do
     return $ LamE [VarP pieces] $ CaseE (VarE pieces) matches
 
 -- | The final expression in the individual Route definitions.
-buildCaller :: Q Exp -- ^ runHandler
-            -> Q Exp -- ^ dispatcher
-            -> Q Exp -- ^ fixHandler
+buildCaller :: MkDispatchSettings
             -> Name -- ^ xrest
             -> [(String, [(CheckOverlap, Piece a)])]
             -> String -- ^ name of resource
             -> Dispatch a
             -> [Name] -- ^ ys
             -> Q Exp
-buildCaller runHandler dispatcher fixHandler xrest parents name resDisp ys = do
-    master <- newName "master"
-    sub <- newName "sub"
-    toMaster <- newName "toMaster"
-    app404 <- newName "_app404"
-    handler405 <- newName "_handler405"
-    method <- newName "_method"
+buildCaller mds xrest parents name resDisp ys = do
+    getEnv <- newName "yesod_dispatch_env"
+    req <- newName "req"
 
-    let pat = map VarP [master, sub, toMaster, app404, handler405, method]
+    method <- [|$(mdsMethod mds) $(return $ VarE req)|]
+
+    let pat = map VarP [getEnv, req]
 
     -- Create the route
     let route = routeFromDynamics parents name ys
@@ -281,13 +298,14 @@ buildCaller runHandler dispatcher fixHandler xrest parents name resDisp ys = do
             Methods _ ms -> do
                 handler <- newName "handler"
 
+                env <- [|$(return $ VarE getEnv) (Just $(return route))|]
+
                 -- Run the whole thing
-                runner <- [|$(runHandler)
-                                $(return $ VarE handler)
-                                $(return $ VarE master)
-                                $(return $ VarE sub)
+                runner <- [|$(return $ VarE handler)
+                                $(return $ VarE getEnv)
                                 (Just $(return route))
-                                $(return $ VarE toMaster)|]
+                                $(return $ VarE req)
+                                |]
 
                 let myLet handlerExp =
                         LetE [FunD handler [Clause [] (NormalB handlerExp) []]] runner
@@ -295,32 +313,40 @@ buildCaller runHandler dispatcher fixHandler xrest parents name resDisp ys = do
                 if null ms
                     then do
                         -- Just a single handler
-                        fh <- fixHandler
-                        let he = fh `AppE` foldl' (\a b -> a `AppE` VarE b) (VarE $ mkName $ "handle" ++ name) ys
-                        return $ myLet he
+                        base <- mdsGetHandler mds Nothing name
+                        let he = foldl' (\a b -> a `AppE` VarE b) base ys
+                        runHandler <- mdsRunHandler mds
+                        return $ myLet $ runHandler `AppE` he
                     else do
                         -- Individual methods
-                        mf <- [|Map.lookup $(return $ VarE method) $(return $ VarE $ methodMapName name)|]
+                        mf <- [|Map.lookup $(return method) $(return $ VarE $ methodMapName name)|]
                         f <- newName "f"
                         let apply = foldl' (\a b -> a `AppE` VarE b) (VarE f) ys
-                        let body405 =
-                                VarE handler405
-                                `AppE` route
+                        body405 <-
+                            [|$(mdsRunHandler mds)
+                                $(mds405 mds)
+                                $(return $ VarE getEnv)
+                                (Just $(return route))
+                                $(return $ VarE req)
+                             |]
                         return $ CaseE mf
                             [ Match (ConP 'Just [VarP f]) (NormalB $ myLet apply) []
                             , Match (ConP 'Nothing []) (NormalB body405) []
                             ]
 
             Subsite _ getSub -> do
-                let sub2 = foldl' (\a b -> a `AppE` VarE b) (VarE (mkName getSub) `AppE` VarE sub) ys
-                [|$(dispatcher)
-                    $(return $ VarE master)
+                sub <- newName "sub"
+                let sub2 = LamE [VarP sub]
+                        (foldl' (\a b -> a `AppE` VarE b) (VarE (mkName getSub) `AppE` VarE sub) ys)
+                [|$(mdsSubDispatcher mds)
+                    $(mdsRunHandler mds)
                     $(return sub2)
-                    ($(return $ VarE toMaster) . $(return route))
-                    $(return $ VarE app404)
-                    ($(return $ VarE handler405) . $(return route))
-                    $(return $ VarE method)
-                    $(return $ VarE xrest)
+                    $(return route)
+                    $(return $ VarE getEnv)
+                    ($(mdsSetPathInfo mds)
+                        $(return $ VarE xrest)
+                        $(return $ VarE req)
+                        )
                  |]
 
     return $ LamE pat exp
diff --git a/yesod-routes/Yesod/Routes/TH/ParseRoute.hs b/yesod-routes/Yesod/Routes/TH/ParseRoute.hs
new file mode 100644
index 00000000..b61037ba
--- /dev/null
+++ b/yesod-routes/Yesod/Routes/TH/ParseRoute.hs
@@ -0,0 +1,178 @@
+{-# LANGUAGE TemplateHaskell #-}
+module Yesod.Routes.TH.ParseRoute
+    ( -- ** ParseRoute
+      mkParseRouteInstance
+    ) where
+
+import Yesod.Routes.TH.Types
+import Language.Haskell.TH.Syntax
+import Data.Text (pack)
+import Web.PathPieces (PathPiece (..), PathMultiPiece (..))
+import Yesod.Routes.Class
+import qualified Yesod.Routes.Dispatch as D
+import Data.List (foldl')
+import Control.Applicative ((<$>))
+import Data.Maybe (catMaybes)
+import Control.Monad (forM)
+import Control.Monad (join)
+
+-- | Clauses for the 'parseRoute' method.
+mkParseRouteClauses :: [ResourceTree a] -> Q [Clause]
+mkParseRouteClauses ress' = do
+    pieces <- newName "pieces0"
+    dispatch <- newName "dispatch"
+    query <- newName "_query"
+
+    -- The 'D.Route's used in the dispatch function
+    routes <- mapM (buildRoute query) ress
+
+    -- The dispatch function itself
+    toDispatch <- [|D.toDispatch|]
+    let dispatchFun = FunD dispatch
+            [Clause
+                []
+                (NormalB $ toDispatch `AppE` ListE routes)
+                []
+            ]
+
+    join' <- [|join|]
+    let body = join' `AppE` (VarE dispatch `AppE` VarE pieces)
+    return $ return $ Clause
+        [TupP [VarP pieces, VarP query]]
+        (NormalB body)
+        [dispatchFun]
+  where
+    ress = map noMethods $ flatten ress'
+    noMethods (FlatResource a b c d) = FlatResource a b c $ noMethods' d
+    noMethods' (Methods a _) = Methods a []
+    noMethods' (Subsite a b) = Subsite a b
+
+mkParseRouteInstance :: Type -> [ResourceTree a] -> Q Dec
+mkParseRouteInstance typ ress = do
+    cls <- mkParseRouteClauses ress
+    return $ InstanceD [] (ConT ''ParseRoute `AppT` typ)
+        [ FunD 'parseRoute cls
+        ]
+
+-- | Build a single 'D.Route' expression.
+buildRoute :: Name -> FlatResource a -> Q Exp
+buildRoute query (FlatResource parents name resPieces resDisp) = do
+    -- First two arguments to D.Route
+    routePieces <- ListE <$> mapM (convertPiece . snd) allPieces
+    isMulti <-
+        case resDisp of
+            Methods Nothing _ -> [|False|]
+            _ -> [|True|]
+
+    [|D.Route
+        $(return routePieces)
+        $(return isMulti)
+        $(routeArg3
+            query
+            parents
+            name
+            (map snd allPieces)
+            resDisp)
+        |]
+  where
+    allPieces = concat $ map snd parents ++ [resPieces]
+
+routeArg3 :: Name -- ^ query string parameters
+          -> [(String, [(CheckOverlap, Piece a)])]
+          -> String -- ^ name of resource
+          -> [Piece a]
+          -> Dispatch a
+          -> Q Exp
+routeArg3 query parents name resPieces resDisp = do
+    pieces <- newName "pieces"
+
+    -- Allocate input piece variables (xs) and variables that have been
+    -- converted via fromPathPiece (ys)
+    xs <- forM resPieces $ \piece ->
+        case piece of
+            Static _ -> return Nothing
+            Dynamic _ -> Just <$> newName "x"
+
+    -- Note: the zipping with Ints is just a workaround for (apparently) a bug
+    -- in GHC where the identifiers are considered to be overlapping. Using
+    -- newName should avoid the problem, but it doesn't.
+    ys <- forM (zip (catMaybes xs) [1..]) $ \(x, i) -> do
+        y <- newName $ "y" ++ show (i :: Int)
+        return (x, y)
+
+    -- In case we have multi pieces at the end
+    xrest <- newName "xrest"
+    yrest <- newName "yrest"
+
+    -- Determine the pattern for matching the pieces
+    pat <-
+        case resDisp of
+            Methods Nothing _ -> return $ ListP $ map (maybe WildP VarP) xs
+            _ -> do
+                let cons = mkName ":"
+                return $ foldr (\a b -> ConP cons [maybe WildP VarP a, b]) (VarP xrest) xs
+
+    -- Convert the xs
+    fromPathPiece' <- [|fromPathPiece|]
+    xstmts <- forM ys $ \(x, y) -> return $ BindS (VarP y) (fromPathPiece' `AppE` VarE x)
+
+    -- Convert the xrest if appropriate
+    (reststmts, yrest') <-
+        case resDisp of
+            Methods (Just _) _ -> do
+                fromPathMultiPiece' <- [|fromPathMultiPiece|]
+                return ([BindS (VarP yrest) (fromPathMultiPiece' `AppE` VarE xrest)], [yrest])
+            _ -> return ([], [])
+
+    -- The final expression that actually uses the values we've computed
+    caller <- buildCaller query xrest parents name resDisp $ map snd ys ++ yrest'
+
+    -- Put together all the statements
+    just <- [|Just|]
+    let stmts = concat
+            [ xstmts
+            , reststmts
+            , [NoBindS $ just `AppE` caller]
+            ]
+
+    errorMsg <- [|error "Invariant violated"|]
+    let matches =
+            [ Match pat (NormalB $ DoE stmts) []
+            , Match WildP (NormalB errorMsg) []
+            ]
+
+    return $ LamE [VarP pieces] $ CaseE (VarE pieces) matches
+
+-- | The final expression in the individual Route definitions.
+buildCaller :: Name -- ^ query string parameters
+            -> Name -- ^ xrest
+            -> [(String, [(CheckOverlap, Piece a)])]
+            -> String -- ^ name of resource
+            -> Dispatch a
+            -> [Name] -- ^ ys
+            -> Q Exp
+buildCaller query xrest parents name resDisp ys = do
+    -- Create the route
+    let route = routeFromDynamics parents name ys
+
+    case resDisp of
+        Methods _ _ -> [|Just $(return route)|]
+        Subsite _ _ -> [|fmap $(return route) $ parseRoute ($(return $ VarE xrest), $(return $ VarE query))|]
+
+-- | Convert a 'Piece' to a 'D.Piece'
+convertPiece :: Piece a -> Q Exp
+convertPiece (Static s) = [|D.Static (pack $(lift s))|]
+convertPiece (Dynamic _) = [|D.Dynamic|]
+
+routeFromDynamics :: [(String, [(CheckOverlap, Piece a)])] -- ^ parents
+                  -> String -- ^ constructor name
+                  -> [Name]
+                  -> Exp
+routeFromDynamics [] name ys = foldl' (\a b -> a `AppE` VarE b) (ConE $ mkName name) ys
+routeFromDynamics ((parent, pieces):rest) name ys =
+    foldl' (\a b -> a `AppE` b) (ConE $ mkName parent) here
+  where
+    (here', ys') = splitAt (length $ filter (isDynamic . snd) pieces) ys
+    isDynamic Dynamic{} = True
+    isDynamic _ = False
+    here = map VarE here' ++ [routeFromDynamics rest name ys']
diff --git a/yesod-routes/Yesod/Routes/TH/RouteAttrs.hs b/yesod-routes/Yesod/Routes/TH/RouteAttrs.hs
new file mode 100644
index 00000000..539e038c
--- /dev/null
+++ b/yesod-routes/Yesod/Routes/TH/RouteAttrs.hs
@@ -0,0 +1,38 @@
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE RecordWildCards #-}
+module Yesod.Routes.TH.RouteAttrs
+    ( mkRouteAttrsInstance
+    ) where
+
+import Yesod.Routes.TH.Types
+import Yesod.Routes.Class
+import Language.Haskell.TH.Syntax
+import Data.Set (fromList)
+import Data.Text (pack)
+
+mkRouteAttrsInstance :: Type -> [ResourceTree a] -> Q Dec
+mkRouteAttrsInstance typ ress = do
+    clauses <- mapM (goTree id) ress
+    return $ InstanceD [] (ConT ''RouteAttrs `AppT` typ)
+        [ FunD 'routeAttrs $ concat clauses
+        ]
+
+goTree :: (Pat -> Pat) -> ResourceTree a -> Q [Clause]
+goTree front (ResourceLeaf res) = fmap return $ goRes front res
+goTree front (ResourceParent name pieces trees) =
+    fmap concat $ mapM (goTree front') trees
+  where
+    ignored = ((replicate toIgnore WildP ++) . return)
+    toIgnore = length $ filter (isDynamic . snd) pieces
+    isDynamic Dynamic{} = True
+    isDynamic Static{} = False
+    front' = front . ConP (mkName name) . ignored
+
+goRes :: (Pat -> Pat) -> Resource a -> Q Clause
+goRes front Resource {..} =
+    return $ Clause
+        [front $ RecP (mkName resourceName) []]
+        (NormalB $ VarE 'fromList `AppE` ListE (map toText resourceAttrs))
+        []
+  where
+    toText s = VarE 'pack `AppE` LitE (StringL s)
diff --git a/yesod-routes/Yesod/Routes/TH/Types.hs b/yesod-routes/Yesod/Routes/TH/Types.hs
index 52cd446f..d0a04052 100644
--- a/yesod-routes/Yesod/Routes/TH/Types.hs
+++ b/yesod-routes/Yesod/Routes/TH/Types.hs
@@ -6,10 +6,12 @@ module Yesod.Routes.TH.Types
     , Piece (..)
     , Dispatch (..)
     , CheckOverlap
+    , FlatResource (..)
       -- ** Helper functions
     , resourceMulti
     , resourceTreePieces
     , resourceTreeName
+    , flatten
     ) where
 
 import Language.Haskell.TH.Syntax
@@ -37,16 +39,17 @@ data Resource typ = Resource
     { resourceName :: String
     , resourcePieces :: [(CheckOverlap, Piece typ)]
     , resourceDispatch :: Dispatch typ
+    , resourceAttrs :: [String]
     }
     deriving Show
 
 type CheckOverlap = Bool
 
 instance Functor Resource where
-    fmap f (Resource a b c) = Resource a (map (second $ fmap f) b) (fmap f c)
+    fmap f (Resource a b c d) = Resource a (map (second $ fmap f) b) (fmap f c) d
 
 instance Lift t => Lift (Resource t) where
-    lift (Resource a b c) = [|Resource $(lift a) $(lift b) $(lift c)|]
+    lift (Resource a b c d) = [|Resource a b c d|]
 
 data Piece typ = Static String | Dynamic typ
     deriving Show
@@ -82,3 +85,13 @@ instance Lift t => Lift (Dispatch t) where
 resourceMulti :: Resource typ -> Maybe typ
 resourceMulti Resource { resourceDispatch = Methods (Just t) _ } = Just t
 resourceMulti _ = Nothing
+
+data FlatResource a = FlatResource [(String, [(CheckOverlap, Piece a)])] String [(CheckOverlap, Piece a)] (Dispatch a)
+
+flatten :: [ResourceTree a] -> [FlatResource a]
+flatten =
+    concatMap (go id)
+  where
+    go front (ResourceLeaf (Resource a b c _)) = [FlatResource (front []) a b c]
+    go front (ResourceParent name pieces children) =
+        concatMap (go (front . ((name, pieces):))) children
diff --git a/yesod-routes/test/Hierarchy.hs b/yesod-routes/test/Hierarchy.hs
index a4bf6316..72a041b9 100644
--- a/yesod-routes/test/Hierarchy.hs
+++ b/yesod-routes/test/Hierarchy.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
@@ -8,10 +9,12 @@
 module Hierarchy
     ( hierarchy
     , Dispatcher (..)
-    , RunHandler (..)
+    , runHandler
     , Handler
     , App
     , toText
+    , Env (..)
+    , subDispatch
     ) where
 
 import Test.Hspec
@@ -22,6 +25,8 @@ import Yesod.Routes.Class
 import Language.Haskell.TH.Syntax
 import qualified Yesod.Routes.Class as YRC
 import Data.Text (Text, pack, append)
+import Data.ByteString (ByteString)
+import qualified Data.ByteString.Char8 as S8
 
 class ToText a where
     toText :: a -> Text
@@ -29,28 +34,41 @@ class ToText a where
 instance ToText Text where toText = id
 instance ToText String where toText = pack
 
-type Handler sub master = Text
-type App sub master = (Text, Maybe (YRC.Route master))
+type Handler sub master a = a
+type Request = ([Text], ByteString) -- path info, method
+type App sub master = Request -> (Text, Maybe (YRC.Route master))
+data Env sub master = Env
+    { envToMaster :: YRC.Route sub -> YRC.Route master
+    , envSub :: sub
+    , envMaster :: master
+    }
+
+subDispatch
+    :: (Env sub master -> App sub master)
+    -> (Handler sub master Text -> Env sub master -> Maybe (YRC.Route sub) -> App sub master)
+    -> (master -> sub)
+    -> (YRC.Route sub -> YRC.Route master)
+    -> Env master master
+    -> App sub master
+subDispatch handler _runHandler getSub toMaster env req =
+    handler env' req
+  where
+    env' = env
+        { envToMaster = envToMaster env . toMaster
+        , envSub = getSub $ envMaster env
+        }
 
 class Dispatcher sub master where
-    dispatcher
-        :: master
-        -> sub
-        -> (YRC.Route sub -> YRC.Route master)
-        -> App sub master -- ^ 404 page
-        -> (YRC.Route sub -> App sub master) -- ^ 405 page
-        -> Text -- ^ method
-        -> [Text]
-        -> App sub master
+    dispatcher :: Env sub master -> App sub master
+
+runHandler
+    :: ToText a
+    => Handler sub master a
+    -> Env sub master
+    -> Maybe (Route sub)
+    -> App sub master
+runHandler h Env {..} route _ = (toText h, fmap envToMaster route)
 
-class RunHandler sub master where
-    runHandler
-        :: Handler sub master
-        -> master
-        -> sub
-        -> Maybe (YRC.Route sub)
-        -> (YRC.Route sub -> YRC.Route master)
-        -> App sub master
 
 data Hierarchy = Hierarchy
 
@@ -63,7 +81,17 @@ do
     /table/#Text TableR GET
 |]
     rrinst <- mkRenderRouteInstance (ConT ''Hierarchy) $ map (fmap parseType) resources
-    dispatch <- mkDispatchClause [|runHandler|] [|dispatcher|] [|toText|] resources
+    prinst <- mkParseRouteInstance (ConT ''Hierarchy) $ map (fmap parseType) resources
+    dispatch <- mkDispatchClause MkDispatchSettings
+        { mdsRunHandler = [|runHandler|]
+        , mdsSubDispatcher = [|subDispatch|]
+        , mdsGetPathInfo = [|fst|]
+        , mdsMethod = [|snd|]
+        , mdsSetPathInfo = [|\p (_, m) -> (p, m)|]
+        , mds404 = [|pack "404"|]
+        , mds405 = [|pack "405"|]
+        , mdsGetHandler = defaultGetHandler
+        } resources
     return
         $ InstanceD
             []
@@ -71,32 +99,41 @@ do
                 `AppT` ConT ''Hierarchy
                 `AppT` ConT ''Hierarchy)
             [FunD (mkName "dispatcher") [dispatch]]
+        : prinst
         : rrinst
 
-getHomeR :: Handler sub master
+getHomeR :: Handler sub master String
 getHomeR = "home"
 
-getAdminRootR :: Int -> Handler sub master
+getAdminRootR :: Int -> Handler sub master Text
 getAdminRootR i = pack $ "admin root: " ++ show i
 
-getLoginR :: Int -> Handler sub master
+getLoginR :: Int -> Handler sub master Text
 getLoginR i = pack $ "login: " ++ show i
 
-postLoginR :: Int -> Handler sub master
+postLoginR :: Int -> Handler sub master Text
 postLoginR i = pack $ "post login: " ++ show i
 
-getTableR :: Int -> Text -> Handler sub master
+getTableR :: Int -> Text -> Handler sub master Text
 getTableR _ t = append "TableR " t
 
-instance RunHandler Hierarchy master where
-    runHandler h _ _ subRoute toMaster = (h, fmap toMaster subRoute)
-
 hierarchy :: Spec
 hierarchy = describe "hierarchy" $ do
     it "renders root correctly" $
         renderRoute (AdminR 5 AdminRootR) @?= (["admin", "5"], [])
     it "renders table correctly" $
         renderRoute (AdminR 6 $ TableR "foo") @?= (["admin", "6", "table", "foo"], [])
-    let disp m ps = dispatcher Hierarchy Hierarchy id (pack "404", Nothing) (\route -> (pack "405", Just route)) (pack m) (map pack ps)
+    let disp m ps = dispatcher
+            (Env
+                { envToMaster = id
+                , envMaster = Hierarchy
+                , envSub = Hierarchy
+                })
+            (map pack ps, S8.pack m)
     it "dispatches root correctly" $ disp "GET" ["admin", "7"] @?= ("admin root: 7", Just $ AdminR 7 AdminRootR)
     it "dispatches table correctly" $ disp "GET" ["admin", "8", "table", "bar"] @?= ("TableR bar", Just $ AdminR 8 $ TableR "bar")
+    it "parses" $ do
+        parseRoute ([], []) @?= Just HomeR
+        parseRoute ([], [("foo", "bar")]) @?= Just HomeR
+        parseRoute (["admin", "5"], []) @?= Just (AdminR 5 AdminRootR)
+        parseRoute (["admin!", "5"], []) @?= (Nothing :: Maybe (Route Hierarchy))
diff --git a/yesod-routes/test/main.hs b/yesod-routes/test/main.hs
index 16db9be9..efc996f7 100644
--- a/yesod-routes/test/main.hs
+++ b/yesod-routes/test/main.hs
@@ -1,4 +1,6 @@
 {-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE ViewPatterns#-}
+{-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE ExistentialQuantification #-}
@@ -15,11 +17,13 @@ import Yesod.Routes.Dispatch hiding (Static, Dynamic)
 import Yesod.Routes.Class hiding (Route)
 import qualified Yesod.Routes.Class as YRC
 import qualified Yesod.Routes.Dispatch as D
-import Yesod.Routes.Parse (parseRoutesNoCheck)
+import Yesod.Routes.Parse (parseRoutesNoCheck, parseTypeTree, TypeTree (..))
 import Yesod.Routes.Overlap (findOverlapNames)
 import Yesod.Routes.TH hiding (Dispatch)
 import Language.Haskell.TH.Syntax
 import Hierarchy
+import qualified Data.ByteString.Char8 as S8
+import qualified Data.Set as Set
 
 result :: ([Text] -> Maybe Int) -> Dispatch Int
 result f ts = f ts
@@ -76,6 +80,8 @@ instance RenderRoute MySub where
         MySub = MySubRoute ([Text], [(Text, Text)])
         deriving (Show, Eq, Read)
     renderRoute (MySubRoute x) = x
+instance ParseRoute MySub where
+    parseRoute = Just . MySubRoute
 
 getMySub :: MyApp -> MySub
 getMySub MyApp = MySub
@@ -91,22 +97,44 @@ instance RenderRoute MySubParam where
         MySubParam = ParamRoute Char
         deriving (Show, Eq, Read)
     renderRoute (ParamRoute x) = ([singleton x], [])
+instance ParseRoute MySubParam where
+    parseRoute ([unpack -> [x]], _) = Just $ ParamRoute x
+    parseRoute _ = Nothing
 
 getMySubParam :: MyApp -> Int -> MySubParam
 getMySubParam _ = MySubParam
 
 do
     texts <- [t|[Text]|]
-    let ress = map ResourceLeaf
-            [ Resource "RootR" [] $ Methods Nothing ["GET"]
-            , Resource "BlogPostR" (addCheck [Static "blog", Dynamic $ ConT ''Text]) $ Methods Nothing ["GET", "POST"]
-            , Resource "WikiR" (addCheck [Static "wiki"]) $ Methods (Just texts) []
-            , Resource "SubsiteR" (addCheck [Static "subsite"]) $ Subsite (ConT ''MySub) "getMySub"
-            , Resource "SubparamR" (addCheck [Static "subparam", Dynamic $ ConT ''Int]) $ Subsite (ConT ''MySubParam) "getMySubParam"
+    let resLeaves = map ResourceLeaf
+            [ Resource "RootR" [] (Methods Nothing ["GET"]) ["foo", "bar"]
+            , Resource "BlogPostR" (addCheck [Static "blog", Dynamic $ ConT ''Text]) (Methods Nothing ["GET", "POST"]) []
+            , Resource "WikiR" (addCheck [Static "wiki"]) (Methods (Just texts) []) []
+            , Resource "SubsiteR" (addCheck [Static "subsite"]) (Subsite (ConT ''MySub) "getMySub") []
+            , Resource "SubparamR" (addCheck [Static "subparam", Dynamic $ ConT ''Int]) (Subsite (ConT ''MySubParam) "getMySubParam") []
             ]
+        resParent = ResourceParent
+            "ParentR"
+            [ (True, Static "foo")
+            , (True, Dynamic $ ConT ''Text)
+            ]
+            [ ResourceLeaf $ Resource "ChildR" [] (Methods Nothing ["GET"]) ["child"]
+            ]
+        ress = resParent : resLeaves
         addCheck = map ((,) True)
     rrinst <- mkRenderRouteInstance (ConT ''MyApp) ress
-    dispatch <- mkDispatchClause [|runHandler|] [|dispatcher|] [|toText|] ress
+    rainst <- mkRouteAttrsInstance (ConT ''MyApp) ress
+    prinst <- mkParseRouteInstance (ConT ''MyApp) ress
+    dispatch <- mkDispatchClause MkDispatchSettings
+        { mdsRunHandler = [|runHandler|]
+        , mdsSubDispatcher = [|subDispatch dispatcher|]
+        , mdsGetPathInfo = [|fst|]
+        , mdsMethod = [|snd|]
+        , mdsSetPathInfo = [|\p (_, m) -> (p, m)|]
+        , mds404 = [|pack "404"|]
+        , mds405 = [|pack "405"|]
+        , mdsGetHandler = defaultGetHandler
+        } ress
     return
         $ InstanceD
             []
@@ -114,19 +142,29 @@ do
                 `AppT` ConT ''MyApp
                 `AppT` ConT ''MyApp)
             [FunD (mkName "dispatcher") [dispatch]]
+        : prinst
+        : rainst
         : rrinst
 
-instance RunHandler MyApp master where
-    runHandler h _ _ subRoute toMaster = (h, fmap toMaster subRoute)
-
 instance Dispatcher MySub master where
-    dispatcher _ _ toMaster _ _ _ pieces = (pack $ "subsite: " ++ show pieces, Just $ toMaster $ MySubRoute (pieces, []))
+    dispatcher env (pieces, _method) =
+        ( pack $ "subsite: " ++ show pieces
+        , Just $ envToMaster env route
+        )
+      where
+        route = MySubRoute (pieces, [])
 
 instance Dispatcher MySubParam master where
-    dispatcher _ (MySubParam i) toMaster app404 _ _ pieces =
+    dispatcher env (pieces, method) =
         case map unpack pieces of
-            [[c]] -> (pack $ "subparam " ++ show i ++ ' ' : [c], Just $ toMaster $ ParamRoute c)
-            _ -> app404
+            [[c]] ->
+                let route = ParamRoute c
+                    toMaster = envToMaster env
+                    MySubParam i = envSub env
+                 in ( pack $ "subparam " ++ show i ++ ' ' : [c]
+                    , Just $ toMaster route
+                    )
+            _ -> (pack "404", Nothing)
 
 {-
 thDispatchAlias
@@ -232,10 +270,16 @@ main = hspec $ do
             @?= (map pack ["subparam", "6", "c"], [])
 
     describe "thDispatch" $ do
-        let disp m ps = dispatcher MyApp MyApp id (pack "404", Nothing) (\route -> (pack "405", Just route)) (pack m) (map pack ps)
+        let disp m ps = dispatcher
+                (Env
+                    { envToMaster = id
+                    , envMaster = MyApp
+                    , envSub = MyApp
+                    })
+                (map pack ps, S8.pack m)
         it "routes to root" $ disp "GET" [] @?= (pack "this is the root", Just RootR)
         it "POST root is 405" $ disp "POST" [] @?= (pack "405", Just RootR)
-        it "invalid page is a 404" $ disp "GET" ["not-found"] @?= (pack "404", Nothing)
+        it "invalid page is a 404" $ disp "GET" ["not-found"] @?= (pack "404", Nothing :: Maybe (YRC.Route MyApp))
         it "routes to blog post" $ disp "GET" ["blog", "somepost"]
             @?= (pack "some blog post: somepost", Just $ BlogPostR $ pack "somepost")
         it "routes to blog post, POST method" $ disp "POST" ["blog", "somepost2"]
@@ -247,6 +291,11 @@ main = hspec $ do
         it "routes to subparam" $ disp "PUT" ["subparam", "6", "q"]
             @?= (pack "subparam 6 q", Just $ SubparamR 6 $ ParamRoute 'q')
 
+    describe "parsing" $ do
+        it "subsites work" $ do
+            parseRoute ([pack "subsite", pack "foo"], [(pack "bar", pack "baz")]) @?=
+                Just (SubsiteR $ MySubRoute ([pack "foo"], [(pack "bar", pack "baz")]))
+
     describe "overlap checking" $ do
         it "catches overlapping statics" $ do
             let routes = [parseRoutesNoCheck|
@@ -298,7 +347,24 @@ main = hspec $ do
 /bar/baz Foo3
 |]
             findOverlapNames routes @?= []
+    describe "routeAttrs" $ do
+        it "works" $ do
+            routeAttrs RootR @?= Set.fromList [pack "foo", pack "bar"]
+        it "hierarchy" $ do
+            routeAttrs (ParentR (pack "ignored") ChildR) @?= Set.singleton (pack "child")
     hierarchy
+    describe "parseRouteTyoe" $ do
+        let success s t = it s $ parseTypeTree s @?= Just t
+            failure s = it s $ parseTypeTree s @?= Nothing
+        success "Int" $ TTTerm "Int"
+        success "(Int)" $ TTTerm "Int"
+        failure "(Int"
+        failure "(Int))"
+        failure "[Int"
+        failure "[Int]]"
+        success "[Int]" $ TTList $ TTTerm "Int"
+        success "Foo-Bar" $ TTApp (TTTerm "Foo") (TTTerm "Bar")
+        success "Foo-Bar-Baz" $ TTApp (TTTerm "Foo") (TTTerm "Bar") `TTApp` TTTerm "Baz"
 
 getRootR :: Text
 getRootR = pack "this is the root"
@@ -311,3 +377,6 @@ postBlogPostR t = pack $ "POST some blog post: " ++ unpack t
 
 handleWikiR :: [Text] -> String
 handleWikiR ts = "the wiki: " ++ show ts
+
+getChildR :: Text -> Text
+getChildR = id
diff --git a/yesod-routes/yesod-routes.cabal b/yesod-routes/yesod-routes.cabal
index eb367b35..5f6a2f14 100644
--- a/yesod-routes/yesod-routes.cabal
+++ b/yesod-routes/yesod-routes.cabal
@@ -1,5 +1,5 @@
 name:            yesod-routes
-version:         1.1.2
+version:         1.2.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -29,6 +29,8 @@ library
                      Yesod.Routes.Overlap
     other-modules:   Yesod.Routes.TH.Dispatch
                      Yesod.Routes.TH.RenderRoute
+                     Yesod.Routes.TH.ParseRoute
+                     Yesod.Routes.TH.RouteAttrs
                      Yesod.Routes.TH.Types
     ghc-options:     -Wall
 
@@ -46,6 +48,7 @@ test-suite runtests
                  , containers
                  , template-haskell
                  , path-pieces
+                 , bytestring
     ghc-options:     -Wall
 
 source-repository head
diff --git a/yesod-sitemap/Yesod/Sitemap.hs b/yesod-sitemap/Yesod/Sitemap.hs
index 517e8cce..308164f8 100644
--- a/yesod-sitemap/Yesod/Sitemap.hs
+++ b/yesod-sitemap/Yesod/Sitemap.hs
@@ -19,18 +19,22 @@
 -- See <http://www.sitemaps.org/>.
 module Yesod.Sitemap
     ( sitemap
+    , sitemapList
+    , sitemapConduit
     , robots
     , SitemapUrl (..)
     , SitemapChangeFreq (..)
     ) where
 
-import Yesod.Content (RepXml (..), RepPlain (..), toContent, formatW3)
-import Yesod.Core (Route, GHandler, getUrlRender)
+import Yesod.Core
 import Data.Time (UTCTime)
-import Data.Monoid (mappend)
-import Text.XML
+import Text.XML.Stream.Render (renderBuilder)
 import Data.Text (Text, pack)
-import qualified Data.Map as Map
+import Data.XML.Types
+import Data.Conduit
+import qualified Data.Conduit.List as CL
+import Data.Default (def)
+import qualified Data.Text as T
 
 data SitemapChangeFreq = Always
                        | Hourly
@@ -51,40 +55,70 @@ showFreq Never   = "never"
 
 data SitemapUrl url = SitemapUrl
     { sitemapLoc :: url
-    , sitemapLastMod :: UTCTime
-    , sitemapChangeFreq :: SitemapChangeFreq
-    , sitemapPriority :: Double
+    , sitemapLastMod :: Maybe UTCTime
+    , sitemapChangeFreq :: Maybe SitemapChangeFreq
+    , sitemapPriority :: Maybe Double
     }
 
-template :: [SitemapUrl url]
-         -> (url -> Text)
-         -> Document
-template urls render =
-    Document (Prologue [] Nothing []) (addNS root) []
-  where
-    addNS (Element (Name ln _ _) as ns) = Element (Name ln (Just namespace) Nothing) as (map addNS' ns)
-    addNS' (NodeElement e) = NodeElement (addNS e)
-    addNS' n = n
-    namespace = "http://www.sitemaps.org/schemas/sitemap/0.9"
-
-    root = Element "urlset" Map.empty $ map go urls
-
-    go SitemapUrl {..} = NodeElement $ Element "url" Map.empty $ map NodeElement
-        [ Element "loc" Map.empty [NodeContent $ render sitemapLoc]
-        , Element "lastmod" Map.empty [NodeContent $ formatW3 sitemapLastMod]
-        , Element "changefreq" Map.empty [NodeContent $ showFreq sitemapChangeFreq]
-        , Element "priority" Map.empty [NodeContent $ pack $ show sitemapPriority]
+-- | A basic robots file which just lists the "Sitemap: " line.
+robots :: MonadHandler m
+       => Route (HandlerSite m) -- ^ sitemap url
+       -> m Text
+robots smurl = do
+    ur <- getUrlRender
+    return $ T.unlines
+        [ "Sitemap: " `T.append` ur smurl
+        , "User-agent: *"
         ]
 
-sitemap :: [SitemapUrl (Route master)] -> GHandler sub master RepXml
+-- | Serve a stream of @SitemapUrl@s as a sitemap.
+--
+-- Since 1.2.0
+sitemap :: Source (HandlerT site IO) (SitemapUrl (Route site))
+        -> HandlerT site IO TypedContent
 sitemap urls = do
     render <- getUrlRender
-    let doc = template urls render
-    return $ RepXml $ toContent $ renderLBS def doc
+    respondSource typeXml $ do
+        yield Flush
+        urls $= sitemapConduit render $= renderBuilder def $= CL.map Chunk
 
--- | A basic robots file which just lists the "Sitemap: " line.
-robots :: Route master -- ^ sitemap url
-       -> GHandler sub master RepPlain
-robots smurl = do
-    render <- getUrlRender
-    return $ RepPlain $ toContent $ "Sitemap: " `mappend` render smurl
+-- | Convenience wrapper for @sitemap@ for the case when the input is an
+-- in-memory list.
+--
+-- Since 1.2.0
+sitemapList :: [SitemapUrl (Route site)] -> HandlerT site IO TypedContent
+sitemapList = sitemap . mapM_ yield
+
+-- | Convert a stream of @SitemapUrl@s to XML @Event@s using the given URL
+-- renderer.
+--
+-- This function is fully general for usage outside of Yesod.
+--
+-- Since 1.2.0
+sitemapConduit :: Monad m
+               => (a -> Text)
+               -> Conduit (SitemapUrl a) m Event
+sitemapConduit render = do
+    yield EventBeginDocument
+    element "urlset" [] $ awaitForever goUrl
+    yield EventEndDocument
+  where
+    namespace = "http://www.sitemaps.org/schemas/sitemap/0.9"
+    element name' attrs inside = do
+        yield $ EventBeginElement name attrs
+        () <- inside
+        yield $ EventEndElement name
+      where
+        name = Name name' (Just namespace) Nothing
+
+    goUrl SitemapUrl {..} = element "url" [] $ do
+        element "loc" [] $ yield $ EventContent $ ContentText $ render sitemapLoc
+        case sitemapLastMod of
+            Nothing -> return ()
+            Just lm -> element "lastmod" [] $ yield $ EventContent $ ContentText $ formatW3 lm
+        case sitemapChangeFreq of
+            Nothing -> return ()
+            Just scf -> element "changefreq" [] $ yield $ EventContent $ ContentText $ showFreq scf
+        case sitemapPriority of
+            Nothing -> return ()
+            Just p -> element "priority" [] $ yield $ EventContent $ ContentText $ pack $ show p
diff --git a/yesod-sitemap/yesod-sitemap.cabal b/yesod-sitemap/yesod-sitemap.cabal
index 53605135..2274334d 100644
--- a/yesod-sitemap/yesod-sitemap.cabal
+++ b/yesod-sitemap/yesod-sitemap.cabal
@@ -1,5 +1,5 @@
 name:            yesod-sitemap
-version:         1.1.0.1
+version:         1.2.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -14,11 +14,14 @@ description:     Generate XML sitemaps.
 
 library
     build-depends:   base                      >= 4        && < 5
-                   , yesod-core                >= 1.1      && < 1.2
+                   , yesod-core                >= 1.2      && < 1.3
                    , time                      >= 1.1.4
                    , xml-conduit               >= 1.0
                    , text
                    , containers
+                   , data-default
+                   , conduit
+                   , xml-types
     exposed-modules: Yesod.Sitemap
     ghc-options:     -Wall
 
diff --git a/yesod-static/Yesod/Static.hs b/yesod-static/Yesod/Static.hs
index 2ad449dc..08e09ec3 100644
--- a/yesod-static/Yesod/Static.hs
+++ b/yesod-static/Yesod/Static.hs
@@ -5,6 +5,7 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards #-}
 ---------------------------------------------------------
 --
 -- | Serve static files from a Yesod app.
@@ -35,6 +36,18 @@ module Yesod.Static
     , static
     , staticDevel
     , embed
+      -- * Combining CSS/JS
+      -- $combining
+    , combineStylesheets'
+    , combineScripts'
+      -- ** Settings
+    , CombineSettings
+    , csStaticDir
+    , csCssPostProcess
+    , csJsPostProcess
+    , csCssPreProcess
+    , csJsPreProcess
+    , csCombinedFolder
       -- * Template Haskell helpers
     , staticFiles
     , staticFilesList
@@ -53,11 +66,12 @@ import Control.Arrow (second)
 import Control.Monad
 import Data.FileEmbed (embedDir)
 
-import Yesod.Core hiding (lift)
+import Yesod.Core
+import Yesod.Core.Types
 
 import Data.List (intercalate)
 import Language.Haskell.TH
-import Language.Haskell.TH.Syntax
+import Language.Haskell.TH.Syntax as TH
 
 import Crypto.Conduit (hashFile, sinkHash)
 import Crypto.Hash.MD5 (MD5)
@@ -73,16 +87,24 @@ import qualified Data.Text as T
 import qualified Data.Set as S
 import qualified Data.Map as M
 import Data.IORef (readIORef, newIORef, writeIORef)
-import Network.Wai (pathInfo)
 import Data.Char (isLower, isDigit)
 import Data.List (foldl', inits, tails)
 import qualified Data.ByteString as S
 import System.PosixCompat.Files (getFileStatus, modificationTime)
 import System.Posix.Types (EpochTime)
-import Data.Conduit (($$))
-import Data.Conduit.List (sourceList)
+import Data.Conduit
+import Data.Conduit.List (sourceList, consume)
+import Data.Conduit.Binary (sourceFile)
+import qualified Data.Conduit.Text as CT
 import Data.Functor.Identity (runIdentity)
 import qualified Filesystem.Path.CurrentOS as F
+import Filesystem.Path.CurrentOS ((</>), (<.>), FilePath)
+import Filesystem (createTree)
+import qualified Data.Text as T
+import qualified Data.Text.Lazy as TL
+import qualified Data.Text.Lazy.Encoding as TLE
+import Data.Default
+import Text.Lucius (luciusRTMinified)
 
 import Network.Wai.Application.Static
     ( StaticSettings (..)
@@ -146,10 +168,14 @@ instance RenderRoute Static where
     data Route Static = StaticRoute [Text] [(Text, Text)]
         deriving (Eq, Show, Read)
     renderRoute (StaticRoute x y) = (x, y)
+instance ParseRoute Static where
+    parseRoute (x, y) = Just $ StaticRoute x y
 
-instance Yesod master => YesodDispatch Static master where
-    yesodDispatch _ _ (Static set) _ _ _ _ textPieces  _ req =
-        staticApp set req { pathInfo = textPieces }
+instance YesodSubDispatch Static m where
+    yesodSubDispatch YesodSubRunnerEnv {..} req =
+        staticApp set req
+      where
+        Static set = ysreGetSub $ yreSite $ ysreParentEnv
 
 notHidden :: Prelude.FilePath -> Bool
 notHidden "tmp" = False
@@ -407,3 +433,173 @@ base64 = map tr
     tr '+' = '-'
     tr '/' = '_'
     tr c   = c
+
+-- $combining
+--
+-- A common scenario on a site is the desire to include many external CSS and
+-- Javascript files on every page. Doing so via the Widget functionality in
+-- Yesod will work, but would also mean that the same content will be
+-- downloaded many times. A better approach would be to combine all of these
+-- files together into a single static file and serve that as a static resource
+-- for every page. That resource can be cached on the client, and bandwidth
+-- usage reduced.
+--
+-- This could be done as a manual process, but that becomes tedious. Instead,
+-- you can use some Template Haskell code which will combine these files into a
+-- single static file at compile time.
+
+data CombineType = JS | CSS
+
+combineStatics' :: CombineType
+                -> CombineSettings
+                -> [Route Static] -- ^ files to combine
+                -> Q Exp
+combineStatics' combineType CombineSettings {..} routes = do
+    texts <- qRunIO $ runResourceT $ mapM_ yield fps $$ awaitForever readUTFFile =$ consume
+    ltext <- qRunIO $ preProcess $ TL.fromChunks texts
+    bs    <- qRunIO $ postProcess fps $ TLE.encodeUtf8 ltext
+    let hash' = base64md5 bs
+        suffix = csCombinedFolder </> F.decodeString hash' <.> extension
+        fp = csStaticDir </> suffix
+    qRunIO $ do
+        createTree $ F.directory fp
+        L.writeFile (F.encodeString fp) bs
+    let pieces = map T.unpack $ T.splitOn "/" $ either id id $ F.toText suffix
+    [|StaticRoute (map pack pieces) []|]
+  where
+    fps :: [F.FilePath]
+    fps = map toFP routes
+    toFP (StaticRoute pieces _) = csStaticDir </> F.concat (map F.fromText pieces)
+    readUTFFile fp = sourceFile (F.encodeString fp) =$= CT.decode CT.utf8
+    postProcess =
+        case combineType of
+            JS -> csJsPostProcess
+            CSS -> csCssPostProcess
+    preProcess =
+        case combineType of
+            JS -> csJsPreProcess
+            CSS -> csCssPreProcess
+    extension =
+        case combineType of
+            JS -> "js"
+            CSS -> "css"
+
+-- | Data type for holding all settings for combining files.
+--
+-- This data type is a settings type. For more information, see:
+--
+-- <http://www.yesodweb.com/book/settings-types>
+--
+-- Since 1.2.0
+data CombineSettings = CombineSettings
+    { csStaticDir :: F.FilePath
+    -- ^ File path containing static files.
+    --
+    -- Default: static
+    --
+    -- Since 1.2.0
+    , csCssPostProcess :: [FilePath] -> L.ByteString -> IO L.ByteString
+    -- ^ Post processing to be performed on CSS files.
+    --
+    -- Default: Use Lucius to minify.
+    --
+    -- Since 1.2.0
+    , csJsPostProcess :: [FilePath] -> L.ByteString -> IO L.ByteString
+    -- ^ Post processing to be performed on Javascript files.
+    --
+    -- Default: Pass-through.
+    --
+    -- Since 1.2.0
+    , csCssPreProcess :: TL.Text -> IO TL.Text
+    -- ^ Pre-processing to be performed on CSS files.
+    --
+    -- Default: convert all occurences of /static/ to ../
+    --
+    -- Since 1.2.0
+    , csJsPreProcess :: TL.Text -> IO TL.Text
+    -- ^ Pre-processing to be performed on Javascript files.
+    --
+    -- Default: Pass-through.
+    --
+    -- Since 1.2.0
+    , csCombinedFolder :: FilePath
+    -- ^ Subfolder to put combined files into.
+    --
+    -- Default: combined
+    --
+    -- Since 1.2.0
+    }
+
+instance Default CombineSettings where
+    def = CombineSettings
+        { csStaticDir = "static"
+        , csCssPostProcess = \fps ->
+              either (error . (errorIntro fps)) (return . TLE.encodeUtf8)
+            . flip luciusRTMinified []
+            . TLE.decodeUtf8
+        , csJsPostProcess = const return
+           -- FIXME The following borders on a hack. With combining of files,
+           -- the final location of the CSS is no longer fixed, so relative
+           -- references will break. Instead, we switched to using /static/
+           -- absolute references. However, when served from a separate domain
+           -- name, this will break too. The solution is that, during
+           -- development, we keep /static/, and in the combining phase, we
+           -- replace /static with a relative reference to the parent folder.
+        , csCssPreProcess =
+              return
+            . TL.replace "'/static/" "'../"
+            . TL.replace "\"/static/" "\"../"
+        , csJsPreProcess = return
+        , csCombinedFolder = "combined"
+        }
+
+errorIntro :: [FilePath] -> [Char] -> [Char]
+errorIntro fps s = "Error minifying " ++ show fps ++ ": " ++ s
+
+liftRoutes :: [Route Static] -> Q Exp
+liftRoutes =
+    fmap ListE . mapM go
+  where
+    go :: Route Static -> Q Exp
+    go (StaticRoute x y) = [|StaticRoute $(liftTexts x) $(liftPairs y)|]
+
+    liftTexts = fmap ListE . mapM liftT
+    liftT t = [|pack $(TH.lift $ T.unpack t)|]
+
+    liftPairs = fmap ListE . mapM liftPair
+    liftPair (x, y) = [|($(liftT x), $(liftT y))|]
+
+-- | Combine multiple CSS files together. Common usage would be:
+--
+-- >>> combineStylesheets' development def 'StaticR [style1_css, style2_css]
+--
+-- Where @development@ is a variable in your site indicated whether you are in
+-- development or production mode.
+--
+-- Since 1.2.0
+combineStylesheets' :: Bool -- ^ development? if so, perform no combining
+                    -> CombineSettings
+                    -> Name -- ^ Static route constructor name, e.g. \'StaticR
+                    -> [Route Static] -- ^ files to combine
+                    -> Q Exp
+combineStylesheets' development cs con routes
+    | development = [| mapM_ (addStylesheet . $(return $ ConE con)) $(liftRoutes routes) |]
+    | otherwise = [| addStylesheet $ $(return $ ConE con) $(combineStatics' CSS cs routes) |]
+
+
+-- | Combine multiple JS files together. Common usage would be:
+--
+-- >>> combineScripts' development def 'StaticR [script1_js, script2_js]
+--
+-- Where @development@ is a variable in your site indicated whether you are in
+-- development or production mode.
+--
+-- Since 1.2.0
+combineScripts' :: Bool -- ^ development? if so, perform no combining
+                -> CombineSettings
+                -> Name -- ^ Static route constructor name, e.g. \'StaticR
+                -> [Route Static] -- ^ files to combine
+                -> Q Exp
+combineScripts' development cs con routes
+    | development = [| mapM_ (addScript . $(return $ ConE con)) $(liftRoutes routes) |]
+    | otherwise = [| addScript $ $(return $ ConE con) $(combineStatics' JS cs routes) |]
diff --git a/yesod-static/sample.hs b/yesod-static/sample.hs
index 8b3df38e..0c903115 100644
--- a/yesod-static/sample.hs
+++ b/yesod-static/sample.hs
@@ -1,7 +1,6 @@
 {-# LANGUAGE QuasiQuotes, TypeFamilies, MultiParamTypeClasses #-}
 {-# LANGUAGE TemplateHaskell #-}
 import Yesod.Static
-import Yesod.Dispatch
 import Yesod.Core
 import Network.Wai.Handler.Warp (run)
 import Network.Wai.Application.Static
diff --git a/yesod-static/yesod-static.cabal b/yesod-static/yesod-static.cabal
index 28310a32..62e819e9 100644
--- a/yesod-static/yesod-static.cabal
+++ b/yesod-static/yesod-static.cabal
@@ -1,5 +1,5 @@
 name:            yesod-static
-version:         1.1.2.3
+version:         1.2.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -23,7 +23,7 @@ library
     build-depends:   base                  >= 4        && < 5
                    , containers            >= 0.2
                    , old-time              >= 1.0
-                   , yesod-core            >= 1.1      && < 1.2
+                   , yesod-core            >= 1.2      && < 1.3
                    , base64-bytestring     >= 0.1.0.1
                    , cereal                >= 0.3
                    , bytestring            >= 0.9.1.4
@@ -40,6 +40,9 @@ library
                    , crypto-conduit        >= 0.4
                    , cryptohash            >= 0.6.1
                    , system-filepath       >= 0.4.6    && < 0.5
+                   , system-fileio         >= 0.3
+                   , data-default
+                   , shakespeare-css       >= 1.0.3
     exposed-modules: Yesod.Static
     ghc-options:     -Wall
 
@@ -70,6 +73,9 @@ test-suite tests
                    , crypto-conduit
                    , cryptohash
                    , system-filepath
+                   , system-fileio
+                   , data-default
+                   , shakespeare-css
 
     ghc-options:     -Wall
 
diff --git a/yesod-test/Yesod/Test.hs b/yesod-test/Yesod/Test.hs
index faffeaa0..38837967 100644
--- a/yesod-test/Yesod/Test.hs
+++ b/yesod-test/Yesod/Test.hs
@@ -1,12 +1,13 @@
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE RecordWildCards #-}
 {-|
 Yesod.Test is a pragmatic framework for testing web applications built
 using wai and persistent.
 
 By pragmatic I may also mean 'dirty'. It's main goal is to encourage integration
-and system testing of web applications by making everything /easy to test/. 
+and system testing of web applications by making everything /easy to test/.
 
 Your tests are like browser sessions that keep track of cookies and the last
 visited page. You can perform assertions on the content of HTML responses,
@@ -22,51 +23,74 @@ backend pre-conditions, or to assert that your session is having the desired eff
 
 -}
 
-module Yesod.Test (
-  -- * Declaring and running your test suite
-  runTests, describe, it, SpecsConn, OneSpec,
+module Yesod.Test
+    ( -- * Declaring and running your test suite
+      yesodSpec
+    , YesodSpec
+    , YesodExample
+    , YesodSpecTree (..)
+    , ydescribe
+    , yit
 
-  -- * Making requests
-  -- | To make a request you need to point to an url and pass in some parameters.
-  --
-  -- To build your parameters you will use the RequestBuilder monad that lets you
-  -- add values, add files, lookup fields by label and find the current
-  -- nonce value and add it to your request too.
-  -- 
-  post, post_, get, get_, doRequest, doRequestHeaders,
-  byName, fileByName,
+    -- * Making requests
+    -- | To make a request you need to point to an url and pass in some parameters.
+    --
+    -- To build your parameters you will use the RequestBuilder monad that lets you
+    -- add values, add files, lookup fields by label and find the current
+    -- nonce value and add it to your request too.
+    --
+    , get
+    , post
+    , request
+    , addRequestHeader
+    , setMethod
+    , addPostParam
+    , addGetParam
+    , addFile
+    , RequestBuilder
+    , setUrl
 
-  -- | Yesod cat auto generate field ids, so you are never sure what
-  -- the argument name should be for each one of your args when constructing
-  -- your requests. What you do know is the /label/ of the field.
-  -- These functions let you add parameters to your request based
-  -- on currently displayed label names.
-  byLabel, fileByLabel,
+    -- | Yesod can auto generate field ids, so you are never sure what
+    -- the argument name should be for each one of your args when constructing
+    -- your requests. What you do know is the /label/ of the field.
+    -- These functions let you add parameters to your request based
+    -- on currently displayed label names.
+    , byLabel
+    , fileByLabel
 
-  -- | Does the current form have a _nonce? Use any of these to add it to your
-  -- request parameters.
-  addNonce, addNonce_,
+    -- | Does the current form have a _nonce? Use any of these to add it to your
+    -- request parameters.
+    , addNonce
+    , addNonce_
 
-  -- * Running database queries
-  runDBRunner,
+    -- * Assertions
+    , assertEqual
+    , assertHeader
+    , assertNoHeader
+    , statusIs
+    , bodyEquals
+    , bodyContains
+    , htmlAllContain
+    , htmlAnyContain
+    , htmlCount
 
-  -- * Assertions
-  assertEqual, assertHeader, assertNoHeader, statusIs, bodyEquals, bodyContains,
-  htmlAllContain, htmlAnyContain, htmlCount,
+    -- * Grab information
+    , getTestYesod
+    , getResponse
 
-  -- * Utils for debugging tests
-  printBody, printMatches,
+    -- * Debug output
+    , printBody
+    , printMatches
 
-  -- * Utils for building your own assertions
-  -- | Please consider generalizing and contributing the assertions you write.
-  htmlQuery, parseHTML, withResponse
-
-)
-
-where
+    -- * Utils for building your own assertions
+    -- | Please consider generalizing and contributing the assertions you write.
+    , htmlQuery
+    , parseHTML
+    , withResponse
+    ) where
 
+import qualified Test.Hspec as Hspec
 import qualified Test.Hspec.Core as Core
-import qualified Test.Hspec.Runner as Runner
 import qualified Data.List as DL
 import qualified Data.ByteString.Char8 as BS8
 import Data.ByteString (ByteString)
@@ -78,39 +102,76 @@ import qualified Network.HTTP.Types as H
 import qualified Network.Socket.Internal as Sock
 import Data.CaseInsensitive (CI)
 import Network.Wai
-import Network.Wai.Test hiding (assertHeader, assertNoHeader)
+import Network.Wai.Test hiding (assertHeader, assertNoHeader, request)
 import qualified Control.Monad.Trans.State as ST
 import Control.Monad.IO.Class
 import System.IO
 import Yesod.Test.TransversingCSS
-import Data.Monoid (mappend)
+import Yesod.Core
 import qualified Data.Text.Lazy as TL
 import Data.Text.Lazy.Encoding (encodeUtf8, decodeUtf8)
 import Text.XML.Cursor hiding (element)
 import qualified Text.XML.Cursor as C
 import qualified Text.HTML.DOM as HD
-import Data.Conduit.Pool (Pool)
-import Control.Monad.Trans.Control (MonadBaseControl)
+import Control.Monad.Trans.Writer
 import qualified Data.Map as M
 import qualified Web.Cookie as Cookie
 import qualified Blaze.ByteString.Builder as Builder
 import Data.Time.Clock (getCurrentTime)
 
--- | The state used in 'describe' to build a list of specs
-data SpecsData conn = SpecsData Application (Pool conn) [Core.SpecTree]
+-- | The state used in a single test case defined using 'yit'
+--
+-- Since 1.2.0
+data YesodExampleData site = YesodExampleData
+    { yedApp :: !Application
+    , yedSite :: !site
+    , yedCookies :: !Cookies
+    , yedResponse :: !(Maybe SResponse)
+    }
 
--- | The specs state monad is where 'describe' runs.
--- parameterized by a database connection.
--- You should create type Specs = SpecsConn MyDBConnection
-type SpecsConn conn = ST.StateT (SpecsData conn) IO ()
+-- | A single test case, to be run with 'yit'.
+--
+-- Since 1.2.0
+type YesodExample site = ST.StateT (YesodExampleData site) IO
 
--- | The state used in a single test case defined using 'it'
-data OneSpecData conn = OneSpecData Application (Pool conn) Cookies (Maybe SResponse)
+-- | Mapping from cookie name to value.
+--
+-- Since 1.2.0
+type Cookies = M.Map ByteString Cookie.SetCookie
 
--- | The OneSpec state monad is where 'it' runs.
-type OneSpec conn = ST.StateT (OneSpecData conn) IO
+-- | Corresponds to hspec\'s 'Spec'.
+--
+-- Since 1.2.0
+type YesodSpec site = Writer [YesodSpecTree site] ()
 
-data RequestBuilderData = RequestBuilderData [RequestPart] (Maybe SResponse)
+-- | Internal data structure, corresponding to hspec\'s 'YesodSpecTree'.
+--
+-- Since 1.2.0
+data YesodSpecTree site
+    = YesodSpecGroup String [YesodSpecTree site]
+    | YesodSpecItem String (YesodExample site ())
+
+-- | Get the foundation value used for the current test.
+--
+-- Since 1.2.0
+getTestYesod :: YesodExample site site
+getTestYesod = fmap yedSite ST.get
+
+-- | Get the most recently provided response value, if available.
+--
+-- Since 1.2.0
+getResponse :: YesodExample site (Maybe SResponse)
+getResponse = fmap yedResponse ST.get
+
+data RequestBuilderData site = RequestBuilderData
+    { rbdPosts :: [RequestPart]
+    , rbdResponse :: (Maybe SResponse)
+    , rbdMethod :: H.Method
+    , rbdSite :: site
+    , rbdPath :: [T.Text]
+    , rbdGets :: H.Query
+    , rbdHeaders :: H.RequestHeaders
+    }
 
 -- | Request parts let us discern regular key/values from files sent in the request.
 data RequestPart
@@ -120,74 +181,73 @@ data RequestPart
 -- | The RequestBuilder state monad constructs an url encoded string of arguments
 -- to send with your requests. Some of the functions that run on it use the current
 -- response to analize the forms that the server is expecting to receive.
-type RequestBuilder = ST.StateT RequestBuilderData IO
-
--- | Both the OneSpec and RequestBuilder monads hold a response that can be analized,
--- by making them instances of this class we can have general methods that work on
--- the last received response.
-class HoldsResponse a where
-  readResponse :: a -> Maybe SResponse
-instance HoldsResponse (OneSpecData conn) where
-  readResponse (OneSpecData _ _ _ x) = x
-instance HoldsResponse RequestBuilderData where
-  readResponse (RequestBuilderData _ x) = x
-
-type Cookies = M.Map ByteString Cookie.SetCookie
-
--- | Runs your test suite, using you wai 'Application' and 'ConnectionPool' for performing 
--- the database queries in your tests.
---
--- You application may already have your connection pool but you need to pass another one
--- separately here.
--- 
--- Look at the examples directory on this package to get an idea of the (small) amount of
--- boilerplate code you'll need to write before calling this.
-runTests :: Application -> Pool conn -> SpecsConn conn -> IO ()
-runTests app connection specsDef = do
-  (SpecsData _ _ specs) <- ST.execStateT specsDef (SpecsData app connection [])
-  (Runner.hspec . Core.fromSpecList) specs
+type RequestBuilder site = ST.StateT (RequestBuilderData site) IO
 
 -- | Start describing a Tests suite keeping cookies and a reference to the tested 'Application'
 -- and 'ConnectionPool'
-describe :: String -> SpecsConn conn -> SpecsConn conn
-describe label action = do
-  sData <- ST.get
-  SpecsData app conn specs <- liftIO $ ST.execStateT action sData
-  ST.put $ SpecsData app conn [Core.describe label specs]
+ydescribe :: String -> YesodSpec site -> YesodSpec site
+ydescribe label yspecs = tell [YesodSpecGroup label $ execWriter yspecs]
+
+yesodSpec :: YesodDispatch site
+          => site
+          -> YesodSpec site
+          -> Hspec.Spec
+yesodSpec site yspecs =
+    Core.fromSpecList $ map unYesod $ execWriter yspecs
+  where
+    unYesod (YesodSpecGroup x y) = Core.SpecGroup x $ map unYesod y
+    unYesod (YesodSpecItem x y) = Core.it x $ do
+        app <- toWaiAppPlain site
+        ST.evalStateT y YesodExampleData
+            { yedApp = app
+            , yedSite = site
+            , yedCookies = M.empty
+            , yedResponse = Nothing
+            }
 
 -- | Describe a single test that keeps cookies, and a reference to the last response.
-it :: String -> OneSpec conn () -> SpecsConn conn
-it label action = do
-  SpecsData app conn specs <- ST.get
-  let spec = Core.it label $ do
-        _ <- ST.execStateT action $ OneSpecData app conn M.empty Nothing
-        return ()
-  ST.put $ SpecsData app conn $ spec : specs
+yit :: String -> YesodExample site () -> YesodSpec site
+yit label example = tell [YesodSpecItem label example]
 
 -- Performs a given action using the last response. Use this to create
 -- response-level assertions
-withResponse :: HoldsResponse a => (SResponse -> ST.StateT a IO b) -> ST.StateT a IO b
-withResponse f = maybe err f =<< fmap readResponse ST.get
+withResponse' :: MonadIO m
+              => (state -> Maybe SResponse)
+              -> (SResponse -> ST.StateT state m a)
+              -> ST.StateT state m a
+withResponse' getter f = maybe err f . getter =<< ST.get
  where err = failure "There was no response, you should make a request"
 
+-- | Performs a given action using the last response. Use this to create
+-- response-level assertions
+withResponse :: (SResponse -> YesodExample site a) -> YesodExample site a
+withResponse = withResponse' yedResponse
+
 -- | Use HXT to parse a value from an html tag.
 -- Check for usage examples in this module's source.
-parseHTML :: Html -> Cursor
+parseHTML :: HtmlLBS -> Cursor
 parseHTML html = fromDocument $ HD.parseLBS html
 
 -- | Query the last response using css selectors, returns a list of matched fragments
-htmlQuery :: HoldsResponse a => Query -> ST.StateT a IO [Html]
-htmlQuery query = withResponse $ \ res ->
+htmlQuery' :: MonadIO m
+           => (state -> Maybe SResponse)
+           -> Query
+           -> ST.StateT state m [HtmlLBS]
+htmlQuery' getter query = withResponse' getter $ \ res ->
   case findBySelector (simpleBody res) query of
     Left err -> failure $ query <> " did not parse: " <> T.pack (show err)
     Right matches -> return $ map (encodeUtf8 . TL.pack) matches
 
+-- | Query the last response using css selectors, returns a list of matched fragments
+htmlQuery :: Query -> YesodExample site [HtmlLBS]
+htmlQuery = htmlQuery' yedResponse
+
 -- | Asserts that the two given values are equal.
-assertEqual :: (Eq a) => String -> a -> a -> OneSpec conn ()
+assertEqual :: (Eq a) => String -> a -> a -> YesodExample site ()
 assertEqual msg a b = liftIO $ HUnit.assertBool msg (a == b)
 
 -- | Assert the last response status is as expected.
-statusIs :: HoldsResponse a => Int -> ST.StateT a IO ()
+statusIs :: Int -> YesodExample site ()
 statusIs number = withResponse $ \ SResponse { simpleStatus = s } ->
   liftIO $ flip HUnit.assertBool (H.statusCode s == number) $ concat
     [ "Expected status was ", show number
@@ -195,7 +255,7 @@ statusIs number = withResponse $ \ SResponse { simpleStatus = s } ->
     ]
 
 -- | Assert the given header key/value pair was returned.
-assertHeader :: HoldsResponse a => CI BS8.ByteString -> BS8.ByteString -> ST.StateT a IO ()
+assertHeader :: CI BS8.ByteString -> BS8.ByteString -> YesodExample site ()
 assertHeader header value = withResponse $ \ SResponse { simpleHeaders = h } ->
   case lookup header h of
     Nothing -> failure $ T.pack $ concat
@@ -215,7 +275,7 @@ assertHeader header value = withResponse $ \ SResponse { simpleHeaders = h } ->
         ]
 
 -- | Assert the given header was not included in the response.
-assertNoHeader :: HoldsResponse a => CI BS8.ByteString -> ST.StateT a IO ()
+assertNoHeader :: CI BS8.ByteString -> YesodExample site ()
 assertNoHeader header = withResponse $ \ SResponse { simpleHeaders = h } ->
   case lookup header h of
     Nothing -> return ()
@@ -228,14 +288,14 @@ assertNoHeader header = withResponse $ \ SResponse { simpleHeaders = h } ->
 
 -- | Assert the last response is exactly equal to the given text. This is
 -- useful for testing API responses.
-bodyEquals :: HoldsResponse a => String -> ST.StateT a IO ()
+bodyEquals :: String -> YesodExample site ()
 bodyEquals text = withResponse $ \ res ->
   liftIO $ HUnit.assertBool ("Expected body to equal " ++ text) $
     (simpleBody res) == BSL8.pack text
 
 -- | Assert the last response has the given text. The check is performed using the response
 -- body in full text form.
-bodyContains :: HoldsResponse a => String -> ST.StateT a IO ()
+bodyContains :: String -> YesodExample site ()
 bodyContains text = withResponse $ \ res ->
   liftIO $ HUnit.assertBool ("Expected body to contain " ++ text) $
     (simpleBody res) `contains` text
@@ -245,7 +305,7 @@ contains a b = DL.isInfixOf b (BSL8.unpack a)
 
 -- | Queries the html using a css selector, and all matched elements must contain
 -- the given string.
-htmlAllContain :: HoldsResponse a => Query -> String -> ST.StateT a IO ()
+htmlAllContain :: Query -> String -> YesodExample site ()
 htmlAllContain query search = do
   matches <- htmlQuery query
   case matches of
@@ -257,7 +317,7 @@ htmlAllContain query search = do
 -- element contains the given string.
 --
 -- Since 0.3.5
-htmlAnyContain :: HoldsResponse a => Query -> String -> ST.StateT a IO ()
+htmlAnyContain :: Query -> String -> YesodExample site ()
 htmlAnyContain query search = do
   matches <- htmlQuery query
   case matches of
@@ -267,41 +327,54 @@ htmlAnyContain query search = do
 
 -- | Performs a css query on the last response and asserts the matched elements
 -- are as many as expected.
-htmlCount :: HoldsResponse a => Query -> Int -> ST.StateT a IO ()
+htmlCount :: Query -> Int -> YesodExample site ()
 htmlCount query count = do
   matches <- fmap DL.length $ htmlQuery query
   liftIO $ flip HUnit.assertBool (matches == count)
     ("Expected "++(show count)++" elements to match "++T.unpack query++", found "++(show matches))
 
 -- | Outputs the last response body to stderr (So it doesn't get captured by HSpec)
-printBody :: HoldsResponse a => ST.StateT a IO ()
-printBody = withResponse $ \ SResponse { simpleBody = b } -> 
+printBody :: YesodExample site ()
+printBody = withResponse $ \ SResponse { simpleBody = b } ->
   liftIO $ hPutStrLn stderr $ BSL8.unpack b
 
 -- | Performs a CSS query and print the matches to stderr.
-printMatches :: HoldsResponse a => Query -> ST.StateT a IO ()
+printMatches :: Query -> YesodExample site ()
 printMatches query = do
   matches <- htmlQuery query
   liftIO $ hPutStrLn stderr $ show matches
 
 -- | Add a parameter with the given name and value.
-byName :: T.Text -> T.Text -> RequestBuilder ()
-byName name value = do
-  RequestBuilderData parts r <- ST.get
-  ST.put $ RequestBuilderData ((ReqPlainPart name value):parts) r
+addPostParam :: T.Text -> T.Text -> RequestBuilder site ()
+addPostParam name value =
+    ST.modify $ \rbd -> rbd
+        { rbdPosts = ReqPlainPart name value : rbdPosts rbd
+        }
+
+addGetParam :: T.Text -> T.Text -> RequestBuilder site ()
+addGetParam name value = ST.modify $ \rbd -> rbd
+    { rbdGets = (TE.encodeUtf8 name, Just $ TE.encodeUtf8 value)
+              : rbdGets rbd
+    }
 
 -- | Add a file to be posted with the current request
 --
 -- Adding a file will automatically change your request content-type to be multipart/form-data
-fileByName :: T.Text -> FilePath -> T.Text -> RequestBuilder ()
-fileByName name path mimetype = do
-  RequestBuilderData parts r <- ST.get
+addFile :: T.Text -> FilePath -> T.Text -> RequestBuilder site ()
+addFile name path mimetype = do
   contents <- liftIO $ BSL8.readFile path
-  ST.put $ RequestBuilderData ((ReqFilePart name path contents mimetype):parts) r
+  ST.modify $ \rbd -> rbd
+    { rbdPosts = ReqFilePart name path contents mimetype : rbdPosts rbd
+    }
 
 -- This looks up the name of a field based on the contents of the label pointing to it.
-nameFromLabel :: T.Text -> RequestBuilder T.Text
-nameFromLabel label = withResponse $ \ res -> do
+nameFromLabel :: T.Text -> RequestBuilder site T.Text
+nameFromLabel label = do
+  mres <- fmap rbdResponse ST.get
+  res <-
+    case mres of
+      Nothing -> failure "nameFromLabel: No response available"
+      Just res -> return res
   let
     body = simpleBody res
     mfor = parseHTML body
@@ -334,138 +407,164 @@ nameFromLabel label = withResponse $ \ res -> do
 (<>) :: T.Text -> T.Text -> T.Text
 (<>) = T.append
 
-byLabel :: T.Text -> T.Text -> RequestBuilder ()
+byLabel :: T.Text -> T.Text -> RequestBuilder site ()
 byLabel label value = do
   name <- nameFromLabel label
-  byName name value
+  addPostParam name value
 
-fileByLabel :: T.Text -> FilePath -> T.Text -> RequestBuilder ()
+fileByLabel :: T.Text -> FilePath -> T.Text -> RequestBuilder site ()
 fileByLabel label path mime = do
   name <- nameFromLabel label
-  fileByName name path mime
+  addFile name path mime
 
--- | Lookup a _nonce form field and add it's value to the params. 
+-- | Lookup a _nonce form field and add it's value to the params.
 -- Receives a CSS selector that should resolve to the form element containing the nonce.
-addNonce_ :: Query -> RequestBuilder ()
+addNonce_ :: Query -> RequestBuilder site ()
 addNonce_ scope = do
-  matches <- htmlQuery $ scope `mappend` "input[name=_token][type=hidden][value]"
+  matches <- htmlQuery' rbdResponse $ scope <> "input[name=_token][type=hidden][value]"
   case matches of
     [] -> failure $ "No nonce found in the current page"
-    element:[] -> byName "_token" $ head $ attribute "value" $ parseHTML element
+    element:[] -> addPostParam "_token" $ head $ attribute "value" $ parseHTML element
     _ -> failure $ "More than one nonce found in the page"
 
 -- | For responses that display a single form, just lookup the only nonce available.
-addNonce :: RequestBuilder ()
+addNonce :: RequestBuilder site ()
 addNonce = addNonce_ ""
 
--- | Perform a POST request to url, using params
-post :: BS8.ByteString -> RequestBuilder () -> OneSpec conn ()
-post url paramsBuild = do
-  doRequest "POST" url paramsBuild
+-- | Perform a POST request to url
+post :: (Yesod site, RedirectUrl site url)
+     => url
+     -> YesodExample site ()
+post url = request $ do
+    setMethod "POST"
+    setUrl url
 
--- | Perform a POST request without params
-post_ :: BS8.ByteString -> OneSpec conn ()
-post_ = flip post $ return ()
- 
 -- | Perform a GET request to url, using params
-get :: BS8.ByteString -> RequestBuilder () -> OneSpec conn ()
-get url paramsBuild = doRequest "GET" url paramsBuild
+get :: (Yesod site, RedirectUrl site url)
+    => url
+    -> YesodExample site ()
+get url = request $ do
+    setMethod "GET"
+    setUrl url
 
--- | Perform a GET request without params
-get_ :: BS8.ByteString -> OneSpec conn ()
-get_ = flip get $ return ()
+setMethod :: H.Method -> RequestBuilder site ()
+setMethod m = ST.modify $ \rbd -> rbd { rbdMethod = m }
 
--- | General interface to performing requests, letting you specify the request method
-doRequest :: H.Method -> BS8.ByteString -> RequestBuilder a -> OneSpec conn ()
-doRequest method url paramsBuild = doRequestHeaders method url [] paramsBuild
+setUrl :: (Yesod site, RedirectUrl site url)
+       => url
+       -> RequestBuilder site ()
+setUrl url' = do
+    site <- fmap rbdSite ST.get
+    eurl <- runFakeHandler
+        M.empty
+        (const $ error "Yesod.Test: No logger available")
+        site
+        (toTextUrl url')
+    url <- either (error . show) return eurl
+    let (urlPath, urlQuery) = T.break (== '?') url
+    ST.modify $ \rbd -> rbd
+        { rbdPath =
+            case DL.filter (/="") $ T.split (== '/') urlPath of
+                ("http:":_:rest) -> rest
+                ("https:":_:rest) -> rest
+                x -> x
+        , rbdGets = rbdGets rbd ++ H.parseQuery (TE.encodeUtf8 urlQuery)
+        }
+
+addRequestHeader :: H.Header -> RequestBuilder site ()
+addRequestHeader header = ST.modify $ \rbd -> rbd
+    { rbdHeaders = header : rbdHeaders rbd
+    }
 
 -- | General interface to performing requests, allowing you to add extra
 -- headers as well as letting you specify the request method.
-doRequestHeaders :: H.Method -> BS8.ByteString -> [H.Header] -> RequestBuilder a -> OneSpec conn ()
-doRequestHeaders method url extrahead paramsBuild = do
-  OneSpecData app conn oldCookies mRes <- ST.get
+request :: Yesod site
+        => RequestBuilder site ()
+        -> YesodExample site ()
+request reqBuilder = do
+    YesodExampleData app site oldCookies mRes <- ST.get
 
-  -- expire cookies and filter them for the current path. TODO: support max age
-  currentUtc <- liftIO getCurrentTime
-  let cookies = M.filter (checkCookieTime currentUtc) oldCookies
-      cookiesForPath = M.filter checkCookiePath cookies
+    RequestBuilderData {..} <- liftIO $ ST.execStateT reqBuilder RequestBuilderData
+      { rbdPosts = []
+      , rbdResponse = mRes
+      , rbdMethod = "GET"
+      , rbdSite = site
+      , rbdPath = []
+      , rbdGets = []
+      , rbdHeaders = []
+      }
+    let path = T.cons '/' $ T.intercalate "/" rbdPath
 
-  RequestBuilderData parts _ <- liftIO $ ST.execStateT paramsBuild $ RequestBuilderData [] mRes
-  let req = if DL.any isFile parts
-          then makeMultipart cookiesForPath parts
-          else makeSinglepart cookiesForPath parts
+    -- expire cookies and filter them for the current path. TODO: support max age
+    currentUtc <- liftIO getCurrentTime
+    let cookies = M.filter (checkCookieTime currentUtc) oldCookies
+        cookiesForPath = M.filter (checkCookiePath path) cookies
 
-  response <- liftIO $ runSession (srequest req) app
-  let newCookies = map (Cookie.parseSetCookie . snd) $ DL.filter (("Set-Cookie"==) . fst) $ simpleHeaders response
-      cookies' = M.fromList [(Cookie.setCookieName c, c) | c <- newCookies] `M.union` cookies
-  ST.put $ OneSpecData app conn cookies' (Just response)
- where
-  isFile (ReqFilePart _ _ _ _) = True
-  isFile _ = False
+    let maker
+          | DL.any isFile rbdPosts = makeMultipart
+          | otherwise = makeSinglepart
+        req = maker cookiesForPath rbdPosts rbdMethod rbdHeaders path rbdGets
 
-  checkCookieTime t c = case Cookie.setCookieExpires c of
-                            Nothing -> True
-                            Just t' -> t < t'
-  checkCookiePath c = case Cookie.setCookiePath c of
-                            Nothing -> True
-                            Just x  -> x `BS8.isPrefixOf` url
+    response <- liftIO $ runSession (srequest req) app
+    let newCookies = map (Cookie.parseSetCookie . snd) $ DL.filter (("Set-Cookie"==) . fst) $ simpleHeaders response
+        cookies' = M.fromList [(Cookie.setCookieName c, c) | c <- newCookies] `M.union` cookies
+    ST.put $ YesodExampleData app site cookies' (Just response)
+  where
+    isFile (ReqFilePart _ _ _ _) = True
+    isFile _ = False
 
-  -- For building the multi-part requests
-  boundary :: String
-  boundary = "*******noneedtomakethisrandom"
-  separator = BS8.concat ["--", BS8.pack boundary, "\r\n"]
-  makeMultipart cookies parts =
-    flip SRequest (BSL8.fromChunks [multiPartBody parts]) $ mkRequest $
+    checkCookieTime t c = case Cookie.setCookieExpires c of
+                              Nothing -> True
+                              Just t' -> t < t'
+    checkCookiePath url c =
+      case Cookie.setCookiePath c of
+        Nothing -> True
+        Just x  -> x `BS8.isPrefixOf` TE.encodeUtf8 url
+
+    -- For building the multi-part requests
+    boundary :: String
+    boundary = "*******noneedtomakethisrandom"
+    separator = BS8.concat ["--", BS8.pack boundary, "\r\n"]
+    makeMultipart cookies parts method extraHeaders urlPath urlQuery =
+      flip SRequest (BSL8.fromChunks [multiPartBody parts]) $ mkRequest
+        [ ("Cookie", Builder.toByteString $ Cookie.renderCookies
+              [(Cookie.setCookieName c, Cookie.setCookieValue c) | c <- map snd $ M.toList cookies])
+        , ("Content-Type", BS8.pack $ "multipart/form-data; boundary=" ++ boundary)
+        ] method extraHeaders urlPath urlQuery
+    multiPartBody parts =
+      BS8.concat $ separator : [BS8.concat [multipartPart p, separator] | p <- parts]
+    multipartPart (ReqPlainPart k v) = BS8.concat
+      [ "Content-Disposition: form-data; "
+      , "name=\"", TE.encodeUtf8 k, "\"\r\n\r\n"
+      , TE.encodeUtf8 v, "\r\n"]
+    multipartPart (ReqFilePart k v bytes mime) = BS8.concat
+      [ "Content-Disposition: form-data; "
+      , "name=\"", TE.encodeUtf8 k, "\"; "
+      , "filename=\"", BS8.pack v, "\"\r\n"
+      , "Content-Type: ", TE.encodeUtf8 mime, "\r\n\r\n"
+      , BS8.concat $ BSL8.toChunks bytes, "\r\n"]
+
+    -- For building the regular non-multipart requests
+    makeSinglepart cookies parts method extraHeaders urlPath urlQuery = SRequest (mkRequest
       [ ("Cookie", Builder.toByteString $ Cookie.renderCookies
-            [(Cookie.setCookieName c, Cookie.setCookieValue c) | c <- map snd $ M.toList cookies])
-      , ("Content-Type", BS8.pack $ "multipart/form-data; boundary=" ++ boundary)
-      ] ++ extrahead
-  multiPartBody parts =
-    BS8.concat $ separator : [BS8.concat [multipartPart p, separator] | p <- parts]
-  multipartPart (ReqPlainPart k v) = BS8.concat
-    [ "Content-Disposition: form-data; "
-    , "name=\"", TE.encodeUtf8 k, "\"\r\n\r\n"
-    , TE.encodeUtf8 v, "\r\n"]
-  multipartPart (ReqFilePart k v bytes mime) = BS8.concat
-    [ "Content-Disposition: form-data; "
-    , "name=\"", TE.encodeUtf8 k, "\"; "
-    , "filename=\"", BS8.pack v, "\"\r\n"
-    , "Content-Type: ", TE.encodeUtf8 mime, "\r\n\r\n"
-    , BS8.concat $ BSL8.toChunks bytes, "\r\n"]
+              [(Cookie.setCookieName c, Cookie.setCookieValue c) | c <- map snd $ M.toList cookies])
+      , ("Content-Type", "application/x-www-form-urlencoded")
+      ] method extraHeaders urlPath urlQuery) $
+      BSL8.fromChunks $ return $ TE.encodeUtf8 $ T.intercalate "&" $ map singlepartPart parts
 
-  -- For building the regular non-multipart requests
-  makeSinglepart cookies parts = SRequest (mkRequest $
-    [ ("Cookie", Builder.toByteString $ Cookie.renderCookies
-            [(Cookie.setCookieName c, Cookie.setCookieValue c) | c <- map snd $ M.toList cookies])
-    , ("Content-Type", "application/x-www-form-urlencoded")
-    ] ++ extrahead) $
-    BSL8.fromChunks $ return $ TE.encodeUtf8 $ T.intercalate "&" $ map singlepartPart parts
+    singlepartPart (ReqFilePart _ _ _ _) = ""
+    singlepartPart (ReqPlainPart k v) = T.concat [k,"=",v]
 
-  singlepartPart (ReqFilePart _ _ _ _) = ""
-  singlepartPart (ReqPlainPart k v) = T.concat [k,"=",v]
-
-  -- General request making 
-  mkRequest headers = defaultRequest
-    { requestMethod = method
-    , remoteHost = Sock.SockAddrInet 1 2
-    , requestHeaders = headers
-    , rawPathInfo = urlPath
-    , pathInfo = DL.filter (/="") $ T.split (== '/') $ TE.decodeUtf8 urlPath
-    , rawQueryString = urlQuery
-    , queryString = H.parseQuery urlQuery
-    }
-
-  (urlPath, urlQuery) = BS8.break (== '?') url
-  
--- | Run a persistent db query. For asserting on the results of performed actions
--- or setting up pre-conditions. At the moment this part is still very raw.
---
--- It is intended that you parametize the first argument of this function for your backend
--- runDB = runDBRunnder SqlPersist
-runDBRunner :: (MonadBaseControl IO m, MonadIO m) => (poolrunner m a -> Pool conn -> IO a) -> poolrunner m a -> OneSpec conn a
-runDBRunner poolRunner query = do
-  OneSpecData _ pool _ _ <- ST.get
-  liftIO $ poolRunner query pool
+    -- General request making
+    mkRequest headers method extraHeaders urlPath urlQuery = defaultRequest
+      { requestMethod = method
+      , remoteHost = Sock.SockAddrInet 1 2
+      , requestHeaders = headers ++ extraHeaders
+      , rawPathInfo = TE.encodeUtf8 urlPath
+      , pathInfo = DL.filter (/="") $ T.split (== '/') urlPath
+      , rawQueryString = H.renderQuery False urlQuery
+      , queryString = urlQuery
+      }
 
 -- Yes, just a shortcut
 failure :: (MonadIO a) => T.Text -> a b
diff --git a/yesod-test/Yesod/Test/TransversingCSS.hs b/yesod-test/Yesod/Test/TransversingCSS.hs
index 2e60638e..4450d300 100644
--- a/yesod-test/Yesod/Test/TransversingCSS.hs
+++ b/yesod-test/Yesod/Test/TransversingCSS.hs
@@ -27,7 +27,7 @@ Only a subset of the CSS spec is currently supported:
 
 module Yesod.Test.TransversingCSS (
   findBySelector,
-  Html,
+  HtmlLBS,
   Query,
   -- * For HXT hackers
   -- | These functions expose some low level details that you can blissfully ignore.
@@ -50,14 +50,14 @@ import Text.Blaze.Html (toHtml)
 import Text.Blaze.Html.Renderer.String (renderHtml)
 
 type Query = T.Text
-type Html = L.ByteString
+type HtmlLBS = L.ByteString
 
 -- | Perform a css 'Query' on 'Html'. Returns Either
 --
 -- * Left: Query parse error.
 --
 -- * Right: List of matching Html fragments.
-findBySelector :: Html -> Query -> Either String [String]
+findBySelector :: HtmlLBS -> Query -> Either String [String]
 findBySelector html query = (\x -> map (renderHtml . toHtml . node) . runQuery x)
     <$> (Right $ fromDocument $ HD.parseLBS html)
     <*> parseQuery query
diff --git a/yesod-test/test/main.hs b/yesod-test/test/main.hs
index cfcf9637..3fd73d3c 100644
--- a/yesod-test/test/main.hs
+++ b/yesod-test/test/main.hs
@@ -1,11 +1,18 @@
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 import Test.HUnit hiding (Test)
 import Test.Hspec
 
+import Yesod.Core
+import Yesod.Form
+import Yesod.Test
 import Yesod.Test.CssQuery
 import Yesod.Test.TransversingCSS
 import Text.XML
+import Data.Text (Text)
+import Data.Monoid ((<>))
+import Control.Applicative
 
 import Data.ByteString.Lazy.Char8 ()
 import qualified Data.Map as Map
@@ -60,3 +67,67 @@ main = hspec $ do
                         ]
                     ]
              in parseHtml_ html @?= doc
+    describe "basic usage" $ yesodSpec app $ do
+        ydescribe "tests1" $ do
+            yit "tests1a" $ do
+                get ("/" :: Text)
+                statusIs 200
+                bodyEquals "Hello world!"
+            yit "tests1b" $ do
+                get ("/foo" :: Text)
+                statusIs 404
+        ydescribe "tests2" $ do
+            yit "type-safe URLs" $ do
+                get $ LiteAppRoute []
+                statusIs 200
+            yit "type-safe URLs with query-string" $ do
+                get (LiteAppRoute [], [("foo", "bar")])
+                statusIs 200
+                bodyEquals "foo=bar"
+            yit "post params" $ do
+                post ("/post" :: Text)
+                statusIs 500
+
+                request $ do
+                    setMethod "POST"
+                    setUrl $ LiteAppRoute ["post"]
+                    addPostParam "foo" "foobarbaz"
+                statusIs 200
+                bodyEquals "foobarbaz"
+            yit "labels" $ do
+                get ("/form" :: Text)
+                statusIs 200
+
+                request $ do
+                    setMethod "POST"
+                    setUrl ("/form" :: Text)
+                    byLabel "Some Label" "12345"
+                    fileByLabel "Some File" "test/main.hs" "text/plain"
+                    addNonce
+                statusIs 200
+                bodyEquals "12345"
+
+instance RenderMessage LiteApp FormMessage where
+    renderMessage _ _ = defaultFormMessage
+
+app :: LiteApp
+app = liteApp $ do
+    dispatchTo $ do
+        mfoo <- lookupGetParam "foo"
+        case mfoo of
+            Nothing -> return "Hello world!"
+            Just foo -> return $ "foo=" <> foo
+    onStatic "post" $ dispatchTo $ do
+        mfoo <- lookupPostParam "foo"
+        case mfoo of
+            Nothing -> error "No foo"
+            Just foo -> return foo
+    onStatic "form" $ dispatchTo $ do
+        ((mfoo, widget), _) <- runFormPost
+                        $ renderDivs
+                        $ (,)
+                      <$> areq textField "Some Label" Nothing
+                      <*> areq fileField "Some File" Nothing
+        case mfoo of
+            FormSuccess (foo, _) -> return $ toHtml foo
+            _ -> defaultLayout widget
diff --git a/yesod-test/yesod-test.cabal b/yesod-test/yesod-test.cabal
index 2fae28ff..cc683f32 100644
--- a/yesod-test/yesod-test.cabal
+++ b/yesod-test/yesod-test.cabal
@@ -1,5 +1,5 @@
 name:               yesod-test
-version:            0.3.5
+version:            1.2.0
 license:            MIT
 license-file:       LICENSE
 author:             Nubis <nubis@woobiz.com.ar>
@@ -38,6 +38,7 @@ library
                    , time
                    , blaze-builder
                    , cookie
+                   , yesod-core                >= 1.2
 
     exposed-modules: Yesod.Test
                      Yesod.Test.CssQuery
@@ -56,6 +57,9 @@ test-suite test
                           , bytestring
                           , containers
                           , html-conduit
+                          , yesod-core
+                          , yesod-form
+                          , text
 
 source-repository head
   type: git
diff --git a/yesod/Yesod.hs b/yesod/Yesod.hs
index ef9623d0..16c6eb1e 100644
--- a/yesod/Yesod.hs
+++ b/yesod/Yesod.hs
@@ -5,17 +5,9 @@ module Yesod
     ( -- * Re-exports from yesod-core
       module Yesod.Core
     , module Yesod.Form
-    , module Yesod.Json
     , module Yesod.Persist
-      -- * Running your application
-    , warp
-    , warpDebug
-    , warpEnv
-    , develServer
       -- * Commonly referenced functions/datatypes
     , Application
-    , liftIO
-    , MonadBaseControl
       -- * Utilities
     , showIntegral
     , readIntegral
@@ -24,13 +16,10 @@ module Yesod
     , hamlet
     , xhamlet
     , HtmlUrl
-    , Html
-    , toHtml
       -- ** Julius
     , julius
     , JavascriptUrl
     , renderJavascriptUrl
-    , toJSON
       -- ** Cassius/Lucius
     , cassius
     , lucius
@@ -45,18 +34,9 @@ import Text.Lucius
 import Text.Julius
 
 import Yesod.Form
-import Yesod.Json
 import Yesod.Persist
-import Control.Monad.IO.Class (liftIO, MonadIO(..))
-import Control.Monad.Trans.Control (MonadBaseControl)
 
 import Network.Wai
-import Network.Wai.Middleware.RequestLogger (logStdout)
-import Network.Wai.Handler.Warp (run)
-import System.IO (stderr, hPutStrLn)
-import Text.Blaze.Html (toHtml)
-import System.Environment (getEnv)
-import Data.Aeson (toJSON)
 
 showIntegral :: Integral a => a -> String
 showIntegral x = show (fromIntegral x :: Integer)
@@ -66,54 +46,3 @@ readIntegral s =
     case reads s of
         (i, _):_ -> Just $ fromInteger i
         [] -> Nothing
-
--- | A convenience method to run an application using the Warp webserver on the
--- specified port. Automatically calls 'toWaiApp'.
-warp :: (Yesod a, YesodDispatch a a) => Int -> a -> IO ()
-warp port a = toWaiApp a >>= run port
-
--- | Same as 'warp', but also sends a message to stdout for each request, and
--- an \"application launched\" message as well. Can be useful for development.
-warpDebug :: (Yesod a, YesodDispatch a a) => Int -> a -> IO ()
-warpDebug port app = do
-  hPutStrLn stderr $ "Application launched, listening on port " ++ show port
-  waiApp <- toWaiApp app
-  run port $ logStdout waiApp
-
--- | Runs your application using default middlewares (i.e., via 'toWaiApp'). It
--- reads port information from the PORT environment variable, as used by tools
--- such as Keter.
---
--- Note that the exact behavior of this function may be modified slightly over
--- time to work correctly with external tools, without a change to the type
--- signature.
-warpEnv :: (Yesod a, YesodDispatch a a) => a -> IO ()
-warpEnv master = do
-    port <- getEnv "PORT" >>= readIO
-    app <- toWaiApp master
-    run port app
-
--- | Run a development server, where your code changes are automatically
--- reloaded.
-develServer :: Int -- ^ port number
-            -> String -- ^ module name holding the code
-            -> String -- ^ name of function providing a with-application
-            -> IO ()
-
-develServer port modu func =
-    mapM_ putStrLn
-        [ "Due to issues with GHC 7.0.2, you must now run the devel server"
-        , "separately. To do so, ensure you have installed the "
-        , "wai-handler-devel package >= 0.2.1 and run:"
-        , concat
-            [ "   wai-handler-devel "
-            , show port
-            , " "
-            , modu
-            , " "
-            , func
-            , " --yesod"
-            ]
-        , ""
-        ]
-
diff --git a/yesod-default/Yesod/Default/Config.hs b/yesod/Yesod/Default/Config.hs
similarity index 100%
rename from yesod-default/Yesod/Default/Config.hs
rename to yesod/Yesod/Default/Config.hs
diff --git a/yesod-default/Yesod/Default/Handlers.hs b/yesod/Yesod/Default/Handlers.hs
similarity index 61%
rename from yesod-default/Yesod/Default/Handlers.hs
rename to yesod/Yesod/Default/Handlers.hs
index cb58e07b..8abc57fa 100644
--- a/yesod-default/Yesod/Default/Handlers.hs
+++ b/yesod/Yesod/Default/Handlers.hs
@@ -4,11 +4,10 @@ module Yesod.Default.Handlers
     , getRobotsR
     ) where
 
-import Yesod.Handler (GHandler, sendFile)
-import Yesod.Content (RepPlain(..))
+import Yesod.Core
 
-getFaviconR :: GHandler s m ()
+getFaviconR :: MonadHandler m => m ()
 getFaviconR = sendFile "image/x-icon" "config/favicon.ico"
 
-getRobotsR :: GHandler s m RepPlain
+getRobotsR :: MonadHandler m => m ()
 getRobotsR = sendFile "text/plain" "config/robots.txt"
diff --git a/yesod-default/Yesod/Default/Main.hs b/yesod/Yesod/Default/Main.hs
similarity index 100%
rename from yesod-default/Yesod/Default/Main.hs
rename to yesod/Yesod/Default/Main.hs
diff --git a/yesod-default/Yesod/Default/Util.hs b/yesod/Yesod/Default/Util.hs
similarity index 97%
rename from yesod-default/Yesod/Default/Util.hs
rename to yesod/Yesod/Default/Util.hs
index 578b9bc7..a10358ec 100644
--- a/yesod-default/Yesod/Default/Util.hs
+++ b/yesod/Yesod/Default/Util.hs
@@ -14,7 +14,6 @@ module Yesod.Default.Util
     , wfsHamletSettings
     ) where
 
-import Control.Monad.IO.Class (liftIO)
 import qualified Data.ByteString.Lazy as L
 import Data.Text (Text, pack, unpack)
 import Yesod.Core -- purposely using complete import so that Haddock will see addStaticContent
@@ -40,7 +39,7 @@ addStaticContentExternal
     -> Text -- ^ filename extension
     -> Text -- ^ mime type
     -> L.ByteString -- ^ file contents
-    -> GHandler sub master (Maybe (Either Text (Route master, [(Text, Text)])))
+    -> HandlerT master IO (Maybe (Either Text (Route master, [(Text, Text)])))
 addStaticContentExternal minify hash staticDir toRoute ext' _ content = do
     liftIO $ createDirectoryIfMissing True statictmp
     exists <- liftIO $ doesFileExist fn'
diff --git a/yesod/static/script.js b/yesod/static/script.js
deleted file mode 100644
index 43c21a53..00000000
--- a/yesod/static/script.js
+++ /dev/null
@@ -1,3 +0,0 @@
-$(function(){
-    $("p.noscript").hide();
-});
diff --git a/yesod/static/style.css b/yesod/static/style.css
deleted file mode 100644
index d09c6b08..00000000
--- a/yesod/static/style.css
+++ /dev/null
@@ -1,12 +0,0 @@
-body {
-    font-family: sans-serif;
-    background: #eee;
-}
-
-#wrapper {
-    width: 760px;
-    margin: 1em auto;
-    border: 2px solid #000;
-    padding: 0.5em;
-    background: #fff;
-}
diff --git a/yesod/static/style2.css b/yesod/static/style2.css
deleted file mode 100644
index 853ac29a..00000000
--- a/yesod/static/style2.css
+++ /dev/null
@@ -1,3 +0,0 @@
-body {
-    font-family: sans-serif;
-}
diff --git a/yesod/test/mongodb-input.txt b/yesod/test/mongodb-input.txt
deleted file mode 100644
index f0f40400..00000000
--- a/yesod/test/mongodb-input.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-Michael
-foobar
-Foobar
-mongo
diff --git a/yesod/test/mysql-input.txt b/yesod/test/mysql-input.txt
deleted file mode 100644
index 6e49d571..00000000
--- a/yesod/test/mysql-input.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-Michael
-foobar
-mysql
diff --git a/yesod/test/postgresql-input.txt b/yesod/test/postgresql-input.txt
deleted file mode 100644
index 5689ebb3..00000000
--- a/yesod/test/postgresql-input.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-Michael
-foobar
-p
diff --git a/yesod/test/run.sh b/yesod/test/run.sh
deleted file mode 100755
index 7095acda..00000000
--- a/yesod/test/run.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-
-cat << EOF
-
-You're using the deprecated ./test/run.sh. This file will be removed
-soon in favor of ../scripts/runtests.
-
-Running ../scripts/runtests...
-
-EOF
-
-../scripts/runtests "$@"
diff --git a/yesod/test/scaffold.sh b/yesod/test/scaffold.sh
deleted file mode 100755
index 92210188..00000000
--- a/yesod/test/scaffold.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash -ex
-
-runghc -i. -idist/build/autogen main.hs init
-
-(
-  cd foobar
-  cabal configure --disable-optimization || cabal install
-  cabal build
-  cabal clean
-  cabal configure -fdev --disable-optimization
-  cabal build
-  cabal clean
-  cabal configure -flibrary-only --disable-optimization
-  cabal build
-  cabal clean
-  cabal configure --enable-tests
-  cabal build
-  cabal test
-)
diff --git a/yesod/test/scaffold.shelltest b/yesod/test/scaffold.shelltest
deleted file mode 100644
index 39ccefd9..00000000
--- a/yesod/test/scaffold.shelltest
+++ /dev/null
@@ -1,33 +0,0 @@
-# Not using this currently!
-#
-# Important! run with test/run.sh
-
-rm -rf foobar && runghc main.hs init && cd foobar && cabal install && cabal install -fdevel && cd ..
-<<<
-Michael
-foobar
-
-Foobar
-t
->>> /.*Registering foobar-0.0.0.*/
->>>= 0
-
-rm -rf foobar && runghc main.hs init && cd foobar && cabal install && cabal install -fdevel && cd ..
-<<<
-Michael
-foobar
-
-Foobar
-s
->>> /.*Registering foobar-0.0.0.*/
->>>= 0
-
-rm -rf foobar && runghc main.hs init && cd foobar && cabal install && cabal install -fdevel && cd .. && rm -rf foobar
-<<<
-Michael
-foobar
-
-Foobar
-p
->>> /.*Registering foobar-0.0.0.*/
->>>= 0
diff --git a/yesod/test/scaffold_test.sh b/yesod/test/scaffold_test.sh
deleted file mode 100644
index f30bfb12..00000000
--- a/yesod/test/scaffold_test.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-setup()    { rm -rf foobar; }
-teardown() { rm -rf foobar; ghc-pkg unregister foobar &>/dev/null; }
-
-test_sqlite()     { ../test/scaffold.sh < ../test/sqlite-input.txt    ; }
-test_postgresql() { ../test/scaffold.sh < ../test/postgresql-input.txt; }
-test_mongodb()    { ../test/scaffold.sh < ../test/mongodb-input.txt   ; }
diff --git a/yesod/test/sqlite-input.txt b/yesod/test/sqlite-input.txt
deleted file mode 100644
index 32257967..00000000
--- a/yesod/test/sqlite-input.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-Michael
-foobar
-s
diff --git a/yesod/test/tiny-input.txt b/yesod/test/tiny-input.txt
deleted file mode 100644
index fb1fe817..00000000
--- a/yesod/test/tiny-input.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-Michael
-foobar
-Foobar
-t
diff --git a/yesod/yesod.cabal b/yesod/yesod.cabal
index 0870b312..9954a3d5 100644
--- a/yesod/yesod.cabal
+++ b/yesod/yesod.cabal
@@ -1,5 +1,5 @@
 name:            yesod
-version:         1.1.9.3
+version:         1.2.0
 license:         MIT
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -17,23 +17,12 @@ cabal-version:   >= 1.6
 build-type:      Simple
 homepage:        http://www.yesodweb.com/
 
-extra-source-files:
-  input/*.cg
-  hsfiles/mongo.hsfiles
-  hsfiles/mysql.hsfiles
-  hsfiles/postgres.hsfiles
-  hsfiles/postgres-fay.hsfiles
-  hsfiles/simple.hsfiles
-  hsfiles/sqlite.hsfiles
-
 library
     build-depends:   base                      >= 4.3      && < 5
-                   , yesod-core                >= 1.1.5    && < 1.2
-                   , yesod-auth                >= 1.1      && < 1.2
-                   , yesod-json                >= 1.1      && < 1.2
-                   , yesod-persistent          >= 1.1      && < 1.2
-                   , yesod-form                >= 1.1      && < 1.3
-                   , yesod-default             >= 1.1.3    && < 1.2
+                   , yesod-core                >= 1.2      && < 1.3
+                   , yesod-auth                >= 1.2      && < 1.3
+                   , yesod-persistent          >= 1.2      && < 1.3
+                   , yesod-form                >= 1.3      && < 1.4
                    , monad-control             >= 0.3      && < 0.4
                    , transformers              >= 0.2.2    && < 0.4
                    , wai                       >= 1.3      && < 1.5
@@ -45,83 +34,25 @@ library
                    , blaze-html                >= 0.5
                    , blaze-markup              >= 0.5.1
                    , aeson
+                   , safe
+                   , data-default
+                   , network-conduit
+                   , unordered-containers
+                   , yaml
+                   , text
+                   , directory
+                   , template-haskell
+                   , bytestring
 
     exposed-modules: Yesod
+                   , Yesod.Default.Config
+                   , Yesod.Default.Main
+                   , Yesod.Default.Util
+                   , Yesod.Default.Handlers
     ghc-options:     -Wall
 
-executable             yesod-ghc-wrapper
-    main-is: ghcwrapper.hs
-    build-depends:
-                    base                       >= 4         && < 5
-                  , Cabal
-
-executable             yesod-ld-wrapper
-    main-is: ghcwrapper.hs
-    cpp-options:     -DLDCMD
-    build-depends:
-                    base                       >= 4         && < 5
-                  , Cabal
-executable             yesod-ar-wrapper
-    main-is: ghcwrapper.hs
-    cpp-options:     -DARCMD
-    build-depends:
-                     base                       >= 4         && < 5
-                   , Cabal
-
-executable             yesod
-    if os(windows)
-        cpp-options:     -DWINDOWS
-    build-depends:     base               >= 4.3          && < 5
-                     , ghc                >= 7.0.3        && < 7.8
-                     , ghc-paths          >= 0.1
-                     , parsec             >= 2.1          && < 4
-                     , text               >= 0.11
-                     , shakespeare-text   >= 1.0          && < 1.1
-                     , shakespeare        >= 1.0.2        && < 1.1
-                     , shakespeare-js     >= 1.0.2        && < 1.2
-                     , shakespeare-css    >= 1.0.2        && < 1.1
-                     , bytestring         >= 0.9.1.4
-                     , time               >= 1.1.4
-                     , template-haskell
-                     , directory          >= 1.0
-                     , Cabal
-                     , unix-compat        >= 0.2          && < 0.5
-                     , containers         >= 0.2
-                     , attoparsec         >= 0.10
-                     , http-types         >= 0.7
-                     , blaze-builder      >= 0.2.1.4      && < 0.4
-                     , filepath           >= 1.1
-                     , process
-                     , zlib               >= 0.5          && < 0.6
-                     , tar                >= 0.4          && < 0.5
-                     , system-filepath    >= 0.4          && < 0.5
-                     , system-fileio      >= 0.3          && < 0.4
-                     , unordered-containers
-                     , yaml               >= 0.8          && < 0.9
-                     , optparse-applicative >= 0.4
-                     , fsnotify           >= 0.0          && < 0.1
-                     , split              >= 0.2          && < 0.3
-                     , file-embed
-                     , conduit            >= 0.5          && < 1.1
-                     , resourcet          >= 0.3          && < 0.5
-                     , base64-bytestring
-                     , lifted-base
-                     , http-reverse-proxy >= 0.1.1
-                     , network
-                     , http-conduit
-                     , network-conduit
-                     , project-template   >= 0.1.1
-
-    ghc-options:       -Wall -threaded
-    main-is:           main.hs
-    other-modules:     Scaffolding.Scaffolder
-                       Devel
-                       Build
-                       GhcBuild
-                       Keter
-                       AddHandler
-                       Paths_yesod
-                       Options
+    if !os(windows)
+         build-depends: unix
 
 source-repository head
   type:     git