socket-function 0.17.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.17.0",
+	"version": "0.19.0",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/require/RequireController.ts

@@ -3,7 +3,7 @@ import debugbreak from "debugbreak";
 import fs from "fs";
 import { SocketFunction } from "../SocketFunction";
 import { getCurrentHTTPRequest, setHTTPResultHeaders } from "../src/callHTTPHandler";
-import { formatNumberSuffixed, isNodeTrue, sha256Hash, sha256HashPromise } from "../src/misc";
+import { formatNumberSuffixed, isNode, isNodeTrue, sha256Hash, sha256HashPromise } from "../src/misc";
 import zlib from "zlib";
 import { cacheLimited } from "../src/caching";
 import { formatNumber } from "../src/formatting/format";
@@ -35,6 +35,15 @@ declare global {
             // Times are both unique (two modules evaluated at the same Date.now() will have different values).
             evalStartTime?: number;
             evalEndTime?: number;
+
+            /** (Presently only called by require.js)
+             *      Called on require calls, to allow providers to create custom exports depending on the caller.
+             *          - Mostly used to allow functions to know the calling module.
+             */
+            remapExports?: (exports: { [key: string]: unknown }, callerModule: NodeJS.Module) => { [key: string]: unknown };
+
+            /** Only set if clientside (and allowed clientside) */
+            source?: string;
         }
     }
     interface Window {
@@ -43,6 +52,16 @@ declare global {
     var suppressUnexpectedModuleWarning: number | undefined;
 }
 
+/** Imports it, serverside, delayed. For dynamic imports, which we need to include once, but don't want to include
+ *      immediately (due to cyclic issues), and isn't included initially.
+ */
+export function lazyImport(getModule: () => Promise<unknown>) {
+    if (!isNode()) return;
+    // Import it, asynchronously, so it isn't preloaded, but it is available for clientside imports.
+    //  NOTE: We track delayed imports (somewhere), and don't preload them by default in RequireController.
+    void Promise.resolve().then(() => getModule());
+}
+
 export interface SerializedModule {
     originalId: string;
     filename: string;

package/require/require.js

@@ -240,7 +240,7 @@
             return requestsResolvedPaths.map(x => getModule(x));
         } finally {
             time = Date.now() - time;
-            console.log(`%cimport(${requests.join(", ")}) finished evaluate ${time}ms (${moduleCount} modules) at ${Date.now() - startTime}ms`, "color: blue");
+            console.log(`%cimport(${requests.join(", ")}) finished evaluate ${time}ms (${moduleCount} modules) at ${Date.now() - startTime}ms`, "color: lightblue");
         }
     }
 
@@ -326,8 +326,6 @@
                             if (property === unloadedModule) return true;
                             if (property === "default") return exportsOverride;
 
-                            serializedModule;
-
                             console.warn(`Accessed non-whitelisted module %c${childId}%c, specifically property %c${String(property)}%c.\n\tAdd %cmodule.allowclient = true%c to the file to allow access.\n\t(IF it is a 3rd party library, use the global "setFlag" helper (in the file you imported the module) to set properties on other modules (it can even recursively set properties)).\n\n\tFrom ${module.id}`,
                                 "color: red", "color: unset",
                                 "color: red", "color: unset",
@@ -343,12 +341,19 @@
                 return exportsOverride;
             }
 
-            let childModule = getModule(resolvedPath);
-            module.children.push(childModule);
+            let providerModule = getModule(resolvedPath);
+            module.children.push(providerModule);
             if (exportsOverride !== undefined) {
-                childModule.exports = exportsOverride;
+                providerModule.exports = exportsOverride;
+            }
+
+            let exports = providerModule.exports;
+            let remapExports = providerModule.remapExports;
+            if (remapExports && typeof remapExports === "function")  {
+                exports = remapExports(exports, module);
             }
-            return childModule.exports;
+
+            return exports;
         };
     }
 
@@ -445,6 +450,7 @@
             }
 
             module.size = source.length;
+            module.source = source;
 
             let moduleFnc = wrapSafe(module.id, source);
 

package/src/CallFactory.ts

@@ -589,8 +589,6 @@ export async function createCallFactory(
             } else if (err.includes("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.")) {
                 console.error(`WebSocket data was dropped by the browser due to exceeding the Blob limit. Either you are about to run out of memory, or you hit the much lower Incognito Blob limit. This will likely break the application. To reset the memory you must close all tabs of this site. This is a bug/feature in chrome.`);
             } else {
-                debugbreak(2);
-                debugger;
                 console.error(e.stack);
             }
         }
@@ -655,23 +653,14 @@ const compressObj = measureWrap(async function wireCallCompress(obj: unknown): P
     return result;
 });
 const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer): Promise<unknown> {
-    try {
-        let buffer = await unzipBase(obj);
-        let lengthBuffer = buffer.slice(0, 8);
-        let lengths = new Float64Array(lengthBuffer.buffer, lengthBuffer.byteOffset, lengthBuffer.byteLength / 8);
-        let buffers: Buffer[] = [];
-        let offset = 8;
-        for (let length of lengths) {
-            buffers.push(buffer.slice(offset, offset + length));
-            offset += length;
-        }
-
-        return await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
-    } catch (e) {
-        // We were encountering issues with the checksum failing when unzipping. Presumably if the data
-        //      is bad deserialize will also fail. I can't repro it anymore though...
-        debugbreak(2);
-        debugger;
-        throw e;
+    let buffer = await unzipBase(obj);
+    let lengthBuffer = buffer.slice(0, 8);
+    let lengths = new Float64Array(lengthBuffer.buffer, lengthBuffer.byteOffset, lengthBuffer.byteLength / 8);
+    let buffers: Buffer[] = [];
+    let offset = 8;
+    for (let length of lengths) {
+        buffers.push(buffer.slice(offset, offset + length));
+        offset += length;
     }
+    return await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
 });

package/src/JSONLACKS/JSONLACKS.ts

@@ -298,10 +298,6 @@ export class JSONLACKS {
             if (type === "ref") {
                 let id = obj.id as string;
                 if (!JSONLACKS.IGNORE_MISSING_REFERENCES && !references.has(id)) {
-                    if (!config?.discardMissingReferences) {
-                        debugbreak(2);
-                        debugger;
-                    }
                     throw new Error(`Reference to undefined id "${id}"`);
                 }
                 return references.get(id);

package/src/batching.ts

@@ -226,7 +226,7 @@ export async function runInfinitePollCallAtStart(
                 try {
                     await fnc();
                 } catch (e: any) {
-                    console.error(`Error in infinite poll ${fnc.name} (continuing poll loop)\n${e.stack}`);
+                    console.error(`Error in infinite poll ${fnc.name || fnc.toString().slice(0, 100)} (continuing poll loop)\n${e.stack}`);
                 }
             }
         })();

package/src/callManager.ts

@@ -69,7 +69,7 @@ export function isDataImmutable(call: CallType) {
 export function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape, config?: {
     noFunctionMeasure?: boolean;
 }) {
-    if (!isHotReloading?.() && classes[classGuid]) {
+    if (!globalThis.isHotReloading?.() && classes[classGuid]) {
         throw new Error(`Class ${classGuid} already registered`);
     }
 

package/src/formatting/logColors.ts

@@ -9,7 +9,7 @@ function ansiRGB(r: number, g: number, b: number, text: string): string {
 }
 
 const lightness = 68;
-export const blue = (text: string) => `\x1b[34m${text}\x1b[0m`;
+export const blue = ansiHSL.bind(null, 235, 100, lightness);
 export const red = ansiHSL.bind(null, 0, 100, lightness);
 export const green = (text: string) => `\x1b[32m${text}\x1b[0m`;
 export const yellow = (text: string) => `\x1b[33m${text}\x1b[0m`;

package/src/https.ts

@@ -11,7 +11,7 @@ export function httpsRequest(
     method = "GET",
     sendSessionCookies = true,
     config?: {
-        headers?: { [key: string]: string },
+        headers?: { [key: string]: string | undefined },
     }
 ): Promise<Buffer> {
     if (isNode()) {
@@ -66,8 +66,9 @@ export function httpsRequest(
         var request = new XMLHttpRequest();
         request.open(method, url, true);
         if (config?.headers) {
-            for (let key in config.headers) {
-                request.setRequestHeader(key, config.headers[key]);
+            for (let [key, value] of Object.entries(config.headers)) {
+                if (value === undefined) continue;
+                request.setRequestHeader(key, value);
             }
         }
         request.responseType = "arraybuffer";

package/src/misc.ts

@@ -1,4 +1,3 @@
-import * as crypto from "crypto";
 import { canHaveChildren, MaybePromise } from "./types";
 import { formatNumber } from "./formatting/format";
 
@@ -18,16 +17,17 @@ export function convertErrorStackToError(error: string): Error {
     return errorObj;
 }
 
+
 export function sha256Hash(buffer: Buffer | string): string {
-    return crypto.createHash("sha256").update(buffer).digest("hex");
+    return require("crypto").createHash("sha256").update(buffer).digest("hex");
 }
 export function sha256HashBuffer(buffer: Buffer | string): Buffer {
-    return crypto.createHash("sha256").update(buffer).digest();
+    return require("crypto").createHash("sha256").update(buffer).digest();
 }
 /** Async, but works both clientside and serverside. */
 export async function sha256HashPromise(buffer: Buffer) {
     if (isNode()) {
-        return crypto.createHash("sha256").update(buffer).digest("hex");
+        return require("crypto").createHash("sha256").update(buffer).digest("hex");
     } else {
         let buf = await window.crypto.subtle.digest("SHA-256", buffer);
         return Buffer.from(buf).toString("hex");
@@ -35,7 +35,7 @@ export async function sha256HashPromise(buffer: Buffer) {
 }
 export async function sha256BufferPromise(buffer: Buffer): Promise<Buffer> {
     if (isNode()) {
-        return crypto.createHash("sha256").update(buffer).digest();
+        return require("crypto").createHash("sha256").update(buffer).digest();
     } else {
         let buf = await window.crypto.subtle.digest("SHA-256", buffer);
         return Buffer.from(buf);

package/src/sniTest.ts

@@ -6,6 +6,7 @@ let tlsExtensionLookup: { [type: number]: string } = {
     2: "client_certificate_url",
     3: "trusted_ca_keys",
     4: "truncated_hmac",
+    // Likely an OCSP status request
     5: "status_request",
     6: "user_mapping",
     7: "client_authz",
@@ -84,18 +85,19 @@ let tlsExtensionLookup: { [type: number]: string } = {
     65281: "renegotiation_info" // 0xFF01
 };
 
+// yarn testsni
 async function main() {
     const packet = Buffer.from(
-        `FgMBBwgBAAcEAwNWbpKnOzI9CRp2ESvA5QzCXg5FYncEObckUkNoG3+/DyAwI4HL0havBXKvPlJtZJBgtZ+I/FqBlKGek8NGJcgdqQAgiooTARMCEwPAK8AvwCzAMMypzKjAE8AUAJwAnQAvADUBAAabSkoAAAAbAAMCAAIACgAMAArq6mOZAB0AFwAYAAUABQEAAAAAAC0AAgEB/wEAAQAAIwAAAAsAAgEAABIAAAANABIAEAQDCAQEAQUDCAUFAQgGBgEAFwAA/g0AugAAAQABCwAgIRJsXQHGN5cbIp9ucgXJ824RS/6hqIikNiMKw7/gsDAAkK8j0YYXYsSnpX4siEVnB/AxzQCPaGMoT4y1i63f4mzV0Sa6puc4sZqkxY7TyQMJLrGPL00HaJZh6ReT/ggPbCwg5f5/2hUCdZSx4aUpYMb7lAx9VVJjhrquZIRRVrk8yV0OjEivreTN02u1mgIgMY/0P8RzOea+iQluEF9ASOYxgNIU20xoKK608ktQrTafSQAQAAsACQhodHRwLzEuMQAzBO8E7erqAAEAY5kEwB8fuK+qumVLi67+BmQ5uQ556Opa122UZFmnfuoKQY1tiXkzM7Z+wmWOLTg7l3Ncu8ECL/Z9G6ZLP4N5OKGjiHE307sEvNRqdEnFYoQMVotF6hNbt3F4GrEBa6CuCEohg9HKg3RtIfMFYNc1lDC4rJCLwNETijo5MlOFnYVGpWOMcBZbdLsGv5JxN7idRUGvxsttaya3GYxSI1yFW9dZaysTsYXA2IzPp7M950GkJzBK5Zy3wBiXoZYGYKJGy5EA1XIE88Y6X2VNghPIatHHjdav+PpsLZCyUowEsAN49gh/yRrBNZxo6gNbfOIds/UpjlYtIEo1lch2ygWzVLS55qxm35IQUVKQjEQiPDNUI6g9RZZD+VSH5vB1ouMwTqbDAAN9EsUxigYmQggjz1jGFEm+DecEQTkXoQOIwWsAq+M39Eq7M3CwYVQ6yDQI+rQD9xxin8I9PrdVoXGaTVwnY9GFKFCYZyewSGeuPGSaPcdKwvBb/IgfFVRt2aU24XNmFsCkgLSzHEkBg1uYqjd+uIY7zTWo5WIevniL4SCIvRyvTQB7DICAZ+BxSUxio9x19OWQCitnoXdoGGwuTIQqSYuimFBedKa2b4Yk3nkPIRqa3jldbGMRwQmpaQFnsOJml/pEr3sQIuEcQ2shaIuqW+Zo86yamflqpCmCbQWNiipRYwQ/AmG7oOeS1iJomPiRJDwVNaoDZzI2ApYIcQckNPNrI9qOrGwww6x1T9EwKadz/1OcHQcbWtej5QkLm5Ss/9paxqYsu1kuohlvPOSd4txqKOGNvOhzxqqOweZ7p8l/H/JhnMkEUCZYvOW4JhthXsYMfnWn8rciE7KuMskf65mqI1tI5SZqzxAfH4MidyUJRNwR6mwWUgzMi7kB3eM3IPUbCDpUIpQBipt2SyenIMXNH9ZjnYtdCwVDe7m6mshYAJVV7oJDw5yn2pYH5nsZ+gM93vNWBvZVQjZZmRdZQ2YqhKaUyQgpOEhlE1w7XAXJp+um2kA5qElw9sNbxvOziNSPLyi17xgy1CSBSzB+o8JAfZamxUHFXEGSRYoR8qekMnlJeVRXlojEoaxMsspFX3itMOqIHNUL9Nltswaqggu7s+NQfshoLEg5gkfM/tok4sISLZlX7ACgcWZBQudMPTyn3FsQIbzNgXBzWTdiCZg9iZttoJtX8FygYbzEF9kFJyc5fIBA4NACVZhOf+onlMcFEbHCu6ilqMuzwQxf6vgV`
+        `FgMBAgABAAH8AwNYhO4jReWM/LOl/teBLLZOLN4z0u+jB3uEYW+9WwzwgSCWYyBiHRCFg/brbyJiNFv2n72FvXHnMHmZvjIBqPC8AgA+EwITAxMBwCzAMACfzKnMqMyqwCvALwCewCTAKABrwCPAJwBnwArAFAA5wAnAEwAzAJ0AnAA9ADwANQAvAP8BAAF1AAsABAMAAQIACgAWABQAHQAXAB4AGQAYAQABAQECAQMBBAAjAAAAFgAAABcAAAANACoAKAQDBQMGAwgHCAgICQgKCAsIBAgFCAYEAQUBBgEDAwMBAwIEAgUCBgIAKwAFBAMEAwMALQACAQEAMwAmACQAHQAgsMkHWnjEPL3IeGuvapE9aEOBVv+o8cDH07vYf4W0ykQAFQDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==`
             .replace(/\s/g, "")
         , "base64"
     );
 
     let data = parseTLSHello(packet);
-    let sni = data.extensions.filter(x => x.type === SNIType).flatMap(x => parseSNIExtension(x.data))[0];
+    //let sni = data.extensions.filter(x => x.type === SNIType).flatMap(x => parseSNIExtension(x.data))[0];
     console.log(`Packet size ${packet.byteLength}, missing bytes ${data.missingBytes}`);
     for (let ext of data.extensions) {
-        console.log(`Extension: ${tlsExtensionLookup[ext.type] || ext.type}, bytes length: ${ext.data.length}`);
+        console.log(`Extension: ${tlsExtensionLookup[ext.type] || ext.type}, bytes length: ${ext.data.length}, ${ext.data.toString("hex")}`);
     }
 }
 main().catch(e => console.error(e)).finally(() => process.exit());

package/src/webSocketServer.ts

@@ -180,6 +180,7 @@ export async function startSocketServer(
     });
 
     let realServer = net.createServer(socket => {
+        const remoteAddress = socket.remoteAddress;
         function handleTLSHello(buffer: Buffer, packetCount: number): void | "more" {
             // All HTTPS requests start with 22, and no HTTP requests start with 22,
             //  so we just need to read the first byte.
@@ -196,7 +197,7 @@ export async function startSocketServer(
                     console.log(`Received TCP connection with SNI ${JSON.stringify(sni)}`);
                 }
                 if (!sni) {
-                    console.warn(`No SNI found in TLS hello, using main server. Packets ${packetCount}`);
+                    console.warn(`No SNI found in TLS hello from ${remoteAddress}, using main server. Packets ${packetCount}`);
                     console.log(buffer.toString("base64"));
                 }
                 server = sniServers.get(sni) || mainHTTPSServer;
@@ -221,7 +222,7 @@ export async function startSocketServer(
         }
         getNextData();
         socket.on("error", (e) => {
-            console.error(`Exposed socket error, ${e.stack}`);
+            console.error(`Socket error for ${remoteAddress}, ${e.stack}`);
         });
     });
 

package/test.ts

@@ -8,23 +8,23 @@ import { forwardPort } from "./src/forwardPort";
 
 // Usage example:
 async function main() {
-    const externalPort = 8088;
+    const externalPort = 11300;
     const internalPort = externalPort;
 
     await forwardPort({ externalPort, internalPort });
 
     // Listen on the external port
-    const server = http.createServer((req, res) => {
-        console.log("Request received");
-        res.end("Hello, world!");
-    });
-    server.listen(externalPort, "0.0.0.0");
-
-    {
-        const externalIP = await getExternalIP();
-        let test = await fetch(`http://${externalIP}:${externalPort}`);
-        console.log(await test.text());
-    }
+    // const server = http.createServer((req, res) => {
+    //     console.log("Request received");
+    //     res.end("Hello, world!");
+    // });
+    // server.listen(externalPort, "0.0.0.0");
+
+    // {
+    //     const externalIP = await getExternalIP();
+    //     let test = await fetch(`http://${externalIP}:${externalPort}`);
+    //     console.log(await test.text());
+    // }
 
 
     //await createPortMapping({ externalPort, internalPort, gateWayIP, internalIP, });

package/time/trueTimeShim.ts

@@ -1,187 +1,212 @@
-import { SocketFunction } from "../SocketFunction";
-import { blue, green, red, yellow } from "../src/formatting/logColors";
-import { isNode } from "../src/misc";
-
-module.allowclient = true;
-
-const UPDATE_INTERVAL = 1000 * 60 * 10;
-// More frequent, to ensure we don't run into major issues with sleep (coming back from sleep,
-//  having the interval not be fired immediately, and having the time be off for a few minutes).
-const UPDATE_SUB_INTERVAL = 1000 * 10;
-// Smearing is important, otherwise some performance timing (especially on load) can easily be off
-//  by a few hundred milliseconds. The current smear parameters will mean even with 1s of offset
-//  we only add 10ms every 100ms, so worst case scenario some timing that takes 0ms will take 10ms.
-const UPDATE_SMEAR_TICK_DURATION = 100;
-const UPDATE_SMEAR_TICK_COUNT = 100;
-const UPDATE_VERIFY_COUNT = 3;
-
-let trueTimeOffset = 0;
-let didFirstTimeSync = false;
-let onFirstTimeSync!: () => void;
-let firstTimeSyncPromise = new Promise<void>((resolve) => {
-    onFirstTimeSync = resolve;
-});
-
-const baseGetTime = Date.now;
-export function getTrueTime() {
-    return baseGetTime() + trueTimeOffset;
-}
-export function getTrueTimeOffset() {
-    return trueTimeOffset;
-}
-export function waitForFirstTimeSync() {
-    return firstTimeSyncPromise;
-}
-export function shimDateNow() {
-    Date.now = getTrueTime;
-}
-
-export function setGetTimeOffsetBase(base: () => Promise<number>) {
-    getTimeOffsetBase = base;
-}
-
-
-async function defaultGetTimeOffset(): Promise<number> {
-    if (!isNode()) {
-        let sendTime = baseGetTime();
-        let serverTrueTime = await TimeController.nodes[SocketFunction.browserNodeId()].getTrueTime();
-        let systemTime = baseGetTime();
-        let predictedServerToClientLatency = (systemTime - sendTime) / 2;
-        let trueTimeRightNow = serverTrueTime + predictedServerToClientLatency;
-        return trueTimeRightNow - systemTime;
-    }
-    const dgram = await import("dgram");
-    const NTP_SERVER = "time.google.com";
-    const NTP_PORT = 123;
-    const NTP_PACKET_SIZE = 48;
-    const NTP_EPOCH_OFFSET = 2208988800000; // Number of milliseconds between 1900-01-01 and 1970-01-01
-    return new Promise((resolve, reject) => {
-        const client = dgram.createSocket("udp4");
-        const message = Buffer.alloc(NTP_PACKET_SIZE);
-
-        // Set the first byte to represent NTP client request (LI = 0, VN = 3, Mode = 3)
-        message[0] = 0x1B;
-
-        const sendTime = baseGetTime();
-
-        client.send(message, 0, message.length, NTP_PORT, NTP_SERVER);
-        client.on("error", (err) => {
-            client.close();
-            reject(err);
-        });
-
-        client.on("message", (msg) => {
-            const receiveTime = baseGetTime();
-
-            // Extract the transmit timestamp from the server response
-            const transmitTimestampSeconds = msg.readUInt32BE(40);
-            const transmitTimestampFraction = msg.readUInt32BE(44);
-            const transmitTimestamp = (transmitTimestampSeconds * 1000) + (transmitTimestampFraction * 1000 / 0x100000000) - NTP_EPOCH_OFFSET;
-
-            const predictedServerToClientLatency = (receiveTime - sendTime) / 2;
-
-            // Calculate the offset
-            const systemTime = baseGetTime();
-            const actualTime = transmitTimestamp + predictedServerToClientLatency;
-            const offset = actualTime - systemTime;
-
-            client.close();
-            resolve(offset);
-        });
-    });
-}
-
-let getTimeOffsetBase: () => Promise<number> = defaultGetTimeOffset;
-let updatingOffset = false;
-async function updateTimeOffset() {
-    if (updatingOffset) return;
-    updatingOffset = true;
-    try {
-        let offsets: number[] = [];
-        for (let i = 0; i < UPDATE_VERIFY_COUNT; i++) {
-            try {
-                offsets.push(await getTimeOffsetBase());
-            } catch (e) {
-                console.error("Error getting time offset:", e);
-            }
-        }
-        // If we have no offsets, it likely means every call errored out (probably because the network is down).
-        //  This is fine, just don't update (DO register the first sync as being done, otherwise calling code
-        //  might be waiting forever).
-        if (offsets.length > 0) {
-            // Pick the middle offset
-            offsets.sort((a, b) => a - b);
-            let offset = offsets[Math.floor(offsets.length / 2)];
-
-            // Smear it slowly
-            let currentSmearCount = UPDATE_SMEAR_TICK_COUNT;
-            // Update the initial time all at once, otherwise initial requests to other servers might
-            //  be rejected (because they could use the system time, which could be off by a few seconds).
-            if (!didFirstTimeSync) {
-                currentSmearCount = 1;
-            }
-
-            let prevOffset = trueTimeOffset;
-            let offsetRound = Math.abs(Math.round(offset));
-            let offsetColored = (
-                Math.abs(offset) > 600 && red(offsetRound + "ms")
-                || Math.abs(offset) > 300 && yellow(offsetRound + "ms")
-                || green(offsetRound + "ms")
-            );
-            if (Math.abs(offset) > 500) {
-                console.log(`${blue("Synchronized time")}, local clock was ${offset > 0 ? "behind" : "ahead"} by ${offsetColored} @ ${blue(Date.now() + "")}`);
-            }
-            for (let i = 0; i < currentSmearCount; i++) {
-                let fraction = (i + 1) / currentSmearCount;
-                trueTimeOffset = prevOffset * (1 - fraction) + offset * fraction;
-                if (i < currentSmearCount - 1) {
-                    await new Promise((resolve) => setTimeout(resolve, UPDATE_SMEAR_TICK_DURATION));
-                }
-            }
-        }
-
-        if (!didFirstTimeSync) {
-            didFirstTimeSync = true;
-            onFirstTimeSync();
-        }
-    } finally {
-        updatingOffset = false;
-    }
-}
-
-let nextUpdateTime = 0;
-setInterval(() => {
-    if (baseGetTime() < nextUpdateTime) return;
-    nextUpdateTime = baseGetTime() + UPDATE_INTERVAL;
-    updateTimeOffset().catch((e) => {
-        console.warn("Error updating time offset:", e);
-    });
-}, UPDATE_SUB_INTERVAL);
-setImmediate(() => {
-    updateTimeOffset().catch((e) => {
-        console.error("Error updating initial offset:", e);
-    });
-});
-
-
-class TimeControllerBase {
-    public async getTrueTime() {
-        await waitForFirstTimeSync();
-        return getTrueTime();
-    }
-}
-
-const TimeController = SocketFunction.register(
-    "TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976",
-    new TimeControllerBase(),
-    () => ({
-        getTrueTime: {},
-    }),
-    () => ({
-    }),
-    {
-        // NOTE: Autoexpose, because our exposed endpoints are incredibly lightweight
-        //  (just a ping), and don't expose really expose any data.
-        // noAutoExpose: true
-    }
+import { SocketFunction } from "../SocketFunction";
+import { blue, green, red, yellow } from "../src/formatting/logColors";
+import { isNode } from "../src/misc";
+
+module.allowclient = true;
+
+const UPDATE_INTERVAL = 1000 * 60 * 10;
+// More frequent, to ensure we don't run into major issues with sleep (coming back from sleep,
+//  having the interval not be fired immediately, and having the time be off for a few minutes).
+const UPDATE_SUB_INTERVAL = 1000 * 10;
+// Smearing is important, otherwise some performance timing (especially on load) can easily be off
+//  by a few hundred milliseconds. The current smear parameters will mean even with 1s of offset
+//  we only add 10ms every 100ms, so worst case scenario some timing that takes 0ms will take 10ms.
+const UPDATE_SMEAR_TICK_DURATION = 100;
+const UPDATE_SMEAR_TICK_COUNT = 100;
+const UPDATE_VERIFY_COUNT = 3;
+
+// Time can never go backwards, but we can run at a slower rate until the output time allows
+//      the real time to catch up with it.
+const MINIMUM_TIME_RATE = 0.5;
+
+let trueTimeOffset = 0;
+let didFirstTimeSync = false;
+let onFirstTimeSync!: () => void;
+let firstTimeSyncPromise = new Promise<void>((resolve) => {
+    onFirstTimeSync = resolve;
+});
+
+const baseGetTime = Date.now;
+let lastTime = 0;
+let lastBaseTime = 0;
+export function getTrueTime() {
+    let baseTime = baseGetTime();
+    let time = baseTime + trueTimeOffset;
+    // Only adjust time once we have a time offset. Otherwise systems with a really bad clock
+    //  might take days be correct. It is better for the time to jump once at startup, rather
+    //  than be off by days, for days at a time.
+    if (lastTime && trueTimeOffset) {
+        if (time < lastTime) {
+            let diff = baseTime - lastBaseTime;
+            if (diff >= 0) {
+                // Some time passed, so we have a baseline for how much to increase the time by.
+                //  This allows the real time to catch up with our time naturally.
+                time = lastTime + diff * MINIMUM_TIME_RATE;
+            } else {
+                // The issue is the system time going backwards. In this case, allow the time to change
+            }
+        }
+    }
+    lastTime = time;
+    lastBaseTime = baseTime;
+    return time;
+}
+export function getTrueTimeOffset() {
+    return trueTimeOffset;
+}
+export function waitForFirstTimeSync() {
+    return firstTimeSyncPromise;
+}
+export function shimDateNow() {
+    Date.now = getTrueTime;
+}
+
+export function setGetTimeOffsetBase(base: () => Promise<number>) {
+    getTimeOffsetBase = base;
+}
+
+
+async function defaultGetTimeOffset(): Promise<number> {
+    if (!isNode()) {
+        let sendTime = baseGetTime();
+        let serverTrueTime = await TimeController.nodes[SocketFunction.browserNodeId()].getTrueTime();
+        let systemTime = baseGetTime();
+        let predictedServerToClientLatency = (systemTime - sendTime) / 2;
+        let trueTimeRightNow = serverTrueTime + predictedServerToClientLatency;
+        return trueTimeRightNow - systemTime;
+    }
+    const dgram = await import("dgram");
+    const NTP_SERVER = "time.google.com";
+    const NTP_PORT = 123;
+    const NTP_PACKET_SIZE = 48;
+    const NTP_EPOCH_OFFSET = 2208988800000; // Number of milliseconds between 1900-01-01 and 1970-01-01
+    return new Promise((resolve, reject) => {
+        const client = dgram.createSocket("udp4");
+        const message = Buffer.alloc(NTP_PACKET_SIZE);
+
+        // Set the first byte to represent NTP client request (LI = 0, VN = 3, Mode = 3)
+        message[0] = 0x1B;
+
+        const sendTime = baseGetTime();
+
+        client.send(message, 0, message.length, NTP_PORT, NTP_SERVER);
+        client.on("error", (err) => {
+            client.close();
+            reject(err);
+        });
+
+        client.on("message", (msg) => {
+            const receiveTime = baseGetTime();
+
+            // Extract the transmit timestamp from the server response
+            const transmitTimestampSeconds = msg.readUInt32BE(40);
+            const transmitTimestampFraction = msg.readUInt32BE(44);
+            const transmitTimestamp = (transmitTimestampSeconds * 1000) + (transmitTimestampFraction * 1000 / 0x100000000) - NTP_EPOCH_OFFSET;
+
+            const predictedServerToClientLatency = (receiveTime - sendTime) / 2;
+
+            // Calculate the offset
+            const systemTime = baseGetTime();
+            const actualTime = transmitTimestamp + predictedServerToClientLatency;
+            const offset = actualTime - systemTime;
+
+            client.close();
+            resolve(offset);
+        });
+    });
+}
+
+let getTimeOffsetBase: () => Promise<number> = defaultGetTimeOffset;
+let updatingOffset = false;
+async function updateTimeOffset() {
+    if (updatingOffset) return;
+    updatingOffset = true;
+    try {
+        let offsets: number[] = [];
+        for (let i = 0; i < UPDATE_VERIFY_COUNT; i++) {
+            try {
+                offsets.push(await getTimeOffsetBase());
+            } catch (e) {
+                console.error("Error getting time offset:", e);
+            }
+        }
+        // If we have no offsets, it likely means every call errored out (probably because the network is down).
+        //  This is fine, just don't update (DO register the first sync as being done, otherwise calling code
+        //  might be waiting forever).
+        if (offsets.length > 0) {
+            // Pick the middle offset
+            offsets.sort((a, b) => a - b);
+            let offset = offsets[Math.floor(offsets.length / 2)];
+
+            // Smear it slowly
+            let currentSmearCount = UPDATE_SMEAR_TICK_COUNT;
+            // Update the initial time all at once, otherwise initial requests to other servers might
+            //  be rejected (because they could use the system time, which could be off by a few seconds).
+            if (!didFirstTimeSync) {
+                currentSmearCount = 1;
+            }
+
+            let prevOffset = trueTimeOffset;
+            let offsetRound = Math.abs(Math.round(offset));
+            let offsetColored = (
+                Math.abs(offset) > 600 && red(offsetRound + "ms")
+                || Math.abs(offset) > 300 && yellow(offsetRound + "ms")
+                || green(offsetRound + "ms")
+            );
+            if (Math.abs(offset) > 500) {
+                console.log(`${blue("Synchronized time")}, local clock was ${offset > 0 ? "behind" : "ahead"} by ${offsetColored} @ ${blue(Date.now() + "")}`);
+            }
+            for (let i = 0; i < currentSmearCount; i++) {
+                let fraction = (i + 1) / currentSmearCount;
+                trueTimeOffset = prevOffset * (1 - fraction) + offset * fraction;
+                if (i < currentSmearCount - 1) {
+                    await new Promise((resolve) => setTimeout(resolve, UPDATE_SMEAR_TICK_DURATION));
+                }
+            }
+        }
+
+        if (!didFirstTimeSync) {
+            didFirstTimeSync = true;
+            onFirstTimeSync();
+        }
+    } finally {
+        updatingOffset = false;
+    }
+}
+
+let nextUpdateTime = 0;
+setInterval(() => {
+    if (baseGetTime() < nextUpdateTime) return;
+    nextUpdateTime = baseGetTime() + UPDATE_INTERVAL;
+    updateTimeOffset().catch((e) => {
+        console.warn("Error updating time offset:", e);
+    });
+}, UPDATE_SUB_INTERVAL);
+setImmediate(() => {
+    updateTimeOffset().catch((e) => {
+        console.error("Error updating initial offset:", e);
+    });
+});
+
+
+class TimeControllerBase {
+    public async getTrueTime() {
+        await waitForFirstTimeSync();
+        return getTrueTime();
+    }
+}
+
+const TimeController = SocketFunction.register(
+    "TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976",
+    new TimeControllerBase(),
+    () => ({
+        getTrueTime: {},
+    }),
+    () => ({
+    }),
+    {
+        // NOTE: Autoexpose, because our exposed endpoints are incredibly lightweight
+        //  (just a ping), and don't expose really expose any data.
+        // noAutoExpose: true
+    }
 );