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

package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/node_runner.js

@@ -75,7 +75,7 @@ console.elmlog = (str) => logs.push(str + "\n");
 const { Elm } = require("./Runner.elm.js");
 
 // Start the Elm app
-const flags = { initialSeed: 2665303026, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 3582516438, fuzzRuns: 100, filter: null };
 const app = Elm.Runner.init({ flags: flags });
 
 // Record the timing at which we received the last "runTest" message

package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/node_supervisor.js

@@ -82,7 +82,7 @@ const verbosity = 0;
 // Create a long lived reporter worker
 const { Elm } = require("./Reporter.elm.js");
 const flags = {
-  initialSeed: 2665303026,
+  initialSeed: 3582516438,
   fuzzRuns: 100,
   mode: "consoleNoColor",
   verbosity: verbosity,

package/generator/review/elm-stuff/tests-0.19.1/js/node_runner.js

@@ -75,7 +75,7 @@ console.elmlog = (str) => logs.push(str + "\n");
 const { Elm } = require("./Runner.elm.js");
 
 // Start the Elm app
-const flags = { initialSeed: 4260939212, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 955237713, fuzzRuns: 100, filter: null };
 const app = Elm.Runner.init({ flags: flags });
 
 // Record the timing at which we received the last "runTest" message

package/generator/review/elm-stuff/tests-0.19.1/js/node_supervisor.js

@@ -82,7 +82,7 @@ const verbosity = 0;
 // Create a long lived reporter worker
 const { Elm } = require("./Reporter.elm.js");
 const flags = {
-  initialSeed: 4260939212,
+  initialSeed: 955237713,
   fuzzRuns: 100,
   mode: "consoleNoColor",
   verbosity: verbosity,

package/generator/src/build.js

@@ -143,9 +143,9 @@ async function run(options) {
 
     const portBackendTaskCompiled = esbuild
       .build({
-        entryPoints: ["./port-data-source"],
+        entryPoints: ["./custom-backend-task"],
         platform: "node",
-        outfile: ".elm-pages/compiled-ports/port-data-source.js",
+        outfile: ".elm-pages/compiled-ports/custom-backend-task.js",
         assetNames: "[name]-[hash]",
         chunkNames: "chunks/[name]-[hash]",
         outExtension: { ".js": ".js" },
@@ -161,11 +161,11 @@ async function run(options) {
       })
       .catch((error) => {
         const portBackendTaskFileFound =
-          globby.sync("./port-data-source.*").length > 0;
+          globby.sync("./custom-backend-task.*").length > 0;
         if (portBackendTaskFileFound) {
-          // don't present error if there are no files matching port-data-source
-          // if there are files matching port-data-source, warn the user in case something went wrong loading it
-          console.error("Failed to start port-data-source watcher", error);
+          // don't present error if there are no files matching custom-backend-task
+          // if there are files matching custom-backend-task, warn the user in case something went wrong loading it
+          console.error("Failed to start custom-backend-task watcher", error);
         }
       });
     // TODO extract common code for compiling ports file?
@@ -617,7 +617,7 @@ async function runAdapter(adaptFn, processedIndexTemplate) {
       apiRoutePatterns: JSON.parse(
         await fsPromises.readFile("./dist/api-patterns.json", "utf-8")
       ),
-      portsFilePath: "./.elm-pages/compiled-ports/port-data-source.js",
+      portsFilePath: "./.elm-pages/compiled-ports/custom-backend-task.js",
       htmlTemplate: processedIndexTemplate,
     });
     console.log("Success - Adapter script complete");

package/generator/src/cli.js

@@ -131,9 +131,9 @@ async function main() {
 
         const portBackendTaskCompiled = esbuild
           .build({
-            entryPoints: ["./port-data-source"],
+            entryPoints: ["./custom-backend-task"],
             platform: "node",
-            outfile: ".elm-pages/compiled-ports/port-data-source.js",
+            outfile: ".elm-pages/compiled-ports/custom-backend-task.js",
             assetNames: "[name]-[hash]",
             chunkNames: "chunks/[name]-[hash]",
             outExtension: { ".js": ".js" },
@@ -151,11 +151,14 @@ async function main() {
           })
           .catch((error) => {
             const portBackendTaskFileFound =
-              globby.sync("./port-data-source.*").length > 0;
+              globby.sync("./custom-backend-task.*").length > 0;
             if (portBackendTaskFileFound) {
-              // don't present error if there are no files matching port-data-source
-              // if there are files matching port-data-source, warn the user in case something went wrong loading it
-              console.error("Failed to start port-data-source watcher", error);
+              // don't present error if there are no files matching custom-backend-task
+              // if there are files matching custom-backend-task, warn the user in case something went wrong loading it
+              console.error(
+                "Failed to start custom-backend-task watcher",
+                error
+              );
             }
           });
         const portsPath = await portBackendTaskCompiled;

package/generator/src/dev-server.js

@@ -140,7 +140,7 @@ async function start(options) {
   );
   esbuild
     .build({
-      entryPoints: ["./port-data-source"],
+      entryPoints: ["./custom-backend-task"],
       platform: "node",
       assetNames: "[name]-[hash]",
       chunkNames: "chunks/[name]-[hash]",
@@ -171,15 +171,15 @@ async function start(options) {
       ],
     })
     .then((result) => {
-      console.log("Watching port-data-source...");
+      console.log("Watching custom-backend-task...");
     })
     .catch((error) => {
       const portBackendTaskFileFound =
-        globby.sync("./port-data-source.*").length > 0;
+        globby.sync("./custom-backend-task.*").length > 0;
       if (portBackendTaskFileFound) {
-        // don't present error if there are no files matching port-data-source
-        // if there are files matching port-data-source, warn the user in case something went wrong loading it
-        console.error("Failed to start port-data-source watcher", error);
+        // don't present error if there are no files matching custom-backend-task
+        // if there are files matching custom-backend-task, warn the user in case something went wrong loading it
+        console.error("Failed to start custom-backend-task watcher", error);
       }
     });
 

package/generator/src/render-test.js

@@ -27,7 +27,7 @@ async function run({ pathname, serverRequest }) {
     console.log("Compiling DONE");
 
     const portsFilePath =
-      ".elm-pages/compiled-ports/port-data-source-FA2IJND6.js";
+      ".elm-pages/compiled-ports/custom-backend-task-FA2IJND6.js";
     const mode = "dev-server";
 
     const renderResult = await renderer.render(

package/generator/src/render.js

@@ -16,8 +16,6 @@ process.on("unhandledRejection", (error) => {
   console.error(error);
 });
 let foundErrors;
-let pendingBackendTaskResponses = new Map();
-let pendingBackendTaskCount;
 
 module.exports = { render, runGenerator };
 
@@ -44,8 +42,6 @@ async function render(
   const { fs, resetInMemoryFs } = require("./request-cache-fs.js")(hasFsAccess);
   resetInMemoryFs();
   foundErrors = false;
-  pendingBackendTaskResponses = new Map();
-  pendingBackendTaskCount = 0;
   // since init/update are never called in pre-renders, and BackendTask.Http is called using pure NodeJS HTTP fetching
   // we can provide a fake HTTP instead of xhr2 (which is otherwise needed for Elm HTTP requests from Node)
   XMLHttpRequest = {};
@@ -74,8 +70,6 @@ async function runGenerator(cliOptions, portsFile, elmModule) {
   const { fs, resetInMemoryFs } = require("./request-cache-fs.js")(true);
   resetInMemoryFs();
   foundErrors = false;
-  pendingBackendTaskResponses = new Map();
-  pendingBackendTaskCount = 0;
   // since init/update are never called in pre-renders, and BackendTask.Http is called using pure NodeJS HTTP fetching
   // we can provide a fake HTTP instead of xhr2 (which is otherwise needed for Elm HTTP requests from Node)
   XMLHttpRequest = {};
@@ -166,33 +160,39 @@ function runGeneratorAppHelp(
           );
         }
       } else if (fromElm.tag === "DoHttp") {
-        const requestHash = fromElm.args[0];
-        const requestToPerform = fromElm.args[1];
-        if (
-          requestToPerform.url !== "elm-pages-internal://port" &&
-          requestToPerform.url.startsWith("elm-pages-internal://")
-        ) {
-          runInternalJob(
-            requestHash,
-            app,
-            mode,
-            requestToPerform,
-            fs,
-            hasFsAccess,
-            patternsToWatch
-          );
-        } else {
-          runHttpJob(
-            requestHash,
-            portsFile,
-            app,
-            mode,
-            requestToPerform,
-            fs,
-            hasFsAccess,
-            fromElm.args[1]
-          );
-        }
+        app.ports.gotBatchSub.send(
+          Object.fromEntries(
+            await Promise.all(
+              fromElm.args[0].map(([requestHash, requestToPerform]) => {
+                if (
+                  requestToPerform.url !== "elm-pages-internal://port" &&
+                  requestToPerform.url.startsWith("elm-pages-internal://")
+                ) {
+                  return runInternalJob(
+                    requestHash,
+                    app,
+                    mode,
+                    requestToPerform,
+                    fs,
+                    hasFsAccess,
+                    patternsToWatch
+                  );
+                } else {
+                  return runHttpJob(
+                    requestHash,
+                    portsFile,
+                    app,
+                    mode,
+                    requestToPerform,
+                    fs,
+                    hasFsAccess,
+                    requestToPerform
+                  );
+                }
+              })
+            )
+          )
+        );
       } else if (fromElm.tag === "Errors") {
         foundErrors = true;
         reject(fromElm.args[0].errorsJson);
@@ -309,33 +309,39 @@ function runElmApp(
           );
         }
       } else if (fromElm.tag === "DoHttp") {
-        const requestHash = fromElm.args[0];
-        const requestToPerform = fromElm.args[1];
-        if (
-          requestToPerform.url !== "elm-pages-internal://port" &&
-          requestToPerform.url.startsWith("elm-pages-internal://")
-        ) {
-          runInternalJob(
-            requestHash,
-            app,
-            mode,
-            requestToPerform,
-            fs,
-            hasFsAccess,
-            patternsToWatch
-          );
-        } else {
-          runHttpJob(
-            requestHash,
-            portsFile,
-            app,
-            mode,
-            requestToPerform,
-            fs,
-            hasFsAccess,
-            fromElm.args[1]
-          );
-        }
+        app.ports.gotBatchSub.send(
+          Object.fromEntries(
+            await Promise.all(
+              fromElm.args[0].map(([requestHash, requestToPerform]) => {
+                if (
+                  requestToPerform.url !== "elm-pages-internal://port" &&
+                  requestToPerform.url.startsWith("elm-pages-internal://")
+                ) {
+                  return runInternalJob(
+                    requestHash,
+                    app,
+                    mode,
+                    requestToPerform,
+                    fs,
+                    hasFsAccess,
+                    patternsToWatch
+                  );
+                } else {
+                  return runHttpJob(
+                    requestHash,
+                    portsFile,
+                    app,
+                    mode,
+                    requestToPerform,
+                    fs,
+                    hasFsAccess,
+                    requestToPerform
+                  );
+                }
+              })
+            )
+          )
+        );
       } else if (fromElm.tag === "Errors") {
         foundErrors = true;
         reject(fromElm.args[0].errorsJson);
@@ -404,7 +410,6 @@ async function runHttpJob(
   hasFsAccess,
   useCache
 ) {
-  pendingBackendTaskCount += 1;
   try {
     const lookupResponse = await lookupOrPerform(
       portsFile,
@@ -416,25 +421,29 @@ async function runHttpJob(
 
     if (lookupResponse.kind === "cache-response-path") {
       const responseFilePath = lookupResponse.value;
-      pendingBackendTaskResponses.set(requestHash, {
-        request: requestToPerform,
-        response: JSON.parse(
-          (await fs.promises.readFile(responseFilePath, "utf8")).toString()
-        ),
-      });
+      return [
+        requestHash,
+        {
+          request: requestToPerform,
+          response: JSON.parse(
+            (await fs.promises.readFile(responseFilePath, "utf8")).toString()
+          ),
+        },
+      ];
     } else if (lookupResponse.kind === "response-json") {
-      pendingBackendTaskResponses.set(requestHash, {
-        request: requestToPerform,
-        response: lookupResponse.value,
-      });
+      return [
+        requestHash,
+        {
+          request: requestToPerform,
+          response: lookupResponse.value,
+        },
+      ];
     } else {
       throw `Unexpected kind ${lookupResponse}`;
     }
   } catch (error) {
-    sendError(app, error);
-  } finally {
-    pendingBackendTaskCount -= 1;
-    flushIfDone(app);
+    console.log("@@@ERROR", error);
+    // sendError(app, error);
   }
 }
 
@@ -461,43 +470,29 @@ async function runInternalJob(
   patternsToWatch
 ) {
   try {
-    pendingBackendTaskCount += 1;
-
     if (requestToPerform.url === "elm-pages-internal://log") {
-      pendingBackendTaskResponses.set(
-        requestHash,
-        await runLogJob(requestToPerform)
-      );
+      return [requestHash, await runLogJob(requestToPerform)];
     } else if (requestToPerform.url === "elm-pages-internal://read-file") {
-      pendingBackendTaskResponses.set(
+      return [
         requestHash,
-        await readFileJobNew(requestToPerform, patternsToWatch)
-      );
+        await readFileJobNew(requestToPerform, patternsToWatch),
+      ];
     } else if (requestToPerform.url === "elm-pages-internal://glob") {
-      pendingBackendTaskResponses.set(
-        requestHash,
-        await runGlobNew(requestToPerform, patternsToWatch)
-      );
+      return [requestHash, await runGlobNew(requestToPerform, patternsToWatch)];
     } else if (requestToPerform.url === "elm-pages-internal://env") {
-      pendingBackendTaskResponses.set(
-        requestHash,
-        await runEnvJob(requestToPerform, patternsToWatch)
-      );
+      return [requestHash, await runEnvJob(requestToPerform, patternsToWatch)];
     } else if (requestToPerform.url === "elm-pages-internal://encrypt") {
-      pendingBackendTaskResponses.set(
+      return [
         requestHash,
-        await runEncryptJob(requestToPerform, patternsToWatch)
-      );
+        await runEncryptJob(requestToPerform, patternsToWatch),
+      ];
     } else if (requestToPerform.url === "elm-pages-internal://decrypt") {
-      pendingBackendTaskResponses.set(
+      return [
         requestHash,
-        await runDecryptJob(requestToPerform, patternsToWatch)
-      );
+        await runDecryptJob(requestToPerform, patternsToWatch),
+      ];
     } else if (requestToPerform.url === "elm-pages-internal://write-file") {
-      pendingBackendTaskResponses.set(
-        requestHash,
-        await runWriteFileJob(requestToPerform)
-      );
+      return [requestHash, await runWriteFileJob(requestToPerform)];
     } else {
       throw `Unexpected internal BackendTask request format: ${kleur.yellow(
         JSON.stringify(2, null, requestToPerform)
@@ -505,9 +500,6 @@ async function runInternalJob(
     }
   } catch (error) {
     sendError(app, error);
-  } finally {
-    pendingBackendTaskCount -= 1;
-    flushIfDone(app);
   }
 }
 
@@ -628,27 +620,6 @@ async function runDecryptJob(req, patternsToWatch) {
   }
 }
 
-function flushIfDone(app) {
-  if (foundErrors) {
-    pendingBackendTaskResponses = new Map();
-  } else if (pendingBackendTaskCount === 0) {
-    // console.log(
-    //   `Flushing ${pendingBackendTaskResponses.length} items in ${timeUntilThreshold}ms`
-    // );
-
-    flushQueue(app);
-  }
-}
-
-function flushQueue(app) {
-  // TODO - could the case where flush is called with size 0 be avoided on the Elm side?
-  // if (pendingBackendTaskResponses.size > 0) {
-  // console.log("@@@ FLUSHING", pendingBackendTaskResponses.size);
-  app.ports.gotBatchSub.send(Object.fromEntries(pendingBackendTaskResponses));
-  pendingBackendTaskResponses = new Map();
-  // }
-}
-
 /**
  * @param {{ ports: { fromJsPort: { send: (arg0: { tag: string; data: any; }) => void; }; }; }} app
  * @param {{ message: string; title: string; }} error

package/generator/src/request-cache.js

@@ -43,21 +43,21 @@ function lookupOrPerform(portsFile, mode, rawRequest, hasFsAccess, useCache) {
             resolve({
               kind: "response-json",
               value: jsonResponse({
-                "elm-pages-internal-error": "PortNotDefined",
+                "elm-pages-internal-error": "CustomBackendTaskNotDefined",
               }),
             });
           } else if (portBackendTaskImportError === "missing") {
             resolve({
               kind: "response-json",
               value: jsonResponse({
-                "elm-pages-internal-error": "MissingPortsFile",
+                "elm-pages-internal-error": "MissingCustomBackendTaskFile",
               }),
             });
           } else {
             resolve({
               kind: "response-json",
               value: jsonResponse({
-                "elm-pages-internal-error": "ErrorInPortsFile",
+                "elm-pages-internal-error": "ErrorInCustomBackendTaskFile",
                 error:
                   (portBackendTaskImportError &&
                     portBackendTaskImportError.stack) ||
@@ -83,7 +83,7 @@ function lookupOrPerform(portsFile, mode, rawRequest, hasFsAccess, useCache) {
             resolve({
               kind: "response-json",
               value: jsonResponse({
-                "elm-pages-internal-error": "PortCallException",
+                "elm-pages-internal-error": "CustomBackendTaskException",
                 error: portCallError,
               }),
             });
@@ -92,7 +92,7 @@ function lookupOrPerform(portsFile, mode, rawRequest, hasFsAccess, useCache) {
       } catch (error) {
         console.trace(error);
         reject({
-          title: "BackendTask.Port Error",
+          title: "BackendTask.Custom Error",
           message: error.toString(),
         });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elm-pages",
-  "version": "3.0.0-beta.16",
+  "version": "3.0.0-beta.18",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",

package/src/BackendTask/{Port.elm → Custom.elm}

@@ -1,30 +1,30 @@
-module BackendTask.Port exposing
-    ( get
+module BackendTask.Custom exposing
+    ( run
     , Error(..)
     )
 
 {-| In a vanilla Elm application, ports let you either send or receive JSON data between your Elm application and the JavaScript context in the user's browser at runtime.
 
-With `BackendTask.Port`, you send and receive JSON to JavaScript running in NodeJS. As with any `BackendTask`, Port BackendTask's are either run at build-time (for pre-rendered routes) or at request-time (for server-rendered routes). See [`BackendTask`](BackendTask) for more about the
+With `BackendTask.Custom`, you send and receive JSON to JavaScript running in NodeJS. As with any `BackendTask`, Custom BackendTask's are either run at build-time (for pre-rendered routes) or at request-time (for server-rendered routes). See [`BackendTask`](BackendTask) for more about the
 lifecycle of `BackendTask`'s.
 
 This means that you can call shell scripts, run NPM packages that are installed, or anything else you could do with NodeJS to perform custom side-effects, get some data, or both.
 
-A `BackendTask.Port` will call an async JavaScript function with the given name from the definition in a file called `port-data-source.js` in your project's root directory. The function receives the input JSON value, and the Decoder is used to decode the return value of the async function.
+A `BackendTask.Custom` will call an async JavaScript function with the given name from the definition in a file called `custom-backend-task.js` in your project's root directory. The function receives the input JSON value, and the Decoder is used to decode the return value of the async function.
 
-@docs get
+@docs run
 
-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,
+Here is the Elm code and corresponding JavaScript definition for getting an environment variable (or an `FatalError BackendTask.Custom.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 BackendTask.Custom
     import Json.Encode
     import OptimizedDecoder as Decode
 
     data : BackendTask FatalError String
     data =
-        BackendTask.Port.get "environmentVariable"
+        BackendTask.Custom.run "environmentVariable"
             (Json.Encode.string "EDITOR")
             Decode.string
             |> BackendTask.allowFatal
@@ -32,7 +32,7 @@ we're using `BackendTask.allowFatal` to let the framework treat that as an unexp
     -- will resolve to "VIM" if you run `EDITOR=vim elm-pages dev`
 
 ```javascript
-// port-data-source.js
+// custom-backend-task.js
 
 module.exports =
   /**
@@ -59,38 +59,38 @@ ${Object.keys(process.env).join("\n")}
 
 ## Performance
 
-As with any JavaScript or NodeJS code, avoid doing blocking IO operations. For example, avoid using `fs.readFileSync`, because blocking IO can slow down your elm-pages builds and dev server. `elm-pages` performances all `BackendTask`'s in parallel whenever possible.
-So if you do `BackendTask.map2 Tuple.pair myHttpBackendTask myPortBackendTask`, it will resolve those two in parallel. NodeJS performs best when you take advantage of its ability to do non-blocking I/O (file reads, HTTP requests, etc.). If you use `BackendTask.andThen`,
-it will need to resolve them in sequence rather than in parallel, but it's still best to avoid blocking IO operations in your BackendTask Port definitions.
+As with any JavaScript or NodeJS code, avoid doing blocking IO operations. For example, avoid using `fs.readFileSync`, because blocking IO can slow down your elm-pages builds and dev server. `elm-pages` performs all `BackendTask`'s in parallel whenever possible.
+So if you do `BackendTask.map2 Tuple.pair myHttpBackendTask myCustomBackendTask`, it will resolve those two in parallel. NodeJS performs best when you take advantage of its ability to do non-blocking I/O (file reads, HTTP requests, etc.). If you use `BackendTask.andThen`,
+it will need to resolve them in sequence rather than in parallel, but it's still best to avoid blocking IO operations in your Custom BackendTask definitions.
 
 
 ## Error Handling
 
-There are a few different things that can go wrong when running a port-data-source. These possible errors are captured in the `BackendTask.Port.Error` type.
+There are a few different things that can go wrong when running a custom-backend-task. These possible errors are captured in the `BackendTask.Custom.Error` type.
 
 @docs Error
 
-Any time you throw a JavaScript exception from a BackendTask.Port definition, it will give you a `PortCallException`. It's usually easier to add a `try`/`catch` in your JavaScript code in `port-data-source.js`
-to handle possible errors, but you can throw a JSON value and handle it in Elm in the `PortCallException` call error.
+Any time you throw a JavaScript exception from a BackendTask.Custom definition, it will give you a `CustomBackendTaskException`. It's usually easier to add a `try`/`catch` in your JavaScript code in `custom-backend-task.js`
+to handle possible errors, but you can throw a JSON value and handle it in Elm in the `CustomBackendTaskException` call error.
 
 -}
 
 import BackendTask
 import BackendTask.Http
 import BackendTask.Internal.Request
-import FatalError exposing (FatalError, Recoverable)
+import FatalError exposing (FatalError)
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
 import TerminalText
 
 
 {-| -}
-get :
+run :
     String
     -> Encode.Value
     -> Decoder b
     -> BackendTask.BackendTask { fatal : FatalError, recoverable : Error } b
-get portName input decoder =
+run portName input decoder =
     BackendTask.Internal.Request.request
         { name = "port"
         , body =
@@ -104,17 +104,17 @@ get portName input decoder =
                 [ Decode.field "elm-pages-internal-error" Decode.string
                     |> Decode.andThen
                         (\errorKind ->
-                            if errorKind == "PortNotDefined" then
+                            if errorKind == "CustomBackendTaskNotDefined" then
                                 FatalError.recoverable
-                                    { title = "Port Error"
+                                    { title = "Custom BackendTask Error"
                                     , body =
-                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I expected to find a port named `"
+                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I expected to find a port named `"
                                         , TerminalText.yellow portName
-                                        , TerminalText.text "` but I couldn't find it. Is the function exported in your port-data-source file?"
+                                        , TerminalText.text "` but I couldn't find it. Is the function exported in your custom-backend-task file?"
                                         ]
                                             |> TerminalText.toString
                                     }
-                                    (PortNotDefined { name = portName })
+                                    (CustomBackendTaskNotDefined { name = portName })
                                     |> Decode.succeed
 
                             else if errorKind == "ExportIsNotFunction" then
@@ -122,78 +122,78 @@ get portName input decoder =
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault "")
                                     |> Decode.map
-                                        (\incorrectPortType ->
+                                        (\incorrectType ->
                                             FatalError.recoverable
-                                                { title = "Port Error"
+                                                { title = "Custom BackendTask Error"
                                                 , body =
-                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I found an export called `"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I found an export called `"
                                                     , TerminalText.yellow portName
                                                     , TerminalText.text "` but I expected its type to be function, but instead its type was: "
-                                                    , TerminalText.red incorrectPortType
+                                                    , TerminalText.red incorrectType
                                                     ]
                                                         |> TerminalText.toString
                                                 }
                                                 ExportIsNotFunction
                                         )
 
-                            else if errorKind == "MissingPortsFile" then
+                            else if errorKind == "MissingCustomBackendTaskFile" then
                                 FatalError.recoverable
-                                    { title = "Port Error"
+                                    { title = "Custom BackendTask 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.text "Something went wrong in a call to BackendTask.Custom.run. I couldn't find your custom-backend-task file. Be sure to create a 'custom-backend-task.ts' or 'custom-backend-task.js' file."
                                         ]
                                             |> TerminalText.toString
                                     }
-                                    MissingPortsFile
+                                    MissingCustomBackendTaskFile
                                     |> Decode.succeed
 
-                            else if errorKind == "ErrorInPortsFile" then
+                            else if errorKind == "ErrorInCustomBackendTaskFile" then
                                 Decode.field "error" Decode.string
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault "")
                                     |> Decode.map
                                         (\errorMessage ->
                                             FatalError.recoverable
-                                                { title = "Port Error"
+                                                { title = "Custom BackendTask 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"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I couldn't import the port definitions file, because of this exception:\n\n"
                                                     , TerminalText.red errorMessage
                                                     , TerminalText.text "\n\nAre there syntax errors or exceptions thrown during import?"
                                                     ]
                                                         |> TerminalText.toString
                                                 }
-                                                ErrorInPortsFile
+                                                ErrorInCustomBackendTaskFile
                                         )
 
-                            else if errorKind == "PortCallException" then
+                            else if errorKind == "CustomBackendTaskException" then
                                 Decode.field "error" Decode.value
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault Encode.null)
                                     |> Decode.map
                                         (\portCallError ->
                                             FatalError.recoverable
-                                                { title = "Port Error"
+                                                { title = "Custom BackendTask 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"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I was able to import the port definitions file, but when running it I encountered this exception:\n\n"
                                                     , TerminalText.red (Encode.encode 2 portCallError)
-                                                    , TerminalText.text "\n\nYou could add a `try`/`catch` in your `port-data-source` JavaScript code to handle that error."
+                                                    , TerminalText.text "\n\nYou could add a `try`/`catch` in your `custom-backend-task` JavaScript code to handle that error."
                                                     ]
                                                         |> TerminalText.toString
                                                 }
-                                                (PortCallException portCallError)
+                                                (CustomBackendTaskException portCallError)
                                         )
 
                             else
                                 FatalError.recoverable
-                                    { title = "Port Error"
+                                    { title = "Custom BackendTask Error"
                                     , body =
-                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I expected to find a port named `"
+                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I expected to find a port named `"
                                         , TerminalText.yellow portName
                                         , TerminalText.text "`."
                                         ]
                                             |> TerminalText.toString
                                     }
-                                    ErrorInPortsFile
+                                    ErrorInCustomBackendTaskFile
                                     |> Decode.succeed
                         )
                     |> Decode.map Err
@@ -207,8 +207,8 @@ get portName input decoder =
 {-| -}
 type Error
     = Error
-    | ErrorInPortsFile
-    | MissingPortsFile
-    | PortNotDefined { name : String }
-    | PortCallException Decode.Value
+    | ErrorInCustomBackendTaskFile
+    | MissingCustomBackendTaskFile
+    | CustomBackendTaskNotDefined { name : String }
+    | CustomBackendTaskException Decode.Value
     | ExportIsNotFunction

package/src/BackendTask/File.elm

@@ -366,7 +366,7 @@ errorDecoder :
     String
     ->
         Decoder
-            { fatal : FatalError.FatalError
+            { fatal : FatalError
             , recoverable : FileReadError decoding
             }
 errorDecoder filePath =

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 FatalError exposing (FatalError, Recoverable)
+import FatalError exposing (FatalError)
 import Json.Decode as Decode
 import Json.Encode as Encode
 import List.Extra
@@ -1054,7 +1054,9 @@ 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 (Recoverable String) a
+expectUniqueMatch :
+    Glob a
+    -> BackendTask { fatal : FatalError, recoverable : String } a
 expectUniqueMatch glob =
     glob
         |> toBackendTask

package/src/BackendTask/Http.elm

@@ -104,7 +104,7 @@ import Base64
 import Bytes exposing (Bytes)
 import Bytes.Decode
 import Dict exposing (Dict)
-import FatalError exposing (FatalError, Recoverable)
+import FatalError exposing (FatalError)
 import Json.Decode
 import Json.Encode as Encode
 import Pages.Internal.StaticHttpBody as Body
@@ -170,7 +170,7 @@ type alias Body =
 getJson :
     String
     -> Json.Decode.Decoder a
-    -> BackendTask (Recoverable Error) a
+    -> BackendTask { fatal : FatalError, recoverable : Error } a
 getJson url decoder =
     getWithOptions
         { url = url
@@ -231,7 +231,7 @@ getWithOptions :
     , timeoutInMs : Maybe Int
     , cachePath : Maybe String
     }
-    -> BackendTask (Recoverable Error) a
+    -> BackendTask { fatal : FatalError, recoverable : Error } a
 getWithOptions request__ =
     let
         request_ : HashRequest.Request
@@ -258,7 +258,7 @@ post :
     String
     -> Body
     -> Expect a
-    -> BackendTask (Recoverable Error) a
+    -> BackendTask { fatal : FatalError, recoverable : Error } a
 post url body expect =
     request
         { url = url
@@ -397,7 +397,7 @@ request :
     , timeoutInMs : Maybe Int
     }
     -> Expect a
-    -> BackendTask (Recoverable Error) a
+    -> BackendTask { fatal : FatalError, 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 (Recoverable Error) a
+    -> BackendTask { fatal : FatalError, recoverable : Error } a
 requestRaw request__ expect =
     let
         request_ : HashRequest.Request

package/src/BackendTask.elm

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

package/src/FatalError.elm

@@ -1,7 +1,4 @@
-module FatalError exposing
-    ( FatalError, fromString, recoverable
-    , Recoverable
-    )
+module FatalError exposing (FatalError, fromString, 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
@@ -59,20 +56,11 @@ when these errors occur.
 
 @docs FatalError, fromString, recoverable
 
-@docs Recoverable
-
 -}
 
 import Pages.Internal.FatalError
 
 
-{-| -}
-type alias Recoverable error =
-    { fatal : FatalError
-    , recoverable : error
-    }
-
-
 {-| -}
 type alias FatalError =
     Pages.Internal.FatalError.FatalError
@@ -94,7 +82,7 @@ fromString string =
 
 
 {-| -}
-recoverable : { title : String, body : String } -> value -> Recoverable value
+recoverable : { title : String, body : String } -> error -> { fatal : FatalError, recoverable : error }
 recoverable info value =
     { fatal = build info
     , recoverable = value

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

@@ -209,8 +209,13 @@ perform site renderRequest config effect =
         Effect.Batch list ->
             flatten site renderRequest config list
 
-        Effect.FetchHttp unmasked ->
-            ToJsPayload.DoHttp (Pages.StaticHttp.Request.hash unmasked) unmasked
+        Effect.FetchHttp requests ->
+            requests
+                |> List.map
+                    (\request ->
+                        ( Pages.StaticHttp.Request.hash request, request )
+                    )
+                |> ToJsPayload.DoHttp
                 |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl "")
                 |> config.toJsPort
                 |> Cmd.map never
@@ -817,10 +822,7 @@ nextStepToEffect model nextStep =
             ( { model
                 | staticResponses = updatedStaticResponsesModel
               }
-            , (httpRequests
-                |> List.map Effect.FetchHttp
-              )
-                |> Effect.Batch
+            , Effect.FetchHttp httpRequests
             )
 
         StaticResponses.FinishedWithErrors errors ->

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

@@ -7,7 +7,7 @@ import Pages.StaticHttp.Request as StaticHttp
 
 type Effect
     = NoEffect
-    | FetchHttp StaticHttp.Request
+    | FetchHttp (List StaticHttp.Request)
     | Batch (List Effect)
     | SendSinglePage ToJsSuccessPayloadNewCombined
     | SendSinglePageNew Bytes ToJsSuccessPayloadNewCombined

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

@@ -183,8 +183,13 @@ perform config effect =
         Effect.Batch list ->
             flatten config list
 
-        Effect.FetchHttp unmasked ->
-            ToJsPayload.DoHttp (Pages.StaticHttp.Request.hash unmasked) unmasked
+        Effect.FetchHttp requests ->
+            requests
+                |> List.map
+                    (\request ->
+                        ( Pages.StaticHttp.Request.hash request, request )
+                    )
+                |> ToJsPayload.DoHttp
                 |> Codec.encoder (ToJsPayload.successCodecNew2 canonicalSiteUrl "")
                 |> config.toJsPort
                 |> Cmd.map never
@@ -349,10 +354,7 @@ nextStepToEffect model nextStep =
             ( { model
                 | staticResponses = updatedStaticResponsesModel
               }
-            , (httpRequests
-                |> List.map Effect.FetchHttp
-              )
-                |> Effect.Batch
+            , Effect.FetchHttp httpRequests
             )
 
         StaticResponses.Finish () ->

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

@@ -2,7 +2,7 @@ module Pages.Internal.Platform.StaticResponses exposing (NextStep(..), empty, ne
 
 import BackendTask exposing (BackendTask)
 import BuildError exposing (BuildError)
-import FatalError exposing (FatalError, Recoverable)
+import FatalError exposing (FatalError)
 import List.Extra
 import Pages.Internal.FatalError
 import Pages.StaticHttp.Request as HashRequest

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

@@ -89,7 +89,7 @@ headCodec canonicalSiteUrl currentPagePath =
 type ToJsSuccessPayloadNewCombined
     = PageProgress ToJsSuccessPayloadNew
     | SendApiResponse { body : Json.Encode.Value, staticHttpCache : Dict String String, statusCode : Int }
-    | DoHttp String Pages.StaticHttp.Request.Request
+    | DoHttp (List ( String, Pages.StaticHttp.Request.Request ))
     | Port String
     | Errors (List BuildError)
     | ApiResponse
@@ -109,8 +109,8 @@ successCodecNew2 canonicalSiteUrl currentPagePath =
                 PageProgress payload ->
                     success payload
 
-                DoHttp hash requestUrl ->
-                    vDoHttp hash requestUrl
+                DoHttp hashRequestPairs ->
+                    vDoHttp hashRequestPairs
 
                 SendApiResponse record ->
                     vSendApiResponse record
@@ -121,10 +121,7 @@ successCodecNew2 canonicalSiteUrl currentPagePath =
         |> Codec.variant1 "Errors" Errors errorCodec
         |> Codec.variant0 "ApiResponse" ApiResponse
         |> Codec.variant1 "PageProgress" PageProgress (successCodecNew canonicalSiteUrl currentPagePath)
-        |> Codec.variant2 "DoHttp"
-            DoHttp
-            Codec.string
-            Pages.StaticHttp.Request.codec
+        |> Codec.variant1 "DoHttp" DoHttp (Codec.list (Codec.tuple Codec.string Pages.StaticHttp.Request.codec))
         |> Codec.variant1 "ApiResponse"
             SendApiResponse
             (Codec.object (\body staticHttpCache statusCode -> { body = body, staticHttpCache = staticHttpCache, statusCode = statusCode })

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 FatalError exposing (FatalError, Recoverable)
+import FatalError exposing (FatalError)
 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 (Recoverable Error) ()
+writeFile : { path : String, body : String } -> BackendTask { fatal : FatalError, recoverable : Error } ()
 writeFile { path, body } =
     BackendTask.Internal.Request.request
         { name = "write-file"