elm-pages 2.1.11 → 3.0.0-beta.1

package/src/Pages/Internal/Platform/Cli.elm

@@ -8,37 +8,37 @@ module Pages.Internal.Platform.Cli exposing (Flags, Model, Msg(..), Program, cli
 
 import ApiRoute
 import BuildError exposing (BuildError)
+import Bytes exposing (Bytes)
+import Bytes.Encode
 import Codec
 import DataSource exposing (DataSource)
-import DataSource.Http exposing (RequestDetails)
-import Dict exposing (Dict)
-import Dict.Extra
+import Dict
 import Head
 import Html exposing (Html)
 import HtmlPrinter
-import Http
 import Internal.ApiRoute exposing (ApiRoute(..))
 import Json.Decode as Decode
 import Json.Encode
-import Pages.ContentCache as ContentCache exposing (ContentCache)
+import PageServerResponse exposing (PageServerResponse)
 import Pages.Flags
 import Pages.Http
-import Pages.Internal.ApplicationType as ApplicationType
-import Pages.Internal.NotFoundReason exposing (NotFoundReason)
+import Pages.Internal.NotFoundReason as NotFoundReason exposing (NotFoundReason)
 import Pages.Internal.Platform.Effect as Effect exposing (Effect)
 import Pages.Internal.Platform.StaticResponses as StaticResponses exposing (StaticResponses)
 import Pages.Internal.Platform.ToJsPayload as ToJsPayload
+import Pages.Internal.ResponseSketch as ResponseSketch
 import Pages.Internal.StaticHttpBody as StaticHttpBody
+import Pages.Msg
 import Pages.ProgramConfig exposing (ProgramConfig)
 import Pages.SiteConfig exposing (SiteConfig)
 import Pages.StaticHttp.Request
 import Pages.StaticHttpRequest as StaticHttpRequest
 import Path exposing (Path)
 import RenderRequest exposing (RenderRequest)
-import SecretsDict exposing (SecretsDict)
+import RequestsAndPending exposing (RequestsAndPending)
 import Task
 import TerminalText as Terminal
-import Url
+import Url exposing (Url)
 
 
 {-| -}
@@ -49,12 +49,9 @@ type alias Flags =
 {-| -}
 type alias Model route =
     { staticResponses : StaticResponses
-    , secrets : SecretsDict
     , errors : List BuildError
-    , allRawResponses : Dict String (Maybe String)
-    , pendingRequests : List { masked : RequestDetails, unmasked : RequestDetails }
+    , allRawResponses : RequestsAndPending
     , unprocessedPages : List ( Path, route )
-    , staticRoutes : Maybe (List ( Path, route ))
     , maybeRequestJson : RenderRequest route
     , isDevServer : Bool
     }
@@ -64,12 +61,11 @@ type alias Model route =
 type Msg
     = GotDataBatch
         (List
-            { request : { masked : RequestDetails, unmasked : RequestDetails }
-            , response : String
+            { request : Pages.StaticHttp.Request.Request
+            , response : RequestsAndPending.Response
             }
         )
     | GotBuildError BuildError
-    | Continue
 
 
 {-| -}
@@ -79,19 +75,15 @@ type alias Program route =
 
 {-| -}
 cliApplication :
-    ProgramConfig userMsg userModel (Maybe route) siteData pageData sharedData
+    ProgramConfig userMsg userModel (Maybe route) pageData actionData sharedData effect mappedMsg errorPage
     -> Program (Maybe route)
 cliApplication config =
     let
-        contentCache : ContentCache
-        contentCache =
-            ContentCache.init Nothing
-
-        site : SiteConfig siteData
+        site : SiteConfig
         site =
             getSiteConfig config
 
-        getSiteConfig : ProgramConfig userMsg userModel (Maybe route) siteData pageData sharedData -> SiteConfig siteData
+        getSiteConfig : ProgramConfig userMsg userModel (Maybe route) pageData actionData sharedData effect mappedMsg errorPage -> SiteConfig
         getSiteConfig fullConfig =
             case fullConfig.site of
                 Just mySite ->
@@ -109,108 +101,130 @@ cliApplication config =
                         Decode.decodeValue (RenderRequest.decoder config) flags
                             |> Result.withDefault RenderRequest.default
                 in
-                init site renderRequest contentCache config flags
-                    |> Tuple.mapSecond (perform site renderRequest config config.toJsPort)
+                init site renderRequest config flags
+                    |> Tuple.mapSecond (perform site renderRequest config)
         , update =
             \msg model ->
-                update site contentCache config msg model
-                    |> Tuple.mapSecond (perform site model.maybeRequestJson config config.toJsPort)
+                update site config msg model
+                    |> Tuple.mapSecond (perform site model.maybeRequestJson config)
         , subscriptions =
             \_ ->
-                config.fromJsPort
-                    |> Sub.map
-                        (\jsonValue ->
-                            let
-                                decoder : Decode.Decoder Msg
-                                decoder =
-                                    Decode.field "tag" Decode.string
-                                        |> Decode.andThen
-                                            (\tag ->
-                                                -- tag: "GotGlob"
-                                                -- tag: "GotFile"
-                                                case tag of
-                                                    "BuildError" ->
-                                                        Decode.field "data"
-                                                            (Decode.map2
-                                                                (\message title ->
-                                                                    { title = title
-                                                                    , message = message
-                                                                    , fatal = True
-                                                                    , path = "" -- TODO wire in current path here
-                                                                    }
-                                                                )
-                                                                (Decode.field "message" Decode.string |> Decode.map Terminal.fromAnsiString)
-                                                                (Decode.field "title" Decode.string)
-                                                            )
-                                                            |> Decode.map GotBuildError
-
-                                                    "GotBatch" ->
-                                                        Decode.field "data"
-                                                            (Decode.list
+                Sub.batch
+                    [ config.fromJsPort
+                        |> Sub.map
+                            (\jsonValue ->
+                                let
+                                    decoder : Decode.Decoder Msg
+                                    decoder =
+                                        Decode.field "tag" Decode.string
+                                            |> Decode.andThen
+                                                (\tag ->
+                                                    case tag of
+                                                        "BuildError" ->
+                                                            Decode.field "data"
                                                                 (Decode.map2
-                                                                    (\requests response ->
-                                                                        { request =
-                                                                            { masked = requests.masked
-                                                                            , unmasked = requests.unmasked
-                                                                            }
-                                                                        , response = response
+                                                                    (\message title ->
+                                                                        { title = title
+                                                                        , message = message
+                                                                        , fatal = True
+                                                                        , path = "" -- TODO wire in current path here
                                                                         }
                                                                     )
-                                                                    (Decode.field "request" requestDecoder)
-                                                                    (Decode.field "response" Decode.string)
+                                                                    (Decode.field "message" Decode.string |> Decode.map Terminal.fromAnsiString)
+                                                                    (Decode.field "title" Decode.string)
                                                                 )
-                                                            )
-                                                            |> Decode.map GotDataBatch
-
-                                                    _ ->
-                                                        Decode.fail "Unhandled msg"
+                                                                |> Decode.map GotBuildError
+
+                                                        _ ->
+                                                            Decode.fail "Unhandled msg"
+                                                )
+                                in
+                                Decode.decodeValue decoder jsonValue
+                                    |> Result.mapError
+                                        (\error ->
+                                            ("From location 1: "
+                                                ++ (error
+                                                        |> Decode.errorToString
+                                                   )
                                             )
-                            in
-                            Decode.decodeValue decoder jsonValue
-                                |> Result.mapError Decode.errorToString
-                                |> Result.withDefault Continue
-                        )
+                                                |> BuildError.internal
+                                                |> GotBuildError
+                                        )
+                                    |> mergeResult
+                            )
+                    , config.gotBatchSub
+                        |> Sub.map
+                            (\newBatch ->
+                                Decode.decodeValue batchDecoder newBatch
+                                    |> Result.map GotDataBatch
+                                    |> Result.mapError
+                                        (\error ->
+                                            ("From location 2: "
+                                                ++ (error
+                                                        |> Decode.errorToString
+                                                   )
+                                            )
+                                                |> BuildError.internal
+                                                |> GotBuildError
+                                        )
+                                    |> mergeResult
+                            )
+                    ]
         }
 
 
+batchDecoder : Decode.Decoder (List { request : Pages.StaticHttp.Request.Request, response : RequestsAndPending.Response })
+batchDecoder =
+    Decode.map2 (\request response -> { request = request, response = response })
+        (Decode.field "request" requestDecoder)
+        (Decode.field "response" RequestsAndPending.decoder)
+        |> Decode.list
+
+
+mergeResult : Result a a -> a
+mergeResult r =
+    case r of
+        Ok rr ->
+            rr
+
+        Err rr ->
+            rr
+
+
 {-| -}
-requestDecoder : Decode.Decoder { masked : Pages.StaticHttp.Request.Request, unmasked : Pages.StaticHttp.Request.Request }
+requestDecoder : Decode.Decoder Pages.StaticHttp.Request.Request
 requestDecoder =
-    (Codec.object (\masked unmasked -> { masked = masked, unmasked = unmasked })
-        |> Codec.field "masked" .masked Pages.StaticHttp.Request.codec
-        |> Codec.field "unmasked" .unmasked Pages.StaticHttp.Request.codec
-        |> Codec.buildObject
-    )
+    Pages.StaticHttp.Request.codec
         |> Codec.decoder
 
 
-gotStaticFileDecoder : Decode.Decoder ( String, Decode.Value )
-gotStaticFileDecoder =
-    Decode.field "data"
-        (Decode.map2 Tuple.pair
-            (Decode.field "filePath" Decode.string)
-            Decode.value
-        )
+flatten : SiteConfig -> RenderRequest route -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage -> List Effect -> Cmd Msg
+flatten site renderRequest config list =
+    Cmd.batch (flattenHelp [] site renderRequest config list)
 
 
-gotPortDecoder : Decode.Decoder ( String, Decode.Value )
-gotPortDecoder =
-    Decode.field "data"
-        (Decode.map2 Tuple.pair
-            (Decode.field "portName" Decode.string)
-            (Decode.field "portResponse" Decode.value)
-        )
+flattenHelp : List (Cmd Msg) -> SiteConfig -> RenderRequest route -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage -> List Effect -> List (Cmd Msg)
+flattenHelp soFar site renderRequest config list =
+    case list of
+        first :: rest ->
+            flattenHelp
+                (perform site renderRequest config first :: soFar)
+                site
+                renderRequest
+                config
+                rest
+
+        [] ->
+            soFar
 
 
 perform :
-    SiteConfig siteData
+    SiteConfig
     -> RenderRequest route
-    -> ProgramConfig userMsg userModel route siteData pageData sharedData
-    -> (Codec.Value -> Cmd Never)
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage
     -> Effect
     -> Cmd Msg
-perform site renderRequest config toJsPort effect =
-    -- elm-review: known-unoptimized-recursion
+perform site renderRequest config effect =
     let
         canonicalSiteUrl : String
         canonicalSiteUrl =
@@ -221,21 +235,19 @@ perform site renderRequest config toJsPort effect =
             Cmd.none
 
         Effect.Batch list ->
-            list
-                |> List.map (perform site renderRequest config toJsPort)
-                |> Cmd.batch
+            flatten site renderRequest config list
 
-        Effect.FetchHttp ({ unmasked, masked } as requests) ->
+        Effect.FetchHttp unmasked ->
             if unmasked.url == "$$elm-pages$$headers" then
                 case
                     renderRequest
                         |> RenderRequest.maybeRequestPayload
-                        |> Maybe.map (Json.Encode.encode 0)
+                        |> Maybe.map (\json -> RequestsAndPending.Response Nothing (RequestsAndPending.JsonBody json))
                         |> Result.fromMaybe (Pages.Http.BadUrl "$$elm-pages$$headers is only available on server-side request (not on build).")
                 of
                     Ok okResponse ->
                         Task.succeed
-                            [ { request = requests
+                            [ { request = unmasked
                               , response = okResponse
                               }
                             ]
@@ -247,8 +259,8 @@ perform site renderRequest config toJsPort effect =
                             [ Terminal.text "I got an error making an HTTP request to this URL: "
 
                             -- TODO include HTTP method, headers, and body
-                            , Terminal.yellow requests.masked.url
-                            , Terminal.text <| Json.Encode.encode 2 <| StaticHttpBody.encode requests.masked.body
+                            , Terminal.yellow unmasked.url
+                            , Terminal.text <| Json.Encode.encode 2 <| StaticHttpBody.encode unmasked.body
                             , Terminal.text "\n\n"
                             , case error of
                                 Pages.Http.BadStatus metadata body ->
@@ -261,7 +273,7 @@ perform site renderRequest config toJsPort effect =
 
                                 Pages.Http.BadUrl _ ->
                                     -- TODO include HTTP method, headers, and body
-                                    Terminal.text <| "Invalid url: " ++ requests.masked.url
+                                    Terminal.text <| "Invalid url: " ++ unmasked.url
 
                                 Pages.Http.Timeout ->
                                     Terminal.text "Timeout"
@@ -275,35 +287,29 @@ perform site renderRequest config toJsPort effect =
                             |> Task.succeed
                             |> Task.perform GotBuildError
 
-            else if unmasked.url |> String.startsWith "file://" then
-                let
-                    filePath : String
-                    filePath =
-                        String.dropLeft 7 unmasked.url
-                in
-                ToJsPayload.ReadFile filePath
+            else
+                ToJsPayload.DoHttp unmasked unmasked.useCache
                     |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl "")
-                    |> toJsPort
+                    |> config.toJsPort
                     |> Cmd.map never
 
-            else if unmasked.url |> String.startsWith "glob://" then
-                let
-                    globPattern : String
-                    globPattern =
-                        String.dropLeft 7 unmasked.url
-                in
-                ToJsPayload.Glob globPattern
-                    |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl "")
-                    |> toJsPort
-                    |> Cmd.map never
+        Effect.SendSinglePage info ->
+            let
+                currentPagePath : String
+                currentPagePath =
+                    case info of
+                        ToJsPayload.PageProgress toJsSuccessPayloadNew ->
+                            toJsSuccessPayloadNew.route
 
-            else
-                ToJsPayload.DoHttp { masked = masked, unmasked = unmasked }
-                    |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl "")
-                    |> toJsPort
-                    |> Cmd.map never
+                        _ ->
+                            ""
+            in
+            info
+                |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl currentPagePath)
+                |> config.toJsPort
+                |> Cmd.map never
 
-        Effect.SendSinglePage done info ->
+        Effect.SendSinglePageNew rawBytes info ->
             let
                 currentPagePath : String
                 currentPagePath =
@@ -314,80 +320,59 @@ perform site renderRequest config toJsPort effect =
                         _ ->
                             ""
             in
-            Cmd.batch
-                [ info
+            { oldThing =
+                info
                     |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl currentPagePath)
-                    |> toJsPort
-                    |> Cmd.map never
-                , if done then
-                    Cmd.none
-
-                  else
-                    Task.succeed ()
-                        |> Task.perform (\_ -> Continue)
-                ]
+            , binaryPageData = rawBytes
+            }
+                |> config.sendPageData
+                |> Cmd.map never
 
         Effect.Continue ->
             Cmd.none
 
-        Effect.ReadFile filePath ->
-            ToJsPayload.ReadFile filePath
-                |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl "")
-                |> toJsPort
-                |> Cmd.map never
-
-        Effect.GetGlob globPattern ->
-            ToJsPayload.Glob globPattern
-                |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl "")
-                |> toJsPort
-                |> Cmd.map never
-
 
 flagsDecoder :
     Decode.Decoder
-        { secrets : SecretsDict
-        , staticHttpCache : Dict String (Maybe String)
+        { staticHttpCache : RequestsAndPending
         , isDevServer : Bool
         }
 flagsDecoder =
-    Decode.map3
-        (\secrets staticHttpCache isDevServer ->
-            { secrets = secrets
-            , staticHttpCache = staticHttpCache
+    Decode.map2
+        (\staticHttpCache isDevServer ->
+            { staticHttpCache = staticHttpCache
             , isDevServer = isDevServer
             }
         )
-        (Decode.field "secrets" SecretsDict.decoder)
-        (Decode.field "staticHttpCache"
-            (Decode.dict
-                (Decode.string
-                    |> Decode.map Just
-                )
-            )
-        )
+        --(Decode.field "staticHttpCache"
+        --    (Decode.dict
+        --        (Decode.string
+        --            |> Decode.map Just
+        --        )
+        --    )
+        --)
+        -- TODO remove hardcoding and decode staticHttpCache here
+        (Decode.succeed Dict.empty)
         (Decode.field "mode" Decode.string |> Decode.map (\mode -> mode == "dev-server"))
 
 
 {-| -}
 init :
-    SiteConfig siteData
+    SiteConfig
     -> RenderRequest route
-    -> ContentCache
-    -> ProgramConfig userMsg userModel route siteData pageData sharedData
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage
     -> Decode.Value
     -> ( Model route, Effect )
-init site renderRequest contentCache config flags =
+init site renderRequest config flags =
     case Decode.decodeValue flagsDecoder flags of
-        Ok { secrets, staticHttpCache, isDevServer } ->
-            initLegacy site renderRequest { secrets = secrets, staticHttpCache = staticHttpCache, isDevServer = isDevServer } contentCache config flags
+        Ok { staticHttpCache, isDevServer } ->
+            initLegacy site renderRequest { staticHttpCache = staticHttpCache, isDevServer = isDevServer } config
 
         Err error ->
             updateAndSendPortIfDone
                 site
-                contentCache
                 config
-                { staticResponses = StaticResponses.error
-                , secrets = SecretsDict.masked
+                { staticResponses = StaticResponses.empty
                 , errors =
                     [ { title = "Internal Error"
                       , message = [ Terminal.text <| "Failed to parse flags: " ++ Decode.errorToString error ]
@@ -396,35 +381,105 @@ init site renderRequest contentCache config flags =
                       }
                     ]
                 , allRawResponses = Dict.empty
-                , pendingRequests = []
                 , unprocessedPages = []
-                , staticRoutes = Just []
                 , maybeRequestJson = renderRequest
                 , isDevServer = False
                 }
 
 
+type ActionRequest
+    = ActionResponseRequest
+    | ActionOnlyRequest
+
+
+isActionDecoder : Decode.Decoder (Maybe ActionRequest)
+isActionDecoder =
+    Decode.map2 Tuple.pair
+        (Decode.field "method" Decode.string)
+        (Decode.field "headers" (Decode.dict Decode.string))
+        |> Decode.map
+            (\( method, headers ) ->
+                case method |> String.toUpper of
+                    "GET" ->
+                        Nothing
+
+                    "OPTIONS" ->
+                        Nothing
+
+                    _ ->
+                        let
+                            actionOnly : Bool
+                            actionOnly =
+                                case headers |> Dict.get "elm-pages-action-only" of
+                                    Just _ ->
+                                        True
+
+                                    Nothing ->
+                                        False
+                        in
+                        Just
+                            (if actionOnly then
+                                ActionOnlyRequest
+
+                             else
+                                ActionResponseRequest
+                            )
+            )
+
+
 initLegacy :
-    SiteConfig siteData
+    SiteConfig
     -> RenderRequest route
-    -> { secrets : SecretsDict, staticHttpCache : Dict String (Maybe String), isDevServer : Bool }
-    -> ContentCache
-    -> ProgramConfig userMsg userModel route siteData pageData sharedData
-    -> Decode.Value
+    -> { staticHttpCache : RequestsAndPending, isDevServer : Bool }
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage
     -> ( Model route, Effect )
-initLegacy site renderRequest { secrets, staticHttpCache, isDevServer } contentCache config flags =
+initLegacy site renderRequest { staticHttpCache, isDevServer } config =
     let
         staticResponses : StaticResponses
         staticResponses =
             case renderRequest of
                 RenderRequest.SinglePage _ singleRequest _ ->
+                    let
+                        globalHeadTags : DataSource (List Head.Tag)
+                        globalHeadTags =
+                            (config.globalHeadTags |> Maybe.withDefault (\_ -> DataSource.succeed [])) HtmlPrinter.htmlToString
+                    in
                     case singleRequest of
                         RenderRequest.Page serverRequestPayload ->
-                            StaticResponses.renderSingleRoute config
-                                serverRequestPayload
-                                (DataSource.map2 (\_ _ -> ())
-                                    (config.data serverRequestPayload.frontmatter)
-                                    config.sharedData
+                            let
+                                isAction : Maybe ActionRequest
+                                isAction =
+                                    renderRequest
+                                        |> RenderRequest.maybeRequestPayload
+                                        |> Maybe.andThen (Decode.decodeValue isActionDecoder >> Result.withDefault Nothing)
+                            in
+                            StaticResponses.renderSingleRoute
+                                (case isAction of
+                                    Just _ ->
+                                        config.action serverRequestPayload.frontmatter
+                                            |> DataSource.andThen
+                                                (\something ->
+                                                    case something of
+                                                        PageServerResponse.ErrorPage _ _ ->
+                                                            DataSource.succeed something
+                                                                |> DataSource.map (\_ -> ())
+
+                                                        PageServerResponse.RenderPage _ _ ->
+                                                            DataSource.map3 (\_ _ _ -> ())
+                                                                (config.data serverRequestPayload.frontmatter)
+                                                                config.sharedData
+                                                                globalHeadTags
+
+                                                        PageServerResponse.ServerResponse _ ->
+                                                            DataSource.succeed something
+                                                                |> DataSource.map (\_ -> ())
+                                                )
+
+                                    Nothing ->
+                                        DataSource.map3 (\_ _ _ -> ())
+                                            (config.data serverRequestPayload.frontmatter)
+                                            config.sharedData
+                                            globalHeadTags
                                 )
                                 (if isDevServer then
                                     config.handleRoute serverRequestPayload.frontmatter
@@ -435,11 +490,17 @@ initLegacy site renderRequest { secrets, staticHttpCache, isDevServer } contentC
 
                         RenderRequest.Api ( path, ApiRoute apiRequest ) ->
                             StaticResponses.renderApiRequest
-                                (apiRequest.matchesToResponse path)
+                                (DataSource.map2 (\_ _ -> ())
+                                    (apiRequest.matchesToResponse path)
+                                    globalHeadTags
+                                )
 
-                        RenderRequest.NotFound path ->
+                        RenderRequest.NotFound _ ->
                             StaticResponses.renderApiRequest
-                                (DataSource.succeed [])
+                                (DataSource.map2 (\_ _ -> ())
+                                    (DataSource.succeed [])
+                                    globalHeadTags
+                                )
 
         unprocessedPages : List ( Path, route )
         unprocessedPages =
@@ -452,104 +513,57 @@ initLegacy site renderRequest { secrets, staticHttpCache, isDevServer } contentC
                         RenderRequest.Api _ ->
                             []
 
-                        RenderRequest.NotFound path ->
+                        RenderRequest.NotFound _ ->
                             []
 
-        unprocessedPagesState : Maybe (List ( Path, route ))
-        unprocessedPagesState =
-            case renderRequest of
-                RenderRequest.SinglePage _ serverRequestPayload _ ->
-                    case serverRequestPayload of
-                        RenderRequest.Page pageData ->
-                            Just [ ( pageData.path, pageData.frontmatter ) ]
-
-                        RenderRequest.Api _ ->
-                            Nothing
-
-                        RenderRequest.NotFound path ->
-                            Just []
-
         initialModel : Model route
         initialModel =
             { staticResponses = staticResponses
-            , secrets = secrets
             , errors = []
             , allRawResponses = staticHttpCache
-            , pendingRequests = []
             , unprocessedPages = unprocessedPages
-            , staticRoutes = unprocessedPagesState
             , maybeRequestJson = renderRequest
             , isDevServer = isDevServer
             }
     in
-    StaticResponses.nextStep config initialModel Nothing
+    StaticResponses.nextStep initialModel Nothing
         |> nextStepToEffect site
-            contentCache
             config
             initialModel
 
 
 updateAndSendPortIfDone :
-    SiteConfig siteData
-    -> ContentCache
-    -> ProgramConfig userMsg userModel route siteData pageData sharedData
+    SiteConfig
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage
     -> Model route
     -> ( Model route, Effect )
-updateAndSendPortIfDone site contentCache config model =
+updateAndSendPortIfDone site config model =
     StaticResponses.nextStep
-        config
         model
         Nothing
-        |> nextStepToEffect site contentCache config model
+        |> nextStepToEffect site config model
 
 
 {-| -}
 update :
-    SiteConfig siteData
-    -> ContentCache
-    -> ProgramConfig userMsg userModel route siteData pageData sharedData
+    SiteConfig
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage
     -> Msg
     -> Model route
     -> ( Model route, Effect )
-update site contentCache config msg model =
+update site config msg model =
     case msg of
         GotDataBatch batch ->
-            let
-                updatedModel : Model route
-                updatedModel =
-                    (case batch of
-                        [ single ] ->
-                            { model
-                                | pendingRequests =
-                                    model.pendingRequests
-                                        |> List.filter
-                                            (\pending ->
-                                                pending /= single.request
-                                            )
-                            }
-
-                        _ ->
-                            { model
-                                | pendingRequests = [] -- TODO is it safe to clear it entirely?
-                            }
-                    )
-                        |> StaticResponses.batchUpdate batch
-            in
-            StaticResponses.nextStep config
-                updatedModel
-                Nothing
-                |> nextStepToEffect site contentCache config updatedModel
-
-        Continue ->
             let
                 updatedModel : Model route
                 updatedModel =
                     model
+                        |> StaticResponses.batchUpdate batch
             in
-            StaticResponses.nextStep config
+            StaticResponses.nextStep
                 updatedModel
                 Nothing
-                |> nextStepToEffect site contentCache config updatedModel
+                |> nextStepToEffect site config updatedModel
 
         GotBuildError buildError ->
             let
@@ -560,51 +574,22 @@ update site contentCache config msg model =
                             buildError :: model.errors
                     }
             in
-            StaticResponses.nextStep config
+            StaticResponses.nextStep
                 updatedModel
                 Nothing
-                |> nextStepToEffect site contentCache config updatedModel
+                |> nextStepToEffect site config updatedModel
 
 
 nextStepToEffect :
-    SiteConfig siteData
-    -> ContentCache
-    -> ProgramConfig userMsg userModel route siteData pageData sharedData
+    SiteConfig
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage
     -> Model route
     -> ( StaticResponses, StaticResponses.NextStep route )
     -> ( Model route, Effect )
-nextStepToEffect site contentCache config model ( updatedStaticResponsesModel, nextStep ) =
+nextStepToEffect site config model ( updatedStaticResponsesModel, nextStep ) =
     case nextStep of
         StaticResponses.Continue updatedAllRawResponses httpRequests maybeRoutes ->
             let
-                nextAndPending : List { masked : RequestDetails, unmasked : RequestDetails }
-                nextAndPending =
-                    model.pendingRequests ++ httpRequests
-
-                doNow : List { masked : RequestDetails, unmasked : RequestDetails }
-                doNow =
-                    nextAndPending
-
-                pending : List { masked : RequestDetails, unmasked : RequestDetails }
-                pending =
-                    []
-
-                updatedRoutes : Maybe (List ( Path, route ))
-                updatedRoutes =
-                    case maybeRoutes of
-                        Just newRoutes ->
-                            newRoutes
-                                |> List.map
-                                    (\route ->
-                                        ( Path.join (config.routeToPath route)
-                                        , route
-                                        )
-                                    )
-                                |> Just
-
-                        Nothing ->
-                            model.staticRoutes
-
                 updatedUnprocessedPages : List ( Path, route )
                 updatedUnprocessedPages =
                     case maybeRoutes of
@@ -624,25 +609,22 @@ nextStepToEffect site contentCache config model ( updatedStaticResponsesModel, n
                 updatedModel =
                     { model
                         | allRawResponses = updatedAllRawResponses
-                        , pendingRequests = pending
                         , staticResponses = updatedStaticResponsesModel
-                        , staticRoutes = updatedRoutes
                         , unprocessedPages = updatedUnprocessedPages
                     }
             in
-            if List.isEmpty doNow && updatedRoutes /= model.staticRoutes then
+            if List.isEmpty httpRequests then
                 nextStepToEffect site
-                    contentCache
                     config
                     updatedModel
-                    (StaticResponses.nextStep config
+                    (StaticResponses.nextStep
                         updatedModel
                         Nothing
                     )
 
             else
                 ( updatedModel
-                , (doNow
+                , (httpRequests
                     |> List.map Effect.FetchHttp
                   )
                     |> Effect.Batch
@@ -655,7 +637,15 @@ nextStepToEffect site contentCache config model ( updatedStaticResponsesModel, n
                         apiResponse : Effect
                         apiResponse =
                             case model.maybeRequestJson of
-                                RenderRequest.SinglePage includeHtml requestPayload value ->
+                                RenderRequest.SinglePage _ requestPayload _ ->
+                                    let
+                                        sharedDataResult : Result BuildError sharedData
+                                        sharedDataResult =
+                                            StaticHttpRequest.resolve
+                                                config.sharedData
+                                                model.allRawResponses
+                                                |> Result.mapError (StaticHttpRequest.toBuildError "")
+                                    in
                                     case requestPayload of
                                         RenderRequest.Api ( path, ApiRoute apiHandler ) ->
                                             let
@@ -663,40 +653,38 @@ nextStepToEffect site contentCache config model ( updatedStaticResponsesModel, n
                                                 thing =
                                                     apiHandler.matchesToResponse path
                                             in
-                                            StaticHttpRequest.resolve ApplicationType.Cli
+                                            StaticHttpRequest.resolve
                                                 thing
                                                 model.allRawResponses
                                                 |> Result.mapError (StaticHttpRequest.toBuildError "TODO - path from request")
                                                 |> (\response ->
                                                         case response of
                                                             Ok (Just okResponse) ->
-                                                                { body = okResponse.body
-                                                                , staticHttpCache = model.allRawResponses |> Dict.Extra.filterMap (\_ v -> v)
+                                                                { body = okResponse
+                                                                , staticHttpCache = Dict.empty -- TODO do I need to serialize the full cache here, or can I handle that from the JS side?
+
+                                                                -- model.allRawResponses |> Dict.Extra.filterMap (\_ v -> v)
                                                                 , statusCode = 200
                                                                 }
                                                                     |> ToJsPayload.SendApiResponse
-                                                                    |> Effect.SendSinglePage True
+                                                                    |> Effect.SendSinglePage
 
                                                             Ok Nothing ->
-                                                                { body = "Hello1!"
-                                                                , staticHttpCache = model.allRawResponses |> Dict.Extra.filterMap (\_ v -> v)
-                                                                , statusCode = 404
-                                                                }
-                                                                    |> ToJsPayload.SendApiResponse
-                                                                    |> Effect.SendSinglePage True
+                                                                render404Page config (Result.toMaybe sharedDataResult) model (Path.fromString path) NotFoundReason.NoMatchingRoute
 
                                                             Err error ->
                                                                 [ error ]
                                                                     |> ToJsPayload.Errors
-                                                                    |> Effect.SendSinglePage True
+                                                                    |> Effect.SendSinglePage
                                                    )
 
                                         RenderRequest.Page payload ->
                                             let
                                                 pageFoundResult : Result BuildError (Maybe NotFoundReason)
                                                 pageFoundResult =
-                                                    StaticHttpRequest.resolve ApplicationType.Browser
+                                                    StaticHttpRequest.resolve
                                                         (if model.isDevServer then
+                                                            -- TODO OPTIMIZATION this is redundant
                                                             config.handleRoute payload.frontmatter
 
                                                          else
@@ -707,309 +695,519 @@ nextStepToEffect site contentCache config model ( updatedStaticResponsesModel, n
                                             in
                                             case pageFoundResult of
                                                 Ok Nothing ->
-                                                    let
-                                                        currentUrl : Url.Url
-                                                        currentUrl =
-                                                            { protocol = Url.Https
-                                                            , host = site.canonicalUrl
-                                                            , port_ = Nothing
-                                                            , path = payload.path |> Path.toRelative
-                                                            , query = Nothing
-                                                            , fragment = Nothing
-                                                            }
-
-                                                        renderedResult : Result BuildError { head : List Head.Tag, view : String, title : String }
-                                                        renderedResult =
-                                                            case includeHtml of
-                                                                RenderRequest.OnlyJson ->
-                                                                    Ok
-                                                                        { head = []
-                                                                        , view = "This page was not rendered because it is a JSON-only request."
-                                                                        , title = "This page was not rendered because it is a JSON-only request."
-                                                                        }
-
-                                                                RenderRequest.HtmlAndJson ->
-                                                                    Result.map2 Tuple.pair pageDataResult sharedDataResult
-                                                                        |> Result.map
-                                                                            (\( pageData, sharedData ) ->
-                                                                                let
-                                                                                    pageModel : userModel
-                                                                                    pageModel =
-                                                                                        config.init
-                                                                                            Pages.Flags.PreRenderFlags
-                                                                                            sharedData
-                                                                                            pageData
-                                                                                            Nothing
-                                                                                            (Just
-                                                                                                { path =
-                                                                                                    { path = currentPage.path
-                                                                                                    , query = Nothing
-                                                                                                    , fragment = Nothing
-                                                                                                    }
-                                                                                                , metadata = currentPage.route
-                                                                                                , pageUrl = Nothing
-                                                                                                }
-                                                                                            )
-                                                                                            |> Tuple.first
-
-                                                                                    viewValue : { title : String, body : Html userMsg }
-                                                                                    viewValue =
-                                                                                        (config.view currentPage Nothing sharedData pageData |> .view) pageModel
-                                                                                in
-                                                                                { head = config.view currentPage Nothing sharedData pageData |> .head
-                                                                                , view = viewValue.body |> HtmlPrinter.htmlToString
-                                                                                , title = viewValue.title
-                                                                                }
-                                                                            )
-
-                                                        staticData : Dict String String
-                                                        staticData =
-                                                            --toJsPayload.pages
-                                                            --    |> Dict.get (Path.toRelative page)
-                                                            --    |> Maybe.withDefault Dict.empty
-                                                            Dict.empty
-
-                                                        currentPage : { path : Path, route : route }
-                                                        currentPage =
-                                                            { path = payload.path, route = config.urlToRoute currentUrl }
-
-                                                        pageDataResult : Result BuildError pageData
-                                                        pageDataResult =
-                                                            StaticHttpRequest.resolve ApplicationType.Browser
-                                                                (config.data (config.urlToRoute currentUrl))
-                                                                (staticData |> Dict.map (\_ v -> Just v))
-                                                                |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
-
-                                                        sharedDataResult : Result BuildError sharedData
-                                                        sharedDataResult =
-                                                            StaticHttpRequest.resolve ApplicationType.Browser
-                                                                config.sharedData
-                                                                (staticData |> Dict.map (\_ v -> Just v))
-                                                                |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
-
-                                                        siteDataResult : Result BuildError siteData
-                                                        siteDataResult =
-                                                            StaticHttpRequest.resolve ApplicationType.Cli
-                                                                site.data
-                                                                (staticData |> Dict.map (\_ v -> Just v))
-                                                                |> Result.mapError (StaticHttpRequest.toBuildError "Site.elm")
-                                                    in
-                                                    case Result.map3 (\a b c -> ( a, b, c )) pageFoundResult renderedResult siteDataResult of
-                                                        Ok ( pageFound, rendered, siteData ) ->
-                                                            { route = payload.path |> Path.toRelative
-                                                            , contentJson =
-                                                                --toJsPayload.pages
-                                                                --    |> Dict.get (Path.toRelative page)
-                                                                --    |> Maybe.withDefault Dict.empty
-                                                                Dict.empty
-                                                            , html = rendered.view
-                                                            , errors = []
-                                                            , head = rendered.head
-                                                            , title = rendered.title
-                                                            , staticHttpCache = model.allRawResponses |> Dict.Extra.filterMap (\_ v -> v)
-                                                            , is404 = False
-                                                            }
-                                                                |> ToJsPayload.PageProgress
-                                                                |> Effect.SendSinglePage False
-
-                                                        Err error ->
-                                                            [ error ] |> ToJsPayload.Errors |> Effect.SendSinglePage True
+                                                    sendSinglePageProgress site model.allRawResponses config model payload
 
                                                 Ok (Just notFoundReason) ->
-                                                    render404Page config model payload.path notFoundReason
+                                                    render404Page config
+                                                        --Nothing
+                                                        (Result.toMaybe sharedDataResult)
+                                                        model
+                                                        payload.path
+                                                        notFoundReason
 
                                                 Err error ->
-                                                    [ error ] |> ToJsPayload.Errors |> Effect.SendSinglePage True
+                                                    [ error ] |> ToJsPayload.Errors |> Effect.SendSinglePage
 
                                         RenderRequest.NotFound path ->
-                                            render404Page config model path Pages.Internal.NotFoundReason.NoMatchingRoute
+                                            render404Page config
+                                                --Nothing
+                                                (Result.toMaybe sharedDataResult)
+                                                model
+                                                path
+                                                NotFoundReason.NoMatchingRoute
                     in
-                    ( { model | staticRoutes = Just [] }
+                    ( model
                     , apiResponse
                     )
 
-                StaticResponses.Page contentJson ->
-                    case model.unprocessedPages |> List.head of
-                        Just pageAndMetadata ->
-                            ( model
-                            , sendSinglePageProgress site contentJson config model pageAndMetadata
-                            )
-
-                        Nothing ->
-                            ( model
-                            , [] |> ToJsPayload.Errors |> Effect.SendSinglePage True
-                            )
-
                 StaticResponses.Errors errors ->
                     ( model
-                    , errors |> ToJsPayload.Errors |> Effect.SendSinglePage True
+                    , errors |> ToJsPayload.Errors |> Effect.SendSinglePage
                     )
 
 
 sendSinglePageProgress :
-    SiteConfig siteData
-    -> Dict String String
-    -> ProgramConfig userMsg userModel route siteData pageData sharedData
+    SiteConfig
+    -> RequestsAndPending
+    -> ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage
     -> Model route
-    -> ( Path, route )
+    -> { path : Path, frontmatter : route }
     -> Effect
-sendSinglePageProgress site contentJson config model =
-    \( page, route ) ->
-        case model.maybeRequestJson of
-            RenderRequest.SinglePage includeHtml _ _ ->
-                let
-                    pageFoundResult : Result BuildError (Maybe NotFoundReason)
-                    pageFoundResult =
-                        StaticHttpRequest.resolve ApplicationType.Browser
-                            (if model.isDevServer then
-                                config.handleRoute route
+sendSinglePageProgress site contentJson config model info =
+    let
+        ( page, route ) =
+            ( info.path, info.frontmatter )
+    in
+    case model.maybeRequestJson of
+        RenderRequest.SinglePage includeHtml _ _ ->
+            let
+                isAction : Maybe ActionRequest
+                isAction =
+                    model.maybeRequestJson
+                        |> RenderRequest.maybeRequestPayload
+                        |> Maybe.andThen (Decode.decodeValue isActionDecoder >> Result.withDefault Nothing)
 
-                             else
-                                DataSource.succeed Nothing
-                            )
-                            model.allRawResponses
-                            |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
-
-                    renderedResult : Result BuildError { head : List Head.Tag, view : String, title : String }
-                    renderedResult =
-                        case includeHtml of
-                            RenderRequest.OnlyJson ->
-                                Ok
-                                    { head = []
-                                    , view = "This page was not rendered because it is a JSON-only request."
-                                    , title = "This page was not rendered because it is a JSON-only request."
-                                    }
+                pageFoundResult : Result BuildError (Maybe NotFoundReason)
+                pageFoundResult =
+                    -- TODO OPTIMIZATION this is redundant
+                    StaticHttpRequest.resolve
+                        (if model.isDevServer then
+                            config.handleRoute route
 
-                            RenderRequest.HtmlAndJson ->
-                                Result.map2 Tuple.pair pageDataResult sharedDataResult
-                                    |> Result.map
-                                        (\( pageData, sharedData ) ->
-                                            let
-                                                pageModel : userModel
-                                                pageModel =
-                                                    config.init
-                                                        Pages.Flags.PreRenderFlags
-                                                        sharedData
-                                                        pageData
-                                                        Nothing
-                                                        (Just
-                                                            { path =
-                                                                { path = currentPage.path
-                                                                , query = Nothing
-                                                                , fragment = Nothing
+                         else
+                            DataSource.succeed Nothing
+                        )
+                        model.allRawResponses
+                        |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
+
+                renderedResult : Result BuildError (PageServerResponse { head : List Head.Tag, view : String, title : String } errorPage)
+                renderedResult =
+                    case includeHtml of
+                        RenderRequest.OnlyJson ->
+                            pageDataResult
+                                |> Result.map
+                                    (\okPageData ->
+                                        case okPageData of
+                                            PageServerResponse.RenderPage responseInfo _ ->
+                                                PageServerResponse.RenderPage
+                                                    { statusCode = responseInfo.statusCode
+                                                    , headers = responseInfo.headers
+                                                    }
+                                                    { head = []
+                                                    , view = "This page was not rendered because it is a JSON-only request."
+                                                    , title = "This page was not rendered because it is a JSON-only request."
+                                                    }
+
+                                            PageServerResponse.ServerResponse serverResponse ->
+                                                PageServerResponse.ServerResponse serverResponse
+
+                                            PageServerResponse.ErrorPage error record ->
+                                                PageServerResponse.ErrorPage error record
+                                    )
+
+                        RenderRequest.HtmlAndJson ->
+                            Result.map2 Tuple.pair pageDataResult sharedDataResult
+                                |> Result.map
+                                    (\( pageData_, sharedData ) ->
+                                        case pageData_ of
+                                            PageServerResponse.RenderPage responseInfo pageData ->
+                                                let
+                                                    currentPage : { path : Path, route : route }
+                                                    currentPage =
+                                                        { path = page, route = urlToRoute config currentUrl }
+
+                                                    maybeActionData : Maybe actionData
+                                                    maybeActionData =
+                                                        case isAction of
+                                                            Just _ ->
+                                                                case actionDataResult of
+                                                                    Ok (PageServerResponse.RenderPage _ actionData) ->
+                                                                        Just actionData
+
+                                                                    _ ->
+                                                                        Nothing
+
+                                                            Nothing ->
+                                                                Nothing
+
+                                                    pageModel : userModel
+                                                    pageModel =
+                                                        config.init
+                                                            Pages.Flags.PreRenderFlags
+                                                            sharedData
+                                                            pageData
+                                                            maybeActionData
+                                                            (Just
+                                                                { path =
+                                                                    { path = currentPage.path
+                                                                    , query = Nothing
+                                                                    , fragment = Nothing
+                                                                    }
+                                                                , metadata = currentPage.route
+                                                                , pageUrl = Nothing
                                                                 }
-                                                            , metadata = currentPage.route
-                                                            , pageUrl = Nothing
-                                                            }
-                                                        )
-                                                        |> Tuple.first
+                                                            )
+                                                            |> Tuple.first
+
+                                                    viewValue : { title : String, body : Html (Pages.Msg.Msg userMsg) }
+                                                    viewValue =
+                                                        (config.view Dict.empty Dict.empty Nothing currentPage Nothing sharedData pageData maybeActionData |> .view) pageModel
+                                                in
+                                                PageServerResponse.RenderPage responseInfo
+                                                    { head = config.view Dict.empty Dict.empty Nothing currentPage Nothing sharedData pageData maybeActionData |> .head
+                                                    , view = viewValue.body |> HtmlPrinter.htmlToString
+                                                    , title = viewValue.title
+                                                    }
+
+                                            PageServerResponse.ServerResponse serverResponse ->
+                                                PageServerResponse.ServerResponse serverResponse
+
+                                            PageServerResponse.ErrorPage error record ->
+                                                let
+                                                    currentPage : { path : Path, route : route }
+                                                    currentPage =
+                                                        { path = page, route = urlToRoute config currentUrl }
+
+                                                    pageModel : userModel
+                                                    pageModel =
+                                                        config.init
+                                                            Pages.Flags.PreRenderFlags
+                                                            sharedData
+                                                            pageData
+                                                            Nothing
+                                                            (Just
+                                                                { path =
+                                                                    { path = currentPage.path
+                                                                    , query = Nothing
+                                                                    , fragment = Nothing
+                                                                    }
+                                                                , metadata = currentPage.route
+                                                                , pageUrl = Nothing
+                                                                }
+                                                            )
+                                                            |> Tuple.first
+
+                                                    pageData : pageData
+                                                    pageData =
+                                                        config.errorPageToData error
+
+                                                    viewValue : { title : String, body : Html (Pages.Msg.Msg userMsg) }
+                                                    viewValue =
+                                                        (config.view Dict.empty Dict.empty Nothing currentPage Nothing sharedData pageData Nothing |> .view) pageModel
+                                                in
+                                                PageServerResponse.RenderPage
+                                                    { statusCode = config.errorStatusCode error
+                                                    , headers = record.headers
+                                                    }
+                                                    { head = config.view Dict.empty Dict.empty Nothing currentPage Nothing sharedData pageData Nothing |> .head
+                                                    , view = viewValue.body |> HtmlPrinter.htmlToString
+                                                    , title = viewValue.title
+                                                    }
+                                    )
 
-                                                viewValue : { title : String, body : Html userMsg }
-                                                viewValue =
-                                                    (config.view currentPage Nothing sharedData pageData |> .view) pageModel
-                                            in
-                                            { head = config.view currentPage Nothing sharedData pageData |> .head
-                                            , view = viewValue.body |> HtmlPrinter.htmlToString
-                                            , title = viewValue.title
-                                            }
-                                        )
+                currentUrl : Url
+                currentUrl =
+                    { protocol = Url.Https
+                    , host = site.canonicalUrl
+                    , port_ = Nothing
+                    , path = page |> Path.toRelative
+                    , query = Nothing
+                    , fragment = Nothing
+                    }
 
-                    currentUrl : Url.Url
-                    currentUrl =
-                        { protocol = Url.Https
-                        , host = site.canonicalUrl
-                        , port_ = Nothing
-                        , path = page |> Path.toRelative
-                        , query = Nothing
-                        , fragment = Nothing
-                        }
+                pageDataResult : Result BuildError (PageServerResponse pageData errorPage)
+                pageDataResult =
+                    -- TODO OPTIMIZATION can these three be included in StaticResponses.Finish?
+                    StaticHttpRequest.resolve
+                        (case isAction of
+                            Just _ ->
+                                config.action (urlToRoute config currentUrl)
+                                    |> DataSource.andThen
+                                        (\something ->
+                                            case something of
+                                                PageServerResponse.ErrorPage a b ->
+                                                    PageServerResponse.ErrorPage a b
+                                                        |> DataSource.succeed
+
+                                                PageServerResponse.RenderPage _ _ ->
+                                                    -- TODO the headers/response codes are ignored from the action here
+                                                    -- is that okay? Should you always do a redirect or another kind of
+                                                    -- server response if you want to control the headers/response code for an action (like logout & redirect, for example)?
+                                                    config.data (urlToRoute config currentUrl)
+
+                                                PageServerResponse.ServerResponse a ->
+                                                    PageServerResponse.ServerResponse a
+                                                        |> DataSource.succeed
+                                        )
 
-                    currentPage : { path : Path, route : route }
-                    currentPage =
-                        { path = page, route = config.urlToRoute currentUrl }
-
-                    pageDataResult : Result BuildError pageData
-                    pageDataResult =
-                        StaticHttpRequest.resolve ApplicationType.Browser
-                            (config.data (config.urlToRoute currentUrl))
-                            (contentJson |> Dict.map (\_ v -> Just v))
-                            |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
-
-                    sharedDataResult : Result BuildError sharedData
-                    sharedDataResult =
-                        StaticHttpRequest.resolve ApplicationType.Browser
-                            config.sharedData
-                            (contentJson |> Dict.map (\_ v -> Just v))
-                            |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
-
-                    siteDataResult : Result BuildError siteData
-                    siteDataResult =
-                        StaticHttpRequest.resolve ApplicationType.Cli
-                            site.data
-                            (contentJson |> Dict.map (\_ v -> Just v))
-                            |> Result.mapError (StaticHttpRequest.toBuildError "Site.elm")
-                in
-                case Result.map3 (\a b c -> ( a, b, c )) pageFoundResult renderedResult siteDataResult of
-                    Ok ( maybeNotFoundReason, rendered, siteData ) ->
-                        case maybeNotFoundReason of
                             Nothing ->
-                                { route = page |> Path.toRelative
-                                , contentJson = contentJson
-                                , html = rendered.view
-                                , errors = []
-                                , head = rendered.head ++ site.head siteData
-                                , title = rendered.title
-                                , staticHttpCache = model.allRawResponses |> Dict.Extra.filterMap (\_ v -> v)
-                                , is404 = False
-                                }
-                                    |> ToJsPayload.PageProgress
-                                    |> Effect.SendSinglePage True
-
-                            Just notFoundReason ->
-                                render404Page config model page notFoundReason
+                                config.data (urlToRoute config currentUrl)
+                        )
+                        contentJson
+                        |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
+
+                actionDataResult : Result BuildError (PageServerResponse actionData errorPage)
+                actionDataResult =
+                    -- TODO OPTIMIZATION can these three be included in StaticResponses.Finish?
+                    StaticHttpRequest.resolve
+                        (config.action (urlToRoute config currentUrl))
+                        contentJson
+                        |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
+
+                sharedDataResult : Result BuildError sharedData
+                sharedDataResult =
+                    StaticHttpRequest.resolve
+                        config.sharedData
+                        contentJson
+                        |> Result.mapError (StaticHttpRequest.toBuildError currentUrl.path)
+
+                globalHeadTags : DataSource (List Head.Tag)
+                globalHeadTags =
+                    (config.globalHeadTags |> Maybe.withDefault (\_ -> DataSource.succeed [])) HtmlPrinter.htmlToString
+
+                siteDataResult : Result BuildError (List Head.Tag)
+                siteDataResult =
+                    StaticHttpRequest.resolve
+                        globalHeadTags
+                        model.allRawResponses
+                        |> Result.mapError (StaticHttpRequest.toBuildError "Site.elm")
+            in
+            case Result.map3 (\a b c -> ( a, b, c )) pageFoundResult renderedResult siteDataResult of
+                Ok ( maybeNotFoundReason, renderedOrApiResponse, siteData ) ->
+                    case maybeNotFoundReason of
+                        Nothing ->
+                            let
+                                byteEncodedPageData : Bytes
+                                byteEncodedPageData =
+                                    case pageDataResult of
+                                        Ok pageServerResponse ->
+                                            case pageServerResponse of
+                                                PageServerResponse.RenderPage _ pageData ->
+                                                    -- TODO want to encode both shared and page data in dev server and HTML-embedded data
+                                                    -- but not for writing out the content.dat files - would be good to optimize this redundant data out
+                                                    --if model.isDevServer then
+                                                    case isAction of
+                                                        Just actionRequestKind ->
+                                                            case actionDataResult of
+                                                                Ok (PageServerResponse.RenderPage _ actionData) ->
+                                                                    case actionRequestKind of
+                                                                        ActionResponseRequest ->
+                                                                            sharedDataResult
+                                                                                |> Result.map (\sharedData -> ResponseSketch.HotUpdate pageData sharedData (Just actionData))
+                                                                                |> Result.withDefault (ResponseSketch.RenderPage pageData (Just actionData))
+                                                                                |> config.encodeResponse
+                                                                                |> Bytes.Encode.encode
+
+                                                                        ActionOnlyRequest ->
+                                                                            ---- TODO need to encode action data when only that is requested (not ResponseSketch?)
+                                                                            actionData
+                                                                                |> config.encodeAction
+                                                                                |> Bytes.Encode.encode
+
+                                                                _ ->
+                                                                    Bytes.Encode.encode (Bytes.Encode.unsignedInt8 0)
+
+                                                        Nothing ->
+                                                            sharedDataResult
+                                                                |> Result.map (\something -> ResponseSketch.HotUpdate pageData something Nothing)
+                                                                |> Result.withDefault (ResponseSketch.RenderPage pageData Nothing)
+                                                                |> config.encodeResponse
+                                                                |> Bytes.Encode.encode
+
+                                                --else
+                                                --    pageData
+                                                --        |> ResponseSketch.RenderPage
+                                                --        |> config.encodeResponse
+                                                --        |> Bytes.Encode.encode
+                                                PageServerResponse.ServerResponse serverResponse ->
+                                                    -- TODO handle error?
+                                                    PageServerResponse.toRedirect serverResponse
+                                                        |> Maybe.map
+                                                            (\{ location } ->
+                                                                location
+                                                                    |> ResponseSketch.Redirect
+                                                                    |> config.encodeResponse
+                                                            )
+                                                        -- TODO handle other cases besides redirects?
+                                                        |> Maybe.withDefault (Bytes.Encode.unsignedInt8 0)
+                                                        |> Bytes.Encode.encode
+
+                                                PageServerResponse.ErrorPage error _ ->
+                                                    -- TODO this case should never happen
+                                                    sharedDataResult
+                                                        |> Result.map
+                                                            (\sharedData ->
+                                                                ResponseSketch.HotUpdate (config.errorPageToData error)
+                                                                    sharedData
+                                                                    Nothing
+                                                            )
+                                                        |> Result.map config.encodeResponse
+                                                        |> Result.map Bytes.Encode.encode
+                                                        |> Result.withDefault (Bytes.Encode.encode (Bytes.Encode.unsignedInt8 0))
 
-                    Err error ->
-                        [ error ]
-                            |> ToJsPayload.Errors
-                            |> Effect.SendSinglePage True
+                                        _ ->
+                                            -- TODO handle error?
+                                            Bytes.Encode.encode (Bytes.Encode.unsignedInt8 0)
+                            in
+                            case renderedOrApiResponse of
+                                PageServerResponse.RenderPage responseInfo rendered ->
+                                    { route = page |> Path.toRelative
+                                    , contentJson = Dict.empty
+                                    , html = rendered.view
+                                    , errors = []
+                                    , head = rendered.head ++ siteData
+                                    , title = rendered.title
+                                    , staticHttpCache = Dict.empty
+                                    , is404 = False
+                                    , statusCode = responseInfo.statusCode
+                                    , headers = responseInfo.headers
+                                    }
+                                        |> ToJsPayload.PageProgress
+                                        |> Effect.SendSinglePageNew byteEncodedPageData
+
+                                PageServerResponse.ServerResponse serverResponse ->
+                                    PageServerResponse.toRedirect serverResponse
+                                        |> Maybe.map
+                                            (\_ ->
+                                                { route = page |> Path.toRelative
+                                                , contentJson = Dict.empty
+                                                , html = "This is intentionally blank HTML"
+                                                , errors = []
+                                                , head = []
+                                                , title = "This is an intentionally blank title"
+                                                , staticHttpCache = Dict.empty
+                                                , is404 = False
+                                                , statusCode =
+                                                    case includeHtml of
+                                                        RenderRequest.OnlyJson ->
+                                                            -- if this is a redirect for a `content.dat`, we don't want to send an *actual* redirect status code because the redirect needs to be handled in Elm (not by the Browser)
+                                                            200
+
+                                                        RenderRequest.HtmlAndJson ->
+                                                            serverResponse.statusCode
+                                                , headers = serverResponse.headers
+                                                }
+                                                    |> ToJsPayload.PageProgress
+                                                    |> Effect.SendSinglePageNew byteEncodedPageData
+                                            )
+                                        |> Maybe.withDefault
+                                            ({ body = serverResponse |> PageServerResponse.toJson
+                                             , staticHttpCache = Dict.empty
+                                             , statusCode = serverResponse.statusCode
+                                             }
+                                                |> ToJsPayload.SendApiResponse
+                                                |> Effect.SendSinglePage
+                                            )
+
+                                PageServerResponse.ErrorPage error responseInfo ->
+                                    -- TODO this case should never happen
+                                    { route = page |> Path.toRelative
+                                    , contentJson = Dict.empty
+                                    , html = "UNEXPECTED!" --HtmlPrinter.htmlToString rendered.body
+                                    , errors = []
+                                    , head = [] -- rendered.head ++ siteData -- TODO this should call ErrorPage.head maybe?
+                                    , title = "UNEXPECTED CASE" --rendered.title
+                                    , staticHttpCache = Dict.empty
+                                    , is404 = False
+                                    , statusCode = config.errorStatusCode error
+                                    , headers = responseInfo.headers
+                                    }
+                                        |> ToJsPayload.PageProgress
+                                        |> Effect.SendSinglePageNew byteEncodedPageData
+
+                        Just notFoundReason ->
+                            render404Page config (Result.toMaybe sharedDataResult) model page notFoundReason
+
+                Err error ->
+                    [ error ]
+                        |> ToJsPayload.Errors
+                        |> Effect.SendSinglePage
 
 
 render404Page :
-    ProgramConfig userMsg userModel route siteData pageData sharedData
+    ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage
+    -> Maybe sharedData
     -> Model route
     -> Path
     -> NotFoundReason
     -> Effect
-render404Page config model path notFoundReason =
-    let
-        notFoundDocument : { title : String, body : Html msg }
-        notFoundDocument =
-            { path = path
-            , reason = notFoundReason
-            }
-                |> Pages.Internal.NotFoundReason.document config.pathPatterns
-    in
-    { route = Path.toAbsolute path
-    , contentJson =
-        Dict.fromList
-            [ ( "notFoundReason"
-              , Json.Encode.encode 0
-                    (Codec.encoder Pages.Internal.NotFoundReason.codec
-                        { path = path
-                        , reason = notFoundReason
-                        }
+render404Page config sharedData model path notFoundReason =
+    case ( model.isDevServer, sharedData ) of
+        ( False, Just justSharedData ) ->
+            let
+                byteEncodedPageData : Bytes
+                byteEncodedPageData =
+                    ResponseSketch.HotUpdate
+                        (config.errorPageToData config.notFoundPage)
+                        justSharedData
+                        -- TODO remove shared action data
+                        Nothing
+                        |> config.encodeResponse
+                        |> Bytes.Encode.encode
+
+                pageModel : userModel
+                pageModel =
+                    config.init
+                        Pages.Flags.PreRenderFlags
+                        justSharedData
+                        pageData
+                        Nothing
+                        Nothing
+                        |> Tuple.first
+
+                pageData : pageData
+                pageData =
+                    config.errorPageToData config.notFoundPage
+
+                pathAndRoute : { path : Path, route : route }
+                pathAndRoute =
+                    { path = path, route = config.notFoundRoute }
+
+                viewValue : { title : String, body : Html (Pages.Msg.Msg userMsg) }
+                viewValue =
+                    (config.view Dict.empty
+                        Dict.empty
+                        Nothing
+                        pathAndRoute
+                        Nothing
+                        justSharedData
+                        pageData
+                        Nothing
+                        |> .view
                     )
-              )
-            , ( "path", Path.toAbsolute path )
-            ]
-
-    -- TODO include the needed info for content.json?
-    , html = HtmlPrinter.htmlToString notFoundDocument.body
-    , errors = []
-    , head = []
-    , title = notFoundDocument.title
-    , staticHttpCache = model.allRawResponses |> Dict.Extra.filterMap (\_ v -> v)
-    , is404 = True
-    }
-        |> ToJsPayload.PageProgress
-        |> Effect.SendSinglePage True
+                        pageModel
+            in
+            { route = Path.toAbsolute path
+            , contentJson = Dict.empty
+            , html = viewValue.body |> HtmlPrinter.htmlToString
+            , errors = []
+            , head = config.view Dict.empty Dict.empty Nothing pathAndRoute Nothing justSharedData pageData Nothing |> .head
+            , title = viewValue.title
+            , staticHttpCache = Dict.empty
+            , is404 = True
+            , statusCode = 404
+            , headers = []
+            }
+                |> ToJsPayload.PageProgress
+                |> Effect.SendSinglePageNew byteEncodedPageData
+
+        _ ->
+            let
+                byteEncodedPageData : Bytes
+                byteEncodedPageData =
+                    ResponseSketch.NotFound { reason = notFoundReason, path = path }
+                        |> config.encodeResponse
+                        |> Bytes.Encode.encode
+
+                notFoundDocument : { title : String, body : Html msg }
+                notFoundDocument =
+                    { path = path
+                    , reason = notFoundReason
+                    }
+                        |> NotFoundReason.document config.pathPatterns
+            in
+            { route = Path.toAbsolute path
+            , contentJson = Dict.empty
+            , html = HtmlPrinter.htmlToString notFoundDocument.body
+            , errors = []
+            , head = []
+            , title = notFoundDocument.title
+            , staticHttpCache = Dict.empty
+
+            -- TODO can I handle caching from the JS-side only?
+            --model.allRawResponses |> Dict.Extra.filterMap (\_ v -> v)
+            , is404 = True
+            , statusCode = 404
+            , headers = []
+            }
+                |> ToJsPayload.PageProgress
+                |> Effect.SendSinglePageNew byteEncodedPageData
+
+
+urlToRoute : ProgramConfig userMsg userModel route pageData actionData sharedData effect mappedMsg errorPage -> Url -> route
+urlToRoute config url =
+    if url.path |> String.startsWith "/____elm-pages-internal____" then
+        config.notFoundRoute
+
+    else
+        config.urlToRoute url