elm-pages 2.1.10 → 3.0.0-beta.0

package/src/Pages/Internal/Platform.elm

@@ -1,65 +1,93 @@
-module Pages.Internal.Platform exposing (Flags, Model, Msg, Program, application)
+module Pages.Internal.Platform exposing
+    ( Flags, Model, Msg(..), Program, application, init, update
+    , Effect(..), RequestInfo, view
+    )
 
 {-| Exposed for internal use only (used in generated code).
 
-@docs Flags, Model, Msg, Program, application
+@docs Flags, Model, Msg, Program, application, init, update
+
+@docs Effect, RequestInfo, view
 
 -}
 
 import AriaLiveAnnouncer
+import Base64
 import Browser
 import Browser.Dom as Dom
 import Browser.Navigation
 import BuildError exposing (BuildError)
+import Bytes exposing (Bytes)
+import Bytes.Decode
+import Dict exposing (Dict)
+import Form.FormData exposing (FormData, Method(..))
+import FormDecoder
 import Html exposing (Html)
 import Html.Attributes as Attr
 import Http
 import Json.Decode as Decode
 import Json.Encode
-import Pages.ContentCache as ContentCache exposing (ContentCache, ContentJson, contentJsonDecoder)
+import Pages.ContentCache as ContentCache
+import Pages.Fetcher
 import Pages.Flags
-import Pages.Internal.ApplicationType as ApplicationType
-import Pages.Internal.NotFoundReason
+import Pages.FormState
+import Pages.Internal.NotFoundReason exposing (NotFoundReason)
+import Pages.Internal.ResponseSketch as ResponseSketch exposing (ResponseSketch)
 import Pages.Internal.String as String
+import Pages.Msg
 import Pages.ProgramConfig exposing (ProgramConfig)
 import Pages.StaticHttpRequest as StaticHttpRequest
+import Pages.Transition
 import Path exposing (Path)
 import QueryParams
 import Task
+import Time
 import Url exposing (Url)
 
 
+type Transition
+    = Loading Int Path
+    | Submitting FormData
+
+
 {-| -}
-type alias Program userModel userMsg pageData sharedData =
-    Platform.Program Flags (Model userModel pageData sharedData) (Msg userMsg)
+type alias Program userModel userMsg pageData actionData sharedData errorPage =
+    Platform.Program Flags (Model userModel pageData actionData sharedData) (Msg userMsg pageData actionData sharedData errorPage)
 
 
 mainView :
-    ProgramConfig userMsg userModel route siteData pageData sharedData
-    -> Model userModel pageData sharedData
-    -> { title : String, body : Html userMsg }
+    ProgramConfig userMsg userModel route pageData actionData sharedData effect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> Model userModel pageData actionData sharedData
+    -> { title : String, body : Html (Pages.Msg.Msg userMsg) }
 mainView config model =
-    let
-        urls : { currentUrl : Url, basePath : List String }
-        urls =
-            { currentUrl = model.url
-            , basePath = config.basePath
-            }
-    in
-    case ContentCache.notFoundReason model.contentCache urls of
-        Just notFoundReason ->
-            Pages.Internal.NotFoundReason.document config.pathPatterns notFoundReason
+    case model.notFound of
+        Just info ->
+            Pages.Internal.NotFoundReason.document config.pathPatterns info
 
         Nothing ->
             case model.pageData of
                 Ok pageData ->
-                    (config.view
+                    let
+                        urls : { currentUrl : Url, basePath : List String }
+                        urls =
+                            { currentUrl = model.url
+                            , basePath = config.basePath
+                            }
+
+                        currentUrl : Url
+                        currentUrl =
+                            model.url
+                    in
+                    (config.view model.pageFormState
+                        (model.inFlightFetchers |> toFetcherState)
+                        (model.transition |> Maybe.map Tuple.second)
                         { path = ContentCache.pathForUrl urls |> Path.join
-                        , route = config.urlToRoute model.url
+                        , route = config.urlToRoute { currentUrl | path = model.currentPath }
                         }
                         Nothing
                         pageData.sharedData
                         pageData.pageData
+                        pageData.actionData
                         |> .view
                     )
                         pageData.userModel
@@ -83,10 +111,11 @@ urlsToPagePath urls =
         |> Path.join
 
 
+{-| -}
 view :
-    ProgramConfig userMsg userModel route siteData pageData sharedData
-    -> Model userModel pageData sharedData
-    -> Browser.Document (Msg userMsg)
+    ProgramConfig userMsg userModel route pageData actionData sharedData effect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> Model userModel pageData actionData sharedData
+    -> Browser.Document (Msg userMsg pageData actionData sharedData errorPage)
 view config model =
     let
         { title, body } =
@@ -119,179 +148,186 @@ type alias Flags =
     Decode.Value
 
 
+type InitKind shared page actionData errorPage
+    = OkPage shared page (Maybe actionData)
+    | NotFound { reason : NotFoundReason, path : Path }
+
+
 {-| -}
 init :
-    ProgramConfig userMsg userModel route staticData pageData sharedData
+    ProgramConfig userMsg userModel route pageData actionData sharedData userEffect (Msg userMsg pageData actionData sharedData errorPage) errorPage
     -> Flags
     -> Url
-    -> Browser.Navigation.Key
-    -> ( Model userModel pageData sharedData, Cmd (Msg userMsg) )
+    -> Maybe Browser.Navigation.Key
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
 init config flags url key =
     let
-        contentCache : ContentCache
-        contentCache =
-            ContentCache.init
-                (Maybe.map
-                    (\cj ->
-                        ( currentPath
-                        , cj
-                        )
-                    )
-                    contentJson
-                )
-
-        currentPath : List String
-        currentPath =
+        pageDataResult : Result BuildError (InitKind sharedData pageData actionData errorPage)
+        pageDataResult =
             flags
-                |> Decode.decodeValue
-                    (Decode.at [ "contentJson", "path" ]
-                        (Decode.string
-                            |> Decode.map Path.fromString
-                            |> Decode.map Path.toSegments
-                        )
-                    )
-                |> Result.mapError Decode.errorToString
+                |> Decode.decodeValue (Decode.field "pageDataBase64" Decode.string)
                 |> Result.toMaybe
-                |> Maybe.withDefault []
+                |> Maybe.andThen Base64.toBytes
+                |> Maybe.andThen
+                    (\justBytes ->
+                        case
+                            Bytes.Decode.decode
+                                -- TODO should this use byteDecodePageData, or should it be decoding ResponseSketch data?
+                                config.decodeResponse
+                                justBytes
+                        of
+                            Just (ResponseSketch.RenderPage _ _) ->
+                                Nothing
 
-        contentJson : Maybe ContentJson
-        contentJson =
-            flags
-                |> Decode.decodeValue (Decode.field "contentJson" contentJsonDecoder)
-                |> Result.toMaybe
+                            Just (ResponseSketch.HotUpdate pageData shared actionData) ->
+                                OkPage shared pageData actionData
+                                    |> Just
 
-        urls : { currentUrl : Url, basePath : List String }
-        urls =
-            { currentUrl = url
-            , basePath = config.basePath
-            }
+                            Just (ResponseSketch.NotFound notFound) ->
+                                NotFound notFound
+                                    |> Just
+
+                            _ ->
+                                Nothing
+                    )
+                |> Result.fromMaybe
+                    (StaticHttpRequest.DecoderError "Bytes decode error"
+                        |> StaticHttpRequest.toBuildError url.path
+                    )
     in
-    case contentJson |> Maybe.map .staticData of
-        Just justContentJson ->
+    case pageDataResult of
+        Ok (OkPage sharedData pageData actionData) ->
             let
-                pageDataResult : Result BuildError pageData
-                pageDataResult =
-                    StaticHttpRequest.resolve ApplicationType.Browser
-                        (config.data (config.urlToRoute url))
-                        justContentJson
-                        |> Result.mapError (StaticHttpRequest.toBuildError url.path)
-
-                sharedDataResult : Result BuildError sharedData
-                sharedDataResult =
-                    StaticHttpRequest.resolve ApplicationType.Browser
-                        config.sharedData
-                        justContentJson
-                        |> Result.mapError (StaticHttpRequest.toBuildError url.path)
+                urls : { currentUrl : Url, basePath : List String }
+                urls =
+                    { currentUrl = url
+                    , basePath = config.basePath
+                    }
 
                 pagePath : Path
                 pagePath =
                     urlsToPagePath urls
-            in
-            case Result.map2 Tuple.pair sharedDataResult pageDataResult of
-                Ok ( sharedData, pageData ) ->
-                    let
-                        userFlags : Pages.Flags.Flags
-                        userFlags =
-                            flags
-                                |> Decode.decodeValue
-                                    (Decode.field "userFlags" Decode.value)
-                                |> Result.withDefault Json.Encode.null
-                                |> Pages.Flags.BrowserFlags
-
-                        ( userModel, userCmd ) =
+
+                userFlags : Pages.Flags.Flags
+                userFlags =
+                    flags
+                        |> Decode.decodeValue
+                            (Decode.field "userFlags" Decode.value)
+                        |> Result.withDefault Json.Encode.null
+                        |> Pages.Flags.BrowserFlags
+
+                ( userModel, userCmd ) =
+                    Just
+                        { path =
+                            { path = pagePath
+                            , query = url.query
+                            , fragment = url.fragment
+                            }
+                        , metadata = config.urlToRoute url
+                        , pageUrl =
                             Just
-                                { path =
-                                    { path = pagePath
-                                    , query = url.query
-                                    , fragment = url.fragment
-                                    }
-                                , metadata = config.urlToRoute url
-                                , pageUrl =
-                                    Just
-                                        { protocol = url.protocol
-                                        , host = url.host
-                                        , port_ = url.port_
-                                        , path = pagePath
-                                        , query = url.query |> Maybe.map QueryParams.fromString
-                                        , fragment = url.fragment
-                                        }
+                                { protocol = url.protocol
+                                , host = url.host
+                                , port_ = url.port_
+                                , path = pagePath
+                                , query = url.query |> Maybe.map QueryParams.fromString
+                                , fragment = url.fragment
                                 }
-                                |> config.init userFlags sharedData pageData (Just key)
-
-                        cmd : Cmd (Msg userMsg)
-                        cmd =
-                            [ userCmd
-                                |> Cmd.map UserMsg
-                                |> Just
-                            , contentCache
-                                |> ContentCache.lazyLoad urls
-                                |> Task.attempt UpdateCache
-                                |> Just
-                            ]
-                                |> List.filterMap identity
-                                |> Cmd.batch
-
-                        initialModel : Model userModel pageData sharedData
-                        initialModel =
-                            { key = key
-                            , url = url
-                            , contentCache = contentCache
-                            , pageData =
-                                Ok
-                                    { pageData = pageData
-                                    , sharedData = sharedData
-                                    , userModel = userModel
-                                    }
-                            , ariaNavigationAnnouncement = ""
-                            , userFlags = flags
+                        }
+                        |> config.init userFlags sharedData pageData actionData
+
+                cmd : Effect userMsg pageData actionData sharedData userEffect errorPage
+                cmd =
+                    UserCmd userCmd
+
+                initialModel : Model userModel pageData actionData sharedData
+                initialModel =
+                    { key = key
+                    , url = url
+                    , currentPath = url.path
+                    , pageData =
+                        Ok
+                            { pageData = pageData
+                            , sharedData = sharedData
+                            , userModel = userModel
+                            , actionData = actionData
                             }
-                    in
-                    ( { initialModel
-                        | ariaNavigationAnnouncement = mainView config initialModel |> .title
-                      }
-                    , cmd
-                    )
+                    , ariaNavigationAnnouncement = ""
+                    , userFlags = flags
+                    , notFound = Nothing
+                    , transition = Nothing
+                    , nextTransitionKey = 0
+                    , inFlightFetchers = Dict.empty
+                    , pageFormState = Dict.empty
+                    , pendingRedirect = False
+                    , pendingData = Nothing
+                    }
+            in
+            ( { initialModel
+                | ariaNavigationAnnouncement = mainView config initialModel |> .title
+              }
+            , cmd
+            )
 
-                Err error ->
-                    ( { key = key
-                      , url = url
-                      , contentCache = contentCache
-                      , pageData = BuildError.errorToString error |> Err
-                      , ariaNavigationAnnouncement = "Error"
-                      , userFlags = flags
-                      }
-                    , Cmd.none
-                    )
+        Ok (NotFound info) ->
+            ( { key = key
+              , url = url
+              , currentPath = url.path
+              , pageData = Err "Not found"
+              , ariaNavigationAnnouncement = "Error" -- TODO use error page title for announcement?
+              , userFlags = flags
+              , notFound = Just info
+              , transition = Nothing
+              , nextTransitionKey = 0
+              , inFlightFetchers = Dict.empty
+              , pageFormState = Dict.empty
+              , pendingRedirect = False
+              , pendingData = Nothing
+              }
+            , NoEffect
+            )
 
-        Nothing ->
+        Err error ->
             ( { key = key
               , url = url
-              , contentCache = contentCache
-              , pageData = Err "TODO"
+              , currentPath = url.path
+              , pageData =
+                    error
+                        |> BuildError.errorToString
+                        |> Err
               , ariaNavigationAnnouncement = "Error"
               , userFlags = flags
+              , notFound = Nothing
+              , transition = Nothing
+              , nextTransitionKey = 0
+              , inFlightFetchers = Dict.empty
+              , pageFormState = Dict.empty
+              , pendingRedirect = False
+              , pendingData = Nothing
               }
-            , Cmd.none
+            , NoEffect
             )
 
 
 {-| -}
-type Msg userMsg
+type Msg userMsg pageData actionData sharedData errorPage
     = LinkClicked Browser.UrlRequest
     | UrlChanged Url
-    | UserMsg userMsg
-    | UpdateCache (Result Http.Error ( Url, ContentJson, ContentCache ))
-    | UpdateCacheAndUrl Url (Result Http.Error ( Url, ContentJson, ContentCache ))
+    | UserMsg (Pages.Msg.Msg userMsg)
+    | SetField { formId : String, name : String, value : String }
+    | UpdateCacheAndUrlNew Bool Url (Maybe userMsg) (Result Http.Error ( Url, ResponseSketch pageData actionData sharedData ))
+    | FetcherComplete Bool String Int (Result Http.Error ( Maybe userMsg, Maybe actionData ))
+    | FetcherStarted String Int FormData Time.Posix
     | PageScrollComplete
-    | HotReloadComplete ContentJson
-    | NoOp
+    | HotReloadCompleteNew Bytes
+    | ProcessFetchResponse Int (Result Http.Error ( Url, ResponseSketch pageData actionData sharedData )) (Result Http.Error ( Url, ResponseSketch pageData actionData sharedData ) -> Msg userMsg pageData actionData sharedData errorPage)
 
 
 {-| -}
-type alias Model userModel pageData sharedData =
-    { key : Browser.Navigation.Key
+type alias Model userModel pageData actionData sharedData =
+    { key : Maybe Browser.Navigation.Key
     , url : Url
-    , contentCache : ContentCache
+    , currentPath : String
     , ariaNavigationAnnouncement : String
     , pageData :
         Result
@@ -299,17 +335,40 @@ type alias Model userModel pageData sharedData =
             { userModel : userModel
             , pageData : pageData
             , sharedData : sharedData
+            , actionData : Maybe actionData
             }
+    , notFound : Maybe { reason : NotFoundReason, path : Path }
     , userFlags : Decode.Value
+    , transition : Maybe ( Int, Pages.Transition.Transition )
+    , nextTransitionKey : Int
+    , inFlightFetchers : Dict String ( Int, Pages.Transition.FetcherState actionData )
+    , pageFormState : Pages.FormState.PageFormState
+    , pendingRedirect : Bool
+    , pendingData : Maybe ( pageData, sharedData, Maybe actionData )
     }
 
 
+{-| -}
+type Effect userMsg pageData actionData sharedData userEffect errorPage
+    = ScrollToTop
+    | NoEffect
+    | BrowserLoadUrl String
+    | BrowserPushUrl String
+    | BrowserReplaceUrl String
+    | FetchPageData Int (Maybe FormData) Url (Result Http.Error ( Url, ResponseSketch pageData actionData sharedData ) -> Msg userMsg pageData actionData sharedData errorPage)
+    | Submit FormData
+    | SubmitFetcher String Int FormData
+    | Batch (List (Effect userMsg pageData actionData sharedData userEffect errorPage))
+    | UserCmd userEffect
+    | CancelRequest Int
+
+
 {-| -}
 update :
-    ProgramConfig userMsg userModel route siteData pageData sharedData
-    -> Msg userMsg
-    -> Model userModel pageData sharedData
-    -> ( Model userModel pageData sharedData, Cmd (Msg userMsg) )
+    ProgramConfig userMsg userModel route pageData actionData sharedData userEffect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> Msg userMsg pageData actionData sharedData errorPage
+    -> Model userModel pageData actionData sharedData
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
 update config appMsg model =
     case appMsg of
         LinkClicked urlRequest ->
@@ -318,185 +377,308 @@ update config appMsg model =
                     let
                         navigatingToSamePage : Bool
                         navigatingToSamePage =
-                            (url.path == model.url.path) && (url /= model.url)
+                            url.path == model.url.path
                     in
                     if navigatingToSamePage then
                         -- this is a workaround for an issue with anchor fragment navigation
                         -- see https://github.com/elm/browser/issues/39
-                        ( model, Browser.Navigation.load (Url.toString url) )
+                        ( model
+                        , BrowserLoadUrl (Url.toString url)
+                        )
 
                     else
                         ( model
-                        , Browser.Navigation.pushUrl model.key (Url.toString url)
+                        , BrowserPushUrl url.path
                         )
 
                 Browser.External href ->
-                    ( model, Browser.Navigation.load href )
+                    ( model
+                    , BrowserLoadUrl href
+                    )
+
+        SetField info ->
+            ( { model | pageFormState = Pages.FormState.setField info model.pageFormState }
+            , NoEffect
+            )
 
         UrlChanged url ->
-            let
-                navigatingToSamePage : Bool
-                navigatingToSamePage =
-                    (url.path == model.url.path) && (url /= model.url)
+            case model.pendingData of
+                Just ( newPageData, newSharedData, newActionData ) ->
+                    loadDataAndUpdateUrl
+                        ( newPageData, newSharedData, newActionData )
+                        Nothing
+                        url
+                        url
+                        False
+                        config
+                        model
+
+                Nothing ->
+                    if model.url.path == url.path then
+                        ( { model
+                            | -- update the URL in case query params or fragment changed
+                              url = url
+                          }
+                        , NoEffect
+                        )
 
-                urls : { currentUrl : Url, basePath : List String }
-                urls =
-                    { currentUrl = url
-                    , basePath = config.basePath
-                    }
-            in
-            if navigatingToSamePage then
-                -- this saves a few CPU cycles, but also
-                -- makes sure we don't send an UpdateCacheAndUrl
-                -- which scrolls to the top after page changes.
-                -- This is important because we may have just scrolled
-                -- to a specific page location for an anchor link.
-                model.pageData
-                    |> Result.map
-                        (\pageData ->
-                            let
-                                updatedPageData : Result String { userModel : userModel, sharedData : sharedData, pageData : pageData }
-                                updatedPageData =
-                                    Ok
-                                        { userModel = userModel
-                                        , sharedData = pageData.sharedData
-                                        , pageData = pageData.pageData
-                                        }
+                    else
+                        ( { model
+                            | url = url
+                          }
+                        , NoEffect
+                        )
+                            -- TODO is it reasonable to always re-fetch route data if you re-navigate to the current route? Might be a good
+                            -- parallel to the browser behavior
+                            |> startNewGetLoad url (UpdateCacheAndUrlNew True url Nothing)
 
-                                ( userModel, userCmd ) =
-                                    config.update
-                                        pageData.sharedData
-                                        pageData.pageData
-                                        (Just model.key)
-                                        (config.onPageChange
-                                            { protocol = model.url.protocol
-                                            , host = model.url.host
-                                            , port_ = model.url.port_
-                                            , path = urlPathToPath config urls.currentUrl
-                                            , query = url.query
-                                            , fragment = url.fragment
-                                            , metadata = config.urlToRoute url
-                                            }
+        FetcherComplete forPageReload fetcherKey transitionId___ userMsgResult ->
+            case userMsgResult of
+                Ok ( userMsg, maybeFetcherDoneActionData ) ->
+                    ( { model
+                        | inFlightFetchers =
+                            model.inFlightFetchers
+                                |> Dict.update fetcherKey
+                                    (Maybe.map
+                                        (\( transitionId, fetcherState ) ->
+                                            ( transitionId
+                                            , { fetcherState
+                                                | status =
+                                                    maybeFetcherDoneActionData
+                                                        |> Maybe.map Pages.Transition.FetcherReloading
+                                                        -- TODO remove this bad default, FetcherSubmitting is incorrect
+                                                        |> Maybe.withDefault Pages.Transition.FetcherSubmitting
+                                              }
+                                            )
                                         )
-                                        pageData.userModel
-                            in
-                            ( { model
-                                | url = url
-                                , pageData = updatedPageData
-                              }
-                            , Cmd.none
-                              --Cmd.batch
-                              --    [ userCmd |> Cmd.map UserMsg
-                              --    , Task.perform (\_ -> PageScrollComplete) (Dom.setViewport 0 0)
-                              --    ]
-                            )
+                                    )
+                      }
+                    , NoEffect
+                    )
+                        |> (case userMsg of
+                                Just justUserMsg ->
+                                    performUserMsg justUserMsg config
+
+                                Nothing ->
+                                    identity
+                           )
+                        |> startNewGetLoad (currentUrlWithPath model.url.path model) (UpdateCacheAndUrlNew False model.url Nothing)
+
+                Err _ ->
+                    -- TODO how to handle error?
+                    ( model, NoEffect )
+                        |> startNewGetLoad (currentUrlWithPath model.url.path model) (UpdateCacheAndUrlNew False model.url Nothing)
+
+        ProcessFetchResponse transitionId response toMsg ->
+            case response of
+                Ok ( _, ResponseSketch.Redirect redirectTo ) ->
+                    ( model, NoEffect )
+                        |> startNewGetLoad (currentUrlWithPath redirectTo model) toMsg
+
+                _ ->
+                    update config (toMsg response) (clearLoadingFetchersAfterDataLoad transitionId model)
+
+        UserMsg userMsg_ ->
+            case userMsg_ of
+                Pages.Msg.UserMsg userMsg ->
+                    ( model, NoEffect )
+                        |> performUserMsg userMsg config
+
+                Pages.Msg.Submit fields ->
+                    ( { model
+                        | transition =
+                            Just
+                                ( -- TODO remove hardcoded number
+                                  -1
+                                , Pages.Transition.Submitting fields
+                                )
+                      }
+                    , Submit fields
+                    )
+
+                Pages.Msg.SubmitIfValid formId fields isValid ->
+                    if isValid then
+                        ( { model
+                            -- TODO should I setSubmitAttempted here, too?
+                            | transition =
+                                Just
+                                    ( -- TODO remove hardcoded number
+                                      -1
+                                    , Pages.Transition.Submitting fields
+                                    )
+                          }
+                        , Submit fields
                         )
-                    |> Result.withDefault ( model, Cmd.none )
 
-            else
-                ( model
-                , model.contentCache
-                    |> ContentCache.lazyLoad urls
-                    |> Task.attempt (UpdateCacheAndUrl url)
-                )
+                    else
+                        ( { model
+                            | pageFormState =
+                                model.pageFormState
+                                    |> Pages.FormState.setSubmitAttempted formId
+                          }
+                        , NoEffect
+                        )
 
-        UserMsg userMsg ->
-            case model.pageData of
-                Ok pageData ->
-                    let
-                        ( userModel, userCmd ) =
-                            config.update pageData.sharedData pageData.pageData (Just model.key) userMsg pageData.userModel
+                Pages.Msg.SubmitFetcher fetcherKey fields isValid maybeUserMsg ->
+                    if isValid then
+                        -- TODO should I setSubmitAttempted here, too?
+                        ( { model | nextTransitionKey = model.nextTransitionKey + 1 }
+                        , SubmitFetcher fetcherKey model.nextTransitionKey fields
+                        )
+                            |> (case maybeUserMsg of
+                                    Just justUserMsg ->
+                                        performUserMsg justUserMsg config
 
-                        updatedPageData : Result error { userModel : userModel, pageData : pageData, sharedData : sharedData }
-                        updatedPageData =
-                            Ok { pageData | userModel = userModel }
-                    in
-                    ( { model | pageData = updatedPageData }, userCmd |> Cmd.map UserMsg )
+                                    Nothing ->
+                                        identity
+                               )
 
-                Err error ->
-                    ( model, Cmd.none )
-
-        UpdateCache cacheUpdateResult ->
-            case cacheUpdateResult of
-                -- TODO can there be race conditions here? Might need to set something in the model
-                -- to keep track of the last url change
-                Ok ( url, contentJson, updatedCache ) ->
-                    ( { model | contentCache = updatedCache }
-                    , Cmd.none
-                    )
+                    else
+                        ( { model
+                            | pageFormState =
+                                model.pageFormState
+                                    |> Pages.FormState.setSubmitAttempted fetcherKey
+                          }
+                        , NoEffect
+                        )
 
-                Err _ ->
-                    -- TODO handle error
-                    ( model, Cmd.none )
+                Pages.Msg.FormFieldEvent value ->
+                    -- TODO when init is called for a new page, also need to clear out client-side `pageFormState`
+                    ( { model | pageFormState = Pages.FormState.update value model.pageFormState }
+                    , NoEffect
+                    )
 
-        UpdateCacheAndUrl url cacheUpdateResult ->
+        UpdateCacheAndUrlNew scrollToTopWhenDone urlWithoutRedirectResolution maybeUserMsg updateResult ->
+            -- TODO remove all fetchers that are in the state `FetcherReloading` here -- I think that's the right logic?
             case
-                Result.map2 Tuple.pair (cacheUpdateResult |> Result.mapError (\error -> "Http error")) model.pageData
+                Result.map2 Tuple.pair
+                    (updateResult
+                        |> Result.mapError (\_ -> "Http error")
+                    )
+                    model.pageData
             of
-                -- TODO can there be race conditions here? Might need to set something in the model
-                -- to keep track of the last url change
-                Ok ( ( _, contentJson, updatedCache ), pageData ) ->
+                Ok ( ( newUrl, newData ), previousPageData ) ->
                     let
-                        updatedPageData : Result String { userModel : userModel, sharedData : sharedData, pageData : pageData }
-                        updatedPageData =
-                            updatedPageStaticData
-                                |> Result.map
-                                    (\pageStaticData ->
-                                        { userModel = userModel
-                                        , sharedData = pageData.sharedData
-                                        , pageData = pageStaticData
-                                        }
-                                    )
+                        redirectPending : Bool
+                        redirectPending =
+                            newUrl /= urlWithoutRedirectResolution
+                    in
+                    if redirectPending then
+                        ( { model
+                            | pendingRedirect = True
+                            , pendingData =
+                                case newData of
+                                    ResponseSketch.RenderPage pageData actionData ->
+                                        Just ( pageData, previousPageData.sharedData, actionData )
+
+                                    ResponseSketch.HotUpdate pageData sharedData actionData ->
+                                        Just ( pageData, sharedData, actionData )
+
+                                    _ ->
+                                        Nothing
+                          }
+                        , BrowserReplaceUrl newUrl.path
+                        )
+
+                    else
+                        let
+                            stayingOnSamePath : Bool
+                            stayingOnSamePath =
+                                newUrl.path == model.url.path
+
+                            ( newPageData, newSharedData, newActionData ) =
+                                case newData of
+                                    ResponseSketch.RenderPage pageData actionData ->
+                                        ( pageData, previousPageData.sharedData, actionData )
+
+                                    ResponseSketch.HotUpdate pageData sharedData actionData ->
+                                        ( pageData, sharedData, actionData )
+
+                                    _ ->
+                                        ( previousPageData.pageData, previousPageData.sharedData, previousPageData.actionData )
+
+                            updatedPageData : { userModel : userModel, sharedData : sharedData, actionData : Maybe actionData, pageData : pageData }
+                            updatedPageData =
+                                { userModel = userModel
+                                , sharedData = newSharedData
+                                , pageData = newPageData
+                                , actionData = newActionData
+                                }
 
-                        updatedPageStaticData : Result String pageData
-                        updatedPageStaticData =
-                            StaticHttpRequest.resolve ApplicationType.Browser
-                                (config.data (config.urlToRoute url))
-                                contentJson.staticData
-                                |> Result.mapError
-                                    (\error ->
-                                        error
-                                            |> StaticHttpRequest.toBuildError ""
-                                            |> BuildError.errorToString
+                            ( userModel, _ ) =
+                                -- TODO if urlWithoutRedirectResolution is different from the url with redirect resolution, then
+                                -- instead of calling update, call pushUrl (I think?)
+                                -- TODO include user Cmd
+                                config.update model.pageFormState
+                                    (model.inFlightFetchers |> toFetcherState)
+                                    (model.transition |> Maybe.map Tuple.second)
+                                    newSharedData
+                                    newPageData
+                                    model.key
+                                    (config.onPageChange
+                                        { protocol = model.url.protocol
+                                        , host = model.url.host
+                                        , port_ = model.url.port_
+                                        , path = urlPathToPath urlWithoutRedirectResolution
+                                        , query = urlWithoutRedirectResolution.query
+                                        , fragment = urlWithoutRedirectResolution.fragment
+                                        , metadata = config.urlToRoute urlWithoutRedirectResolution
+                                        }
                                     )
+                                    previousPageData.userModel
+
+                            updatedModel : Model userModel pageData actionData sharedData
+                            updatedModel =
+                                -- TODO should these be the same (no if)?
+                                if model.pendingRedirect || redirectPending then
+                                    { model
+                                        | url = newUrl
+                                        , pageData = Ok updatedPageData
+                                        , transition = Nothing
+                                        , pendingRedirect = False
+                                        , pageFormState = Dict.empty
+                                    }
 
-                        ( userModel, userCmd ) =
-                            config.update
-                                pageData.sharedData
-                                (updatedPageStaticData |> Result.withDefault pageData.pageData)
-                                (Just model.key)
-                                (config.onPageChange
-                                    { protocol = model.url.protocol
-                                    , host = model.url.host
-                                    , port_ = model.url.port_
-                                    , path = url |> urlPathToPath config
-                                    , query = url.query
-                                    , fragment = url.fragment
-                                    , metadata = config.urlToRoute url
+                                else
+                                    { model
+                                        | url = newUrl
+                                        , pageData = Ok updatedPageData
+                                        , pendingRedirect = False
+                                        , transition = Nothing
                                     }
-                                )
-                                pageData.userModel
 
-                        updatedModel : Model userModel pageData sharedData
-                        updatedModel =
-                            { model
-                                | url = url
-                                , contentCache = updatedCache
-                                , pageData = updatedPageData
-                            }
-                    in
-                    ( { updatedModel
-                        | ariaNavigationAnnouncement = mainView config updatedModel |> .title
-                      }
-                    , Cmd.batch
-                        [ userCmd |> Cmd.map UserMsg
-                        , Task.perform (\_ -> PageScrollComplete) (Dom.setViewport 0 0)
-                        ]
-                    )
+                            onActionMsg : Maybe userMsg
+                            onActionMsg =
+                                newActionData |> Maybe.andThen config.onActionData
+                        in
+                        ( { updatedModel
+                            | ariaNavigationAnnouncement = mainView config updatedModel |> .title
+                            , currentPath = newUrl.path
+                          }
+                        , if not stayingOnSamePath && scrollToTopWhenDone then
+                            ScrollToTop
+
+                          else
+                            NoEffect
+                        )
+                            |> (case maybeUserMsg of
+                                    Just userMsg ->
+                                        withUserMsg config userMsg
 
-                Err error ->
+                                    Nothing ->
+                                        identity
+                               )
+                            |> (case onActionMsg of
+                                    Just actionMsg ->
+                                        withUserMsg config actionMsg
+
+                                    Nothing ->
+                                        identity
+                               )
+
+                Err _ ->
                     {-
-                       When there is an error loading the content.json, we are either
+                       When there is an error loading the content.dat, we are either
                        1) in the dev server, and should show the relevant DataSource error for the page
                           we're navigating to. This could be done more cleanly, but it's simplest to just
                           do a fresh page load and use the code path for presenting an error for a fresh page.
@@ -509,237 +691,795 @@ update config appMsg model =
 
                     -}
                     ( model
-                    , url
+                    , urlWithoutRedirectResolution
                         |> Url.toString
-                        |> Browser.Navigation.load
+                        |> BrowserLoadUrl
                     )
 
         PageScrollComplete ->
-            ( model, Cmd.none )
+            ( model, NoEffect )
+
+        HotReloadCompleteNew pageDataBytes ->
+            model.pageData
+                |> Result.map
+                    (\pageData ->
+                        let
+                            newThing : Maybe (ResponseSketch pageData actionData sharedData)
+                            newThing =
+                                -- TODO if ErrorPage, call ErrorPage.init to get appropriate Model?
+                                pageDataBytes
+                                    |> Bytes.Decode.decode config.decodeResponse
+                        in
+                        case newThing of
+                            Just (ResponseSketch.RenderPage newPageData newActionData) ->
+                                ( { model
+                                    | pageData =
+                                        Ok
+                                            { userModel = pageData.userModel
+                                            , sharedData = pageData.sharedData
+                                            , pageData = newPageData
+                                            , actionData = newActionData
+                                            }
+                                    , notFound = Nothing
+                                  }
+                                , NoEffect
+                                )
+
+                            Just (ResponseSketch.HotUpdate newPageData newSharedData newActionData) ->
+                                ( { model
+                                    | pageData =
+                                        Ok
+                                            { userModel = pageData.userModel
+                                            , sharedData = newSharedData
+                                            , pageData = newPageData
+                                            , actionData = newActionData
+                                            }
+                                    , notFound = Nothing
+                                  }
+                                , NoEffect
+                                )
+
+                            Just (ResponseSketch.NotFound info) ->
+                                ( { model | notFound = Just info }, NoEffect )
+
+                            _ ->
+                                ( model, NoEffect )
+                    )
+                |> Result.withDefault ( model, NoEffect )
+
+        FetcherStarted fetcherKey transitionId fetcherData initiatedAt ->
+            ( { model
+                | inFlightFetchers =
+                    model.inFlightFetchers
+                        |> Dict.insert fetcherKey
+                            ( transitionId
+                            , { payload = fetcherData
+                              , status = Pages.Transition.FetcherSubmitting
+                              , initiatedAt = initiatedAt
+                              }
+                            )
+              }
+            , NoEffect
+            )
+
+
+toFetcherState : Dict String ( Int, Pages.Transition.FetcherState actionData ) -> Dict String (Pages.Transition.FetcherState actionData)
+toFetcherState inFlightFetchers =
+    inFlightFetchers
+        |> Dict.map (\_ ( index, fetcherState ) -> fetcherState)
 
-        HotReloadComplete contentJson ->
+
+performUserMsg :
+    userMsg
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData userEffect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
+performUserMsg userMsg config ( model, effect ) =
+    case model.pageData of
+        Ok pageData ->
             let
-                urls : { currentUrl : Url, basePath : List String }
-                urls =
-                    { currentUrl = model.url
-                    , basePath = config.basePath
-                    }
+                ( userModel, userCmd ) =
+                    config.update model.pageFormState (model.inFlightFetchers |> toFetcherState) (model.transition |> Maybe.map Tuple.second) pageData.sharedData pageData.pageData model.key userMsg pageData.userModel
 
-                pageDataResult : Result BuildError pageData
-                pageDataResult =
-                    StaticHttpRequest.resolve ApplicationType.Browser
-                        (config.data (config.urlToRoute model.url))
-                        contentJson.staticData
-                        |> Result.mapError (StaticHttpRequest.toBuildError model.url.path)
-
-                sharedDataResult : Result BuildError sharedData
-                sharedDataResult =
-                    StaticHttpRequest.resolve ApplicationType.Browser
-                        config.sharedData
-                        contentJson.staticData
-                        |> Result.mapError (StaticHttpRequest.toBuildError model.url.path)
-
-                from404ToNon404 : Bool
-                from404ToNon404 =
-                    not contentJson.is404
-                        && was404
-
-                was404 : Bool
-                was404 =
-                    ContentCache.is404 model.contentCache urls
+                updatedPageData : Result error { userModel : userModel, pageData : pageData, actionData : Maybe actionData, sharedData : sharedData }
+                updatedPageData =
+                    Ok { pageData | userModel = userModel }
             in
-            case Result.map2 Tuple.pair sharedDataResult pageDataResult of
-                Ok ( sharedData, pageData ) ->
-                    let
-                        updateResult : Maybe ( userModel, Cmd userMsg )
-                        updateResult =
-                            if from404ToNon404 then
-                                case model.pageData of
-                                    Ok pageData_ ->
-                                        config.update
-                                            sharedData
-                                            pageData
-                                            (Just model.key)
-                                            (config.onPageChange
-                                                { protocol = model.url.protocol
-                                                , host = model.url.host
-                                                , port_ = model.url.port_
-                                                , path = model.url |> urlPathToPath config
-                                                , query = model.url.query
-                                                , fragment = model.url.fragment
-                                                , metadata = config.urlToRoute model.url
-                                                }
-                                            )
-                                            pageData_.userModel
-                                            |> Just
+            ( { model | pageData = updatedPageData }
+            , Batch [ effect, UserCmd userCmd ]
+            )
 
-                                    Err error ->
-                                        Nothing
+        Err _ ->
+            ( model, effect )
 
-                            else
-                                Nothing
+
+perform : ProgramConfig userMsg userModel route pageData actionData sharedData userEffect (Msg userMsg pageData actionData sharedData errorPage) errorPage -> Model userModel pageData actionData sharedData -> Effect userMsg pageData actionData sharedData userEffect errorPage -> Cmd (Msg userMsg pageData actionData sharedData errorPage)
+perform config model effect =
+    -- elm-review: known-unoptimized-recursion
+    case effect of
+        NoEffect ->
+            Cmd.none
+
+        Batch effects ->
+            effects
+                |> List.map (perform config model)
+                |> Cmd.batch
+
+        ScrollToTop ->
+            Task.perform (\_ -> PageScrollComplete) (Dom.setViewport 0 0)
+
+        BrowserLoadUrl url ->
+            Browser.Navigation.load url
+
+        BrowserPushUrl url ->
+            model.key
+                |> Maybe.map
+                    (\key ->
+                        Browser.Navigation.pushUrl key url
+                    )
+                |> Maybe.withDefault Cmd.none
+
+        BrowserReplaceUrl url ->
+            model.key
+                |> Maybe.map
+                    (\key ->
+                        Browser.Navigation.replaceUrl key url
+                    )
+                |> Maybe.withDefault Cmd.none
+
+        FetchPageData transitionKey maybeRequestInfo url toMsg ->
+            fetchRouteData True transitionKey toMsg config url maybeRequestInfo
+
+        Submit fields ->
+            if fields.method == Get then
+                model.key
+                    |> Maybe.map (\key -> Browser.Navigation.pushUrl key (appendFormQueryParams fields))
+                    |> Maybe.withDefault Cmd.none
+
+            else
+                let
+                    urlToSubmitTo : Url
+                    urlToSubmitTo =
+                        -- TODO add optional path parameter to Submit variant to allow submitting to other routes
+                        model.url
+                in
+                fetchRouteData False -1 (UpdateCacheAndUrlNew False model.url Nothing) config urlToSubmitTo (Just fields)
+
+        SubmitFetcher fetcherKey transitionId formData ->
+            startFetcher2 config False fetcherKey transitionId formData model
+
+        UserCmd cmd ->
+            case model.key of
+                Just key ->
+                    let
+                        prepare :
+                            (Result Http.Error Url -> userMsg)
+                            -> Result Http.Error ( Url, ResponseSketch pageData actionData sharedData )
+                            -> Msg userMsg pageData actionData sharedData errorPage
+                        prepare toMsg info =
+                            UpdateCacheAndUrlNew False model.url (info |> Result.map Tuple.first |> toMsg |> Just) info
                     in
-                    case updateResult of
-                        Just ( userModel, userCmd ) ->
-                            ( { model
-                                | contentCache =
-                                    ContentCache.init
-                                        (Just
-                                            ( urls.currentUrl
-                                                |> config.urlToRoute
-                                                |> config.routeToPath
-                                            , contentJson
-                                            )
-                                        )
-                                , pageData =
-                                    Ok
-                                        { pageData = pageData
-                                        , sharedData = sharedData
-                                        , userModel = userModel
-                                        }
-                              }
-                            , Cmd.batch
-                                [ userCmd |> Cmd.map UserMsg
-                                ]
-                            )
+                    cmd
+                        |> config.perform
+                            { fetchRouteData =
+                                \fetchInfo ->
+                                    fetchRouteData False
+                                        -1
+                                        (prepare fetchInfo.toMsg)
+                                        config
+                                        (urlFromAction model.url fetchInfo.data)
+                                        fetchInfo.data
+
+                            ---- TODO map the Msg with the wrapper type (like in the PR branch)
+                            , submit =
+                                \fetchInfo ->
+                                    fetchRouteData False -1 (prepare fetchInfo.toMsg) config (fetchInfo.values.action |> Url.fromString |> Maybe.withDefault model.url) (Just fetchInfo.values)
+                            , runFetcher =
+                                \(Pages.Fetcher.Fetcher options) ->
+                                    -- TODO need to get the fetcherId here
+                                    -- TODO need to increment and pass in the transitionId
+                                    startFetcher "TODO" -1 options model
+                            , fromPageMsg = Pages.Msg.UserMsg >> UserMsg
+                            , key = key
+                            , setField = \info -> Task.succeed (SetField info) |> Task.perform identity
+                            }
 
-                        Nothing ->
-                            let
-                                pagePath : Path
-                                pagePath =
-                                    urlsToPagePath urls
-
-                                userFlags : Pages.Flags.Flags
-                                userFlags =
-                                    model.userFlags
-                                        |> Decode.decodeValue
-                                            (Decode.field "userFlags" Decode.value)
-                                        |> Result.withDefault Json.Encode.null
-                                        |> Pages.Flags.BrowserFlags
-
-                                ( userModel, userCmd ) =
-                                    Just
-                                        { path =
-                                            { path = pagePath
-                                            , query = model.url.query
-                                            , fragment = model.url.fragment
-                                            }
-                                        , metadata = config.urlToRoute model.url
-                                        , pageUrl =
-                                            Just
-                                                { protocol = model.url.protocol
-                                                , host = model.url.host
-                                                , port_ = model.url.port_
-                                                , path = pagePath
-                                                , query = model.url.query |> Maybe.map QueryParams.fromString
-                                                , fragment = model.url.fragment
-                                                }
-                                        }
-                                        |> config.init userFlags sharedData pageData (Just model.key)
-                            in
-                            ( { model
-                                | contentCache =
-                                    ContentCache.init
-                                        (Just
-                                            ( urls.currentUrl
-                                                |> config.urlToRoute
-                                                |> config.routeToPath
-                                            , contentJson
-                                            )
-                                        )
-                                , pageData =
-                                    model.pageData
-                                        |> Result.map
-                                            (\previousPageData ->
-                                                { pageData = pageData
-                                                , sharedData = sharedData
-                                                , userModel = previousPageData.userModel
-                                                }
-                                            )
-                                        |> Result.withDefault
-                                            { pageData = pageData
-                                            , sharedData = sharedData
-                                            , userModel = userModel
-                                            }
-                                        |> Ok
-                              }
-                            , userCmd |> Cmd.map UserMsg
-                            )
+                Nothing ->
+                    Cmd.none
 
-                Err error ->
-                    ( { model
-                        | contentCache =
-                            ContentCache.init
-                                (Just
-                                    ( urls.currentUrl
-                                        |> config.urlToRoute
-                                        |> config.routeToPath
-                                    , contentJson
-                                    )
+        CancelRequest transitionKey ->
+            Http.cancel (String.fromInt transitionKey)
+
+
+startFetcher : String -> Int -> { fields : List ( String, String ), url : Maybe String, decoder : Result error Bytes -> value, headers : List ( String, String ) } -> Model userModel pageData actionData sharedData -> Cmd (Msg value pageData actionData sharedData errorPage)
+startFetcher fetcherKey transitionId options model =
+    let
+        encodedBody : String
+        encodedBody =
+            FormDecoder.encodeFormData
+                { fields = options.fields
+
+                -- TODO remove hardcoding
+                , action = ""
+
+                -- TODO remove hardcoding
+                , method = Post
+                , id = Nothing
+                }
+
+        formData : { method : Method, action : String, fields : List ( String, String ), id : Maybe String }
+        formData =
+            { -- TODO remove hardcoding
+              method = Get
+
+            -- TODO pass FormData directly
+            , action = options.url |> Maybe.withDefault model.url.path
+            , fields = options.fields
+            , id = Nothing
+            }
+    in
+    -- TODO make sure that `actionData` isn't updated in Model for fetchers
+    Cmd.batch
+        [ cancelStaleFetchers model
+        , Time.now |> Task.map (FetcherStarted fetcherKey transitionId formData) |> Task.perform identity
+        , Http.request
+            { expect =
+                Http.expectBytesResponse (FetcherComplete False fetcherKey model.nextTransitionKey)
+                    (\bytes ->
+                        case bytes of
+                            Http.GoodStatus_ metadata bytesBody ->
+                                ( options.decoder (Ok bytesBody)
+                                    |> Just
+                                , Nothing
                                 )
-                      }
-                    , Cmd.none
+                                    |> Ok
+
+                            Http.BadUrl_ string ->
+                                Err <| Http.BadUrl string
+
+                            Http.Timeout_ ->
+                                Err <| Http.Timeout
+
+                            Http.NetworkError_ ->
+                                Err <| Http.NetworkError
+
+                            Http.BadStatus_ metadata body ->
+                                Err <| Http.BadStatus metadata.statusCode
                     )
+            , tracker = Nothing
+            , body = Http.stringBody "application/x-www-form-urlencoded" encodedBody
+            , headers = options.headers |> List.map (\( name, value ) -> Http.header name value)
+            , url = options.url |> Maybe.withDefault (Path.join [ model.url.path, "content.dat" ] |> Path.toAbsolute)
+            , method = "POST"
+            , timeout = Nothing
+            }
+        ]
+
+
+startFetcher2 :
+    ProgramConfig userMsg userModel route pageData actionData sharedData effect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> Bool
+    -> String
+    -> Int
+    -> FormData
+    -> Model userModel pageData actionData sharedData
+    -> Cmd (Msg userMsg pageData actionData sharedData errorPage)
+startFetcher2 config fromPageReload fetcherKey transitionId formData model =
+    let
+        encodedBody : String
+        encodedBody =
+            FormDecoder.encodeFormData formData
+    in
+    -- TODO make sure that `actionData` isn't updated in Model for fetchers
+    Cmd.batch
+        [ cancelStaleFetchers model
+        , case Dict.get fetcherKey model.inFlightFetchers of
+            Just ( inFlightId, inFlightFetcher ) ->
+                Http.cancel (String.fromInt inFlightId)
+
+            Nothing ->
+                Cmd.none
+        , Time.now |> Task.map (FetcherStarted fetcherKey transitionId formData) |> Task.perform identity
+        , Http.request
+            { expect =
+                Http.expectBytesResponse (FetcherComplete fromPageReload fetcherKey model.nextTransitionKey)
+                    (\bytes ->
+                        case bytes of
+                            Http.GoodStatus_ metadata bytesBody ->
+                                let
+                                    decodedAction : Maybe actionData
+                                    decodedAction =
+                                        case Bytes.Decode.decode config.decodeResponse bytesBody of
+                                            Just (ResponseSketch.RenderPage _ maybeAction) ->
+                                                maybeAction
+
+                                            Just (ResponseSketch.HotUpdate pageData shared maybeAction) ->
+                                                maybeAction
+
+                                            Just (ResponseSketch.NotFound notFound) ->
+                                                Nothing
+
+                                            _ ->
+                                                Nothing
+                                in
+                                -- TODO maybe have an optional way to pass the bytes through?
+                                Ok ( Nothing, decodedAction )
+
+                            Http.BadUrl_ string ->
+                                Err <| Http.BadUrl string
+
+                            Http.Timeout_ ->
+                                Err <| Http.Timeout
+
+                            Http.NetworkError_ ->
+                                Err <| Http.NetworkError
+
+                            Http.BadStatus_ metadata body ->
+                                Err <| Http.BadStatus metadata.statusCode
+                    )
+            , tracker = Just (String.fromInt transitionId)
+
+            -- TODO use formData.method to do either query params or POST body
+            , body = Http.stringBody "application/x-www-form-urlencoded" encodedBody
+            , headers = []
+
+            -- TODO use formData.method to do either query params or POST body
+            , url = formData.action |> Url.fromString |> Maybe.map (\{ path } -> Path.join [ path, "content.dat" ] |> Path.toAbsolute) |> Maybe.withDefault "/"
+            , method = formData.method |> FormDecoder.methodToString
+            , timeout = Nothing
+            }
+        ]
+
+
+cancelStaleFetchers : Model userModel pageData actionData sharedData -> Cmd msg
+cancelStaleFetchers model =
+    model.inFlightFetchers
+        |> Dict.toList
+        |> List.filterMap
+            (\( fetcherKey, ( id, fetcher ) ) ->
+                case fetcher.status of
+                    Pages.Transition.FetcherReloading _ ->
+                        Http.cancel (String.fromInt id)
+                            |> Just
+
+                    Pages.Transition.FetcherSubmitting ->
+                        Nothing
+
+                    Pages.Transition.FetcherComplete _ ->
+                        Nothing
+            )
+        |> Cmd.batch
+
 
-        NoOp ->
-            ( model, Cmd.none )
+appendFormQueryParams : FormData -> String
+appendFormQueryParams fields =
+    (fields.action
+        |> Url.fromString
+        |> Maybe.map .path
+        |> Maybe.withDefault "/"
+    )
+        ++ (case fields.method of
+                Get ->
+                    "?" ++ FormDecoder.encodeFormData fields
+
+                Post ->
+                    ""
+           )
+
+
+urlFromAction : Url -> Maybe FormData -> Url
+urlFromAction currentUrl fetchInfo =
+    fetchInfo |> Maybe.map .action |> Maybe.andThen Url.fromString |> Maybe.withDefault currentUrl
 
 
 {-| -}
 application :
-    ProgramConfig userMsg userModel route staticData pageData sharedData
-    -> Platform.Program Flags (Model userModel pageData sharedData) (Msg userMsg)
+    ProgramConfig userMsg userModel route pageData actionData sharedData effect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> Platform.Program Flags (Model userModel pageData actionData sharedData) (Msg userMsg pageData actionData sharedData errorPage)
 application config =
     Browser.application
         { init =
             \flags url key ->
-                init config flags url key
+                let
+                    ( model, effect ) =
+                        init config flags url (Just key)
+                in
+                ( model
+                , effect |> perform config model
+                )
         , view = view config
-        , update = update config
+        , update =
+            \msg model ->
+                update config msg model |> Tuple.mapSecond (perform config model)
         , subscriptions =
             \model ->
-                let
-                    urls : { currentUrl : Url }
-                    urls =
-                        { currentUrl = model.url }
-                in
                 case model.pageData of
                     Ok pageData ->
+                        let
+                            urls : { currentUrl : Url }
+                            urls =
+                                { currentUrl = model.url }
+                        in
                         Sub.batch
                             [ config.subscriptions (model.url |> config.urlToRoute)
                                 (urls.currentUrl |> config.urlToRoute |> config.routeToPath |> Path.join)
                                 pageData.userModel
-                                |> Sub.map UserMsg
-                            , config.fromJsPort
-                                |> Sub.map
-                                    (\decodeValue ->
-                                        case decodeValue |> Decode.decodeValue (Decode.field "contentJson" contentJsonDecoder) of
-                                            Ok contentJson ->
-                                                HotReloadComplete contentJson
-
-                                            Err _ ->
-                                                -- TODO should be no message here
-                                                NoOp
-                                    )
+                                |> Sub.map (Pages.Msg.UserMsg >> UserMsg)
+                            , config.hotReloadData
+                                |> Sub.map HotReloadCompleteNew
                             ]
 
                     Err _ ->
-                        config.fromJsPort
-                            |> Sub.map
-                                (\decodeValue ->
-                                    case decodeValue |> Decode.decodeValue (Decode.field "contentJson" contentJsonDecoder) of
-                                        Ok contentJson ->
-                                            HotReloadComplete contentJson
-
-                                        Err _ ->
-                                            -- TODO should be no message here
-                                            NoOp
-                                )
+                        config.hotReloadData
+                            |> Sub.map HotReloadCompleteNew
         , onUrlChange = UrlChanged
         , onUrlRequest = LinkClicked
         }
 
 
-urlPathToPath : ProgramConfig userMsg userModel route siteData pageData sharedData -> Url -> Path
-urlPathToPath config urls =
+{-| -}
+type alias RequestInfo =
+    { contentType : String
+    , body : String
+    }
+
+
+withUserMsg :
+    ProgramConfig userMsg userModel route pageData actionData sharedData userEffect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> userMsg
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
+withUserMsg config userMsg ( model, effect ) =
+    case model.pageData of
+        Ok pageData ->
+            let
+                ( userModel, userCmd ) =
+                    config.update model.pageFormState (model.inFlightFetchers |> toFetcherState) (model.transition |> Maybe.map Tuple.second) pageData.sharedData pageData.pageData model.key userMsg pageData.userModel
+
+                updatedPageData : Result error { userModel : userModel, pageData : pageData, actionData : Maybe actionData, sharedData : sharedData }
+                updatedPageData =
+                    Ok { pageData | userModel = userModel }
+            in
+            ( { model | pageData = updatedPageData }
+            , Batch
+                [ effect
+                , UserCmd userCmd
+                ]
+            )
+
+        Err _ ->
+            ( model, effect )
+
+
+urlPathToPath : Url -> Path
+urlPathToPath urls =
     urls.path |> Path.fromString
+
+
+fetchRouteData :
+    Bool
+    -> Int
+    -> (Result Http.Error ( Url, ResponseSketch pageData actionData sharedData ) -> Msg userMsg pageData actionData sharedData errorPage)
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData effect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> Url
+    -> Maybe FormData
+    -> Cmd (Msg userMsg pageData actionData sharedData errorPage)
+fetchRouteData forPageDataReload transitionKey toMsg config url details =
+    {-
+       TODO:
+       - [X] `toMsg` needs a parameter for the callback Msg so it can pass it on if there is a Redirect response
+       - [X] Handle ResponseSketch.Redirect in `update`
+       - [ ] Set transition state when loading
+       - [ ] Set transition state when submitting
+       - [ ] Should transition state for redirect after submit be the same as a regular load transition state?
+       - [ ] Expose transition state (in Shared?)
+       - [ ] Abort stale transitions
+       - [ ] Increment cancel key counter in Model on new transitions
+
+    -}
+    let
+        formMethod : Method
+        formMethod =
+            details
+                |> Maybe.map .method
+                |> Maybe.withDefault Get
+    in
+    Http.request
+        { method = details |> Maybe.map (.method >> FormDecoder.methodToString) |> Maybe.withDefault "GET"
+        , headers = []
+        , url =
+            "/"
+                ++ ((details
+                        |> Maybe.map .action
+                        |> Maybe.andThen Url.fromString
+                        -- TODO what should happen when there is an action pointing to a different domain? Should it be a no-op? Log a warning?
+                        |> Maybe.withDefault url
+                    )
+                        |> .path
+                        |> chopForwardSlashes
+                        |> String.split "/"
+                        |> List.filter ((/=) "")
+                        |> (\l -> l ++ [ "content.dat" ])
+                        |> String.join "/"
+                   )
+                ++ (case formMethod of
+                        Post ->
+                            "/"
+
+                        Get ->
+                            details
+                                |> Maybe.map FormDecoder.encodeFormData
+                                |> Maybe.map (\encoded -> "?" ++ encoded)
+                                |> Maybe.withDefault ""
+                   )
+                ++ (case formMethod of
+                        -- TODO extract this to something unit testable
+                        -- TODO make states mutually exclusive for submissions and direct URL requests (shouldn't be possible to append two query param strings)
+                        Post ->
+                            ""
+
+                        Get ->
+                            url.query
+                                |> Maybe.map (\encoded -> "?" ++ encoded)
+                                |> Maybe.withDefault ""
+                   )
+        , body =
+            case formMethod of
+                Post ->
+                    let
+                        urlEncodedFields : Maybe String
+                        urlEncodedFields =
+                            details
+                                |> Maybe.map FormDecoder.encodeFormData
+                    in
+                    urlEncodedFields
+                        |> Maybe.map (\encoded -> Http.stringBody "application/x-www-form-urlencoded" encoded)
+                        |> Maybe.withDefault Http.emptyBody
+
+                _ ->
+                    Http.emptyBody
+        , expect =
+            Http.expectBytesResponse (\response -> ProcessFetchResponse transitionKey response toMsg)
+                (\response ->
+                    case response of
+                        Http.BadUrl_ url_ ->
+                            Err (Http.BadUrl url_)
+
+                        Http.Timeout_ ->
+                            Err Http.Timeout
+
+                        Http.NetworkError_ ->
+                            Err Http.NetworkError
+
+                        Http.BadStatus_ metadata body ->
+                            body
+                                |> Bytes.Decode.decode config.decodeResponse
+                                |> Result.fromMaybe "Decoding error"
+                                |> Result.mapError Http.BadBody
+                                |> Result.map (\okResponse -> ( url, okResponse ))
+
+                        Http.GoodStatus_ _ body ->
+                            body
+                                |> Bytes.Decode.decode config.decodeResponse
+                                |> Result.fromMaybe "Decoding error"
+                                |> Result.mapError Http.BadBody
+                                |> Result.map (\okResponse -> ( url, okResponse ))
+                )
+        , timeout = Nothing
+        , tracker = Just (String.fromInt transitionKey)
+        }
+
+
+chopForwardSlashes : String -> String
+chopForwardSlashes =
+    chopStart "/" >> chopEnd "/"
+
+
+chopStart : String -> String -> String
+chopStart needle string =
+    if String.startsWith needle string then
+        chopStart needle (String.dropLeft (String.length needle) string)
+
+    else
+        string
+
+
+chopEnd : String -> String -> String
+chopEnd needle string =
+    if String.endsWith needle string then
+        chopEnd needle (String.dropRight (String.length needle) string)
+
+    else
+        string
+
+
+startNewGetLoad :
+    Url
+    -> (Result Http.Error ( Url, ResponseSketch pageData actionData sharedData ) -> Msg userMsg pageData actionData sharedData errorPage)
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
+startNewGetLoad urlToGet toMsg ( model, effect ) =
+    let
+        cancelIfStale : Effect userMsg pageData actionData sharedData userEffect errorPage
+        cancelIfStale =
+            case model.transition of
+                Just ( transitionKey, Pages.Transition.Loading path loadingKind ) ->
+                    CancelRequest transitionKey
+
+                _ ->
+                    NoEffect
+    in
+    ( { model
+        | nextTransitionKey = model.nextTransitionKey + 1
+        , transition =
+            ( model.nextTransitionKey
+            , case model.transition of
+                Just ( transitionKey, Pages.Transition.LoadAfterSubmit submitData _ _ ) ->
+                    Pages.Transition.LoadAfterSubmit
+                        submitData
+                        (urlToGet.path |> Path.fromString)
+                        Pages.Transition.Load
+
+                Just ( transitionKey, Pages.Transition.Submitting submitData ) ->
+                    Pages.Transition.LoadAfterSubmit
+                        submitData
+                        (urlToGet.path |> Path.fromString)
+                        Pages.Transition.Load
+
+                _ ->
+                    Pages.Transition.Loading
+                        (urlToGet.path |> Path.fromString)
+                        Pages.Transition.Load
+            )
+                |> Just
+      }
+    , Batch
+        [ FetchPageData
+            model.nextTransitionKey
+            Nothing
+            urlToGet
+            toMsg
+        , cancelIfStale
+        , effect
+        ]
+    )
+
+
+clearLoadingFetchersAfterDataLoad : Int -> Model userModel pageData actionData sharedData -> Model userModel pageData actionData sharedData
+clearLoadingFetchersAfterDataLoad completedTransitionId model =
+    { model
+        | inFlightFetchers =
+            model.inFlightFetchers
+                |> Dict.map
+                    (\_ ( transitionId, fetcherState ) ->
+                        -- TODO fetchers are never removed from the list. Need to decide how and when to remove them.
+                        --(fetcherState.status /= Pages.Transition.FetcherReloading) || (transitionId > completedTransitionId)
+                        case ( transitionId > completedTransitionId, fetcherState.status ) of
+                            ( False, Pages.Transition.FetcherReloading actionData ) ->
+                                ( transitionId
+                                , { fetcherState | status = Pages.Transition.FetcherComplete actionData }
+                                )
+
+                            _ ->
+                                ( transitionId, fetcherState )
+                    )
+    }
+
+
+currentUrlWithPath : String -> Model userModel pageData actionData sharedData -> Url
+currentUrlWithPath path { url } =
+    { url | path = path }
+
+
+loadDataAndUpdateUrl :
+    ( pageData, sharedData, Maybe actionData )
+    -> Maybe userMsg
+    -> Url
+    -> Url
+    -> Bool
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData userEffect (Msg userMsg pageData actionData sharedData errorPage) errorPage
+    -> Model userModel pageData actionData sharedData
+    -> ( Model userModel pageData actionData sharedData, Effect userMsg pageData actionData sharedData userEffect errorPage )
+loadDataAndUpdateUrl ( newPageData, newSharedData, newActionData ) maybeUserMsg urlWithoutRedirectResolution newUrl redirectPending config model =
+    case model.pageData of
+        Ok previousPageData ->
+            let
+                updatedPageData : { userModel : userModel, sharedData : sharedData, actionData : Maybe actionData, pageData : pageData }
+                updatedPageData =
+                    { userModel = userModel
+                    , sharedData = newSharedData
+                    , pageData = newPageData
+                    , actionData = newActionData
+                    }
+
+                ( userModel, _ ) =
+                    -- TODO if urlWithoutRedirectResolution is different from the url with redirect resolution, then
+                    -- instead of calling update, call pushUrl (I think?)
+                    -- TODO include user Cmd
+                    config.update model.pageFormState
+                        (model.inFlightFetchers |> toFetcherState)
+                        (model.transition |> Maybe.map Tuple.second)
+                        newSharedData
+                        newPageData
+                        model.key
+                        (config.onPageChange
+                            { protocol = model.url.protocol
+                            , host = model.url.host
+                            , port_ = model.url.port_
+                            , path = urlPathToPath urlWithoutRedirectResolution
+                            , query = urlWithoutRedirectResolution.query
+                            , fragment = urlWithoutRedirectResolution.fragment
+                            , metadata = config.urlToRoute urlWithoutRedirectResolution
+                            }
+                        )
+                        previousPageData.userModel
+
+                updatedModel : Model userModel pageData actionData sharedData
+                updatedModel =
+                    -- TODO should these be the same (no if)?
+                    if model.pendingRedirect || redirectPending then
+                        { model
+                            | url = newUrl
+                            , pageData = Ok updatedPageData
+                            , transition = Nothing
+                            , pendingRedirect = False
+                            , pageFormState = Dict.empty
+
+                            --, inFlightFetchers = Dict.empty
+                            , pendingData = Nothing
+                        }
+
+                    else
+                        { model
+                            | url = newUrl
+                            , pageData = Ok updatedPageData
+                            , pendingRedirect = False
+                            , transition = Nothing
+                            , inFlightFetchers = Dict.empty
+                            , pendingData = Nothing
+                        }
+
+                onActionMsg : Maybe userMsg
+                onActionMsg =
+                    newActionData |> Maybe.andThen config.onActionData
+            in
+            ( { updatedModel
+                | ariaNavigationAnnouncement = mainView config updatedModel |> .title
+                , currentPath = newUrl.path
+              }
+            , ScrollToTop
+            )
+                |> (case maybeUserMsg of
+                        Just userMsg ->
+                            withUserMsg config userMsg
+
+                        Nothing ->
+                            identity
+                   )
+                |> (case onActionMsg of
+                        Just actionMsg ->
+                            withUserMsg config actionMsg
+
+                        Nothing ->
+                            identity
+                   )
+
+        Err _ ->
+            {-
+               When there is an error loading the content.dat, we are either
+               1) in the dev server, and should show the relevant DataSource error for the page
+                  we're navigating to. This could be done more cleanly, but it's simplest to just
+                  do a fresh page load and use the code path for presenting an error for a fresh page.
+               2) In a production app. That means we had a successful build, so there were no DataSource failures,
+                  so the app must be stale (unless it's in some unexpected state from a bug). In the future,
+                  it probably makes sense to include some sort of hash of the app version we are fetching, match
+                  it with the current version that's running, and perform this logic when we see there is a mismatch.
+                  But for now, if there is any error we do a full page load (not a single-page navigation), which
+                  gives us a fresh version of the app to make sure things are in sync.
+
+            -}
+            ( model
+            , urlWithoutRedirectResolution
+                |> Url.toString
+                |> BrowserLoadUrl
+            )