elm-pages 3.0.24 → 3.0.26

package/README.md

@@ -11,7 +11,7 @@
 
 - [elm-pages Docs Site](https://elm-pages.com/docs)
 - [elm-pages site showcase](https://elm-pages.com/showcase/)
-- [elm-pages Elm API Docs](https://package.elm-lang.org/packages/dillonkearns/elm-pages/10.2.1/)
+- [elm-pages Elm API Docs](https://package.elm-lang.org/packages/dillonkearns/elm-pages/10.2.2/)
 - [Quick start repo](https://github.com/dillonkearns/elm-pages-starter) [(live site hosted here)](https://elm-pages-starter.netlify.com)
 - [Introducing `elm-pages` blog post](https://elm-pages.com/blog/introducing-elm-pages)
 - [`examples` folder](https://github.com/dillonkearns/elm-pages/blob/master/examples/) (includes https://elm-pages.com site source) Use `git clone --recurse-submodules https://github.com/dillonkearns/elm-pages.git` so that there aren't missing files when you try to build the examples.

package/generator/src/build.js

@@ -741,7 +741,9 @@ async function runAdapter(adaptFn, processedIndexTemplate) {
  * @param {string} file
  */
 function defaultPreloadForFile(file) {
-  if (file.endsWith(".js")) {
+  if (/\/elm\.[a-f0-9]+\.js$/.test(file)) {
+    return `<link rel="preload" as="script" href="${file}">`;
+  } else if (file.endsWith(".js")) {
     return `<link rel="modulepreload" crossorigin href="${file}">`;
   } else if (file.endsWith(".css")) {
     return `<link rel="preload" href="${file}" as="style">`;

package/generator/src/cli.js

@@ -162,8 +162,7 @@ async function main() {
           moduleName
         );
       } catch (error) {
-        console.trace(error);
-        console.log(restoreColorSafe(error));
+        printCaughtError(error);
         process.exit(1);
       }
     });
@@ -283,7 +282,7 @@ await(async()=>{let{dirname:e}=await import("path"),{fileURLToPath:i}=await impo
         });
         // await runTerser(path.resolve(cwd, options.output));
       } catch (error) {
-        console.log(restoreColorSafe(error));
+        printCaughtError(error);
         process.exit(1);
       }
     });
@@ -327,6 +326,17 @@ function safeSubscribe(program, portName, subscribeFunction) {
     program.ports[portName].subscribe(subscribeFunction);
 }
 
+/**
+ * @param {Error|string|any[]} error - Thing that was thrown and caught.
+ */
+function printCaughtError(error) {
+  if (typeof error === "string" || Array.isArray(error)) {
+    console.log(restoreColorSafe(error));
+  } else {
+    console.trace(error);
+  }
+}
+
 /**
  * @param {string} rawPagePath
  */
@@ -404,7 +414,13 @@ async function compileElmForScript(elmModulePath) {
   // await codegen.generate("");
   ensureDirSync(path.join(process.cwd(), ".elm-pages", "http-response-cache"));
   if (fs.existsSync("./codegen/") && process.env.SKIP_ELM_CODEGEN !== "true") {
-    await runElmCodegenInstall();
+    const result = await runElmCodegenInstall();
+    if (!result.success) {
+      console.error(`Warning: ${result.message}. This may cause stale generated code or missing module errors.\n`);
+      if (result.error) {
+        console.error(result.error);
+      }
+    }
   }
 
   ensureDirSync(`${projectDirectory}/elm-stuff`);

package/generator/src/compatibility-key.js

@@ -1,3 +1,3 @@
 export const compatibilityKey = 22;
 
-export const packageVersion = "3.0.24";
+export const packageVersion = "3.0.26";

package/generator/src/compile-elm.js

@@ -133,6 +133,12 @@ async function compileElm(options, elmEntrypointPath, outputPath, cwd) {
 
 function spawnElmMake(options, elmEntrypointPath, outputPath, cwd) {
   return new Promise(async (resolve, reject) => {
+    try {
+      await fsPromises.unlink(outputPath);
+    } catch (e) {
+      /* File may not exist, so ignore errors */
+    }
+
     const subprocess = spawnCallback(
       `lamdera`,
       [
@@ -152,13 +158,6 @@ function spawnElmMake(options, elmEntrypointPath, outputPath, cwd) {
         cwd: cwd,
       }
     );
-    if (await fsHelpers.fileExists(outputPath)) {
-      try {
-        await fsPromises.unlink(outputPath, {
-          force: true /* ignore errors if file doesn't exist */,
-        });
-      } catch (e) {}
-    }
     let commandOutput = "";
 
     subprocess.stderr.on("data", function (data) {

package/generator/src/elm-codegen.js

@@ -1,35 +1,39 @@
 import { spawn as spawnCallback } from "cross-spawn";
+import which from "which";
 
-export function runElmCodegenInstall() {
-  return new Promise(async (resolve, reject) => {
-    const subprocess = spawnCallback(`elm-codegen`, ["install"], {
-      // ignore stdout
-      // stdio: ["inherit", "ignore", "inherit"],
-      //       cwd: cwd,
-    });
-    //     if (await fsHelpers.fileExists(outputPath)) {
-    //       await fsPromises.unlink(outputPath, {
-    //         force: true /* ignore errors if file doesn't exist */,
-    //       });
-    //     }
-    let commandOutput = "";
+/**
+ * @returns {Promise<{ success: true } | { success: false; message: string; error?: Error }>}
+ */
+export async function runElmCodegenInstall() {
+  try {
+    await which("elm-codegen");
+  } catch (error) {
+    return { success: false, message: "Unable to find elm-codegen on the PATH" };
+  }
 
+  return new Promise((resolve) => {
+    const subprocess = spawnCallback("elm-codegen", ["install"]);
+
+    let commandOutput = "";
     subprocess.stderr.on("data", function (data) {
       commandOutput += data;
     });
     subprocess.stdout.on("data", function (data) {
       commandOutput += data;
     });
-    subprocess.on("error", function () {
-      reject(commandOutput);
+    subprocess.on("error", function (error) {
+      resolve({ success: false, message: "Failed to run elm-codegen", error });
     });
 
-    subprocess.on("close", async (code) => {
-      if (code == 0) {
-        resolve();
-      } else {
-        reject(commandOutput);
+    subprocess.on("close", (code) => {
+      if (code === 0) {
+        return resolve({ success: true });
       }
+      resolve({
+        success: false,
+        message: `elm-codegen exited with code ${code}`,
+        error: commandOutput.length > 0 ? new Error(commandOutput) : undefined
+      });
     });
   });
 }

package/generator/src/error-formatter.js

@@ -107,7 +107,7 @@ export const restoreColor = (error) => {
 };
 
 /**
- * @param {string} error
+ * @param {string|RootObject[]} error
  * @returns {string}
  */
 export function restoreColorSafe(error) {

package/generator/src/render.js

@@ -65,8 +65,7 @@ export async function render(
     mode,
     path,
     request,
-    addBackendTaskWatcher,
-    hasFsAccess
+    addBackendTaskWatcher
   );
   return result;
 }
@@ -102,7 +101,6 @@ export async function runGenerator(
       scriptModuleName,
       "production",
       "",
-      true,
       versionMessage
     );
     return result;
@@ -120,7 +118,6 @@ export async function runGenerator(
  * @param {string[]} cliOptions
  * @param {any} portsFile
  * @param {typeof import("fs") | import("memfs").IFs} fs
- * @param {boolean} hasFsAccess
  * @param {string} scriptModuleName
  * @param {string} versionMessage
  */
@@ -132,7 +129,6 @@ function runGeneratorAppHelp(
   scriptModuleName,
   mode,
   pagePath,
-  hasFsAccess,
   versionMessage
 ) {
   const isDevServer = mode !== "build";
@@ -208,9 +204,7 @@ function runGeneratorAppHelp(
                   return runInternalJob(
                     requestHash,
                     app,
-                    mode,
                     requestToPerform,
-                    hasFsAccess,
                     patternsToWatch,
                     portsFile
                   );
@@ -218,10 +212,7 @@ function runGeneratorAppHelp(
                   return runHttpJob(
                     requestHash,
                     portsFile,
-                    app,
                     mode,
-                    requestToPerform,
-                    hasFsAccess,
                     requestToPerform
                   );
                 }
@@ -262,8 +253,7 @@ function runElmApp(
   mode,
   pagePath,
   request,
-  addBackendTaskWatcher,
-  hasFsAccess
+  addBackendTaskWatcher
 ) {
   const isDevServer = mode !== "build";
   let patternsToWatch = new Set();
@@ -347,9 +337,7 @@ function runElmApp(
                   return runInternalJob(
                     requestHash,
                     app,
-                    mode,
                     requestToPerform,
-                    hasFsAccess,
                     patternsToWatch,
                     portsFile
                   );
@@ -357,10 +345,7 @@ function runElmApp(
                   return runHttpJob(
                     requestHash,
                     portsFile,
-                    app,
                     mode,
-                    requestToPerform,
-                    hasFsAccess,
                     requestToPerform
                   );
                 }
@@ -427,22 +412,12 @@ async function outputString(
 
 /** @typedef { { head: any[]; errors: any[]; contentJson: any[]; html: string; route: string; title: string; } } Arg */
 
-async function runHttpJob(
-  requestHash,
-  portsFile,
-  app,
-  mode,
-  requestToPerform,
-  hasFsAccess,
-  useCache
-) {
+async function runHttpJob(requestHash, portsFile, mode, requestToPerform) {
   try {
     const lookupResponse = await lookupOrPerform(
       portsFile,
       mode,
-      requestToPerform,
-      hasFsAccess,
-      useCache
+      requestToPerform
     );
 
     if (lookupResponse.kind === "cache-response-path") {
@@ -485,29 +460,43 @@ function jsonResponse(request, json) {
     response: { bodyKind: "json", body: json },
   };
 }
+/**
+ * @param {any} request
+ * @param {WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>} buffer
+ */
+function bytesResponse(request, buffer) {
+  return {
+    request,
+    response: {
+      bodyKind: "bytes",
+      body: Buffer.from(buffer).toString("base64"),
+    },
+  };
+}
 
+/**
+ * @param {{ url: string; body: { args: any[] } }} requestToPerform
+ */
 async function runInternalJob(
   requestHash,
   app,
-  mode,
   requestToPerform,
-  hasFsAccess,
   patternsToWatch,
   portsFile
 ) {
   try {
-    const cwd = path.resolve(...requestToPerform.dir);
-    const quiet = requestToPerform.quiet;
-    const env = { ...process.env, ...requestToPerform.env };
-
-    const context = { cwd, quiet, env };
     switch (requestToPerform.url) {
       case "elm-pages-internal://log":
         return [requestHash, await runLogJob(requestToPerform)];
       case "elm-pages-internal://read-file":
         return [
           requestHash,
-          await readFileJobNew(requestToPerform, patternsToWatch, context),
+          await readFileJobNew(requestToPerform, patternsToWatch),
+        ];
+      case "elm-pages-internal://read-file-binary":
+        return [
+          requestHash,
+          await readFileBinaryJobNew(requestToPerform, patternsToWatch),
         ];
       case "elm-pages-internal://glob":
         return [
@@ -540,7 +529,7 @@ async function runInternalJob(
           await runDecryptJob(requestToPerform, patternsToWatch),
         ];
       case "elm-pages-internal://write-file":
-        return [requestHash, await runWriteFileJob(requestToPerform, context)];
+        return [requestHash, await runWriteFileJob(requestToPerform)];
       case "elm-pages-internal://sleep":
         return [requestHash, await runSleep(requestToPerform)];
       case "elm-pages-internal://which":
@@ -550,10 +539,7 @@ async function runInternalJob(
       case "elm-pages-internal://shell":
         return [requestHash, await runShell(requestToPerform)];
       case "elm-pages-internal://stream":
-        return [
-          requestHash,
-          await runStream(requestToPerform, portsFile, context),
-        ];
+        return [requestHash, await runStream(requestToPerform, portsFile)];
       case "elm-pages-internal://start-spinner":
         return [requestHash, runStartSpinner(requestToPerform)];
       case "elm-pages-internal://stop-spinner":
@@ -568,7 +554,19 @@ async function runInternalJob(
   }
 }
 
-async function readFileJobNew(req, patternsToWatch, { cwd }) {
+/**
+ * @param {{ dir: string[]; quiet: boolean; env: { [key:string]: string; }; }} requestToPerform
+ */
+function getContext(requestToPerform) {
+  const cwd = path.resolve(...requestToPerform.dir);
+  const quiet = requestToPerform.quiet;
+  const env = { ...process.env, ...requestToPerform.env };
+
+  return { cwd, quiet, env };
+}
+
+async function readFileJobNew(req, patternsToWatch) {
+  const { cwd } = getContext(req);
   // TODO use cwd
   const filePath = path.resolve(cwd, req.body.args[1]);
   try {
@@ -590,6 +588,34 @@ async function readFileJobNew(req, patternsToWatch, { cwd }) {
   }
 }
 
+/**
+ * @param {{ url: string; body: { args: any[] } }} req
+ * @param {{ add: (arg0: string) => void; }} patternsToWatch
+ */
+async function readFileBinaryJobNew(req, patternsToWatch) {
+  const filePath = req.body.args[1];
+  try {
+    patternsToWatch.add(filePath);
+
+    const fileContents = await fsPromises.readFile(filePath);
+    // It's safe to use allocUnsafe here because we're going to overwrite it immediately anyway
+    const buffer = new Uint8Array(4 + fileContents.length);
+    const view = new DataView(
+      buffer.buffer,
+      buffer.byteOffset,
+      buffer.byteLength
+    );
+    view.setInt32(0, fileContents.length);
+    fileContents.copy(buffer, 4);
+
+    return bytesResponse(req, buffer);
+  } catch (error) {
+    const buffer = new Int32Array(1);
+    buffer[0] = -1;
+    return bytesResponse(req, buffer);
+  }
+}
+
 function runSleep(req) {
   const { milliseconds } = req.body.args[0];
   return new Promise((resolve) => {
@@ -612,8 +638,9 @@ async function runQuestion(req) {
   return jsonResponse(req, await question(req.body.args[0]));
 }
 
-function runStream(req, portsFile, context) {
+function runStream(req, portsFile) {
   return new Promise(async (resolve) => {
+    const context = getContext(req);
     let metadataResponse = null;
     let lastStream = null;
     try {
@@ -1126,7 +1153,8 @@ export async function question({ prompt }) {
   });
 }
 
-async function runWriteFileJob(req, { cwd }) {
+async function runWriteFileJob(req) {
+  const { cwd } = getContext(req);
   const data = req.body.args[0];
   const filePath = path.resolve(cwd, data.path);
   try {

package/generator/src/request-cache.js

@@ -11,15 +11,12 @@ const defaultHttpCachePath = "./.elm-pages/http-cache";
  * @param {string} mode
  * @param {{url: string;headers: {[x: string]: string;};method: string;body: Body; }} rawRequest
  * @param {Record<string, unknown>} portsFile
- * @param {boolean} hasFsAccess
  * @returns {Promise<Response>}
  */
 export function lookupOrPerform(
   portsFile,
   mode,
-  rawRequest,
-  hasFsAccess,
-  useCache
+  rawRequest
 ) {
   const uniqueTimeId =
     Date.now().toString(36) + Math.random().toString(36).slice(2, 8);

package/generator/template/elm.json

@@ -14,7 +14,7 @@
             "dillonkearns/elm-bcp47-language-tag": "2.0.0",
             "dillonkearns/elm-form": "3.0.1",
             "dillonkearns/elm-markdown": "7.0.1",
-            "dillonkearns/elm-pages": "10.2.1",
+            "dillonkearns/elm-pages": "10.2.2",
             "elm/browser": "1.0.2",
             "elm/bytes": "1.0.8",
             "elm/core": "1.0.5",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elm-pages",
   "type": "module",
-  "version": "3.0.24",
+  "version": "3.0.26",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Hybrid Elm framework with full-stack and static routes.",

package/src/BackendTask/Custom.elm

@@ -126,6 +126,7 @@ import Date
 import FatalError exposing (FatalError)
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
+import Pages.StaticHttpRequest
 import TerminalText
 import Time
 
@@ -331,7 +332,6 @@ request :
     }
     -> BackendTask { fatal : FatalError, recoverable : Error } a
 request { body, expect } =
-    -- elm-review: known-unoptimized-recursion
     BackendTask.Http.request
         { url = "elm-pages-internal://port"
         , method = "GET"
@@ -343,8 +343,6 @@ request { body, expect } =
         expect
         |> BackendTask.onError
             (\error ->
-                -- TODO avoid crash here, this should be handled as an internal error
-                --request params
                 case error.recoverable of
                     BackendTask.Http.BadBody (Just jsonError) _ ->
                         { recoverable = DecodeError jsonError
@@ -353,8 +351,5 @@ request { body, expect } =
                             |> BackendTask.fail
 
                     _ ->
-                        { recoverable = Error
-                        , fatal = error.fatal
-                        }
-                            |> BackendTask.fail
+                        Pages.StaticHttpRequest.InternalError error.fatal
             )

package/src/BackendTask/File.elm

@@ -1,6 +1,6 @@
 module BackendTask.File exposing
     ( bodyWithFrontmatter, bodyWithoutFrontmatter, onlyFrontmatter
-    , jsonFile, rawFile
+    , jsonFile, rawFile, binaryFile
     , FileReadError(..)
     )
 
@@ -40,7 +40,7 @@ plain old JSON in Elm.
 
 ## Reading Files Without Frontmatter
 
-@docs jsonFile, rawFile
+@docs jsonFile, rawFile, binaryFile
 
 
 ## FatalErrors
@@ -52,6 +52,8 @@ plain old JSON in Elm.
 import BackendTask exposing (BackendTask)
 import BackendTask.Http
 import BackendTask.Internal.Request
+import Bytes exposing (Bytes)
+import Bytes.Decode
 import FatalError exposing (FatalError)
 import Json.Decode as Decode exposing (Decoder)
 import TerminalText
@@ -337,6 +339,39 @@ rawFile filePath =
     read filePath (Decode.field "rawFile" Decode.string)
 
 
+{-| Get the raw file content as `Bytes`.
+
+You could read a file called `hello.jpg` in your root project directory like this:
+
+    import BackendTask exposing (BackendTask)
+    import BackendTask.File as File
+    import Bytes exposing (Bytes)
+
+    elmBinaryFile : BackendTask Bytes
+    elmBinaryFile =
+        File.binaryFile "hello.jpg"
+
+-}
+binaryFile : String -> BackendTask { fatal : FatalError, recoverable : FileReadError decoderError } Bytes
+binaryFile filePath =
+    BackendTask.Internal.Request.request
+        { name = "read-file-binary"
+        , body = BackendTask.Http.stringBody "" filePath
+        , expect =
+            Bytes.Decode.signedInt32 Bytes.BE
+                |> Bytes.Decode.andThen
+                    (\length ->
+                        if length < 0 then
+                            Bytes.Decode.fail
+
+                        else
+                            Bytes.Decode.bytes length
+                    )
+                |> BackendTask.Http.expectBytes
+        }
+        |> BackendTask.mapError (\_ -> fileNotFound filePath)
+
+
 {-| Read a file as JSON.
 
 The Decode will strip off any unused JSON data.
@@ -410,23 +445,25 @@ read filePath decoder =
         |> BackendTask.andThen BackendTask.fromResult
 
 
-errorDecoder :
+errorDecoder : String -> Decoder { fatal : FatalError, recoverable : FileReadError decoding }
+errorDecoder filePath =
+    Decode.succeed (fileNotFound filePath)
+
+
+fileNotFound :
     String
     ->
-        Decoder
-            { fatal : FatalError
-            , recoverable : FileReadError decoding
-            }
-errorDecoder filePath =
-    Decode.succeed
-        (FatalError.recoverable
-            { title = "File Doesn't Exist"
-            , body =
-                [ TerminalText.text "Couldn't find file at path `"
-                , TerminalText.yellow filePath
-                , TerminalText.text "`"
-                ]
-                    |> TerminalText.toString
-            }
-            FileDoesntExist
-        )
+        { fatal : FatalError
+        , recoverable : FileReadError decoding
+        }
+fileNotFound filePath =
+    FatalError.recoverable
+        { title = "File Doesn't Exist"
+        , body =
+            [ TerminalText.text "Couldn't find file at path `"
+            , TerminalText.yellow filePath
+            , TerminalText.text "`"
+            ]
+                |> TerminalText.toString
+        }
+        FileDoesntExist

package/src/BackendTask/Internal/Request.elm

@@ -4,6 +4,7 @@ import BackendTask exposing (BackendTask)
 import BackendTask.Http exposing (Body, Expect)
 import Json.Decode exposing (Decoder)
 import Json.Encode as Encode
+import Pages.StaticHttpRequest
 
 
 request :
@@ -12,8 +13,7 @@ request :
     , expect : Expect a
     }
     -> BackendTask error a
-request ({ name, body, expect } as params) =
-    -- elm-review: known-unoptimized-recursion
+request { name, body, expect } =
     BackendTask.Http.request
         { url = "elm-pages-internal://" ++ name
         , method = "GET"
@@ -24,9 +24,8 @@ request ({ name, body, expect } as params) =
         }
         expect
         |> BackendTask.onError
-            (\_ ->
-                -- TODO avoid crash here, this should be handled as an internal error
-                request params
+            (\err ->
+                Pages.StaticHttpRequest.InternalError err.fatal
             )
 
 

package/src/BackendTask.elm

@@ -143,6 +143,9 @@ but mapping allows you to change the resulting values by applying functions to t
 map : (a -> b) -> BackendTask error a -> BackendTask error b
 map fn requestInfo =
     case requestInfo of
+        InternalError err ->
+            InternalError err
+
         ApiRoute value ->
             ApiRoute (Result.map fn value)
 
@@ -221,6 +224,9 @@ inDir dir backendTask =
     -- elm-review: known-unoptimized-recursion
     -- TODO try to find a way to optimize tail-call recursion here
     case backendTask of
+        InternalError _ ->
+            backendTask
+
         ApiRoute _ ->
             backendTask
 
@@ -243,6 +249,9 @@ quiet backendTask =
     -- elm-review: known-unoptimized-recursion
     -- TODO try to find a way to optimize tail-call recursion here
     case backendTask of
+        InternalError _ ->
+            backendTask
+
         ApiRoute _ ->
             backendTask
 
@@ -260,6 +269,9 @@ withEnv key value backendTask =
     -- elm-review: known-unoptimized-recursion
     -- TODO try to find a way to optimize tail-call recursion here
     case backendTask of
+        InternalError _ ->
+            backendTask
+
         ApiRoute _ ->
             backendTask
 
@@ -422,6 +434,12 @@ map2 fn request1 request2 =
     -- elm-review: known-unoptimized-recursion
     -- TODO try to find a way to optimize tail-call recursion here
     case ( request1, request2 ) of
+        ( InternalError err1, _ ) ->
+            InternalError err1
+
+        ( _, InternalError err2 ) ->
+            InternalError err2
+
         ( ApiRoute value1, ApiRoute value2 ) ->
             ApiRoute (Result.map2 fn value1 value2)
 
@@ -478,6 +496,9 @@ andThen fn requestInfo =
     -- elm-review: known-unoptimized-recursion
     -- TODO try to find a way to optimize recursion here
     case requestInfo of
+        InternalError errA ->
+            InternalError errA
+
         ApiRoute a ->
             case a of
                 Ok okA ->
@@ -503,6 +524,9 @@ onError : (error -> BackendTask mappedError value) -> BackendTask error value ->
 onError fromError backendTask =
     -- elm-review: known-unoptimized-recursion
     case backendTask of
+        InternalError err ->
+            InternalError err
+
         ApiRoute a ->
             case a of
                 Ok okA ->
@@ -569,6 +593,9 @@ fromResult result =
 mapError : (error -> errorMapped) -> BackendTask error value -> BackendTask errorMapped value
 mapError mapFn requestInfo =
     case requestInfo of
+        InternalError internal ->
+            InternalError internal
+
         ApiRoute value ->
             ApiRoute (Result.mapError mapFn value)
 

package/src/Pages/Internal/Platform.elm

@@ -84,7 +84,15 @@ mainView config model =
                         { path = ContentCache.pathForUrl urls |> UrlPath.join
                         , route = config.urlToRoute { currentUrl | path = model.currentPath }
                         }
-                        Nothing
+                        (Just
+                            { protocol = currentUrl.protocol
+                            , host = currentUrl.host
+                            , port_ = currentUrl.port_
+                            , path = ContentCache.pathForUrl urls
+                            , query = currentUrl.query |> Maybe.map QueryParams.fromString |> Maybe.withDefault Dict.empty
+                            , fragment = currentUrl.fragment
+                            }
+                        )
                         pageData.sharedData
                         pageData.pageData
                         pageData.actionData

package/src/Pages/StaticHttpRequest.elm

@@ -1,7 +1,9 @@
 module Pages.StaticHttpRequest exposing (Error(..), MockResolver, RawRequest(..), Status(..), cacheRequestResolution, mockResolve, toBuildError)
 
 import BuildError exposing (BuildError)
+import FatalError exposing (FatalError)
 import Json.Encode
+import Pages.Internal.FatalError
 import Pages.StaticHttp.Request
 import RequestsAndPending exposing (RequestsAndPending)
 import TerminalText as Terminal
@@ -15,11 +17,13 @@ type alias MockResolver =
 type RawRequest error value
     = Request (List Pages.StaticHttp.Request.Request) (Maybe MockResolver -> RequestsAndPending -> RawRequest error value)
     | ApiRoute (Result error value)
+    | InternalError FatalError
 
 
 type Error
     = DecoderError String
     | UserCalledStaticHttpFail String
+    | InternalFailure FatalError
 
 
 toBuildError : String -> Error -> BuildError
@@ -43,18 +47,36 @@ toBuildError path error =
             , fatal = True
             }
 
+        InternalFailure (Pages.Internal.FatalError.FatalError buildError) ->
+            { title = "Internal error"
+            , message =
+                [ Terminal.text <| "Please report this error!"
+                , Terminal.text ""
+                , Terminal.text ""
+                , Terminal.text buildError.body
+                ]
+            , path = path
+            , fatal = True
+            }
+
 
-mockResolve : RawRequest error value -> MockResolver -> Result error value
-mockResolve request mockResolver =
+mockResolve : (FatalError -> error) -> RawRequest error value -> MockResolver -> Result error value
+mockResolve onInternalError request mockResolver =
     case request of
         Request _ lookupFn ->
-            case lookupFn (Just mockResolver) (Json.Encode.object []) of
-                nextRequest ->
-                    mockResolve nextRequest mockResolver
+            let
+                nextRequest : RawRequest error value
+                nextRequest =
+                    lookupFn (Just mockResolver) (Json.Encode.object [])
+            in
+            mockResolve onInternalError nextRequest mockResolver
 
         ApiRoute value ->
             value
 
+        InternalError err ->
+            Err (onInternalError err)
+
 
 cacheRequestResolution :
     RawRequest error value
@@ -72,6 +94,9 @@ cacheRequestResolution request rawResponses =
         ApiRoute value ->
             Complete value
 
+        InternalError err ->
+            HasPermanentError (InternalFailure err)
+
 
 type Status error value
     = Incomplete (List Pages.StaticHttp.Request.Request) (RawRequest error value)

package/src/RequestsAndPending.elm

@@ -36,10 +36,12 @@ bodyDecoder =
                             Decode.string
                                 |> Decode.andThen
                                     (\base64String ->
-                                        base64String
-                                            |> Base64.toBytes
-                                            |> Maybe.map (BytesBody >> Decode.succeed)
-                                            |> Maybe.withDefault (Decode.fail "Couldn't parse base64 string into Bytes.")
+                                        case Base64.toBytes base64String of
+                                            Just bytes ->
+                                                Decode.succeed (BytesBody bytes)
+
+                                            Nothing ->
+                                                Decode.fail "Couldn't parse base64 string into Bytes."
                                     )
 
                         "string" ->