elm-pages 3.0.0-beta.15 → 3.0.0-beta.17

package/src/BackendTask/Http.elm

@@ -104,7 +104,7 @@ import Base64
 import Bytes exposing (Bytes)
 import Bytes.Decode
 import Dict exposing (Dict)
-import Exception exposing (Exception)
+import FatalError exposing (FatalError, Recoverable)
 import Json.Decode
 import Json.Encode as Encode
 import Pages.Internal.StaticHttpBody as Body
@@ -157,10 +157,10 @@ type alias Body =
 
     import BackendTask
     import BackendTask.Http
-    import Exception exposing (Exception)
+    import FatalError exposing (FatalError)
     import Json.Decode as Decode exposing (Decoder)
 
-    getRequest : BackendTask (Exception Error) Int
+    getRequest : BackendTask (FatalError Error) Int
     getRequest =
         BackendTask.Http.getJson
             "https://api.github.com/repos/dillonkearns/elm-pages"
@@ -170,7 +170,7 @@ type alias Body =
 getJson :
     String
     -> Json.Decode.Decoder a
-    -> BackendTask (Exception Error) a
+    -> BackendTask (Recoverable Error) a
 getJson url decoder =
     getWithOptions
         { url = url
@@ -189,9 +189,9 @@ use the more flexible `getWithOptions`.
 
     import BackendTask
     import BackendTask.Http
-    import Exception exposing (Exception)
+    import FatalError exposing (FatalError)
 
-    getRequest : BackendTask (Exception Error) String
+    getRequest : BackendTask (FatalError Error) String
     getRequest =
         BackendTask.Http.get
             "https://api.github.com/repos/dillonkearns/elm-pages"
@@ -201,7 +201,7 @@ use the more flexible `getWithOptions`.
 get :
     String
     -> Expect a
-    -> BackendTask (Exception Error) a
+    -> BackendTask { fatal : FatalError, recoverable : Error } a
 get url expect =
     getWithOptions
         { url = url
@@ -231,7 +231,7 @@ getWithOptions :
     , timeoutInMs : Maybe Int
     , cachePath : Maybe String
     }
-    -> BackendTask (Exception Error) a
+    -> BackendTask (Recoverable Error) a
 getWithOptions request__ =
     let
         request_ : HashRequest.Request
@@ -258,7 +258,7 @@ post :
     String
     -> Body
     -> Expect a
-    -> BackendTask (Exception Error) a
+    -> BackendTask (Recoverable Error) a
 post url body expect =
     request
         { url = url
@@ -397,7 +397,7 @@ request :
     , timeoutInMs : Maybe Int
     }
     -> Expect a
-    -> BackendTask (Exception Error) a
+    -> BackendTask (Recoverable Error) a
 request request__ expect =
     let
         request_ : HashRequest.Request
@@ -475,7 +475,7 @@ with this as a low-level detail, or you can use functions like [BackendTask.Http
 requestRaw :
     HashRequest.Request
     -> Expect a
-    -> BackendTask (Exception Error) a
+    -> BackendTask (Recoverable Error) a
 requestRaw request__ expect =
     let
         request_ : HashRequest.Request
@@ -573,7 +573,7 @@ requestRaw request__ expect =
                 |> BackendTask.fromResult
                 |> BackendTask.mapError
                     (\error ->
-                        Exception.Exception error (errorToString error)
+                        FatalError.recoverable (errorToString error) error
                     )
         )
 

package/src/BackendTask.elm

@@ -5,7 +5,7 @@ module BackendTask exposing
     , andThen, resolve, combine
     , andMap
     , map2, map3, map4, map5, map6, map7, map8, map9
-    , catch, throw, mapError, onError, toResult
+    , allowFatal, mapError, onError, toResult
     )
 
 {-| In an `elm-pages` app, each Route Module can define a value `data` which is a `BackendTask` that will be resolved **before** `init` is called. That means it is also available
@@ -16,7 +16,7 @@ A `BackendTask` lets you pull in data from:
   - Local files ([`BackendTask.File`](BackendTask-File))
   - HTTP requests ([`BackendTask.Http`](BackendTask-Http))
   - Globs, i.e. listing out local files based on a pattern like `content/*.txt` ([`BackendTask.Glob`](BackendTask-Glob))
-  - Ports, i.e. getting JSON data from running custom NodeJS, similar to a port in a vanilla Elm app except run at build-time in NodeJS, rather than at run-time in the browser ([`BackendTask.Port`](BackendTask-Port))
+  - Ports, i.e. getting JSON data from running custom NodeJS, similar to a port in a vanilla Elm app except run at build-time in NodeJS, rather than at run-time in the browser ([`BackendTask.Custom`](BackendTask-Custom))
   - Hardcoded data (`BackendTask.succeed "Hello!"`)
   - Or any combination of the above, using `BackendTask.map2`, `BackendTask.andThen`, or other combining/continuing helpers from this module
 
@@ -80,13 +80,13 @@ Any place in your `elm-pages` app where the framework lets you pass in a value o
 @docs map2, map3, map4, map5, map6, map7, map8, map9
 
 
-## Exception Handling
+## FatalError Handling
 
-@docs catch, throw, mapError, onError, toResult
+@docs allowFatal, mapError, onError, toResult
 
 -}
 
-import Exception exposing (Exception(..), Throwable)
+import FatalError exposing (FatalError)
 import Json.Encode
 import Pages.StaticHttpRequest exposing (RawRequest(..))
 
@@ -524,28 +524,14 @@ map9 combineFn request1 request2 request3 request4 request5 request6 request7 re
 
 
 {-| -}
-catch : BackendTask (Exception error) value -> BackendTask error value
-catch ds =
-    ds
-        |> onError
-            (\exception ->
-                case exception of
-                    Exception error _ ->
-                        fail error
-            )
-
-
-{-| -}
-throw : BackendTask (Exception error) data -> BackendTask Throwable data
-throw backendTask =
-    backendTask
-        |> onError (Exception.throw >> fail)
+allowFatal : BackendTask { error | fatal : FatalError } data -> BackendTask FatalError data
+allowFatal backendTask =
+    mapError .fatal backendTask
 
 
 {-| -}
-toResult : BackendTask (Exception error) data -> BackendTask noError (Result error data)
+toResult : BackendTask error data -> BackendTask noError (Result error data)
 toResult backendTask =
     backendTask
-        |> catch
         |> andThen (Ok >> succeed)
         |> onError (Err >> succeed)

package/src/{Exception.elm → FatalError.elm}

@@ -1,13 +1,16 @@
-module Exception exposing (Throwable, Exception(..), fromString, fromStringWithValue, throw, unwrap)
+module FatalError exposing
+    ( FatalError, fromString, recoverable
+    , Recoverable
+    )
 
 {-| The Elm language doesn't have the concept of exceptions or special control flow for errors. It just has
 Custom Types, and by convention types like `Result` and the `Err` variant are used to represent possible failure states
 and combine together different error states.
 
 `elm-pages` doesn't change that, Elm still doesn't have special exception control flow at the language level. It does have
-a type, which is just a regular old Elm type, called `Exception`. Why? Because this plain old Elm type does have one
+a type, which is just a regular old Elm type, called `FatalError`. Why? Because this plain old Elm type does have one
 special characteristic - the `elm-pages` framework knows how to turn it into an error message. This becomes interesting
-because an `elm-pages` app has several places that accept a value of type `BackendTask Exception.Throwable value`.
+because an `elm-pages` app has several places that accept a value of type `BackendTask FatalError.FatalError value`.
 This design lets the `elm-pages` framework do some of the work for you.
 
 For example, if you wanted to handle possible errors to present them to the user
@@ -15,34 +18,34 @@ For example, if you wanted to handle possible errors to present them to the user
     type alias Data =
         String
 
-    data : RouteParams -> BackendTask Throwable Data
+    data : RouteParams -> BackendTask FatalError Data
     data routeParams =
         BackendTask.Http.getJson "https://api.github.com/repos/dillonkearns/elm-pages"
             (Decode.field "description" Decode.string)
             |> BackendTask.onError
                 (\error ->
-                    case Exception.unwrap error of
+                    case FatalError.unwrap error of
                         BackendTask.Http.BadStatus metadata string ->
                             if metadata.statusCode == 401 || metadata.statusCode == 403 || metadata.statusCode == 404 then
                                 BackendTask.succeed "Either this repo doesn't exist or you don't have access to it."
 
                             else
                                 -- we're only handling these expected error cases. In the case of an HTTP timeout,
-                                -- we'll let the error propagate as a Throwable
-                                BackendTask.fail error |> BackendTask.throw
+                                -- we'll let the error propagate as a FatalError
+                                BackendTask.fail error |> BackendTask.allowFatal
 
                         _ ->
-                            BackendTask.fail error |> BackendTask.throw
+                            BackendTask.fail error |> BackendTask.allowFatal
                 )
 
 This can be a lot of work for all possible errors, though. If you don't expect this kind of error (it's an _exceptional_ case),
 you can let the framework handle it if the error ever does unexpectedly occur.
 
-    data : RouteParams -> BackendTask Throwable Data
+    data : RouteParams -> BackendTask FatalError Data
     data routeParams =
         BackendTask.Http.getJson "https://api.github.com/repos/dillonkearns/elm-pages"
             (Decode.field "description" Decode.string)
-            |> BackendTask.throw
+            |> BackendTask.allowFatal
 
 This is especially useful for pages generated at build-time (`RouteBuilder.preRender`) where you want the build
 to fail if anything unexpected happens. With pre-rendered routes, you know that these error cases won't
@@ -54,42 +57,45 @@ issue.
 In the case of server-rendered Routes (`RouteBuilder.serverRender`), `elm-pages` will show your 500 error page
 when these errors occur.
 
-@docs Throwable, Exception, fromString, fromStringWithValue, throw, unwrap
+@docs FatalError, fromString, recoverable
 
--}
+@docs Recoverable
 
+-}
 
-{-| -}
-type alias Throwable =
-    Exception ()
+import Pages.Internal.FatalError
 
 
 {-| -}
-type Exception error
-    = Exception error { title : String, body : String }
+type alias Recoverable error =
+    { fatal : FatalError
+    , recoverable : error
+    }
 
 
 {-| -}
-fromString : String -> Exception ()
-fromString string =
-    fromStringWithValue string ()
+type alias FatalError =
+    Pages.Internal.FatalError.FatalError
 
 
 {-| -}
-fromStringWithValue : String -> value -> Exception value
-fromStringWithValue string value =
-    Exception value { title = "Custom Error", body = string }
+build : { title : String, body : String } -> FatalError
+build info =
+    Pages.Internal.FatalError.FatalError info
 
 
 {-| -}
-throw : Exception error -> Exception ()
-throw exception =
-    case exception of
-        Exception _ string ->
-            Exception () string
+fromString : String -> FatalError
+fromString string =
+    build
+        { title = "Custom Error"
+        , body = string
+        }
 
 
 {-| -}
-unwrap : Exception error -> error
-unwrap (Exception error _) =
-    error
+recoverable : { title : String, body : String } -> value -> Recoverable value
+recoverable info value =
+    { fatal = build info
+    , recoverable = value
+    }

package/src/Form.elm

@@ -269,7 +269,7 @@ Totally customizable. Uses [`Form.FieldView`](Form-FieldView) to render all of t
 
 import BackendTask exposing (BackendTask)
 import Dict exposing (Dict)
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import Form.Field as Field exposing (Field(..))
 import Form.FieldStatus as FieldStatus exposing (FieldStatus)
 import Form.FieldView
@@ -682,7 +682,7 @@ toServerForm :
     ->
         Form
             error
-            { combine : Validation.Validation error (BackendTask Throwable (Validation.Validation error combined kind constraints)) kind constraints
+            { combine : Validation.Validation error (BackendTask FatalError (Validation.Validation error combined kind constraints)) kind constraints
             , view : viewFn
             }
             data
@@ -695,7 +695,7 @@ toServerForm (Form a b c) =
                 { result : Dict String (List error)
                 , isMatchCandidate : Bool
                 , combineAndView :
-                    { combine : Validation.Validation error (BackendTask Throwable (Validation.Validation error combined kind constraints)) kind constraints
+                    { combine : Validation.Validation error (BackendTask FatalError (Validation.Validation error combined kind constraints)) kind constraints
                     , view : viewFn
                     }
                 }

package/src/Internal/ApiRoute.elm

@@ -9,7 +9,7 @@ module Internal.ApiRoute exposing
     )
 
 import BackendTask exposing (BackendTask)
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import Head
 import Json.Decode
 import Pattern exposing (Pattern)
@@ -46,12 +46,12 @@ tryMatchDone path (ApiRoute handler) =
 type ApiRoute response
     = ApiRoute
         { regex : Regex
-        , matchesToResponse : Json.Decode.Value -> String -> BackendTask Throwable (Maybe response)
-        , buildTimeRoutes : BackendTask Throwable (List String)
-        , handleRoute : String -> BackendTask Throwable Bool
+        , matchesToResponse : Json.Decode.Value -> String -> BackendTask FatalError (Maybe response)
+        , buildTimeRoutes : BackendTask FatalError (List String)
+        , handleRoute : String -> BackendTask FatalError Bool
         , pattern : Pattern
         , kind : String
-        , globalHeadTags : Maybe (BackendTask Throwable (List Head.Tag))
+        , globalHeadTags : Maybe (BackendTask FatalError (List Head.Tag))
         }
 
 

package/src/Pages/Generate.elm

@@ -1409,6 +1409,6 @@ throwableTask : Elm.Annotation.Annotation -> Elm.Annotation.Annotation
 throwableTask dataType =
     Elm.Annotation.namedWith [ "BackendTask" ]
         "BackendTask"
-        [ Elm.Annotation.named [ "Exception" ] "Throwable"
+        [ Elm.Annotation.named [ "FatalError" ] "FatalError"
         , dataType
         ]

package/src/Pages/Internal/FatalError.elm

@@ -0,0 +1,5 @@
+module Pages.Internal.FatalError exposing (FatalError(..))
+
+
+type FatalError
+    = FatalError { title : String, body : String }

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

@@ -12,7 +12,7 @@ import Bytes exposing (Bytes)
 import Bytes.Encode
 import Codec
 import Dict
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import Head exposing (Tag)
 import Html exposing (Html)
 import HtmlPrinter
@@ -51,7 +51,7 @@ currentCompatibilityKey =
 
 {-| -}
 type alias Model route =
-    { staticResponses : BackendTask Throwable Effect
+    { staticResponses : BackendTask FatalError Effect
     , errors : List BuildError
     , maybeRequestJson : RenderRequest route
     , isDevServer : Bool
@@ -376,11 +376,11 @@ initLegacy :
     -> ( Model route, Effect )
 initLegacy site ((RenderRequest.SinglePage includeHtml singleRequest _) as renderRequest) { isDevServer } config =
     let
-        globalHeadTags : BackendTask Throwable (List Tag)
+        globalHeadTags : BackendTask FatalError (List Tag)
         globalHeadTags =
             (config.globalHeadTags |> Maybe.withDefault (\_ -> BackendTask.succeed [])) HtmlPrinter.htmlToString
 
-        staticResponsesNew : BackendTask Throwable Effect
+        staticResponsesNew : BackendTask FatalError Effect
         staticResponsesNew =
             StaticResponses.renderApiRequest
                 (case singleRequest of

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

@@ -3,4 +3,4 @@ module Pages.Internal.Platform.CompatibilityKey exposing (currentCompatibilityKe
 
 currentCompatibilityKey : Int
 currentCompatibilityKey =
-    5
+    6

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

@@ -11,7 +11,7 @@ import BuildError exposing (BuildError)
 import Cli.Program as Program exposing (FlagsIncludingArgv)
 import Codec
 import Dict
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import HtmlPrinter
 import Json.Decode as Decode
 import Json.Encode as Encode
@@ -33,7 +33,7 @@ type alias Flags =
 
 {-| -}
 type alias Model =
-    { staticResponses : BackendTask Throwable ()
+    { staticResponses : BackendTask FatalError ()
     , errors : List BuildError
     }
 
@@ -47,10 +47,10 @@ type Msg
 {-| -}
 app :
     GeneratorProgramConfig
-    -> Program.StatefulProgram Model Msg (BackendTask Throwable ()) Flags
+    -> Program.StatefulProgram Model Msg (BackendTask FatalError ()) Flags
 app config =
     let
-        cliConfig : Program.Config (BackendTask Throwable ())
+        cliConfig : Program.Config (BackendTask FatalError ())
         cliConfig =
             case config.data of
                 Pages.Internal.Script.Script theCliConfig ->
@@ -246,7 +246,7 @@ perform config effect =
 
 {-| -}
 init :
-    BackendTask Throwable ()
+    BackendTask FatalError ()
     -> FlagsIncludingArgv Flags
     -> ( Model, Effect )
 init execute flags =
@@ -282,11 +282,11 @@ init execute flags =
 
 
 initLegacy :
-    BackendTask Throwable ()
+    BackendTask FatalError ()
     -> ( Model, Effect )
 initLegacy execute =
     let
-        staticResponses : BackendTask Throwable ()
+        staticResponses : BackendTask FatalError ()
         staticResponses =
             StaticResponses.renderApiRequest execute
 

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

@@ -2,35 +2,36 @@ module Pages.Internal.Platform.StaticResponses exposing (NextStep(..), empty, ne
 
 import BackendTask exposing (BackendTask)
 import BuildError exposing (BuildError)
-import Exception exposing (Exception(..), Throwable)
+import FatalError exposing (FatalError)
 import List.Extra
+import Pages.Internal.FatalError
 import Pages.StaticHttp.Request as HashRequest
 import Pages.StaticHttpRequest as StaticHttpRequest
 import RequestsAndPending exposing (RequestsAndPending)
 import TerminalText
 
 
-empty : a -> BackendTask Throwable a
+empty : a -> BackendTask FatalError a
 empty a =
     BackendTask.succeed a
 
 
 renderApiRequest :
-    BackendTask Throwable response
-    -> BackendTask Throwable response
+    BackendTask FatalError response
+    -> BackendTask FatalError response
 renderApiRequest request =
     request
 
 
 type NextStep route value
-    = Continue (List HashRequest.Request) (StaticHttpRequest.RawRequest Throwable value)
+    = Continue (List HashRequest.Request) (StaticHttpRequest.RawRequest FatalError value)
     | Finish value
     | FinishedWithErrors (List BuildError)
 
 
 nextStep :
     RequestsAndPending
-    -> BackendTask Throwable a
+    -> BackendTask FatalError a
     ->
         { model
             | errors : List BuildError
@@ -38,7 +39,7 @@ nextStep :
     -> NextStep route a
 nextStep allRawResponses staticResponses { errors } =
     let
-        staticRequestsStatus : StaticHttpRequest.Status Throwable a
+        staticRequestsStatus : StaticHttpRequest.Status FatalError a
         staticRequestsStatus =
             allRawResponses
                 |> StaticHttpRequest.cacheRequestResolution staticResponses
@@ -63,7 +64,7 @@ nextStep allRawResponses staticResponses { errors } =
                 StaticHttpRequest.HasPermanentError _ ->
                     ( ( False, Nothing )
                     , []
-                    , BackendTask.fail (Exception.fromString "TODO this shouldn't happen")
+                    , BackendTask.fail (FatalError.fromString "TODO this shouldn't happen")
                     )
     in
     if pendingRequests then
@@ -111,7 +112,7 @@ nextStep allRawResponses staticResponses { errors } =
                 Just (Ok completed) ->
                     Finish completed
 
-                Just (Err (Exception () buildError)) ->
+                Just (Err (Pages.Internal.FatalError.FatalError buildError)) ->
                     FinishedWithErrors
                         [ { title = buildError.title |> String.toUpper
                           , path = "" -- TODO include path here

package/src/Pages/Internal/Script.elm

@@ -2,7 +2,7 @@ module Pages.Internal.Script exposing (Script(..))
 
 import BackendTask exposing (BackendTask)
 import Cli.Program as Program
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import Html exposing (Html)
 
 
@@ -13,5 +13,5 @@ type Script
           -> Html Never
           -> String
          )
-         -> Program.Config (BackendTask Throwable ())
+         -> Program.Config (BackendTask FatalError ())
         )

package/src/Pages/Manifest.elm

@@ -68,7 +68,7 @@ import BackendTask exposing (BackendTask)
 import Color exposing (Color)
 import Color.Convert
 import Dict exposing (Dict)
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import Head
 import Json.Encode as Encode
 import LanguageTag exposing (LanguageTag, emptySubtags)
@@ -345,7 +345,7 @@ nonEmptyList list =
 
 {-| A generator for Api.elm to include a manifest.json.
 -}
-generator : String -> BackendTask Throwable Config -> ApiRoute.ApiRoute ApiRoute.Response
+generator : String -> BackendTask FatalError Config -> ApiRoute.ApiRoute ApiRoute.Response
 generator canonicalSiteUrl config =
     ApiRoute.succeed
         (config

package/src/Pages/ProgramConfig.elm

@@ -7,7 +7,7 @@ import Bytes exposing (Bytes)
 import Bytes.Decode
 import Bytes.Encode
 import Dict exposing (Dict)
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import Form.FormData exposing (FormData)
 import Head
 import Html exposing (Html)
@@ -49,9 +49,9 @@ type alias ProgramConfig userMsg userModel route pageData actionData sharedData
         -> ( userModel, effect )
     , update : Pages.FormState.PageFormState -> Dict String (Pages.Transition.FetcherState actionData) -> Maybe Pages.Transition.Transition -> sharedData -> pageData -> Maybe Browser.Navigation.Key -> userMsg -> userModel -> ( userModel, effect )
     , subscriptions : route -> Path -> userModel -> Sub userMsg
-    , sharedData : BackendTask Throwable sharedData
-    , data : Decode.Value -> route -> BackendTask Throwable (PageServerResponse pageData errorPage)
-    , action : Decode.Value -> route -> BackendTask Throwable (PageServerResponse actionData errorPage)
+    , sharedData : BackendTask FatalError sharedData
+    , data : Decode.Value -> route -> BackendTask FatalError (PageServerResponse pageData errorPage)
+    , action : Decode.Value -> route -> BackendTask FatalError (PageServerResponse actionData errorPage)
     , onActionData : actionData -> Maybe userMsg
     , view :
         Pages.FormState.PageFormState
@@ -69,8 +69,8 @@ type alias ProgramConfig userMsg userModel route pageData actionData sharedData
             { view : userModel -> { title : String, body : List (Html (Pages.Msg.Msg userMsg)) }
             , head : List Head.Tag
             }
-    , handleRoute : route -> BackendTask Throwable (Maybe NotFoundReason)
-    , getStaticRoutes : BackendTask Throwable (List route)
+    , handleRoute : route -> BackendTask FatalError (Maybe NotFoundReason)
+    , getStaticRoutes : BackendTask FatalError (List route)
     , urlToRoute : Url -> route
     , routeToPath : route -> List String
     , site : Maybe SiteConfig
@@ -102,7 +102,7 @@ type alias ProgramConfig userMsg userModel route pageData actionData sharedData
     , encodeResponse : ResponseSketch pageData actionData sharedData -> Bytes.Encode.Encoder
     , encodeAction : actionData -> Bytes.Encode.Encoder
     , decodeResponse : Bytes.Decode.Decoder (ResponseSketch pageData actionData sharedData)
-    , globalHeadTags : Maybe ((Maybe { indent : Int, newLines : Bool } -> Html Never -> String) -> BackendTask Throwable (List Head.Tag))
+    , globalHeadTags : Maybe ((Maybe { indent : Int, newLines : Bool } -> Html Never -> String) -> BackendTask FatalError (List Head.Tag))
     , cmdToEffect : Cmd userMsg -> effect
     , perform :
         { fetchRouteData :

package/src/Pages/Script.elm

@@ -34,7 +34,7 @@ import BackendTask.Http
 import BackendTask.Internal.Request
 import Cli.OptionsParser as OptionsParser
 import Cli.Program as Program
-import Exception exposing (Exception, Throwable)
+import FatalError exposing (FatalError, Recoverable)
 import Json.Decode as Decode
 import Json.Encode as Encode
 import Pages.Internal.Script
@@ -52,7 +52,7 @@ type Error
 
 
 {-| -}
-writeFile : { path : String, body : String } -> BackendTask (Exception Error) ()
+writeFile : { path : String, body : String } -> BackendTask (Recoverable Error) ()
 writeFile { path, body } =
     BackendTask.Internal.Request.request
         { name = "write-file"
@@ -85,7 +85,7 @@ log message =
 
 
 {-| -}
-withoutCliOptions : BackendTask Throwable () -> Script
+withoutCliOptions : BackendTask FatalError () -> Script
 withoutCliOptions execute =
     Pages.Internal.Script.Script
         (\_ ->
@@ -100,7 +100,7 @@ withoutCliOptions execute =
 
 
 {-| -}
-withCliOptions : Program.Config cliOptions -> (cliOptions -> BackendTask Throwable ()) -> Script
+withCliOptions : Program.Config cliOptions -> (cliOptions -> BackendTask FatalError ()) -> Script
 withCliOptions config execute =
     Pages.Internal.Script.Script
         (\_ ->

package/src/Pages/SiteConfig.elm

@@ -1,11 +1,11 @@
 module Pages.SiteConfig exposing (SiteConfig)
 
 import BackendTask exposing (BackendTask)
-import Exception exposing (Throwable)
+import FatalError exposing (FatalError)
 import Head
 
 
 type alias SiteConfig =
     { canonicalUrl : String
-    , head : BackendTask Throwable (List Head.Tag)
+    , head : BackendTask FatalError (List Head.Tag)
     }