querysub 0.155.0 → 0.157.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.155.0",
+  "version": "0.157.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -24,7 +24,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "preact": "^10.11.3",
-    "socket-function": "^0.88.0",
+    "socket-function": "^0.89.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.6.3",
     "yaml": "^2.5.0",

package/src/-b-authorities/cloudflareHelpers.ts

@@ -3,7 +3,8 @@ import { getArchives } from "../-a-archives/archives";
 import { lazy } from "socket-function/src/caching";
 import { getStorageDir, getSubFolder } from "../fs";
 import fs from "fs";
-export const keys = getArchives("keys");
+import { isNodeTrue } from "socket-function/src/misc";
+export const keys = isNodeTrue() && getArchives("keys");
 
 export const getCloudflareCreds = lazy(async (): Promise<{ key: string; email: string }> => {
     let credsJSON = await keys.get("cloudflare.json");

package/src/-b-authorities/dnsAuthority.ts

@@ -1,7 +1,7 @@
 import os from "os";
 import * as fs from "fs";
 import { cache, lazy } from "socket-function/src/caching";
-import { isNode } from "socket-function/src/misc";
+import { isNode, isNodeTrue } from "socket-function/src/misc";
 import { httpsRequest } from "../https";
 import { getStorageDir } from "../fs";
 import { SocketFunction } from "socket-function/SocketFunction";
@@ -16,7 +16,7 @@ const DNS_TTLSeconds = {
     "A": 60,
 };
 
-export const keys = getArchives("keys");
+export const keys = isNodeTrue() && getArchives("keys");
 
 export const hasDNSWritePermissions = lazy(async () => {
     if (!isNode()) return false;

package/src/-f-node-discovery/NodeDiscovery.ts

@@ -243,13 +243,12 @@ export async function triggerNodeChange() {
     }));
 }
 
-let seenNodesForEvilDNS = new Set<string>();
 async function syncArchives() {
     if (isServer()) {
         // Make sure we are present
         await writeHeartbeat();
         let nodeIds = await archives().find("");
-        console.log(green(`Syncing archives`), { nodeIds });
+        console.log(green(`Syncing node ids from archives`), { nodeIds });
         setNodeIds(nodeIds);
     } else {
         if (isNoNetwork() || !isNode()) {

package/src/0-path-value-core/archiveLocks/ArchiveLocks2.ts

@@ -18,7 +18,6 @@ import { logNodeStateStats, logNodeStats } from "../../-0-hooks/hooks";
 /** Clean up old files after a while */
 const DEAD_CREATE_THRESHOLD = timeInHour * 12;
 const ARCHIVE_PROPAGATION_TIME = 5000;
-const LOG = false;
 // NOTE: There isn't a reason for transaction to not apply. If applying throws, we throw,
 //  and can throw infinite times, but if it doesn't throw, it SHOULD be applied. We retry
 //  a few times though, just in case the storage system was having some issues. After enough
@@ -309,9 +308,7 @@ class TransactionLocker {
     }
     public async createConfirm(key: string) {
         let path = this.getConfirmKey(key);
-        if (LOG) {
-            console.log(`Creating confirmation for ${key}`);
-        }
+        diskLog(`Creating confirmation for ${key}`);
         await this.storage.setValue(path, Buffer.from(""));
         return path;
     }
@@ -363,9 +360,10 @@ class TransactionLocker {
             delete: ellipsize(deletes.map(a => debugFileInfo(a.key)).join(","), 50),
         });
 
-        if (LOG) {
-            console.log(`Writing transaction ${transaction.seqNum} with ${transaction.ops.length} ops`);
-        }
+        diskLog(`Writing transaction`, {
+            name,
+            ops: transaction.ops.length,
+        });
 
         let key = `transaction_${name}.transaction`;
         let strippedTransaction: Transaction = { ops: transaction.ops.map(a => ({ ...a, value: undefined })) };
@@ -490,10 +488,8 @@ class TransactionLocker {
         while (true) {
             let result = await tryToRead();
             if (result) {
-                if (LOG) {
-                    let timeToRead = Date.now() - startTime;
-                    console.log(`Read data state in ${formatTime(timeToRead)}`);
-                }
+                let timeToRead = Date.now() - startTime;
+                diskLog(`Read data state in ${formatTime(timeToRead)}`);
                 return result;
             }
         }
@@ -532,20 +528,20 @@ class TransactionLocker {
         let rawLookup = new Set(Array.from(rawDataFiles).map(a => a.file));
         // If any creates are not confirmed, it must not have been applied
         if (transaction.ops.some(a => a.type === "create" && rawLookup.has(a.key) && !confirmedKeys.has(a.key))) {
-            if (LOG) {
-                console.log(`Transaction has pending confirmations of creates.`);
-                let pending = transaction.ops.filter(a => a.type === "create" && rawLookup.has(a.key) && !confirmedKeys.has(a.key));
-                for (let p of pending) {
-                    console.log(`    ${p.key}`);
-                }
-            }
+            diskLog(`Transaction not applied (has pending confirmations of creates)`, {
+                keys: transaction.ops
+                    .filter(a => a.type === "create" && rawLookup.has(a.key) && !confirmedKeys.has(a.key))
+                    .map(a => a.key)
+            });
             return false;
         }
         // If any deletes still exist, it must not have been applied
         if (transaction.ops.some(a => a.type === "delete" && confirmedKeys.has(a.key))) {
-            if (LOG) {
-                console.log(`transaction has pending deletes`);
-            }
+            diskLog(`Transaction not applied (has pending deletes)`, {
+                keys: transaction.ops
+                    .filter(a => a.type === "delete" && confirmedKeys.has(a.key))
+                    .map(a => a.key)
+            });
             return false;
         }
         return true;
@@ -554,9 +550,9 @@ class TransactionLocker {
         let createCount = transaction.ops.filter(a => a.type === "create").length;
         let deleteCount = transaction.ops.filter(a => a.type === "delete").length;
         let lockedFiles = transaction.lockedFilesMustEqual?.length;
-        if (LOG) {
-            console.log(`Applying transaction with ${createCount} creates and ${deleteCount} deletes. ${lockedFiles !== undefined && `Lock state depends on ${lockedFiles} files` || ""}`);
-        }
+        diskLog(`Applying transaction with ${createCount} creates and ${deleteCount} deletes. ${lockedFiles !== undefined && `Lock state depends on ${lockedFiles} files` || ""}`, {
+            transactions: transaction.ops.map(x => JSON.stringify(x)),
+        });
         logNodeStats(`archives|TΔ Apply`, formatNumber, 1);
         let opsRemaining = transaction.ops.slice();
         // NOTE: Order doesn't matter here. If anything is reading the values
@@ -580,9 +576,9 @@ class TransactionLocker {
         };
         await Promise.all(list(CONCURRENT_WRITE_COUNT).map(runThread));
 
-        if (LOG) {
-            console.log(`Applied transaction with ${createCount} creates and ${deleteCount} deletes. ${lockedFiles !== undefined && `Lock state depends on ${lockedFiles} files` || ""}`);
-        }
+        diskLog(`Applied transaction with ${createCount} creates and ${deleteCount} deletes. ${lockedFiles !== undefined && `Lock state depends on ${lockedFiles} files` || ""}`, {
+            transactions: transaction.ops.map(x => JSON.stringify(x)),
+        });
     }
 
     /** Only returns data files (no transaction files, or confirmations).
@@ -646,9 +642,7 @@ class TransactionLocker {
         let threshold = activeT.createTime + this.storage.propagationTime;
         if (Date.now() < threshold) {
             let waitTime = threshold - Date.now();
-            if (LOG) {
-                console.log(`Waiting ${formatTime(waitTime)} for transaction ${activeT.seqNum} to settle.`);
-            }
+            diskLog(`Waiting ${formatTime(waitTime)} for transaction ${activeT.seqNum} to settle.`);
             await new Promise(resolve => setTimeout(resolve, waitTime));
             return this.getFilesBase();
         }
@@ -688,9 +682,7 @@ class TransactionLocker {
                     //  triggered (without this check), and deletes all of our files...
                     let unconfirmedOldFiles2 = veryOldFiles.filter(a => !doubleCheckLookup.has(a) && doubleCheckDataFiles.has(a.file));
                     console.warn(red(`Deleted ${unconfirmedOldFiles2.length} very old unconfirmed files`));
-                    if (LOG) {
-                        logNodeStats(`archives|TΔ Delete Old Rejected File`, formatNumber, unconfirmedOldFiles2.length);
-                    }
+                    diskLog(`archives|TΔ Delete Old Rejected File`, formatNumber, unconfirmedOldFiles2.length);
                     // At the point the file was very old when we started reading, not part of the active transaction.
                     for (let file of unconfirmedOldFiles2) {
                         await this.deleteDataFile(file.file, `old unconfirmed file (${getOwnNodeId()}, ${process.argv[1]})`);
@@ -706,10 +698,8 @@ class TransactionLocker {
                 let oldEnoughConfirms = dataState.rawDataFiles.filter(x => x.file.endsWith(".confirm") && x.createTime < oldThreshold);
                 let deprecatedFiles = oldEnoughConfirms.filter(a => !usedConfirmations.has(a.file));
                 if (deprecatedFiles.length > 0) {
-                    if (LOG) {
-                        console.warn(red(`Deleted ${deprecatedFiles.length} / ${oldEnoughConfirms.length} confirmations, for not having corresponding data files`));
-                        logNodeStats(`archives|TΔ Delete Deprecated Confirm`, formatNumber, deprecatedFiles.length);
-                    }
+                    console.warn(red(`Deleted ${deprecatedFiles.length} / ${oldEnoughConfirms.length} confirmations, for not having corresponding data files`));
+                    logNodeStats(`archives|TΔ Delete Deprecated Confirm`, formatNumber, deprecatedFiles.length);
                     for (let file of deprecatedFiles) {
                         await this.storage.deleteKey(file.file);
                     }
@@ -744,12 +734,10 @@ class TransactionLocker {
 
     /** If any deleted files were deleted by other transactions, then we will be rejected. */
     public async addTransaction(transaction: Transaction): Promise<"accepted" | "rejected"> {
-        if (LOG) {
-            let dels = transaction.ops.filter(a => a.type === "delete").length;
-            let creates = transaction.ops.filter(a => a.type === "create").length;
-            let createBytes = transaction.ops.map(a => a.type === "create" && a.value?.length || 0).reduce((a, b) => a + b, 0);
-            console.log(blue(`Starting transaction with ${creates} creates and ${dels} deletes, ${formatNumber(createBytes)}B`));
-        }
+        let dels = transaction.ops.filter(a => a.type === "delete").length;
+        let creates = transaction.ops.filter(a => a.type === "create").length;
+        let createBytes = transaction.ops.map(a => a.type === "create" && a.value?.length || 0).reduce((a, b) => a + b, 0);
+        diskLog(`Starting transaction with ${creates} creates and ${dels} deletes, ${formatNumber(createBytes)}B`);
         transaction = { ...transaction, ops: transaction.ops.slice() };
         function normalizePath(path: string) {
             // Replace duplicate slashes with a single slash
@@ -775,9 +763,7 @@ class TransactionLocker {
             let beforeData = await this.getFilesBase();
             if (!this.isTransactionValid(transaction, beforeData.dataFiles, beforeData.rawDataFiles)) {
                 logNodeStats(`archives|TΔ Rejected`, formatNumber, 1);
-                if (LOG) {
-                    console.log(red(`Finished transaction with rejection, ${transaction.ops.length} ops`));
-                }
+                diskLog(`Finished transaction with rejection, ${transaction.ops.length} ops`);
                 return "rejected";
             }
 
@@ -786,9 +772,7 @@ class TransactionLocker {
             let afterData = await this.getFilesBase();
             if (this.wasTransactionApplied(transaction, afterData.dataFiles, afterData.rawDataFiles)) {
                 logNodeStats(`archives|TΔ Accepted`, formatNumber, 1);
-                if (LOG) {
-                    console.log(green(`Finished transaction with ${transaction.ops.length} ops`));
-                }
+                diskLog(`Finished transaction with ${transaction.ops.length} ops`);
                 return "accepted";
             }
         }

package/src/2-proxy/archiveMoveHarness.ts

@@ -1,7 +1,3 @@
-
-
-// yarn typenode src\framework-beta\archiveMoveBase\archiveMoveHarness.ts --nonetwork
-
 import { formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { blue, green, red } from "socket-function/src/formatting/logColors";
 import { measureBlock, measureWrap } from "socket-function/src/profiling/measure";
@@ -22,6 +18,7 @@ import debugbreak from "debugbreak";
 let lastFileWrites = new Map<string, string[]>();
 
 export async function runArchiveMover(config: {
+    debugName: string;
     // Defaults to getOurAuthorities
     //  NOTE: Runs once per authority, as we want to keep data as sharded as possible
     authorities?: AuthorityPath[];
@@ -307,10 +304,11 @@ export async function runArchiveMover(config: {
             || lastResult === "aborted" && green("noop")
             || red("rejected")
         );
-        console.log(`ArchiveMover ${config.runMover.name} on ${authorityDir} in ${formatTime(time)}. Result = ${resultFormat}.`);
+        console.log(`ArchiveMover ${config.debugName ?? config.runMover.name} on ${authorityDir} in ${formatTime(time)}. Result = ${resultFormat}.`);
         if (lastResult === "accepted" && !abortedDueToInsufficientReduction) {
             console.log(
-                `    { files: ${formatNumber(inputFiles)}, values: ${formatNumber(inputValueCount)}, bytes: ${formatNumber(inputBytes)} }`
+                `ArchiveMover free committed ${config.debugName ?? config.runMover.name} on ${authorityDir}`
+                + `    { files: ${formatNumber(inputFiles)}, values: ${formatNumber(inputValueCount)}, bytes: ${formatNumber(inputBytes)} }`
                 + "\n=>\n"
                 + `    { files: ${formatNumber(outputFiles)}, values: ${formatNumber(outputValueCount)}, bytes: ${formatNumber(outputBytes)} }`
                 ,

package/src/2-proxy/garbageCollection.ts

@@ -542,6 +542,7 @@ export async function runAliveCheckerIteration(config?: {
 
             let lockWrites: PathValue[] = [];
             await runArchiveMover({
+                debugName: type,
                 outputType: type,
                 readLiveData: example.unsafeLiveReads,
                 force: config?.force,
@@ -719,7 +720,15 @@ export async function runAliveCheckerIteration(config?: {
                     }
 
                     let allFrees = new Set(freeLists.flat().flat().map(x => x.value));
+                    let allValues = values;
                     values = values.filter(x => !allFrees.has(x));
+                    if (allValues.length !== values.length) {
+                        console.log("Freeding values due to garbage collection", {
+                            before: allValues.length,
+                            after: values.length,
+                            freed: allValues.length - values.length,
+                        });
+                    }
 
                     // NOTE: We don't notify any servers about this. We will eventually have to write
                     //  audit code to periodically check against the disk to get updates.

package/src/3-path-functions/pathFunctionLoader.ts

@@ -23,6 +23,7 @@ import { getControllerNodeId, getControllerNodeIdList } from "../-g-core-values/
 import { sha256 } from "js-sha256";
 import os from "os";
 import { formatTime } from "socket-function/src/formatting/format";
+import path from "path";
 
 export type LoadFunctionSpec = {
     gitURL: string;
@@ -169,7 +170,7 @@ let moduleResolver = async (spec: {
 
             // Remove any previous attempt to sync it
             if (fs.existsSync(repoPath)) {
-                await fs.promises.rename(repoPath, repoPath.slice(0, -1) + "_" + Date.now());
+                await fs.promises.rmdir(repoPath, { recursive: true });
             }
             // Clone it
             await executeCommand("git", ["clone", gitURL, repoPath]);
@@ -178,6 +179,14 @@ let moduleResolver = async (spec: {
             // Yarn install
             await executeCommand("yarn", ["install"], { cwd: repoPath });
 
+            // Delete querysub, and replace it with a symlink. Otherwise the synchronization code
+            //  will run again, and a lot of setup code will run again, etc, and nothing will work correctly.
+            let querysubPath = repoPath + "node_modules/querysub";
+            await fs.promises.rmdir(querysubPath, { recursive: true });
+
+            let actualQuerysubPath = path.resolve("./node_modules/querysub");
+            await fs.promises.symlink(actualQuerysubPath, querysubPath, "junction");
+
             // Mark it as loaded. If we don't reach this point we will move the folder and try again next time
             await fs.promises.writeFile(repoPath + loadTimeIndicatorFileName, Date.now() + "");
 
@@ -186,15 +195,6 @@ let moduleResolver = async (spec: {
         });
     }
 
-    let querysubPath = repoPath + "node_modules/querysub";
-    if (fs.existsSync(querysubPath)) {
-        // By moving querysub, it forces the repo to use the parent querysub. This is nice, as it even
-        //  works when this code is required clientside!
-        //  - Recursive deletes are slow, but moving is fast, so just move it. This repos don't update anyways
-        //      (we have one per hash), so it's not this will fill up with moved files.
-        await fs.promises.rename(querysubPath, querysubPath + "_" + Date.now());
-    }
-
     return repoPath;
 };
 

package/src/4-deploy/edgeNodes.ts

@@ -7,7 +7,7 @@ import { getArchivesBackblazePublic } from "../-a-archives/archivesBackBlaze";
 import { nestArchives } from "../-a-archives/archives";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { runInSerial, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
-import { compare, compareArray, timeInMinute } from "socket-function/src/misc";
+import { compare, compareArray, isNodeTrue, timeInMinute } from "socket-function/src/misc";
 import { cacheLimited, lazy } from "socket-function/src/caching";
 import { canHaveChildren } from "socket-function/src/types";
 import { shutdown } from "../diagnostics/periodic";
@@ -29,7 +29,7 @@ import { startEdgeNotifier } from "./edgeClientWatcher";
 const UPDATE_POLL_INTERVAL = timeInMinute;
 const DEAD_NODE_COUNT_THRESHOLD = 15;
 
-const edgeNodeStorage = nestArchives("edgenodes/", getArchivesBackblazePublic(getDomain()));
+const edgeNodeStorage = isNodeTrue() && nestArchives("edgenodes/", getArchivesBackblazePublic(getDomain()));
 const edgeNodeIndexFile = "edge-nodes-index.json";
 
 const getEdgeNodeConfig = cacheLimited(10000, async (fileName: string): Promise<EdgeNodeConfig | undefined> => {
@@ -206,6 +206,7 @@ async function runEdgeNodesAliveCheck() {
     for (let [fileName, count] of Array.from(deadCounts)) {
         if (count < DEAD_NODE_COUNT_THRESHOLD) continue;
         console.log(`Node is dead. Removing from edgeNodes.`, { fileName, count });
+        deadCounts.delete(fileName);
         await edgeNodeStorage.del(fileName);
     }
 }

package/src/4-querysub/Querysub.ts

@@ -43,7 +43,6 @@ import { measureBlock, measureFnc } from "socket-function/src/profiling/measure"
 import { delay } from "socket-function/src/batching";
 import { MaybePromise } from "socket-function/src/types";
 import { devDebugbreak, getDomain, isDevDebugbreak, isDynamicallyLoading, isNoNetwork, isPublic } from "../config";
-import { hookErrors } from "../diagnostics/errorLogs/hookErrors";
 import { Schema2, Schema2T, t } from "../2-proxy/schema2";
 import { CALL_PERMISSIONS_KEY } from "./permissionsShared";
 import { isDynamicModule } from "../3-path-functions/pathFunctionLoader";
@@ -953,9 +952,12 @@ setImmediate(() => {
     });
 });
 
-setImmediate(() => {
-    hookErrors();
-});
+if (isNode()) {
+    setImmediate(async () => {
+        const { hookErrors } = await import("../diagnostics/errorLogs/hookErrors");
+        hookErrors();
+    });
+}
 
 setImmediate(async () => {
     // Import, so it registers addStatPeriodic

package/src/archiveapps/archiveMergeEntry.tsx

@@ -10,6 +10,7 @@ const MERGE_DELAY = timeInHour;
 
 async function mergeFiles() {
     await runArchiveMover({
+        debugName: "merge",
         outputType: "merge",
         async runMover(config) {
             let values = config.values;

package/src/config.ts

@@ -62,7 +62,7 @@ export function authorityRaw() {
 
 export function isPublic() {
     if (!isNode()) {
-        return !location.hostname.startsWith("noproxy.");
+        return !location.hostname.startsWith("127-0-0-1.");
     }
     return !!yargObj.public;
 }

package/src/diagnostics/errorLogs/ErrorLogController.ts

@@ -19,7 +19,6 @@ import { atomic, doAtomicWrites } from "../../2-proxy/PathValueProxyWatcher";
 import { isClient } from "../../config2";
 import { ControllerPick, SocketRegistered } from "socket-function/SocketFunctionTypes";
 
-
 const NOTIFY_HISTORY = timeInDay * 7;
 // Only error / fatal are tracked, for now... we might also add warns?
 const logIssueNotifyTypes: LogType[] = ["error", "fatal"];

package/src/diagnostics/errorLogs/LogTimeSelector.tsx

@@ -14,7 +14,6 @@ import { ButtonSelector } from "../../library-components/ButtonSelector";
 import { Icon } from "../../library-components/icons";
 import { MeasuredDiv } from "../../library-components/MeasuredDiv";
 
-
 type RangeSize = "lastYear" | "lastMonth" | "lastWeek" | "lastDay" | "lastHour";
 export let logNowTime = Date.now();
 const logFilterStart = new URLParam<number | RangeSize>("logFilterStartTime", "lastWeek");

package/src/diagnostics/managementPages.tsx

@@ -18,7 +18,6 @@ import { getNextTime } from "../0-path-value-core/pathValueCore";
 import { encodeArgs } from "../3-path-functions/PathFunctionHelpers";
 import { CallSpec, getCurrentCall, getCurrentCallAllowUndefined, overrideCurrentCall } from "../3-path-functions/PathFunctionRunner";
 import { createLazyComponent } from "../library-components/LazyComponent";
-import { LogNotify } from "./errorLogs/LogNotify";
 import { isTrusted } from "../-d-trust/NetworkTrust2";
 import { devDebugbreak, getDomain } from "../config";
 import { getCallWrites } from "../4-querysub/querysubPrediction";
@@ -27,7 +26,9 @@ import * as hooks from "../-0-hooks/hooks";
 import { addComponentUI } from "../5-diagnostics/qreactDebug";
 import { addComponentButton } from "../5-diagnostics/qreactDebug";
 import { closeAllModals } from "../5-diagnostics/Modal";
+import { delay } from "socket-function/src/batching";
 
+const LogNotify = createLazyComponent(() => import("./errorLogs/LogNotify"))("LogNotify");
 
 export const managementPageURL = new URLParam("managementpage", "");
 export const showingManagementURL = new URLParam("showingmanagement", false);
@@ -134,14 +135,21 @@ export async function registerManagementPages2(config: {
     __schema = config.schema;
 
     setImmediate(async () => {
-        if (!isNode() && !await ManagementController.nodes[getBrowserUrlNode()].isManagementUser()) return;
+        if (!isNode() &&
+            !await ManagementController.nodes[getBrowserUrlNode()].isManagementUser()
+            && new URLSearchParams(window.location.search).get("dropto") !== "user"
+        ) return;
+
+        // Wait, so the import system knows the modules are async imports
+        await delay(0);
+
+        const ComponentSyncStats = createLazyComponent(() => import("./misc-pages/ComponentSyncStats"))("ComponentSyncStats");
 
-        const { filtersURL } = await import("./misc-pages/archiveViewerShared");
-        const { watchValueType } = await import("./misc-pages/LocalWatchViewer");
-        const { ComponentSyncStats } = await import("./misc-pages/ComponentSyncStats");
         addComponentButton({
             title: "View in Path Navigator",
-            callback(component) {
+            async callback(component) {
+                const { filtersURL } = await import("./misc-pages/archiveViewerShared");
+                const { watchValueType } = await import("./misc-pages/LocalWatchViewer");
                 filtersURL.value[nextId()] = { column: "path", match: component.debugName, type: "and" };
                 managementPageURL.value = "LocalWatchViewer";
                 watchValueType.value = "component";
@@ -168,6 +176,8 @@ export async function registerManagementPages2(config: {
     }
 
     if (isServer()) {
+        // Wait, so the import system knows the modules are async imports
+        await delay(0);
         for (let page of inputPages) {
             // NOTE: If we split this into a module for component/controller, we need to make sure we
             //  import both serverside, so we can whitelist them for import clientside.

package/src/user-implementation/loginEmail.tsx

@@ -114,11 +114,11 @@ export function generateLoginEmail(config: {
                 <td {...{ "nowrap": true }} style={{ paddingLeft: "40px", }}></td>
             </tr></tbody></table>
             <table><tbody><tr><td style={{ paddingTop: "20px" }}></td></tr></tbody></table>
-            {line(<div style={{ color: "rgb(140, 140, 140)", width: "100%" }}><b>Do NOT share or forward this email with anyone.</b></div>)}
+            {line(<div style={{ color: "rgb(140, 140, 140)", width: "100%" }}><b>Do NOT share or forward this email to anyone.</b></div>)}
             <table><tbody><tr><td style={{ paddingTop: "10px" }}></td></tr></tbody></table>
             {line(<div style={{ color: "rgb(140, 140, 140)", width: "100%" }}>
-                This link will only work with the current device and browser.
-                This link can only be used one time, until {new Date(config.timeoutTime).toLocaleString()}.
+                This link will only work in the current device and browser.
+                This link can only be used one time, and will expire at {new Date(config.timeoutTime).toLocaleString()}.
             </div>)}
         </>
     );