socket-function 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.17.0",
+	"version": "0.18.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

@@ -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/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/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/time/trueTimeShim.ts

@@ -1,187 +1,187 @@
-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;
+
+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
+    }
 );