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

package/src/BackendTask/File.elm

@@ -51,7 +51,7 @@ plain old JSON in Elm.
 import BackendTask exposing (BackendTask)
 import BackendTask.Http
 import BackendTask.Internal.Request
-import Exception exposing (Exception)
+import FatalError exposing (FatalError)
 import Json.Decode as Decode exposing (Decoder)
 import TerminalText
 
@@ -141,7 +141,15 @@ It's common to parse the body with a markdown parser or other format.
                 )
 
 -}
-bodyWithFrontmatter : (String -> Decoder frontmatter) -> String -> BackendTask (Exception (FileReadError Decode.Error)) frontmatter
+bodyWithFrontmatter :
+    (String -> Decoder frontmatter)
+    -> String
+    ->
+        BackendTask
+            { fatal : FatalError
+            , recoverable : FileReadError Decode.Error
+            }
+            frontmatter
 bodyWithFrontmatter frontmatterDecoder filePath =
     read filePath
         (body
@@ -213,7 +221,15 @@ the [`BackendTask`](BackendTask) API along with [`BackendTask.Glob`](BackendTask
             |> BackendTask.resolve
 
 -}
-onlyFrontmatter : Decoder frontmatter -> String -> BackendTask (Exception (FileReadError Decode.Error)) frontmatter
+onlyFrontmatter :
+    Decoder frontmatter
+    -> String
+    ->
+        BackendTask
+            { fatal : FatalError
+            , recoverable : FileReadError Decode.Error
+            }
+            frontmatter
 onlyFrontmatter frontmatterDecoder filePath =
     read filePath
         (frontmatter frontmatterDecoder)
@@ -240,7 +256,14 @@ Hey there! This is my first post :)
 Then data will yield the value `"Hey there! This is my first post :)"`.
 
 -}
-bodyWithoutFrontmatter : String -> BackendTask (Exception (FileReadError decoderError)) String
+bodyWithoutFrontmatter :
+    String
+    ->
+        BackendTask
+            { fatal : FatalError
+            , recoverable : FileReadError decoderError
+            }
+            String
 bodyWithoutFrontmatter filePath =
     read filePath
         body
@@ -264,7 +287,7 @@ You could read a file called `hello.txt` in your root project directory like thi
         File.rawFile "hello.txt"
 
 -}
-rawFile : String -> BackendTask (Exception (FileReadError decoderError)) String
+rawFile : String -> BackendTask { fatal : FatalError, recoverable : FileReadError decoderError } String
 rawFile filePath =
     read filePath (Decode.field "rawFile" Decode.string)
 
@@ -286,7 +309,15 @@ The Decode will strip off any unused JSON data.
             "elm.json"
 
 -}
-jsonFile : Decoder a -> String -> BackendTask (Exception (FileReadError Decode.Error)) a
+jsonFile :
+    Decoder a
+    -> String
+    ->
+        BackendTask
+            { fatal : FatalError
+            , recoverable : FileReadError Decode.Error
+            }
+            a
 jsonFile jsonFileDecoder filePath =
     rawFile filePath
         |> BackendTask.andThen
@@ -295,13 +326,14 @@ jsonFile jsonFileDecoder filePath =
                     |> Decode.decodeString jsonFileDecoder
                     |> Result.mapError
                         (\jsonDecodeError ->
-                            Exception.Exception (DecodingError jsonDecodeError)
+                            FatalError.recoverable
                                 { title = "JSON Decoding Error"
                                 , body =
                                     [ TerminalText.text (Decode.errorToString jsonDecodeError)
                                     ]
                                         |> TerminalText.toString
                                 }
+                                (DecodingError jsonDecodeError)
                         )
                     |> BackendTask.fromResult
             )
@@ -314,7 +346,7 @@ body =
     Decode.field "withoutFrontmatter" Decode.string
 
 
-read : String -> Decoder a -> BackendTask (Exception (FileReadError error)) a
+read : String -> Decoder a -> BackendTask { fatal : FatalError, recoverable : FileReadError error } a
 read filePath decoder =
     BackendTask.Internal.Request.request
         { name = "read-file"
@@ -330,10 +362,16 @@ read filePath decoder =
         |> BackendTask.andThen BackendTask.fromResult
 
 
-errorDecoder : String -> Decoder (Exception (FileReadError decoding))
+errorDecoder :
+    String
+    ->
+        Decoder
+            { fatal : FatalError.FatalError
+            , recoverable : FileReadError decoding
+            }
 errorDecoder filePath =
     Decode.succeed
-        (Exception.Exception FileDoesntExist
+        (FatalError.recoverable
             { title = "File Doesn't Exist"
             , body =
                 [ TerminalText.text "Couldn't find file at path `"
@@ -342,4 +380,5 @@ errorDecoder filePath =
                 ]
                     |> TerminalText.toString
             }
+            FileDoesntExist
         )

package/src/BackendTask/Glob.elm

@@ -229,7 +229,7 @@ import BackendTask exposing (BackendTask)
 import BackendTask.Http
 import BackendTask.Internal.Glob exposing (Glob(..))
 import BackendTask.Internal.Request
-import Exception exposing (Exception, Throwable)
+import FatalError exposing (FatalError, Recoverable)
 import Json.Decode as Decode
 import Json.Encode as Encode
 import List.Extra
@@ -1054,7 +1054,7 @@ so it's ideal to make this kind of assertion rather than having fallback behavio
 issues (like if we had instead ignored the case where there are two or more matching blog post files).
 
 -}
-expectUniqueMatch : Glob a -> BackendTask (Exception String) a
+expectUniqueMatch : Glob a -> BackendTask (Recoverable String) a
 expectUniqueMatch glob =
     glob
         |> toBackendTask
@@ -1066,14 +1066,14 @@ expectUniqueMatch glob =
 
                     [] ->
                         BackendTask.fail <|
-                            Exception.fromStringWithValue
-                                ("No files matched the pattern: " ++ toPatternString glob)
+                            FatalError.recoverable
+                                { title = "Non-Unique Glob", body = "No files matched the pattern: " ++ toPatternString glob }
                                 ("No files matched the pattern: " ++ toPatternString glob)
 
                     _ ->
                         BackendTask.fail <|
-                            Exception.fromStringWithValue
-                                "More than one file matched."
+                            FatalError.recoverable
+                                { title = "Non-Unique Glob", body = "Expected a unique match, but more than one file matched." }
                                 "More than one file matched."
             )
 

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/Port.elm

@@ -14,20 +14,20 @@ A `BackendTask.Port` will call an async JavaScript function with the given name
 
 @docs get
 
-Here is the Elm code and corresponding JavaScript definition for getting an environment variable (or an `Exception BackendTask.Port.Error` if it isn't found). In this example,
-we're using `BackendTask.throw` to let the framework treat that as an unexpected exception, but we could also handle the possible failures of the `Exception` (see [`Exception`](Exception)).
+Here is the Elm code and corresponding JavaScript definition for getting an environment variable (or an `FatalError BackendTask.Port.Error` if it isn't found). In this example,
+we're using `BackendTask.allowFatal` to let the framework treat that as an unexpected exception, but we could also handle the possible failures of the `FatalError` (see [`FatalError`](FatalError)).
 
     import BackendTask exposing (BackendTask)
     import BackendTask.Port
     import Json.Encode
     import OptimizedDecoder as Decode
 
-    data : BackendTask Throwable String
+    data : BackendTask FatalError String
     data =
         BackendTask.Port.get "environmentVariable"
             (Json.Encode.string "EDITOR")
             Decode.string
-            |> BackendTask.throw
+            |> BackendTask.allowFatal
 
     -- will resolve to "VIM" if you run `EDITOR=vim elm-pages dev`
 
@@ -78,14 +78,18 @@ to handle possible errors, but you can throw a JSON value and handle it in Elm i
 import BackendTask
 import BackendTask.Http
 import BackendTask.Internal.Request
-import Exception exposing (Exception)
+import FatalError exposing (FatalError, Recoverable)
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
 import TerminalText
 
 
 {-| -}
-get : String -> Encode.Value -> Decoder b -> BackendTask.BackendTask (Exception Error) b
+get :
+    String
+    -> Encode.Value
+    -> Decoder b
+    -> BackendTask.BackendTask { fatal : FatalError, recoverable : Error } b
 get portName input decoder =
     BackendTask.Internal.Request.request
         { name = "port"
@@ -101,7 +105,7 @@ get portName input decoder =
                     |> Decode.andThen
                         (\errorKind ->
                             if errorKind == "PortNotDefined" then
-                                Exception.Exception (PortNotDefined { name = portName })
+                                FatalError.recoverable
                                     { title = "Port Error"
                                     , body =
                                         [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I expected to find a port named `"
@@ -110,6 +114,7 @@ get portName input decoder =
                                         ]
                                             |> TerminalText.toString
                                     }
+                                    (PortNotDefined { name = portName })
                                     |> Decode.succeed
 
                             else if errorKind == "ExportIsNotFunction" then
@@ -118,7 +123,7 @@ get portName input decoder =
                                     |> Decode.map (Maybe.withDefault "")
                                     |> Decode.map
                                         (\incorrectPortType ->
-                                            Exception.Exception ExportIsNotFunction
+                                            FatalError.recoverable
                                                 { title = "Port Error"
                                                 , body =
                                                     [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I found an export called `"
@@ -128,16 +133,18 @@ get portName input decoder =
                                                     ]
                                                         |> TerminalText.toString
                                                 }
+                                                ExportIsNotFunction
                                         )
 
                             else if errorKind == "MissingPortsFile" then
-                                Exception.Exception MissingPortsFile
+                                FatalError.recoverable
                                     { title = "Port Error"
                                     , body =
                                         [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I couldn't find your port-data-source file. Be sure to create a 'port-data-source.ts' or 'port-data-source.js' file."
                                         ]
                                             |> TerminalText.toString
                                     }
+                                    MissingPortsFile
                                     |> Decode.succeed
 
                             else if errorKind == "ErrorInPortsFile" then
@@ -146,8 +153,7 @@ get portName input decoder =
                                     |> Decode.map (Maybe.withDefault "")
                                     |> Decode.map
                                         (\errorMessage ->
-                                            Exception.Exception
-                                                ErrorInPortsFile
+                                            FatalError.recoverable
                                                 { title = "Port Error"
                                                 , body =
                                                     [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I couldn't import the port definitions file, because of this exception:\n\n"
@@ -156,6 +162,7 @@ get portName input decoder =
                                                     ]
                                                         |> TerminalText.toString
                                                 }
+                                                ErrorInPortsFile
                                         )
 
                             else if errorKind == "PortCallException" then
@@ -164,8 +171,7 @@ get portName input decoder =
                                     |> Decode.map (Maybe.withDefault Encode.null)
                                     |> Decode.map
                                         (\portCallError ->
-                                            Exception.Exception
-                                                (PortCallException portCallError)
+                                            FatalError.recoverable
                                                 { title = "Port Error"
                                                 , body =
                                                     [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I was able to import the port definitions file, but when running it I encountered this exception:\n\n"
@@ -174,10 +180,11 @@ get portName input decoder =
                                                     ]
                                                         |> TerminalText.toString
                                                 }
+                                                (PortCallException portCallError)
                                         )
 
                             else
-                                Exception.Exception ErrorInPortsFile
+                                FatalError.recoverable
                                     { title = "Port Error"
                                     , body =
                                         [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I expected to find a port named `"
@@ -186,6 +193,7 @@ get portName input decoder =
                                         ]
                                             |> TerminalText.toString
                                     }
+                                    ErrorInPortsFile
                                     |> Decode.succeed
                         )
                     |> Decode.map Err

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
@@ -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 }