socket-function 1.1.5 → 1.1.7

package/SocketFunction.d.ts

@@ -29,6 +29,10 @@ export declare class SocketFunction {
         serialize: (obj: unknown) => MaybePromise<Buffer[]>;
         deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
     };
+    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
+     *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+     */
+    static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
     static WIRE_WARN_TIME: number;
     private static onMountCallbacks;
     static exposedClasses: Set<string>;

package/SocketFunction.ts

@@ -72,11 +72,17 @@ export class SocketFunction {
     // In retrospect... dynamically changing the wire serializer is a BAD idea. If any calls happen
     //  before it is changed, things just break. Also, it needs to be changed on both sides,
     //  or else things break. Also, it is very hard to detect when the issue is different serializers
+    // NOTE: The only reason this is still exposed is in case in the future we want to intercept our traffic, and we want convenient functions to know how to decode it (although there are a still few other layers under this, for compression and Buffer[] sending efficiency).
     public static readonly WIRE_SERIALIZER = {
         serialize: measureWrap((obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)], "WIRE_SERIALIZER|serialize"),
         deserialize: measureWrap((buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]), "WIRE_SERIALIZER|deserialize"),
     };
 
+    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID. 
+     *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+     */
+    public static GET_ALTERNATE_NODE_IDS = (nodeId: string): MaybePromise<string[] | undefined> => undefined;
+
     public static WIRE_WARN_TIME = 100;
 
     private static onMountCallbacks = new Map<string, (() => MaybePromise<void>)[]>();

package/SocketFunctionTypes.ts

@@ -130,5 +130,6 @@ export type CallerContextBase = {
     //  requests can be redirected to us and would accept them, even though they are being
     //  blatantly MITMed).
     //  IF they are the server, calling us back, then this will just be ""
+    // If they're connecting on the same machine, this might be a special domain (127-0-0-1.querysub.com). This is controlled by the GET_ALTERNATE_NODE_IDS override.
     localNodeId: string;
 };

package/index.d.ts

@@ -38,6 +38,10 @@ declare module "socket-function/SocketFunction" {
             serialize: (obj: unknown) => MaybePromise<Buffer[]>;
             deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
         };
+        /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
+         *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+         */
+        static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
         static WIRE_WARN_TIME: number;
         private static onMountCallbacks;
         static exposedClasses: Set<string>;
@@ -1408,6 +1412,17 @@ declare module "socket-function/test" {
 }
 
 declare module "socket-function/time/trueTimeShim" {
+    export declare function getTimeComponentsDetailed(): {
+        systemTime: number;
+        fromOffset: number;
+        toOffset: number;
+        fromTime: number;
+        toTime: number;
+    };
+    export declare function getTimeComponents(): {
+        systemTime: number;
+        offset: number;
+    };
     export declare function getTrueTime(): number;
     export declare function getTrueTimeOffset(): number;
     export declare function waitForFirstTimeSync(): Promise<void> | undefined;

package/package.json

@@ -1,12 +1,13 @@
 {
 	"name": "socket-function",
-	"version": "1.1.5",
+	"version": "1.1.7",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
 		"@types/pako": "^2.0.3",
 		"@types/ws": "^8.5.3",
 		"cbor-x": "^1.6.0",
+		"lmdb": "^3.5.1",
 		"mobx": "^6.6.2",
 		"pako": "^2.1.0",
 		"preact": "10.24.3",
@@ -16,11 +17,11 @@
 	},
 	"types": "index.d.ts",
 	"scripts": {
-		"test": "yarn typenode ./test/server.ts",
+		"test": "yarn typenode ./test.ts",
+		"test-all": "node run-test.js",
 		"type": "yarn tsc --noEmit",
 		"emit-dts": "yarn tsc --project tsconfig.declarations.json || exit 0",
 		"generate-index-dts": "node ./generateIndexDts.js",
-		"update-typings": "yarn generate-index-dts && yarn emit-dts",
 		"update-types": "yarn emit-dts && yarn generate-index-dts",
 		"prepublishOnly": "yarn update-types",
 		"testsni": "yarn typenode ./src/sniTest.ts"

package/run-test.js

@@ -0,0 +1,59 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Clean up old test files
+console.log('Cleaning up old test files...');
+const distDir = path.join(__dirname, 'dist');
+if (fs.existsSync(distDir)) {
+    const files = fs.readdirSync(distDir)
+        .filter(f => f.startsWith('time-samples-') && f.endsWith('.json'));
+    for (const file of files) {
+        fs.unlinkSync(path.join(distDir, file));
+    }
+}
+
+// Launch 4 concurrent processes
+console.log('Launching 4 concurrent test processes...\n');
+
+function runTest() {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('yarn', ['test'], {
+            stdio: 'inherit',
+            shell: true
+        });
+        
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            } else {
+                reject(new Error(`Process exited with code ${code}`));
+            }
+        });
+        
+        proc.on('error', reject);
+    });
+}
+
+Promise.all([
+    runTest(),
+    runTest(),
+    runTest(),
+    runTest()
+])
+.then(() => {
+    console.log('\n\nAll sampling complete. Running verification...\n');
+    
+    const verify = spawn('yarn', ['test', 'verify'], {
+        stdio: 'inherit',
+        shell: true
+    });
+    
+    verify.on('close', (code) => {
+        process.exit(code);
+    });
+})
+.catch((err) => {
+    console.error('Error running tests:', err);
+    process.exit(1);
+});

package/src/CallFactory.ts

@@ -19,8 +19,6 @@ import { measureFnc, measureWrap, registerMeasureInfo } from "./profiling/measur
 import { MaybePromise } from "./types";
 import { Zip } from "./Zip";
 import { LZ4 } from "./lz4/LZ4";
-//LZ4.compress;
-//LZ4.decompress;
 
 setFlag(require, "pako", "allowclient", true);
 
@@ -282,16 +280,22 @@ export async function createCallFactory(
     };
 
     let webSocketPromise: Promise<SenderInterface> | undefined;
+    let hasEverConnected = false;
     if (webSocketBase) {
         webSocketPromise = Promise.resolve(webSocketBase);
         await initializeWebsocket(webSocketBase);
     }
 
-    async function initializeWebsocket(newWebSocket: SenderInterface) {
+    async function initializeWebsocket(newWebSocket: SenderInterface, skipCloseHandling = false) {
         registerOnce();
         callFactory.receivedInitializeState = undefined;
 
         function onClose(error: string) {
+            // We try various connections, and if they fail, we will just try other node IDs until we finally do connect, and then we stick with that nodeId, and when it disconnects we need to handle disconnections normally.
+            if (skipCloseHandling && !hasEverConnected) {
+                return;
+            }
+
             callFactory.connectionId = { nodeId };
             callFactory.lastClosed = Date.now();
             callFactory.isConnected = false;
@@ -341,6 +345,7 @@ export async function createCallFactory(
                         console.log(`Connection established to ${niceConnectionName}`);
                     }
                     callFactory.isConnected = true;
+                    hasEverConnected = true;
                     resolve();
                 });
                 newWebSocket.addEventListener("close", () => resolve());
@@ -348,6 +353,7 @@ export async function createCallFactory(
             });
         } else if (newWebSocket.readyState === 1 /* OPEN */) {
             callFactory.isConnected = true;
+            hasEverConnected = true;
         } else {
             onClose(new Error(`Websocket received in closed state`).stack!);
         }
@@ -441,6 +447,23 @@ export async function createCallFactory(
         }
         lastConnectionAttempt = Date.now();
 
+        // Try alternates, and if any work, use them
+        try {
+            let alternates = await SocketFunction.GET_ALTERNATE_NODE_IDS(nodeId);
+            if (alternates) {
+                for (let alternateNodeId of alternates) {
+                    let newWebSocket = createWebsocket(alternateNodeId);
+                    await initializeWebsocket(newWebSocket, true);
+
+                    if (callFactory.isConnected) {
+                        return newWebSocket;
+                    }
+                }
+            }
+        } catch (e) {
+            console.error("Error getting alternate node IDs", e);
+        }
+
         let newWebSocket = createWebsocket(nodeId);
         await initializeWebsocket(newWebSocket);
 

package/test.ts

@@ -1,33 +1,167 @@
-import { getExternalIP } from "./src/networking";
-import http from "http";
-import * as dgram from "dgram";
-import os from "os";
-import debugbreak from "debugbreak";
-import { forwardPort } from "./src/forwardPort";
+import { getTimeComponentsDetailed, waitForFirstTimeSync } from "./time/trueTimeShim";
+import * as fs from "fs";
+import * as path from "path";
 
+const SAMPLE_COUNT = 1000;
+const SAMPLE_INTERVAL_MS = 10;
 
-// Usage example:
-async function main() {
-    const externalPort = 11300;
-    const internalPort = externalPort;
+// Generate a simple numeric ID for this test run
+const TEST_RUN_ID = Math.floor(Math.random() * 10000);
+
+async function sampleMode() {
+    await waitForFirstTimeSync();
+
+    type Sample = {
+        id: number;
+        systemTime: number;
+        offset: number;
+        fromOffset: number;
+        toOffset: number;
+        fromTime: number;
+        toTime: number;
+        fraction: number;
+    };
+
+    const samples: Sample[] = [];
+
+    console.log(`[Test ID: ${TEST_RUN_ID}] Sampling ${SAMPLE_COUNT} time components...`);
+    for (let i = 0; i < SAMPLE_COUNT; i++) {
+        const detailed = getTimeComponentsDetailed();
+
+        // Calculate smearing using the same systemTime
+        const elapsed = detailed.systemTime - detailed.fromTime;
+        const duration = detailed.toTime - detailed.fromTime;
+        const fraction = duration > 0 ? Math.min(1, elapsed / duration) : 0;
+        const offset = detailed.fromOffset + (detailed.toOffset - detailed.fromOffset) * fraction;
+
+        samples.push({
+            id: TEST_RUN_ID,
+            systemTime: detailed.systemTime,
+            offset,
+            fromOffset: detailed.fromOffset,
+            toOffset: detailed.toOffset,
+            fromTime: detailed.fromTime,
+            toTime: detailed.toTime,
+            fraction,
+        });
+
+        if (SAMPLE_INTERVAL_MS > 0) {
+            await new Promise(resolve => setTimeout(resolve, SAMPLE_INTERVAL_MS));
+        }
+    }
+
+    // Write to file with unique name
+    const distDir = path.join(__dirname, "dist");
+    if (!fs.existsSync(distDir)) {
+        fs.mkdirSync(distDir, { recursive: true });
+    }
+
+    const filename = path.join(distDir, `time-samples-${Date.now()}-${process.pid}.json`);
+    fs.writeFileSync(filename, JSON.stringify(samples, null, 2));
+
+    console.log(`[Test ID: ${TEST_RUN_ID}] Wrote ${samples.length} samples to ${filename}`);
+}
+
+async function verifyMode() {
+    const distDir = path.join(__dirname, "dist");
+    if (!fs.existsSync(distDir)) {
+        console.error("No dist directory found. Run sampling mode first.");
+        process.exit(1);
+    }
 
-    await forwardPort({ externalPort, internalPort });
+    const files = fs.readdirSync(distDir)
+        .filter(f => f.startsWith("time-samples-") && f.endsWith(".json"))
+        .map(f => path.join(distDir, f));
 
-    // 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");
+    if (files.length === 0) {
+        console.error("No sample files found. Run sampling mode first.");
+        process.exit(1);
+    }
 
-    // {
-    //     const externalIP = await getExternalIP();
-    //     let test = await fetch(`http://${externalIP}:${externalPort}`);
-    //     console.log(await test.text());
-    // }
+    console.log(`Found ${files.length} sample files`);
 
+    type Sample = {
+        id: number;
+        systemTime: number;
+        offset: number;
+        fromOffset: number;
+        toOffset: number;
+        fromTime: number;
+        toTime: number;
+        fraction: number;
+        file: string;
+    };
+
+    // Load all samples from all files
+    const allSamples: Sample[] = [];
+
+    for (const file of files) {
+        const content = fs.readFileSync(file, "utf-8");
+        const samples = JSON.parse(content);
+        for (const sample of samples) {
+            allSamples.push({ ...sample, file: path.basename(file) });
+        }
+    }
+
+    console.log(`Loaded ${allSamples.length} total samples`);
+
+    // Sort by systemTime
+    allSamples.sort((a, b) => a.systemTime - b.systemTime);
+
+    // Verify that systemTime + offset is monotonically increasing
+    let errors = 0;
+    let lastTrueTime = -Infinity;
+
+    for (let i = 0; i < allSamples.length; i++) {
+        const sample = allSamples[i];
+        const trueTime = sample.systemTime + sample.offset;
+
+        if (trueTime < lastTrueTime) {
+            errors++;
+            const prev = allSamples[i - 1];
+            const prevTrueTime = prev.systemTime + prev.offset;
+
+            console.error(`\nERROR at index ${i}: trueTime went backwards!`);
+            console.error(`  Previous [ID: ${prev.id}, file: ${prev.file}]:`);
+            console.error(`    systemTime: ${prev.systemTime}`);
+            console.error(`    offset: ${prev.offset}`);
+            console.error(`    trueTime: ${prevTrueTime}`);
+            console.error(`    smearing: ${prev.fromOffset} -> ${prev.toOffset} (${(prev.fraction * 100).toFixed(2)}%)`);
+            console.error(`    timeWindow: ${prev.fromTime} -> ${prev.toTime}`);
+            console.error(`  Current [ID: ${sample.id}, file: ${sample.file}]:`);
+            console.error(`    systemTime: ${sample.systemTime}`);
+            console.error(`    offset: ${sample.offset}`);
+            console.error(`    trueTime: ${trueTime}`);
+            console.error(`    smearing: ${sample.fromOffset} -> ${sample.toOffset} (${(sample.fraction * 100).toFixed(2)}%)`);
+            console.error(`    timeWindow: ${sample.fromTime} -> ${sample.toTime}`);
+            console.error(`  Difference: ${trueTime - lastTrueTime}ms`);
+        }
+
+        lastTrueTime = trueTime;
+    }
+
+    if (errors === 0) {
+        console.log(`✓ SUCCESS: All ${allSamples.length} samples are correctly ordered!`);
+        console.log(`  Time range: ${allSamples[0].systemTime} to ${allSamples[allSamples.length - 1].systemTime}`);
+        console.log(`  Duration: ${allSamples[allSamples.length - 1].systemTime - allSamples[0].systemTime}ms`);
+    } else {
+        console.error(`✗ FAILED: Found ${errors} ordering violations`);
+        process.exit(1);
+    }
+}
+
+async function main() {
+    const mode = process.argv[2];
 
-    //await createPortMapping({ externalPort, internalPort, gateWayIP, internalIP, });
+    if (mode === "once") {
+        await waitForFirstTimeSync();
+        console.log(Date.now());
+    }
+    else if (mode === "verify") {
+        await verifyMode();
+    } else {
+        await sampleMode();
+    }
 }
 
-main().catch(e => console.error(e));
+main().catch(e => console.error(e)).finally(() => process.exit(0));

package/time/trueTimeShim.d.ts

@@ -1,3 +1,14 @@
+export declare function getTimeComponentsDetailed(): {
+    systemTime: number;
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+    toTime: number;
+};
+export declare function getTimeComponents(): {
+    systemTime: number;
+    offset: number;
+};
 export declare function getTrueTime(): number;
 export declare function getTrueTimeOffset(): number;
 export declare function waitForFirstTimeSync(): Promise<void> | undefined;

package/time/trueTimeShim.ts

@@ -1,225 +1,528 @@
-import { SocketFunction } from "../SocketFunction";
-import { blue, green, red, yellow } from "../src/formatting/logColors";
-import { isNode } from "../src/misc";
-
-// IMPOTRANT! We don't ensure that the times of return are unique. We cannot ensure they are unique because the amount of precision is only about ten thousand date times per millisecond, Which would mean if the calling code called date.now frequently enough, which doesn't even have to be that frequent, it could slowly drift farther and farther ahead of the real time, which would be really bad.
-
-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(): Promise<void> | undefined {
-    if (didFirstTimeSync) return undefined;
-    return firstTimeSyncPromise;
-}
-let shimmed = false;
-export function shimDateNow() {
-    if (shimmed) return;
-    shimmed = true;
-    Date.now = getTrueTime;
-}
-export function getBrowserTime() {
-    return baseGetTime();
-}
-
-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: {
-            // No hooks, as this needs to run very early on. Also, it is basically just a ping,
-            //  so it should be safe for anyone to use (we might even make it just a regular HTTPS endpoint,
-            //  or even just set up a dedicated domain for this).
-            noDefaultHooks: true,
-            noClientHooks: true,
-        },
-    }),
-    () => ({}),
-    {
-        // 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";
+
+// IMPOTRANT! We don't ensure that the times of return are unique. We cannot ensure they are unique because the amount of precision is only about ten thousand date times per millisecond, Which would mean if the calling code called date.now frequently enough, which doesn't even have to be that frequent, it could slowly drift farther and farther ahead of the real time, which would be really bad.
+
+module.allowclient = true;
+
+
+const UPDATE_VERIFY_COUNT = 3;
+
+// Configuration for cross-process synchronization
+const UPDATE_TRANSITION_GAP = 1000 * 60 * 20; // 5 minutes between current and next
+const UPDATE_CHECK_INTERVAL = 1000 * 60 * 5; // Check every 1 minute
+const DEBUG_TIME_SYNC = false; // Enable debug logging for time synchronization
+
+// 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;
+
+const THROW_ON_ERROR = false;
+
+// Hugely important as if we don't synchronize between processes, it means our logs are going to be confusing and out of order. 
+//  - Of course, cross-machine, the logs could be out of order. However, due to the latency between machines, that's less likely. The latency will probably be a few milliseconds, and hopefully, our time isn't more than a few milliseconds off of the real time. However, between processes, the latency could easily be microseconds, and our time will absolutely certainly be microseconds off of the real time. 
+let USE_LMDB_PROCESS_SYNC = true;
+
+function debugLog(...args: any[]) {
+    if (DEBUG_TIME_SYNC) {
+        console.log("[TimeSync]", ...args);
+    }
+}
+
+type TimeOffsetData = {
+    lastOffset: number;
+    lastUpdateTime: number;
+    offset: number;
+    updateTime: number;
+    nextOffset: number;
+    nextUpdateTime: number;
+};
+
+let cachedTimeOffsetData: TimeOffsetData | undefined = undefined;
+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 getTimeComponentsDetailed(): {
+    systemTime: number;
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+    toTime: number;
+} {
+    const systemTime = baseGetTime();
+    const data = cachedTimeOffsetData;
+
+    if (!data) {
+        return {
+            systemTime,
+            fromOffset: 0,
+            toOffset: 0,
+            fromTime: systemTime,
+            toTime: systemTime,
+        };
+    }
+
+    if (systemTime < data.lastUpdateTime) {
+        // Before everything (shouldn't happen)
+        if (THROW_ON_ERROR) throw new Error(`systemTime ${systemTime} is before lastUpdateTime ${data.lastUpdateTime}`);
+        return {
+            systemTime,
+            fromOffset: data.lastOffset,
+            toOffset: data.lastOffset,
+            fromTime: data.lastUpdateTime,
+            toTime: data.lastUpdateTime,
+        };
+    } else if (systemTime < data.updateTime) {
+        // Smear between lastOffset and offset
+        return {
+            systemTime,
+            fromOffset: data.lastOffset,
+            toOffset: data.offset,
+            fromTime: data.lastUpdateTime,
+            toTime: data.updateTime,
+        };
+    } else if (systemTime < data.nextUpdateTime) {
+        // Smear between offset and nextOffset
+        return {
+            systemTime,
+            fromOffset: data.offset,
+            toOffset: data.nextOffset,
+            fromTime: data.updateTime,
+            toTime: data.nextUpdateTime,
+        };
+    } else {
+        // Past everything (shouldn't happen often)
+        if (THROW_ON_ERROR) throw new Error(`systemTime ${systemTime} is past nextUpdateTime ${data.nextUpdateTime}`);
+        return {
+            systemTime,
+            fromOffset: data.nextOffset,
+            toOffset: data.nextOffset,
+            fromTime: data.nextUpdateTime,
+            toTime: data.nextUpdateTime,
+        };
+    }
+}
+
+export function getTimeComponents(): { systemTime: number; offset: number } {
+    const detailed = getTimeComponentsDetailed();
+    const elapsed = detailed.systemTime - detailed.fromTime;
+    const duration = detailed.toTime - detailed.fromTime;
+    const fraction = duration > 0 ? Math.min(1, elapsed / duration) : 0;
+    const offset = detailed.fromOffset + (detailed.toOffset - detailed.fromOffset) * fraction;
+    return { systemTime: detailed.systemTime, offset };
+}
+
+export function getTrueTime() {
+    const { systemTime, offset } = getTimeComponents();
+    let time = systemTime + offset;
+
+    // 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 && offset) {
+        if (time < lastTime) {
+            let diff = systemTime - 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 = systemTime;
+    return time;
+}
+export function getTrueTimeOffset() {
+    const { offset } = getTimeComponents();
+    return offset;
+}
+export function waitForFirstTimeSync(): Promise<void> | undefined {
+    if (didFirstTimeSync) return undefined;
+    return firstTimeSyncPromise;
+}
+let shimmed = false;
+export function shimDateNow() {
+    if (shimmed) return;
+    shimmed = true;
+    Date.now = getTrueTime;
+}
+export function getBrowserTime() {
+    return baseGetTime();
+}
+
+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 timeOffsetDb: import("lmdb").RootDatabase<TimeOffsetData, string> | undefined = undefined;
+async function getTimeOffsetDb() {
+    if (!USE_LMDB_PROCESS_SYNC) return undefined;
+    if (timeOffsetDb) return timeOffsetDb;
+    if (!isNode()) return undefined;
+
+    try {
+        const lmdb = await import("lmdb");
+        const path = await import("path");
+        const os = await import("os");
+
+        const dbPath = path.join(os.tmpdir(), "socket-function-time-offset-2");
+        timeOffsetDb = lmdb.open<TimeOffsetData, string>({
+            path: dbPath,
+            // Enable versioning for conditional writes
+            useVersions: true,
+        });
+        return timeOffsetDb;
+    } catch (e) {
+        console.error("Error opening LMDB database:", e);
+        return undefined;
+    }
+}
+
+async function getTimeOffsetFromLmdb(): Promise<{
+    data: TimeOffsetData;
+    version: number;
+} | undefined> {
+    if (!isNode() || !USE_LMDB_PROCESS_SYNC) {
+        // Skip LMDB for browsers or if disabled
+        return undefined;
+    }
+
+    try {
+        const db = await getTimeOffsetDb();
+        if (!db) return undefined;
+
+        const entry = await db.getEntry("timeOffset"); // Gets {value, version} atomically
+        if (!entry) return undefined;
+
+        const data = entry.value;
+        const version = entry.version;
+
+        if (data &&
+            typeof version === "number" &&
+            typeof data.lastOffset === "number" &&
+            typeof data.lastUpdateTime === "number" &&
+            typeof data.offset === "number" &&
+            typeof data.updateTime === "number" &&
+            typeof data.nextOffset === "number" &&
+            typeof data.nextUpdateTime === "number") {
+            return { data, version };
+        }
+        return undefined;
+    } catch (e) {
+        console.error("Error reading from LMDB database:", e);
+        return undefined;
+    }
+}
+
+async function setTimeOffsetInLmdb(
+    data: TimeOffsetData,
+    expectedVersion: number
+): Promise<boolean> {
+    try {
+        const db = await getTimeOffsetDb();
+        if (!db) return false;
+
+        // Atomic conditional write - only succeeds if version matches expectedVersion
+        // Use random version to minimize collision probability on retries
+        const newVersion = Math.random();
+
+        // Conditional write with version check
+        const success = await db.ifVersion("timeOffset", expectedVersion, () => {
+            return db.put("timeOffset", data, newVersion);
+        });
+
+        return success !== undefined;
+    } catch (e) {
+        console.error("Error writing to LMDB database:", e);
+        return false;
+    }
+}
+
+let getTimeOffsetBase: () => Promise<number> = defaultGetTimeOffset;
+
+async function fetchNewOffset(): Promise<number> {
+    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 (offsets.length === 0) {
+        // All calls failed, return 0 as fallback
+        return 0;
+    }
+
+    // Pick the middle offset
+    offsets.sort((a, b) => a - b);
+    let offset = offsets[Math.floor(offsets.length / 2)];
+
+    // Log if offset is significant
+    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() + "")}`);
+    }
+
+    return offset;
+}
+
+let updatingOffset = false;
+async function updateTimeOffset() {
+    if (updatingOffset) return;
+    updatingOffset = true;
+
+    try {
+        const db = await getTimeOffsetDb();
+        if (!db) {
+            // IMPORTANT: Always use baseGetTime() for scheduling, never getTrueTime().
+            // Our update schedule must be based on the stable system clock, not the
+            // offset-adjusted time which changes as we synchronize.
+            const currentTime = baseGetTime();
+            let cachedData = cachedTimeOffsetData;
+            if (cachedData && currentTime >= cachedData.nextUpdateTime) {
+                // Past the end - reset and reinitialize
+                cachedData = undefined;
+                debugLog("Past nextUpdateTime, resetting");
+            }
+
+            if (!cachedData) {
+                // First time initialization
+                const offset = await fetchNewOffset();
+                cachedTimeOffsetData = {
+                    lastOffset: offset,
+                    lastUpdateTime: currentTime,
+                    offset: offset,
+                    updateTime: currentTime + UPDATE_TRANSITION_GAP,
+                    nextOffset: offset,
+                    nextUpdateTime: currentTime + UPDATE_TRANSITION_GAP * 2,
+                };
+                debugLog("Initialized - time offset:", offset, "ms, next update in", UPDATE_TRANSITION_GAP, "ms");
+            } else if (currentTime >= cachedData.updateTime) {
+                // Time to rotate
+                const newOffset = await fetchNewOffset();
+                cachedTimeOffsetData = {
+                    lastOffset: cachedData.offset,
+                    lastUpdateTime: cachedData.updateTime,
+                    offset: cachedData.nextOffset,
+                    updateTime: cachedData.nextUpdateTime,
+                    nextOffset: newOffset,
+                    nextUpdateTime: cachedData.nextUpdateTime + UPDATE_TRANSITION_GAP,
+                };
+                const timeUntilNext = cachedTimeOffsetData.nextUpdateTime - baseGetTime();
+                debugLog("Advancing time offset - current:", cachedTimeOffsetData.offset, "ms, next:", cachedTimeOffsetData.nextOffset, "ms, next update in", timeUntilNext, "ms");
+            }
+
+            if (!didFirstTimeSync) {
+                didFirstTimeSync = true;
+                onFirstTimeSync();
+            }
+            return;
+        }
+
+        // At this point: Node.js, LMDB enabled and working
+        // Main LMDB path with atomic synchronization
+        while (true) {
+            const entry = await getTimeOffsetFromLmdb();
+            // IMPORTANT: Always use baseGetTime() for scheduling, never getTrueTime().
+            // Our update schedule must be based on the stable system clock, not the
+            // offset-adjusted time which changes as we synchronize.
+            const currentTime = baseGetTime();
+
+            let cachedData = entry?.data;
+            const readVersion = entry?.version;
+
+            if (cachedData && currentTime >= cachedData.nextUpdateTime) {
+                // Past the end - reset and reinitialize
+                cachedData = undefined;
+                debugLog("Past nextUpdateTime, resetting");
+            }
+
+            if (!cachedData || !readVersion) {
+                // First time initialization - use conditional write to handle race
+                const offset = await fetchNewOffset();
+                const initData: TimeOffsetData = {
+                    lastOffset: offset,
+                    lastUpdateTime: currentTime,
+                    offset: offset,
+                    updateTime: currentTime + UPDATE_TRANSITION_GAP,
+                    nextOffset: offset,
+                    nextUpdateTime: currentTime + UPDATE_TRANSITION_GAP * 2,
+                };
+
+                const newVersion = Math.random();
+
+                if (readVersion) {
+                    const success = await setTimeOffsetInLmdb(initData, readVersion);
+                    if (!success) {
+                        debugLog("Lost the race, retrying");
+                        // Lost the race, retry
+                        continue;
+                    }
+                    console.log("Successfully wrote atomic reset");
+                    break;
+                }
+
+                // Try to write our data
+                await db.put("timeOffset", initData, newVersion);
+
+                // Read back to see what actually got written
+                const actualEntry = await db.getEntry("timeOffset");
+                if (actualEntry?.version !== newVersion) {
+                    // Lost the race, another process wrote after us
+                    // Retry from the top to read their data
+                    debugLog("Value was changed by another process, retrying");
+                    continue;
+                }
+
+                // We won the race, use our data
+                cachedTimeOffsetData = initData;
+                debugLog("Initialized - time offset:", offset, "ms, next update in", UPDATE_TRANSITION_GAP, "ms");
+                break;
+            }
+
+            if (currentTime >= cachedData.updateTime) {
+                // Time to rotate
+                const newOffset = await fetchNewOffset();
+                const newData: TimeOffsetData = {
+                    lastOffset: cachedData.offset,
+                    lastUpdateTime: cachedData.updateTime,
+                    offset: cachedData.nextOffset,
+                    updateTime: cachedData.nextUpdateTime,
+                    nextOffset: newOffset,
+                    nextUpdateTime: cachedData.nextUpdateTime + UPDATE_TRANSITION_GAP,
+                };
+
+                const success = await setTimeOffsetInLmdb(newData, readVersion);
+                if (!success) {
+                    // Lost the race, retry
+                    continue;
+                }
+
+                const timeUntilNext = newData.nextUpdateTime - baseGetTime();
+                debugLog("Advancing time offset - current:", newData.offset, "ms, next:", newData.nextOffset, "ms, next update in", timeUntilNext, "ms");
+                cachedTimeOffsetData = newData;
+                break;
+            } else {
+                cachedTimeOffsetData = cachedData;
+                const timeUntilNext = cachedData.updateTime - baseGetTime();
+                debugLog("Loaded from LMDB - current:", cachedData.offset, "ms, next:", cachedData.nextOffset, "ms, next update in", timeUntilNext, "ms");
+                break;
+            }
+        }
+
+        if (!didFirstTimeSync) {
+            didFirstTimeSync = true;
+            onFirstTimeSync();
+        }
+    } finally {
+        updatingOffset = false;
+    }
+}
+
+setInterval(() => {
+    updateTimeOffset().catch((e) => {
+        console.warn("Error updating time offset:", e);
+    });
+}, UPDATE_CHECK_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: {
+            // No hooks, as this needs to run very early on. Also, it is basically just a ping,
+            //  so it should be safe for anyone to use (we might even make it just a regular HTTPS endpoint,
+            //  or even just set up a dedicated domain for this).
+            noDefaultHooks: true,
+            noClientHooks: true,
+        },
+    }),
+    () => ({}),
+    {
+        // NOTE: Autoexpose, because our exposed endpoints are incredibly lightweight
+        //  (just a ping), and don't expose really expose any data.
+        // noAutoExpose: true
+    }
 );