elm-pages 3.0.0-beta.19 → 3.0.0-beta.20

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: 3718366887, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 3129741668, 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: 3718366887,
+  initialSeed: 3129741668,
   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: 1328864607, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 939943801, 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: 1328864607,
+  initialSeed: 939943801,
   fuzzRuns: 100,
   mode: "consoleNoColor",
   verbosity: verbosity,

package/generator/src/build.js

@@ -145,18 +145,18 @@ export async function run(options) {
       );
     await fsPromises.writeFile("dist/template.html", processedIndexTemplate);
     await fsPromises.unlink(assetManifestPath);
-
     const portBackendTaskCompiled = esbuild
       .build({
         entryPoints: ["./custom-backend-task"],
         platform: "node",
-        outfile: ".elm-pages/compiled-ports/custom-backend-task.js",
+        outfile: ".elm-pages/compiled-ports/custom-backend-task.mjs",
         assetNames: "[name]-[hash]",
         chunkNames: "chunks/[name]-[hash]",
         outExtension: { ".js": ".js" },
         metafile: true,
         bundle: true,
-        watch: false,
+        format: "esm",
+        packages: "external",
         logLevel: "silent",
       })
       .then((result) => {
@@ -356,7 +356,7 @@ async function fingerprintElmAsset(fullOutputPath, withoutExtension) {
   return fileHash;
 }
 
-function elmOptimizeLevel2(outputPath, cwd) {
+export function elmOptimizeLevel2(outputPath, cwd) {
   return new Promise((resolve, reject) => {
     const optimizedOutputPath = outputPath + ".opt";
     const subprocess = spawnCallback(
@@ -618,14 +618,14 @@ function _HtmlAsJson_toJson(html) {
 async function runAdapter(adaptFn, processedIndexTemplate) {
   try {
     await adaptFn({
-      renderFunctionFilePath: "./elm-stuff/elm-pages/elm.js",
+      renderFunctionFilePath: "./elm-stuff/elm-pages/elm.cjs",
       routePatterns: JSON.parse(
         await fsPromises.readFile("./dist/route-patterns.json", "utf-8")
       ),
       apiRoutePatterns: JSON.parse(
         await fsPromises.readFile("./dist/api-patterns.json", "utf-8")
       ),
-      portsFilePath: "./.elm-pages/compiled-ports/custom-backend-task.js",
+      portsFilePath: "./.elm-pages/compiled-ports/custom-backend-task.mjs",
       htmlTemplate: processedIndexTemplate,
     });
     console.log("Success - Adapter script complete");

package/generator/src/cli.js

@@ -5,20 +5,23 @@ import * as build from "./build.js";
 import * as dev from "./dev-server.js";
 import * as init from "./init.js";
 import * as codegen from "./codegen.js";
-import * as fs from "fs";
-import * as path from "path";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { restoreColorSafe } from "./error-formatter.js";
 import * as renderer from "./render.js";
 import { globbySync } from "globby";
 import * as esbuild from "esbuild";
 import { rewriteElmJson } from "./rewrite-elm-json.js";
 import { ensureDirSync, deleteIfExists } from "./file-helpers.js";
+import * as url from "url";
 
 import * as commander from "commander";
 import { runElmCodegenInstall } from "./elm-codegen.js";
 
 const Argument = commander.Argument;
 const Option = commander.Option;
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 import * as packageJson from "../../package.json" assert { type: "json" };
 const packageVersion = packageJson.version;
@@ -135,13 +138,13 @@ async function main() {
           .build({
             entryPoints: ["./custom-backend-task"],
             platform: "node",
-            outfile: ".elm-pages/compiled-ports/custom-backend-task.js",
+            outfile: ".elm-pages/compiled-ports/custom-backend-task.mjs",
             assetNames: "[name]-[hash]",
             chunkNames: "chunks/[name]-[hash]",
-            outExtension: { ".js": ".js" },
             metafile: true,
             bundle: true,
-            watch: false,
+            format: "esm",
+            packages: "external",
             logLevel: "silent",
           })
           .then((result) => {
@@ -164,8 +167,6 @@ async function main() {
             }
           });
         const portsPath = await portBackendTaskCompiled;
-        const resolvedPortsPath =
-          portsPath && path.join(process.cwd(), portsPath);
 
         process.chdir("./script");
         // TODO have option for compiling with --debug or not (maybe allow running with elm-optimize-level-2 as well?)
@@ -177,7 +178,7 @@ async function main() {
         );
         await renderer.runGenerator(
           unprocessedCliOptions,
-          resolvedPortsPath,
+          await import(url.pathToFileURL(path.resolve(portsPath)).href),
           await requireElm("./script/elm-stuff/elm-pages/elm.cjs"),
           moduleName
         );
@@ -187,6 +188,105 @@ async function main() {
       }
     });
 
+  program
+    .command("bundle-script <moduleName>")
+    .description("bundle an elm-pages script")
+    .option(
+      "--debug",
+      "Skip elm-optimize-level-2 and run elm make with --debug"
+    )
+    .option(
+      "--output <path>",
+      "Output path for compiled script",
+      "./myscript.mjs"
+    )
+    .option(
+      "--external <package-or-pattern>",
+      "build site to be served under a base path",
+      collect,
+      []
+    )
+    .action(async (moduleName, options, options2) => {
+      if (!/^[A-Z][a-zA-Z0-9_]*(\.[A-Z][a-zA-Z0-9_]*)*$/.test(moduleName)) {
+        throw `Invalid module name "${moduleName}", must be in the format of an Elm module`;
+      }
+      const splitModuleName = moduleName.split(".");
+      const expectedFilePath = path.join(
+        process.cwd(),
+        "script/src/",
+        `${splitModuleName.join("/")}.elm`
+      );
+      if (!fs.existsSync(expectedFilePath)) {
+        throw `I couldn't find a module named ${expectedFilePath}`;
+      }
+      try {
+        if (fs.existsSync("./codegen/")) {
+          await runElmCodegenInstall();
+        }
+
+        ensureDirSync("./script/elm-stuff");
+        ensureDirSync("./script/elm-stuff/elm-pages/.elm-pages");
+        await fs.promises.writeFile(
+          path.join("./script/elm-stuff/elm-pages/.elm-pages/Main.elm"),
+          generatorWrapperFile(moduleName)
+        );
+        await rewriteElmJson(
+          "./script/elm.json",
+          "./script/elm-stuff/elm-pages/elm.json"
+        );
+
+        process.chdir("./script");
+        // TODO have option for compiling with --debug or not (maybe allow running with elm-optimize-level-2 as well?)
+        console.log("Compiling...");
+        await build.compileCliApp({ debug: options.debug });
+        process.chdir("../");
+        if (!options.debug) {
+          console.log("Running elm-optimize-level-2...");
+          await build.elmOptimizeLevel2(
+            "./script/elm-stuff/elm-pages/elm.js",
+            process.cwd()
+          );
+        }
+        fs.renameSync(
+          "./script/elm-stuff/elm-pages/elm.js",
+          "./script/elm-stuff/elm-pages/elm.cjs"
+        );
+        const scriptRunner = `import * as customBackendTask from "${path.resolve(
+          "./custom-backend-task.ts"
+        )}";
+import * as renderer from "./render.js";
+import { default as Elm } from "${path.resolve(
+          "./script/elm-stuff/elm-pages/elm.cjs"
+        )}";
+
+await renderer.runGenerator(
+  [...process.argv].splice(2),
+  customBackendTask,
+  Elm,
+  "${moduleName}"
+);
+        `;
+        // source: https://github.com/evanw/esbuild/pull/2067#issuecomment-1073039746
+        const ESM_REQUIRE_SHIM = `
+await(async()=>{let{dirname:e}=await import("path"),{fileURLToPath:i}=await import("url");if(typeof globalThis.__filename>"u"&&(globalThis.__filename=i(import.meta.url)),typeof globalThis.__dirname>"u"&&(globalThis.__dirname=e(globalThis.__filename)),typeof globalThis.require>"u"){let{default:a}=await import("module");globalThis.require=a.createRequire(import.meta.url)}})();
+`;
+
+        await esbuild.build({
+          format: "esm",
+          platform: "node",
+          stdin: { contents: scriptRunner, resolveDir: __dirname },
+          bundle: true,
+          outfile: options.output,
+          external: ["node:*", ...options.external],
+          minify: true,
+          banner: { js: `#!/usr/bin/env node\n\n${ESM_REQUIRE_SHIM}` },
+        });
+      } catch (error) {
+        console.log(restoreColorSafe(error));
+        process.exit(1);
+      }
+    });
+
   program
     .command("docs")
     .description("open the docs for locally generated modules")
@@ -311,5 +411,8 @@ port gotBatchSub : (Decode.Value -> msg) -> Sub msg
 port sendPageData : { oldThing : Encode.Value, binaryPageData : Bytes.Bytes } -> Cmd msg
 `;
 }
+function collect(value, previous) {
+  return previous.concat([value]);
+}
 
 main();

package/generator/src/codegen.js

@@ -1,4 +1,4 @@
-import * as fs from "fs";
+import * as fs from "node:fs";
 import * as fsExtra from "fs-extra/esm";
 import { rewriteElmJson } from "./rewrite-elm-json.js";
 import { rewriteClientElmJson } from "./rewrite-client-elm-json.js";

package/generator/src/copy-dir.js

@@ -1,5 +1,5 @@
-const util = require("util");
-const fsSync = require("fs");
+const util = require("node:util");
+const fsSync = require("node:fs");
 const fs = {
   writeFile: util.promisify(fsSync.writeFile),
   mkdir: util.promisify(fsSync.mkdir),

package/generator/src/dev-server.js

@@ -143,10 +143,11 @@ export async function start(options) {
     merge_vite_configs(
       {
         server: {
-          middlewareMode: "ssr",
+          middlewareMode: true,
           base: options.base,
           port: options.port,
         },
+        appType: "custom",
         configFile: false,
         root: process.cwd(),
         base: options.base,
@@ -155,50 +156,61 @@ export async function start(options) {
       config.vite
     )
   );
-  esbuild
-    .build({
-      entryPoints: ["./custom-backend-task"],
-      platform: "node",
-      assetNames: "[name]-[hash]",
-      chunkNames: "chunks/[name]-[hash]",
-      outExtension: { ".js": ".js" },
-      metafile: true,
-      bundle: true,
-      watch: true,
-      logLevel: "silent",
-
-      outdir: ".elm-pages/compiled-ports",
-      entryNames: "[dir]/[name]-[hash]",
-
-      plugins: [
-        {
-          name: "example",
-          setup(build) {
-            build.onEnd((result) => {
-              try {
-                global.portsFilePath = Object.keys(result.metafile.outputs)[0];
+
+  const ctx = await esbuild.context({
+    entryPoints: ["./custom-backend-task"],
+    platform: "node",
+    assetNames: "[name]-[hash]",
+    chunkNames: "chunks/[name]-[hash]",
+    outExtension: { ".js": ".mjs" },
+    format: "esm",
+    metafile: true,
+    bundle: true,
+    packages: "external",
+    logLevel: "silent",
+    outdir: ".elm-pages/compiled-ports",
+    entryNames: "[dir]/[name]-[hash]",
+
+    plugins: [
+      {
+        name: "example",
+        setup(build) {
+          build.onEnd(async (result) => {
+            try {
+              global.portsFilePath = Object.keys(result.metafile.outputs)[0];
+
+              clients.forEach((client) => {
+                client.response.write(`data: content.dat\n\n`);
+              });
+            } catch (e) {
+              const portBackendTaskFileFound =
+                globbySync("./custom-backend-task.*").length > 0;
+              if (portBackendTaskFileFound) {
+                // 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
+                const messages = (
+                  await esbuild.formatMessages(result.errors, {
+                    kind: "error",
+                    color: true,
+                  })
+                ).join("\n");
+                global.portsFilePath = {
+                  __internalElmPagesError: messages,
+                };
 
                 clients.forEach((client) => {
                   client.response.write(`data: content.dat\n\n`);
                 });
-              } catch (e) {}
-            });
-          },
+              } else {
+                global.portsFilePath = null;
+              }
+            }
+          });
         },
-      ],
-    })
-    .then((result) => {
-      console.log("Watching custom-backend-task...");
-    })
-    .catch((error) => {
-      const portBackendTaskFileFound =
-        globbySync("./custom-backend-task.*").length > 0;
-      if (portBackendTaskFileFound) {
-        // 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);
-      }
-    });
+      },
+    ],
+  });
+  await ctx.watch();
 
   const app = connect()
     .use(timeMiddleware())

package/generator/src/dir-helpers.js

@@ -1,6 +1,6 @@
-import * as util from "util";
-import * as fsSync from "fs";
-import * as path from "path";
+import * as util from "node:util";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
 
 const fs = {
   writeFile: util.promisify(fsSync.writeFile),
@@ -75,4 +75,3 @@ export async function copyDirNested(src, dest) {
     fs.copyFile(src, dest);
   }
 }
-

package/generator/src/error-formatter.js

@@ -58,9 +58,6 @@ function toKleurColor(color) {
       case "33BBC8": {
         return "cyan";
       }
-      case "33BBC8": {
-        return "cyan";
-      }
       case "FFFF00": {
         return "yellow";
       }

package/generator/src/file-helpers.js

@@ -1,4 +1,4 @@
-import * as fs from "fs";
+import * as fs from "node:fs";
 
 export function ensureDirSync(dirpath) {
   try {

package/generator/src/render-worker.js

@@ -1,15 +1,18 @@
 import * as renderer from "../../generator/src/render.js";
-import * as path from "path";
+import * as path from "node:path";
 import * as fs from "./dir-helpers.js";
-import { readFileSync, writeFileSync } from "fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { stat } from "fs/promises";
-import { parentPort, threadId, workerData } from "worker_threads";
+import { parentPort, threadId, workerData } from "node:worker_threads";
+import * as url from "url";
 
 async function run({ mode, pathname, serverRequest, portsFilePath }) {
   console.time(`${threadId} ${pathname}`);
   try {
     const renderResult = await renderer.render(
-      portsFilePath,
+      typeof portsFilePath === "string"
+        ? await import(url.pathToFileURL(path.resolve(portsFilePath)).href)
+        : portsFilePath,
       workerData.basePath,
       await requireElm(mode),
       mode,

package/generator/src/render.js

@@ -1,16 +1,18 @@
 // @ts-check
 
-import * as path from "path";
+import * as path from "node:path";
 import { default as mm } from "micromatch";
 import { default as matter } from "gray-matter";
-import { globby } from "globby";
-import * as fsPromises from "fs/promises";
+import * as globby from "globby";
+import * as fsPromises from "node:fs/promises";
 import * as preRenderHtml from "./pre-render-html.js";
 import { lookupOrPerform } from "./request-cache.js";
 import * as kleur from "kleur/colors";
 import * as cookie from "cookie-signature";
 import { compatibilityKey } from "./compatibility-key.js";
-import * as fs from "fs";
+import * as fs from "node:fs";
+import * as crypto from "node:crypto";
+import { restoreColorSafe } from "./error-formatter.js";
 
 process.on("unhandledRejection", (error) => {
   console.error(error);
@@ -76,17 +78,21 @@ export async function runGenerator(
   // 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)
   global.XMLHttpRequest = {};
-  const result = await runGeneratorAppHelp(
-    cliOptions,
-    portsFile,
-    "",
-    elmModule,
-    scriptModuleName,
-    "production",
-    "",
-    true
-  );
-  return result;
+  try {
+    const result = await runGeneratorAppHelp(
+      cliOptions,
+      portsFile,
+      "",
+      elmModule,
+      scriptModuleName,
+      "production",
+      "",
+      true
+    );
+    return result;
+  } catch (error) {
+    console.log(restoreColorSafe(error));
+  }
 }
 /**
  * @param {string} basePath
@@ -468,6 +474,16 @@ async function runInternalJob(
       ];
     } else if (requestToPerform.url === "elm-pages-internal://glob") {
       return [requestHash, await runGlobNew(requestToPerform, patternsToWatch)];
+    } else if (requestToPerform.url === "elm-pages-internal://randomSeed") {
+      return [
+        requestHash,
+        jsonResponse(
+          requestToPerform,
+          crypto.getRandomValues(new Uint32Array(1))[0]
+        ),
+      ];
+    } else if (requestToPerform.url === "elm-pages-internal://now") {
+      return [requestHash, jsonResponse(requestToPerform, Date.now())];
     } else if (requestToPerform.url === "elm-pages-internal://env") {
       return [requestHash, await runEnvJob(requestToPerform, patternsToWatch)];
     } else if (requestToPerform.url === "elm-pages-internal://encrypt") {
@@ -538,7 +554,7 @@ async function runWriteFileJob(req) {
 async function runGlobNew(req, patternsToWatch) {
   try {
     const { pattern, options } = req.body.args[0];
-    const matchedPaths = await globby(pattern, options);
+    const matchedPaths = await globby.globby(pattern, options);
     patternsToWatch.add(pattern);
 
     return jsonResponse(

package/generator/src/request-cache.js

@@ -10,7 +10,7 @@ const defaultHttpCachePath = "./.elm-pages/http-cache";
 /**
  * @param {string} mode
  * @param {{url: string;headers: {[x: string]: string;};method: string;body: Body;}} rawRequest
- * @param {string} portsFile
+ * @param {Record<string, unknown>} portsFile
  * @param {boolean} hasFsAccess
  * @returns {Promise<Response>}
  */
@@ -27,16 +27,12 @@ export function lookupOrPerform(
   return new Promise(async (resolve, reject) => {
     const request = toRequest(rawRequest);
 
-    let portBackendTask = {};
+    let portBackendTask = portsFile;
     let portBackendTaskImportError = null;
     try {
       if (portsFile === undefined) {
         throw "missing";
       }
-      const portBackendTaskPath = path.resolve(portsFile);
-      // On Windows, we need cannot use paths directly and instead must use a file:// URL.
-      // portBackendTask = await require(url.pathToFileURL(portBackendTaskPath).href);
-      portBackendTask = await import(portBackendTaskPath);
     } catch (e) {
       portBackendTaskImportError = e;
     }
@@ -45,7 +41,22 @@ export function lookupOrPerform(
       try {
         const { input, portName } = rawRequest.body.args[0];
 
-        if (!portBackendTask[portName]) {
+        if (portBackendTask === null) {
+          resolve({
+            kind: "response-json",
+            value: jsonResponse({
+              "elm-pages-internal-error": "MissingCustomBackendTaskFile",
+            }),
+          });
+        } else if (portBackendTask && portBackendTask.__internalElmPagesError) {
+          resolve({
+            kind: "response-json",
+            value: jsonResponse({
+              "elm-pages-internal-error": "ErrorInCustomBackendTaskFile",
+              error: portBackendTask.__internalElmPagesError,
+            }),
+          });
+        } else if (portBackendTask && !portBackendTask[portName]) {
           if (portBackendTaskImportError === null) {
             resolve({
               kind: "response-json",

package/generator/src/rewrite-client-elm-json.js

@@ -1,4 +1,4 @@
-import * as fs from "fs";
+import * as fs from "node:fs";
 
 export async function rewriteClientElmJson() {
   var elmJson = JSON.parse(

package/generator/src/rewrite-elm-json.js

@@ -1,4 +1,4 @@
-import * as fs from "fs";
+import * as fs from "node:fs";
 
 export async function rewriteElmJson(sourceElmJsonPath, targetElmJsonPath) {
   var elmJson = JSON.parse(

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elm-pages",
   "type": "module",
-  "version": "3.0.0-beta.19",
+  "version": "3.0.0-beta.20",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",
@@ -34,7 +34,7 @@
     "devcert": "^1.2.2",
     "elm-doc-preview": "^5.0.5",
     "elm-hot": "^1.1.6",
-    "esbuild": "^0.16.15",
+    "esbuild": "^0.17.5",
     "fs-extra": "^11.1.0",
     "globby": "^13.1.3",
     "gray-matter": "^4.0.3",

package/src/BackendTask/Random.elm

@@ -0,0 +1,79 @@
+module BackendTask.Random exposing
+    ( generate
+    , int32
+    )
+
+{-|
+
+@docs generate
+
+@docs int32
+
+-}
+
+import BackendTask exposing (BackendTask)
+import BackendTask.Http
+import BackendTask.Internal.Request
+import Json.Decode as Decode
+import Json.Encode as Encode
+import Random
+
+
+{-| Takes an `elm/random` `Random.Generator` and runs it using a randomly generated initial seed.
+
+    type alias Data =
+        { randomData : ( Int, Float )
+        }
+
+    data : BackendTask FatalError Data
+    data =
+        BackendTask.map Data
+            (BackendTask.Random.generate generator)
+
+    generator : Random.Generator ( Int, Float )
+    generator =
+        Random.map2 Tuple.pair (Random.int 0 100) (Random.float 0 100)
+
+The random initial seed is generated using <https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues>
+to generate a single 32-bit Integer. That 32-bit Integer is then used with `Random.initialSeed` to create an Elm Random.Seed value.
+Then that `Seed` used to run the `Generator`.
+
+Note that this is different than `elm/random`'s `Random.generate`. This difference shouldn't be problematic, and in fact the `BackendTask`
+random seed generation is more cryptographically independent because you can't determine the
+random seed based solely on the time at which it is run. Each time you call `BackendTask.generate` it uses a newly
+generated random seed to run the `Random.Generator` that is passed in. In contrast, `elm/random`'s `Random.generate`
+generates an initial seed using `Time.now`, and then continues with that same seed using using [`Random.step`](https://package.elm-lang.org/packages/elm/random/latest/Random#step)
+to get new random values after that. You can [see the implementation here](https://github.com/elm/random/blob/c1c9da4d861363cee1c93382d2687880279ed0dd/src/Random.elm#L865-L896).
+However, `elm/random` is still not suitable in general for cryptographic uses of random because it uses 32-bits for when it
+steps through new seeds while running a single `Random.Generator`.
+
+-}
+generate : Random.Generator value -> BackendTask error value
+generate generator =
+    int32
+        |> BackendTask.map
+            (Random.initialSeed
+                >> Random.step generator
+                >> Tuple.first
+            )
+
+
+{-| Gives a random 32-bit Int. This can be useful if you want to do low-level things with a cryptographically sound
+random 32-bit integer.
+
+The value comes from running this code in Node using <https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues>:
+
+```js
+import * as crypto from "node:crypto";
+
+crypto.getRandomValues(new Uint32Array(1))[0]
+```
+
+-}
+int32 : BackendTask error Int
+int32 =
+    BackendTask.Internal.Request.request
+        { name = "randomSeed"
+        , body = BackendTask.Http.jsonBody Encode.null
+        , expect = BackendTask.Http.expectJson Decode.int
+        }

package/src/BackendTask/Time.elm

@@ -0,0 +1,47 @@
+module BackendTask.Time exposing (now)
+
+{-|
+
+@docs now
+
+-}
+
+import BackendTask exposing (BackendTask)
+import BackendTask.Http
+import BackendTask.Internal.Request
+import Json.Decode as Decode
+import Json.Encode as Encode
+import Time
+
+
+{-| Gives a `Time.Posix` of when the `BackendTask` executes.
+
+    type alias Data =
+        { time : Time.Posix
+        }
+
+    data : BackendTask FatalError Data
+    data =
+        BackendTask.map Data
+            BackendTask.Time.now
+
+It's better to use [`Server.Request.requestTime`](Server-Request#requestTime) or `Pages.builtAt` when those are the semantics
+you are looking for. `requestTime` gives you a single reliable and consistent time for when the incoming HTTP request was received in
+a server-rendered Route or server-rendered API Route. `Pages.builtAt` gives a single reliable and consistent time when the
+site was built.
+
+`BackendTask.Time.now` gives you the time that it happened to execute, which might give you what you need, but be
+aware that the time you get is dependent on how BackendTask's are scheduled and executed internally in elm-pages, and
+its best to avoid depending on that variation when possible.
+
+-}
+now : BackendTask error Time.Posix
+now =
+    BackendTask.Internal.Request.request
+        { name = "now"
+        , body =
+            BackendTask.Http.jsonBody Encode.null
+        , expect =
+            BackendTask.Http.expectJson
+                (Decode.int |> Decode.map Time.millisToPosix)
+        }

package/src/Pages/Internal/Form.elm

@@ -22,9 +22,16 @@ type Response error
     = Response
         { fields : List ( String, String )
         , errors : Dict String (List error)
+        , clientErrors : Dict String (List error)
         }
 
 
-unwrapResponse : Response error -> { fields : List ( String, String ), errors : Dict String (List error) }
+unwrapResponse :
+    Response error
+    ->
+        { fields : List ( String, String )
+        , errors : Dict String (List error)
+        , clientErrors : Dict String (List error)
+        }
 unwrapResponse (Response response) =
     response

package/src/Server/Request.elm

@@ -906,19 +906,17 @@ formDataWithServerValidation formParsers =
                                                     ( Pages.Internal.Form.Response
                                                         { fields = rawFormData_
                                                         , errors = Dict.empty
+                                                        , clientErrors = Dict.empty
                                                         }
                                                     , decodedFinal
                                                     )
 
-                                            ( _, maybeErrors ) ->
+                                            _ ->
                                                 Err
                                                     (Pages.Internal.Form.Response
                                                         { fields = rawFormData_
-                                                        , errors =
-                                                            maybeErrors
-                                                                |> Maybe.map List.NonEmpty.toList
-                                                                |> Maybe.withDefault []
-                                                                |> Dict.fromList
+                                                        , errors = errors2
+                                                        , clientErrors = errors
                                                         }
                                                     )
                                     )
@@ -933,6 +931,7 @@ formDataWithServerValidation formParsers =
                                         |> Maybe.map List.NonEmpty.toList
                                         |> Maybe.withDefault []
                                         |> Dict.fromList
+                                , clientErrors = Dict.empty
                                 }
                             )
                             |> BackendTask.succeed
@@ -943,7 +942,7 @@ formDataWithServerValidation formParsers =
 {-| -}
 formData :
     Form.ServerForms error combined
-    -> Parser ( Form.Response error, Result { fields : List ( String, String ), errors : Dict String (List error) } combined )
+    -> Parser ( Form.Response error, Result { fields : List ( String, String ), errors : Dict String (List error), clientErrors : Dict String (List error) } combined )
 formData formParsers =
     rawFormData
         |> andThen
@@ -956,17 +955,18 @@ formData formParsers =
                 in
                 case ( maybeDecoded, errors |> Dict.toList |> List.filter (\( _, value ) -> value |> List.isEmpty |> not) |> List.NonEmpty.fromList ) of
                     ( Just decoded, Nothing ) ->
-                        ( Pages.Internal.Form.Response { fields = [], errors = Dict.empty }
+                        ( Pages.Internal.Form.Response { fields = [], errors = Dict.empty, clientErrors = Dict.empty }
                         , Ok decoded
                         )
                             |> succeed
 
                     ( _, maybeErrors ) ->
                         let
-                            record : { fields : List ( String, String ), errors : Dict String (List error) }
+                            record : { fields : List ( String, String ), errors : Dict String (List error), clientErrors : Dict String (List error) }
                             record =
                                 { fields = rawFormData_
-                                , errors =
+                                , errors = Dict.empty
+                                , clientErrors =
                                     maybeErrors
                                         |> Maybe.map List.NonEmpty.toList
                                         |> Maybe.withDefault []