socket-function 1.1.49 → 1.2.1

package/src/dist/CallFactory.ts.cache

@@ -0,0 +1,930 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.getStats = exports.createCallFactory = exports.harvestCallTimes = exports.getPendingCallCount = exports.harvestFailedCallCount = void 0;
+const callManager_1 = require("./callManager");
+const misc_1 = require("./misc");
+const websocketFactory_1 = require("./websocketFactory");
+const SocketFunction_1 = require("../SocketFunction");
+const nodeCache_1 = require("./nodeCache");
+const caching_1 = require("./caching");
+const logColors_1 = require("./formatting/logColors");
+const fixLargeNetworkCalls_1 = require("./fixLargeNetworkCalls");
+const batching_1 = require("./batching");
+const format_1 = require("./formatting/format");
+const compileFlags_1 = require("../require/compileFlags");
+const measure_1 = require("./profiling/measure");
+const Zip_1 = require("./Zip");
+const protocolNegotiation_1 = require("./protocolNegotiation");
+setImmediate(() => Promise.resolve().then(() => __importStar(require("./lz4/LZ4"))));
+(0, compileFlags_1.setFlag)(require, "pako", "allowclient", true);
+// NOTE: If it is too low, and too many servers disconnect, we can easily spend 100% of our time
+//  trying to reconnect.
+//  (Or... maybe the delay is just waiting, and we aren't actually overloading the server?)
+const MIN_RETRY_DELAY = 5000;
+const INITIALIZE_STATE_SEQ_NUM = -1;
+let pendingCallCount = 0;
+let harvestableFailedCalls = 0;
+const CALL_TIMES_LIMIT = 1000 * 1000 * 10;
+let harvestableCallTimes = [];
+function harvestFailedCallCount() {
+    let count = harvestableFailedCalls;
+    harvestableFailedCalls = 0;
+    return count;
+}
+exports.harvestFailedCallCount = harvestFailedCallCount;
+function getPendingCallCount() {
+    return pendingCallCount;
+}
+exports.getPendingCallCount = getPendingCallCount;
+function harvestCallTimes() {
+    let times = harvestableCallTimes;
+    harvestableCallTimes = [];
+    return times;
+}
+exports.harvestCallTimes = harvestCallTimes;
+(0, batching_1.runInfinitePoll)(misc_1.timeInMinute * 15, () => {
+    if (harvestableCallTimes.length > CALL_TIMES_LIMIT) {
+        harvestableCallTimes = harvestableCallTimes.slice(-CALL_TIMES_LIMIT);
+    }
+});
+async function createCallFactory(webSocketBase, 
+// The node id we are connecting to (or that connected to us)
+nodeId, 
+// The node id that we were contacted on
+localNodeId = "") {
+    let niceConnectionName = nodeId;
+    const createWebsocket = (0, websocketFactory_1.createWebsocketFactory)();
+    const registerOnce = (0, caching_1.lazy)(() => (0, nodeCache_1.registerNodeClient)(callFactory));
+    let canReconnect = !!(0, nodeCache_1.getNodeIdLocation)(nodeId);
+    let pendingCalls = new Map();
+    // NOTE: It is important to make this as random as possible, to prevent
+    //  reconnections dues to a process being reset causing seqNum collisions
+    //  in return calls.
+    let nextSeqNum = Date.now() + Math.random();
+    // NOTE: I'm not sure if this is needed, I thought it was, but... now I think
+    //  it probably isn't...
+    // if (webSocketBase?.readyState === 1 /* OPEN */ && webSocketBase.ping) {
+    //     // Heartbeat loop, otherwise onDisconnect is never called.
+    //     ((async () => {
+    //         while (webSocketBase?.readyState === 1 /* OPEN */ && webSocketBase.ping) {
+    //             await delay(1000 * 60);
+    //             webSocketBase.ping?.();
+    //         }
+    //     }))().catch(() => { });
+    // }
+    let lastConnectionAttempt = 0;
+    let callerContext = {
+        nodeId,
+        localNodeId
+    };
+    let disconnectCallbacks = new Set();
+    function onNextDisconnect(callback) {
+        disconnectCallbacks.add(callback);
+    }
+    let callFactory = {
+        nodeId,
+        lastClosed: 0,
+        connectionId: { nodeId },
+        receivedInitializeState: undefined,
+        onNextDisconnect,
+        disconnect() {
+            canReconnect = false;
+            callFactory.closedForever = true;
+            if (webSocketPromise) {
+                webSocketPromise.then(ws => ws.close()).catch(() => { });
+            }
+        },
+        async performCall(call) {
+            var _a;
+            let seqNum = nextSeqNum++;
+            let fullCall = {
+                nodeId,
+                isReturn: false,
+                args: call.args,
+                classGuid: call.classGuid,
+                functionName: call.functionName,
+                seqNum,
+            };
+            let data;
+            let originalArgs = call.args;
+            let time = Date.now();
+            let sendStats = {
+                uncompressedSize: 0,
+                compressedSize: 0,
+            };
+            try {
+                if ((_a = callFactory.receivedInitializeState) === null || _a === void 0 ? void 0 : _a.supportsLZ4) {
+                    let compressMode = (0, callManager_1.shouldCompressCall)(fullCall);
+                    // If it's undefined, then we compress it. We basically always want to compress from now on, because LZ4 is so fast. 
+                    if (compressMode !== false) {
+                        fullCall.args = await compressObjLZ4(fullCall.args, sendStats);
+                        fullCall.isArgsCompressed = "LZ4";
+                    }
+                }
+                else {
+                    if ((0, callManager_1.shouldCompressCall)(fullCall)) {
+                        fullCall.args = await compressObj(fullCall.args, sendStats);
+                        fullCall.isArgsCompressed = "zip";
+                    }
+                }
+                let dataMaybePromise = SocketFunction_1.SocketFunction.WIRE_SERIALIZER.serialize(fullCall);
+                if (dataMaybePromise instanceof Promise) {
+                    data = await dataMaybePromise;
+                }
+                else {
+                    data = dataMaybePromise;
+                }
+                if (!sendStats.compressedSize) {
+                    let totalSize = 0;
+                    for (let d of data) {
+                        totalSize += d.length;
+                    }
+                    sendStats.uncompressedSize = totalSize;
+                    sendStats.compressedSize = totalSize;
+                }
+                addSendStats(sendStats);
+            }
+            catch (e) {
+                throw new Error(`Error serializing data for call ${call.classGuid}.${call.functionName}\n${e.stack}`);
+            }
+            time = Date.now() - time;
+            let size = data.map(x => x.length).reduce((a, b) => a + b, 0);
+            if (time > SocketFunction_1.SocketFunction.WIRE_WARN_TIME) {
+                console.log((0, logColors_1.red)(`Slow serialize, took ${(0, format_1.formatTime)(time)} to serialize ${(0, format_1.formatNumber)(size)} bytes. For ${call.classGuid}.${call.functionName}`));
+            }
+            if (size > SocketFunction_1.SocketFunction.MAX_MESSAGE_SIZE * 1.5) {
+                let splitArgIndex = originalArgs.findIndex(fixLargeNetworkCalls_1.isSplitableArray);
+                if (splitArgIndex >= 0) {
+                    console.log((0, logColors_1.yellow)(`Splitting large call due to large args: ${call.classGuid}.${call.functionName}`));
+                    let SPLIT_GROUPS = 10;
+                    let splitArg = originalArgs[splitArgIndex];
+                    let subCalls = (0, misc_1.list)(SPLIT_GROUPS).map(index => {
+                        let start = Math.floor(index / SPLIT_GROUPS * splitArg.length);
+                        let end = Math.floor((index + 1) / SPLIT_GROUPS * splitArg.length);
+                        return splitArg.slice(start, end);
+                    }).filter(x => x.length > 0);
+                    let calls = subCalls.map(async (splitList) => {
+                        let subCall = { ...call };
+                        subCall.args = subCall.args.slice();
+                        subCall.args[splitArgIndex] = (0, fixLargeNetworkCalls_1.markArrayAsSplitable)(splitList);
+                        await callFactory.performCall(subCall);
+                    });
+                    await Promise.allSettled(calls);
+                    await Promise.all(calls);
+                    // Eh... we COULD return the array of results, but... then the result would sometimes be an array,
+                    //  some times not, so, it is better to return a string which will make it more clear why it sometimes varies.
+                    return "CALLS_SPLIT_DUE_TO_LARGE_ARGS";
+                }
+                throw new Error(`Call too large to send (${call.classGuid}.${call.functionName}, size: ${(0, format_1.formatNumber)(size)} > ${(0, format_1.formatNumber)(SocketFunction_1.SocketFunction.MAX_MESSAGE_SIZE)}). If you need to handle very large static data use some external service, such as Backblaze B2 or AWS S3. Or consider fragmenting data at an application level, because sending large data will cause large lag spikes for other clients using this server. Or, if absolutely required, set SocketFunction.MAX_MESSAGE_SIZE to a higher value.`);
+            }
+            let resultPromise = new Promise((resolve, reject) => {
+                let startTime = Date.now();
+                pendingCallCount++;
+                let callback = (result) => {
+                    pendingCallCount--;
+                    pendingCalls.delete(seqNum);
+                    harvestableCallTimes.push({ start: startTime, end: Date.now(), });
+                    if (result.error) {
+                        reject((0, misc_1.convertErrorStackToError)(result.error));
+                    }
+                    else {
+                        resolve(result.result);
+                    }
+                };
+                pendingCalls.set(seqNum, { callback, data, call: fullCall });
+            });
+            {
+                let resultSize = data.map(x => x.length).reduce((a, b) => a + b, 0);
+                for (let callback of SocketFunction_1.SocketFunction.trackMessageSizes.upload) {
+                    callback(resultSize);
+                }
+                if (SocketFunction_1.SocketFunction.logMessages) {
+                    let fncHack = "";
+                    if (call.functionName === "addCall") {
+                        let arg = originalArgs[0];
+                        fncHack = `.${arg.DomainName}.${arg.ModuleId}.${arg.FunctionId}`;
+                    }
+                    console.log(`SIZE\t${((0, misc_1.formatNumberSuffixed)(resultSize) + `B`).padEnd(4, " ")}\t${(0, format_1.formatNumber)(data.length)} buffers\tREMOTE CALL\t${call.classGuid}.${call.functionName}${fncHack} at ${Date.now()}`);
+                }
+            }
+            // If sending OR resultPromise throws, we want to error out. This solves some issues with resultPromise
+            //      erroring out first, which is before we await it, which makes NodeJS angry (unhandled promise rejection).
+            //      Also, technically, we could receive the result before we finish sending, in which case, we might
+            //      as well return it immediately.
+            await Promise.race([send(data), resultPromise]);
+            return await resultPromise;
+        }
+    };
+    let webSocketPromise;
+    let hasEverConnected = false;
+    if (webSocketBase) {
+        webSocketPromise = Promise.resolve(webSocketBase);
+        await initializeWebsocket(webSocketBase);
+    }
+    async function initializeWebsocket(newWebSocket, skipCloseHandling = false) {
+        registerOnce();
+        callFactory.receivedInitializeState = undefined;
+        function onClose(error) {
+            // 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;
+            webSocketPromise = undefined;
+            if (!canReconnect) {
+                callFactory.closedForever = true;
+            }
+            for (let [key, call] of pendingCalls) {
+                harvestableFailedCalls++;
+                pendingCalls.delete(key);
+                call.callback({
+                    isReturn: true,
+                    result: undefined,
+                    error: error,
+                    seqNum: call.call.seqNum,
+                });
+            }
+            let callbacks = disconnectCallbacks;
+            disconnectCallbacks = new Set();
+            for (let callback of callbacks) {
+                try {
+                    callback();
+                }
+                catch (_a) { }
+            }
+        }
+        newWebSocket.addEventListener("error", e => {
+            // NOTE: No more logging, as we throw, so the caller should be logging the
+            //  error (or swallowing it, if that is what it wants to do).
+            //console.log(`Websocket error for ${niceConnectionName}`, e.message);
+            onClose(new Error(`Connection error for ${niceConnectionName}: ${e.message}`).stack);
+        });
+        newWebSocket.addEventListener("close", async () => {
+            //console.log(`Websocket closed ${niceConnectionName}`);
+            onClose(new Error(`Connection closed to ${niceConnectionName}`).stack);
+        });
+        newWebSocket.addEventListener("message", onMessage);
+        if (newWebSocket.readyState === 0 /* CONNECTING */) {
+            await new Promise(resolve => {
+                newWebSocket.addEventListener("open", () => {
+                    if (!SocketFunction_1.SocketFunction.silent) {
+                        console.log(`Connection established to ${niceConnectionName}`);
+                    }
+                    callFactory.isConnected = true;
+                    hasEverConnected = true;
+                    resolve();
+                });
+                newWebSocket.addEventListener("close", () => resolve());
+                newWebSocket.addEventListener("error", () => resolve());
+            });
+        }
+        else if (newWebSocket.readyState === 1 /* OPEN */) {
+            callFactory.isConnected = true;
+            hasEverConnected = true;
+        }
+        else {
+            onClose(new Error(`Websocket received in closed state`).stack);
+        }
+        if (callFactory.lastClosed && callFactory.isConnected) {
+            console.log(`Successfully reconnected to ${nodeId}, which has been closed for ${(0, format_1.formatTime)(Date.now() - callFactory.lastClosed)}`, { nodeId });
+        }
+        if (callFactory.isConnected && newWebSocket.protocol) {
+            let decoded = (0, protocolNegotiation_1.decodeProtocol)(newWebSocket.protocol);
+            if (decoded) {
+                callFactory.receivedInitializeState = {
+                    supportsLZ4: decoded.flags.serverLZ4,
+                };
+                callFactory.protocolNegotiated = true;
+                if (SocketFunction_1.SocketFunction.logMessages) {
+                    console.log((0, logColors_1.green)(`Negotiated protocol with ${niceConnectionName}: target=${decoded.target}, clientLZ4=${decoded.flags.clientLZ4}, serverLZ4=${decoded.flags.serverLZ4}`));
+                }
+            }
+        }
+    }
+    const BASE_LENGTH_OFFSET = 324432461592612;
+    let sendInSerial = (0, batching_1.runInSerial)(async (val) => val());
+    async function sendRaw(data) {
+        if (!webSocketPromise) {
+            if (canReconnect) {
+                webSocketPromise = tryToReconnect();
+            }
+            else {
+                throw new Error(`Cannot send data to ${niceConnectionName} as the connection has closed`);
+            }
+        }
+        let webSocket = await webSocketPromise;
+        await sendInSerial(async () => {
+            for (let d of data) {
+                if (d.length > 1000 * 1000 * 10) {
+                    console.log(`Sending large packet ${(0, format_1.formatNumber)(d.length)}B to ${nodeId} at ${Date.now()}`);
+                }
+                // NOTE: If our latency is 500ms, with 10MB/s, then we need a high water
+                //  mark of at least 5MB, otherwise our connection is slowed down.
+                //  - Using the actual high water mark is too difficult, as we receive incoming connections.
+                //      This is also easier to configure, and we can dynamically change it if we have to.
+                // NOTE: In practice we only hit this when sending large Buffers (~30MB), so low values
+                //  are equivalent to waiting for drain. We want to avoid waiting for drain, so we use a high value.
+                const maxWriteBuffer = 128 * 1024 * 1024;
+                webSocket.send(d);
+                let socket = webSocket._socket;
+                if (socket) {
+                    while (socket.writableLength > maxWriteBuffer) {
+                        // NOTE: Waiting 1ms probably waits more like 16ms.
+                        await new Promise(r => setTimeout(r, 1));
+                    }
+                }
+            }
+        });
+    }
+    async function send(data) {
+        await sendRaw([
+            (data.length + BASE_LENGTH_OFFSET).toString(),
+            ...data,
+        ]);
+    }
+    async function sendWithHeader(data, header) {
+        if (data.some(x => x.length > SocketFunction_1.SocketFunction.MAX_MESSAGE_SIZE * 1.5)) {
+            if (header.type === "Buffer" || header.type === "Buffer[]") {
+                header.bufferLengths = data.map(x => x.length);
+                let fitBuffers = [];
+                for (let buf of data) {
+                    if (buf.length > SocketFunction_1.SocketFunction.MAX_MESSAGE_SIZE) {
+                        let offset = 0;
+                        while (offset < buf.length) {
+                            fitBuffers.push(buf.slice(offset, offset + SocketFunction_1.SocketFunction.MAX_MESSAGE_SIZE));
+                            offset += SocketFunction_1.SocketFunction.MAX_MESSAGE_SIZE;
+                        }
+                    }
+                    else {
+                        fitBuffers.push(buf);
+                    }
+                }
+                data = fitBuffers;
+                header.bufferCount = fitBuffers.length;
+            }
+            else {
+                throw new Error(`Cannot send large amounts of data unless we are returning Buffer or Buffer[]`);
+            }
+        }
+        // if (totalResultSize > SocketFunction.MAX_MESSAGE_SIZE * 1.5) {
+        // Split up Buffer[] if they are too large
+        await sendRaw([
+            JSON.stringify(header),
+            ...data,
+        ]);
+    }
+    // IMPORTANT! NEVER allow for reconnection of client ids. A lot of code depends on the fact that clients will reconnect with a new client node id when they disconnect!
+    async function tryToReconnect() {
+        // Don't try to reconnect too often!
+        let timeSinceLastAttempt = Date.now() - lastConnectionAttempt;
+        if (timeSinceLastAttempt < MIN_RETRY_DELAY) {
+            await new Promise(r => setTimeout(r, MIN_RETRY_DELAY - timeSinceLastAttempt));
+        }
+        lastConnectionAttempt = Date.now();
+        // Try alternates, and if any work, use them.
+        try {
+            let alternates = await SocketFunction_1.SocketFunction.GET_ALTERNATE_NODE_IDS(nodeId);
+            if (alternates) {
+                for (let alternateNodeId of alternates) {
+                    let newWebSocket = createWebsocket(alternateNodeId, (0, protocolNegotiation_1.proposeProtocols)((0, misc_1.isNode)() ? nodeId : undefined, { lz4: true }));
+                    await initializeWebsocket(newWebSocket, true);
+                    if (callFactory.isConnected) {
+                        return newWebSocket;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error("Error getting alternate node IDs", e);
+        }
+        let newWebSocket = createWebsocket(nodeId, (0, protocolNegotiation_1.proposeProtocols)(!SocketFunction_1.SocketFunction.isClient() ? nodeId : undefined, { lz4: true }));
+        await initializeWebsocket(newWebSocket);
+        return newWebSocket;
+    }
+    let pendingCall;
+    async function processPendingCall() {
+        var _a, _b;
+        if (!pendingCall)
+            throw new Error(`No pending call`);
+        let currentCall = pendingCall;
+        pendingCall = undefined;
+        let currentBuffers = currentCall.buffers;
+        let call;
+        let resultSize;
+        let time = Date.now();
+        if (currentCall.type === "Buffer" || currentCall.type === "Buffer[]") {
+            let result = currentBuffers;
+            if (currentCall.bufferLengths) {
+                let pendingBuffers = currentBuffers;
+                function takeBuffer(len) {
+                    let lenLeft = len;
+                    let buffers = [];
+                    while (lenLeft > 0) {
+                        let buf = currentBuffers.shift();
+                        if (!buf) {
+                            throw new Error(`Not enough buffers received.`);
+                        }
+                        if (buf.length > lenLeft) {
+                            buffers.push(buf.slice(0, lenLeft));
+                            currentBuffers.unshift(buf.slice(lenLeft));
+                            break;
+                        }
+                        else {
+                            buffers.push(buf);
+                            lenLeft -= buf.length;
+                        }
+                    }
+                    if (buffers.length === 1) {
+                        return buffers[0];
+                    }
+                    return Buffer.concat(buffers);
+                }
+                result = currentCall.bufferLengths.map(takeBuffer);
+                if (pendingBuffers.length > 0) {
+                    throw new Error(`Received too many buffers.`);
+                }
+            }
+            resultSize = result.map(x => x.length).reduce((a, b) => a + b, 0);
+            if (currentCall.type === "Buffer") {
+                if (result.length === 1) {
+                    result = result[0];
+                }
+                else {
+                    result = Buffer.concat(result);
+                }
+            }
+            call = {
+                ...currentCall.metadata,
+                result,
+            };
+        }
+        else {
+            resultSize = currentBuffers.map(x => x.length).reduce((a, b) => a + b, 0);
+            call = await SocketFunction_1.SocketFunction.WIRE_SERIALIZER.deserialize(currentBuffers);
+        }
+        let parseTime = Date.now() - time;
+        for (let callback of SocketFunction_1.SocketFunction.trackMessageSizes.download) {
+            callback(resultSize);
+        }
+        let receiveStats = {
+            uncompressedSize: resultSize,
+            compressedSize: resultSize,
+        };
+        let sendStats = {
+            uncompressedSize: 0,
+            compressedSize: 0,
+        };
+        if (call.isReturn) {
+            // Tolerate the legacy initialize packet from old peers — silently
+            // ignore so it doesn't get logged as an unknown call. Our actual
+            // initialize state comes from Sec-WebSocket-Protocol negotiation.
+            if (call.seqNum === INITIALIZE_STATE_SEQ_NUM) {
+                return;
+            }
+            let callbackObj = pendingCalls.get(call.seqNum);
+            if (parseTime > SocketFunction_1.SocketFunction.WIRE_WARN_TIME) {
+                console.log((0, logColors_1.red)(`Slow parse, took ${parseTime}ms to parse ${resultSize} bytes, for receiving result of call to ${callbackObj === null || callbackObj === void 0 ? void 0 : callbackObj.call.classGuid}.${callbackObj === null || callbackObj === void 0 ? void 0 : callbackObj.call.functionName}`));
+            }
+            if (!callbackObj) {
+                console.log((0, logColors_1.blue)(`Got return for unknown call ${call.seqNum} (created at time ${new Date(call.seqNum)}), ${nodeId} / ${localNodeId}`));
+                return;
+            }
+            if (SocketFunction_1.SocketFunction.logMessages) {
+                let call = callbackObj.call;
+                console.log(`SIZE\t${((0, misc_1.formatNumberSuffixed)(resultSize) + "B").padEnd(4, " ")}\t${(0, format_1.formatNumber)(currentBuffers.length)} buffers\tRETURN\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
+            }
+            if (call.isResultCompressed === "LZ4") {
+                call.result = await decompressObjLZ4(call.result, receiveStats);
+                call.isResultCompressed = undefined;
+            }
+            else if (call.isResultCompressed === "zip" || call.isResultCompressed === true) {
+                call.result = await decompressObj(call.result, receiveStats);
+                call.isResultCompressed = undefined;
+            }
+            callbackObj.callback(call);
+        }
+        else {
+            if (call.isArgsCompressed === "LZ4") {
+                call.args = await decompressObjLZ4(call.args, sendStats);
+                call.isArgsCompressed = undefined;
+            }
+            else if (call.isArgsCompressed === "zip" || call.isArgsCompressed === true) {
+                call.args = await decompressObj(call.args, sendStats);
+                call.isArgsCompressed = undefined;
+            }
+            if (SocketFunction_1.SocketFunction.logMessages) {
+                console.log(`SIZE\t${((0, misc_1.formatNumberSuffixed)(resultSize) + "B").padEnd(4, " ")}\tEVALUATE\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
+            }
+            if (parseTime > SocketFunction_1.SocketFunction.WIRE_WARN_TIME) {
+                console.log((0, logColors_1.red)(`Slow parse, took ${parseTime}ms to parse ${resultSize} bytes, for call to ${call.classGuid}.${call.functionName}`));
+            }
+            let response;
+            try {
+                SocketFunction_1.SocketFunction.TOTAL_CALLS++;
+                let result = await (0, callManager_1.performLocalCall)({ call, caller: callerContext });
+                response = {
+                    isReturn: true,
+                    result,
+                    seqNum: call.seqNum,
+                };
+                if (SocketFunction_1.SocketFunction.logMessages) {
+                    let timeTaken = Date.now() - time;
+                    console.log(`DUR\t${((0, format_1.formatTime)(timeTaken)).padEnd(6, " ")}\tFINISH\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
+                }
+                if ((_a = callFactory.receivedInitializeState) === null || _a === void 0 ? void 0 : _a.supportsLZ4) {
+                    let compressMode = (0, callManager_1.shouldCompressCall)(call);
+                    if (compressMode !== false) {
+                        response.result = await compressObjLZ4(response.result, sendStats);
+                        response.isResultCompressed = "LZ4";
+                    }
+                }
+                else {
+                    if ((0, callManager_1.shouldCompressCall)(call)) {
+                        response.result = await compressObj(response.result, sendStats);
+                        response.isResultCompressed = "zip";
+                    }
+                }
+            }
+            catch (e) {
+                response = {
+                    isReturn: true,
+                    result: undefined,
+                    seqNum: call.seqNum,
+                    error: e.stack,
+                };
+            }
+            {
+                let start = time;
+                let end = Date.now();
+                for (let fnc of SocketFunction_1.SocketFunction.trackMessageSizes.callTimes) {
+                    fnc({ start, end });
+                }
+            }
+            let size = 0;
+            if (response.result instanceof Buffer) {
+                let { result, ...remaining } = response;
+                size = result.length;
+                await sendWithHeader([result], { type: "Buffer", bufferCount: 1, metadata: remaining });
+            }
+            else if (Array.isArray(response.result) && response.result.every(x => x instanceof Buffer)) {
+                let { result, ...remaining } = response;
+                for (let r of result) {
+                    size += r.length;
+                }
+                await sendWithHeader(result, { type: "Buffer[]", bufferCount: result.length, metadata: remaining });
+            }
+            else {
+                const LIMIT = ((_b = (0, callManager_1.getCallFlags)(call)) === null || _b === void 0 ? void 0 : _b.responseLimit) || SocketFunction_1.SocketFunction.MAX_MESSAGE_SIZE * 1.5;
+                let result = await SocketFunction_1.SocketFunction.WIRE_SERIALIZER.serialize(response);
+                let totalResultSize = result.map(x => x.length).reduce((a, b) => a + b, 0);
+                if (totalResultSize > LIMIT) {
+                    response = {
+                        isReturn: true,
+                        result: undefined,
+                        seqNum: call.seqNum,
+                        error: new Error(`Response too large to send. Return Buffer[] to exceed the limits, or set responseLimit when registering the collection. ${call.classGuid}.${call.functionName}, size: ${(0, format_1.formatNumber)(totalResultSize)} > ${(0, format_1.formatNumber)(SocketFunction_1.SocketFunction.MAX_MESSAGE_SIZE)}. If you need to handle very large static data use some external service, such as Backblaze B2 or AWS S3. Or, if absolutely required, set SocketFunction.MAX_MESSAGE_SIZE to a higher value.`).stack,
+                    };
+                    result = await SocketFunction_1.SocketFunction.WIRE_SERIALIZER.serialize(response);
+                }
+                for (let r of result) {
+                    size += r.length;
+                }
+                await send(result);
+            }
+            // If we have no size, then it's probably uncompressed
+            if (!sendStats.compressedSize) {
+                sendStats.compressedSize = size;
+                sendStats.uncompressedSize = size;
+            }
+        }
+        addSendStats(sendStats);
+        addReceiveStats(receiveStats);
+    }
+    let clientsideSerial = (0, batching_1.runInSerial)(async (val) => val);
+    async function onMessage(message) {
+        try {
+            if (typeof message === "object" && "data" in message) {
+                message = message.data;
+            }
+            // Extra clienside parsing is required
+            if (!(0, misc_1.isNode)()) {
+                // Immediately start the arrayBuffer conversion. This should be fast, but...
+                //  maybe we will add more here, and so doing it in parallel might be useful.
+                let fixMessageBlob = (async () => {
+                    if (message instanceof Blob) {
+                        message = Buffer.from(await message.arrayBuffer());
+                    }
+                })();
+                // We need to force the results to be in serial, otherwise strings leapfrog
+                //  ahead of buffers, which breaks things.
+                await clientsideSerial(fixMessageBlob);
+            }
+            if (typeof message === "string") {
+                if (message.startsWith("{")) {
+                    let obj = JSON.parse(message);
+                    pendingCall = {
+                        ...obj,
+                        buffers: [],
+                    };
+                }
+                else {
+                    let count = parseInt(message);
+                    if (isNaN(count)) {
+                        throw new Error(`Invalid message count ${message}`);
+                    }
+                    if (count < BASE_LENGTH_OFFSET) {
+                        throw new Error(`Invalid message count ${message}`);
+                    }
+                    count -= BASE_LENGTH_OFFSET;
+                    if (count > 1000 * 1000) {
+                        throw new Error(`Invalid message count ${count}`);
+                    }
+                    pendingCall = {
+                        buffers: [],
+                        bufferCount: count,
+                        type: "serialized",
+                    };
+                }
+                if ((pendingCall === null || pendingCall === void 0 ? void 0 : pendingCall.bufferCount) === 0) {
+                    await processPendingCall();
+                }
+                return;
+            }
+            if (message instanceof Buffer) {
+                if (!pendingCall) {
+                    throw new Error(`Received data without size ${message.byteLength}B, first 100 bytes: ${message.slice(0, 100).toString("hex")}`);
+                }
+                let totalSize = message.byteLength + pendingCall.buffers.reduce((a, b) => a + b.length, 0);
+                if (totalSize > 1000 * 1000 * 10 || pendingCall.bufferCount > 1000 && (pendingCall.buffers.length % 100 === 0)) {
+                    if (pendingCall.buffers.length === 0) {
+                        console.log(`Received large/many packets ${(0, format_1.formatNumber)(totalSize)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) at ${Date.now()}`);
+                    }
+                    else {
+                        let elapsed = Date.now() - (pendingCall.firstReceivedTime || 0);
+                        console.log(`Received large/many packets ${(0, format_1.formatNumber)(totalSize)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) after ${(0, format_1.formatTime)(elapsed)}`);
+                    }
+                }
+                if (pendingCall.buffers.length === 0) {
+                    pendingCall.firstReceivedTime = Date.now();
+                }
+                pendingCall.buffers.push(message);
+                if (pendingCall.buffers.length !== pendingCall.bufferCount) {
+                    return;
+                }
+                await processPendingCall();
+                return;
+            }
+            throw new Error(`Unhandled data type ${typeof message}`);
+        }
+        catch (e) {
+            let err = e.stack || e.message || e;
+            // NOTE: I'm looking for all types of errors here (specifically, .send errors), in case
+            //  there are errors I should be handling.
+            if (err.startsWith("Error: Cannot send data to") && err.includes("as the connection has closed")) {
+                // This is fine, just ignore it
+            }
+            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 {
+                console.error(e.stack);
+            }
+        }
+    }
+    return callFactory;
+}
+exports.createCallFactory = createCallFactory;
+let uncompressedSent = 0;
+let compressedSent = 0;
+let uncompressedReceived = 0;
+let compressedReceived = 0;
+let sendCount = 0;
+let receiveCount = 0;
+function addSendStats(stats) {
+    uncompressedSent += stats.uncompressedSize;
+    compressedSent += stats.compressedSize;
+    sendCount++;
+}
+function addReceiveStats(stats) {
+    uncompressedReceived += stats.uncompressedSize;
+    compressedReceived += stats.compressedSize;
+    receiveCount++;
+}
+function getStats() {
+    return {
+        uncompressedSent,
+        compressedSent,
+        uncompressedReceived,
+        compressedReceived,
+        sendCount,
+        receiveCount,
+    };
+}
+exports.getStats = getStats;
+// Register this late as I don't want it to appear before the memory register info, which is use more useful than the network one. 
+setImmediate(() => {
+    (0, measure_1.registerMeasureInfo)(() => `NET => ${(0, format_1.formatNumber)(compressedSent)}B (${(0, format_1.formatNumber)(uncompressedSent)}B/${(0, format_1.formatNumber)(sendCount)}) / <= ${(0, format_1.formatNumber)(compressedReceived)}B (${(0, format_1.formatNumber)(uncompressedReceived)}B/${(0, format_1.formatNumber)(receiveCount)})`);
+});
+const compressObj = (0, measure_1.measureWrap)(async function wireCallCompress(obj, stats) {
+    let buffers = await SocketFunction_1.SocketFunction.WIRE_SERIALIZER.serialize(obj);
+    if (buffers.length > 1) {
+        throw new Error("Legacy CompressObj only supports single buffer");
+    }
+    let lengthBuffer = Buffer.from((new Float64Array(buffers.map(x => x.length))).buffer);
+    let buffer = Buffer.concat([lengthBuffer, ...buffers]);
+    stats.uncompressedSize += buffer.length;
+    let result = await Zip_1.Zip.gzip(buffer);
+    stats.compressedSize += result.length;
+    return result;
+});
+// Assumes the caller already added the obj.length to both the uncompressedSize and compressedSize, and is just looking to update the uncompressedSize to be larger according to the size after we uncompress
+const decompressObj = (0, measure_1.measureWrap)(async function wireCallDecompress(obj, stats) {
+    let buffer = await Zip_1.Zip.gunzip(obj);
+    stats.uncompressedSize += buffer.length - obj.length;
+    let lengthBuffer = buffer.slice(0, 8);
+    let lengths = new Float64Array(lengthBuffer.buffer, lengthBuffer.byteOffset, lengthBuffer.byteLength / 8);
+    let buffers = [];
+    let offset = 8;
+    for (let length of lengths) {
+        buffers.push(buffer.slice(offset, offset + length));
+        offset += length;
+    }
+    let result = await SocketFunction_1.SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
+    return result;
+});
+const compressObjLZ4 = (0, measure_1.measureWrap)(async function wireCallCompressLZ4(obj, stats) {
+    const { LZ4 } = await Promise.resolve().then(() => __importStar(require("./lz4/LZ4")));
+    let headerParts;
+    let dataBuffers;
+    if (obj instanceof Buffer) {
+        headerParts = [1];
+        dataBuffers = [obj];
+    }
+    else if (Array.isArray(obj) && obj.every((x) => x instanceof Buffer)) {
+        let bufferArray = obj;
+        const TARGET_SIZE = 50 * 1024 * 1024;
+        const MIN_INDIVIDUAL_SIZE = 10 * 1024 * 1024;
+        const MAX_UNSPLIT_SIZE = 100 * 1024 * 1024;
+        let outputBuffers = [];
+        let outputDescriptors = [];
+        let currentGroup = [];
+        let currentGroupSize = 0;
+        function flushCurrentGroup() {
+            if (currentGroup.length > 0) {
+                outputBuffers.push(Buffer.concat(currentGroup));
+                outputDescriptors.push(currentGroup.map(b => b.length));
+                currentGroup = [];
+                currentGroupSize = 0;
+            }
+        }
+        for (let buf of bufferArray) {
+            if (buf.length >= MIN_INDIVIDUAL_SIZE) {
+                flushCurrentGroup();
+                if (buf.length > MAX_UNSPLIT_SIZE) {
+                    let offset = 0;
+                    while (offset < buf.length) {
+                        let chunkSize = Math.min(TARGET_SIZE, buf.length - offset);
+                        outputBuffers.push(buf.slice(offset, offset + chunkSize));
+                        outputDescriptors.push([chunkSize]);
+                        offset += chunkSize;
+                    }
+                }
+                else {
+                    outputBuffers.push(buf);
+                    outputDescriptors.push([buf.length]);
+                }
+            }
+            else {
+                currentGroup.push(buf);
+                currentGroupSize += buf.length;
+                if (currentGroupSize >= TARGET_SIZE) {
+                    flushCurrentGroup();
+                }
+            }
+        }
+        flushCurrentGroup();
+        headerParts = [2, outputBuffers.length];
+        for (let descriptor of outputDescriptors) {
+            headerParts.push(descriptor.length, ...descriptor);
+        }
+        dataBuffers = outputBuffers;
+    }
+    else {
+        let buffers = await SocketFunction_1.SocketFunction.WIRE_SERIALIZER.serialize(obj);
+        headerParts = [3, buffers.length];
+        dataBuffers = buffers;
+    }
+    let headerBuffer = Buffer.from((new Float64Array(headerParts)).buffer);
+    let allBuffers = [headerBuffer, ...dataBuffers];
+    stats.uncompressedSize += allBuffers.reduce((sum, buf) => sum + buf.length, 0);
+    let compressed = [];
+    let startTime = Date.now();
+    let lastWarnTime = startTime;
+    let currentUncompressedSize = 0;
+    let currentCompressedSize = 0;
+    function logIfSlow(i) {
+        let now = Date.now();
+        if (now - lastWarnTime > 500) {
+            let elapsed = now - startTime;
+            console.log(`Slow LZ4 compress (${(0, format_1.formatTime)(elapsed)}: ${i + 1}/${allBuffers.length} buffers, ${(0, format_1.formatNumber)(currentUncompressedSize)}B => ${(0, format_1.formatNumber)(currentCompressedSize)}B`);
+            lastWarnTime = now;
+        }
+    }
+    for (let i = 0; i < allBuffers.length; i++) {
+        let buf = allBuffers[i];
+        currentUncompressedSize += buf.length;
+        let compressedBuf = LZ4.compress(buf);
+        compressed.push(compressedBuf);
+        currentCompressedSize += compressedBuf.length;
+        logIfSlow(i);
+    }
+    logIfSlow(allBuffers.length);
+    stats.compressedSize += currentCompressedSize;
+    return compressed;
+});
+const decompressObjLZ4 = (0, measure_1.measureWrap)(async function wireCallDecompressLZ4(obj, stats) {
+    const { LZ4 } = await Promise.resolve().then(() => __importStar(require("./lz4/LZ4")));
+    stats.compressedSize += obj.reduce((sum, buf) => sum + buf.length, 0);
+    let decompressed = [];
+    let startTime = Date.now();
+    let lastWarnTime = startTime;
+    let currentCompressedSize = 0;
+    let currentUncompressedSize = 0;
+    function logIfSlow(i) {
+        let now = Date.now();
+        if (now - lastWarnTime > 500) {
+            let elapsed = now - startTime;
+            console.log(`Slow LZ4 decompress (${(0, format_1.formatTime)(elapsed)}): ${i + 1}/${obj.length} buffers, ${(0, format_1.formatNumber)(currentCompressedSize)}B => ${(0, format_1.formatNumber)(currentUncompressedSize)}B`);
+            lastWarnTime = now;
+        }
+    }
+    for (let i = 0; i < obj.length; i++) {
+        let buf = obj[i];
+        currentCompressedSize += buf.length;
+        let decompressedBuf = LZ4.decompress(buf);
+        decompressed.push(decompressedBuf);
+        currentUncompressedSize += decompressedBuf.length;
+        logIfSlow(i);
+    }
+    logIfSlow(obj.length);
+    stats.uncompressedSize += currentUncompressedSize;
+    let headerBuffer = decompressed[0];
+    let dataBuffers = decompressed.slice(1);
+    let typeBuffer = headerBuffer.slice(0, 8);
+    let type = new Float64Array(typeBuffer.buffer, typeBuffer.byteOffset, 1)[0];
+    if (type === 1) {
+        return dataBuffers[0];
+    }
+    if (type === 2) {
+        let headerData = new Float64Array(headerBuffer.buffer, headerBuffer.byteOffset, headerBuffer.byteLength / 8);
+        let outputBufferCount = headerData[1];
+        let buffers = [];
+        let headerIndex = 2;
+        for (let i = 0; i < outputBufferCount; i++) {
+            let inputBufferCount = headerData[headerIndex++];
+            let sizes = [];
+            for (let j = 0; j < inputBufferCount; j++) {
+                sizes.push(headerData[headerIndex++]);
+            }
+            let outputBuffer = dataBuffers[i];
+            let offset = 0;
+            for (let size of sizes) {
+                buffers.push(outputBuffer.slice(offset, offset + size));
+                offset += size;
+            }
+        }
+        return buffers;
+    }
+    if (type === 3) {
+        let result = await SocketFunction_1.SocketFunction.WIRE_SERIALIZER.deserialize(dataBuffers);
+        return result;
+    }
+    throw new Error(`Unknown compression type ${type}`);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CallFactory.js","sourceRoot":"","sources":["CallFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { CallerContext, CallerContextBase, CallType, FullCallType } from \"../SocketFunctionTypes\";\nimport * as ws from \"ws\";\nimport { getCallFlags, performLocalCall, shouldCompressCall } from \"./callManager\";\nimport { convertErrorStackToError, formatNumberSuffixed, isBufferType, isNode, list, timeInHour, timeInMinute } from \"./misc\";\nimport { createWebsocketFactory, getTLSSocket } from \"./websocketFactory\";\nimport { SocketFunction } from \"../SocketFunction\";\nimport * as tls from \"tls\";\nimport { getClientNodeId, getNodeIdLocation, registerNodeClient } from \"./nodeCache\";\nimport debugbreak from \"debugbreak\";\nimport { lazy } from \"./caching\";\nimport { blue, green, red, yellow } from \"./formatting/logColors\";\nimport { isSplitableArray, markArrayAsSplitable } from \"./fixLargeNetworkCalls\";\nimport { delay, runInfinitePoll, runInSerial } from \"./batching\";\nimport { formatNumber, formatTime } from \"./formatting/format\";\nimport zlib from \"zlib\";\nimport pako from \"pako\";\nimport { setFlag } from \"../require/compileFlags\";\nimport { measureFnc, measureWrap, registerMeasureInfo } from \"./profiling/measure\";\nimport { MaybePromise } from \"./types\";\nimport { Zip } from \"./Zip\";\nimport { decodeProtocol, proposeProtocols } from \"./protocolNegotiation\";\nsetImmediate(() => import(\"./lz4/LZ4\"));\n\nsetFlag(require, \"pako\", \"allowclient\", true);\n\n// NOTE: If it is too low, and too many servers disconnect, we can easily spend 100% of our time\n//  trying to reconnect.\n//  (Or... maybe the delay is just waiting, and we aren't actually overloading the server?)\nconst MIN_RETRY_DELAY = 5000;\n\ntype InternalCallType = FullCallType & {\n    seqNum: number;\n    isReturn: false;\n    isArgsCompressed?: boolean | \"LZ4\" | \"zip\";\n}\n\ntype InternalReturnType = {\n    isReturn: true;\n    result: unknown;\n    error?: string;\n    seqNum: number;\n    isResultCompressed?: boolean | \"LZ4\" | \"zip\";\n};\n\n\nexport interface CallFactory {\n    nodeId: string;\n    realNodeId?: string;\n    lastClosed: number;\n    closedForever?: boolean;\n    isConnected?: boolean;\n    receivedInitializeState?: InitializeState;\n    // True if the connection was established with a negotiated\n    // Sec-WebSocket-Protocol (so the legacy initialize packet should be skipped).\n    protocolNegotiated?: boolean;\n    // NOTE: May or may not have reconnection or retry logic inside of performCall.\n    //  Trigger performLocalCall on the other side of the connection\n    performCall(call: CallType): Promise<unknown>;\n    onNextDisconnect(callback: () => void): void;\n    disconnect(): void;\n    // If we change the node ID we need to recreate this object, essentially this object should be immutable. I forget why we wanted this. I think it's because we didn't know for sure if node ID would be unique, but it will be. \n    connectionId: { nodeId: string };\n}\n\nexport interface SenderInterface {\n    nodeId?: string;\n    // Only set AFTER \"open\" (if set at all, as in the browser we don't have access to the socket).\n    _socket?: tls.TLSSocket;\n    // The chosen Sec-WebSocket-Protocol value (set after \"open\" by both Node `ws`\n    // and the browser WebSocket). Empty string means none was negotiated.\n    protocol?: string;\n\n    send(data: string | Buffer): void;\n    close(): void;\n\n    addEventListener(event: \"open\", listener: () => void): void;\n    addEventListener(event: \"close\", listener: () => void): void;\n    addEventListener(event: \"error\", listener: (err: { message: string }) => void): void;\n    addEventListener(event: \"message\", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;\n\n    readyState: number;\n\n    ping?(): void;\n}\n\ntype InitializeState = {\n    supportsLZ4?: boolean;\n};\n\nconst INITIALIZE_STATE_SEQ_NUM = -1;\n\nlet pendingCallCount = 0;\nlet harvestableFailedCalls = 0;\nconst CALL_TIMES_LIMIT = 1000 * 1000 * 10;\nlet harvestableCallTimes: { start: number; end: number; }[] = [];\nexport function harvestFailedCallCount() {\n    let count = harvestableFailedCalls;\n    harvestableFailedCalls = 0;\n    return count;\n}\nexport function getPendingCallCount() {\n    return pendingCallCount;\n}\nexport function harvestCallTimes() {\n    let times = harvestableCallTimes;\n    harvestableCallTimes = [];\n    return times;\n}\nrunInfinitePoll(timeInMinute * 15, () => {\n    if (harvestableCallTimes.length > CALL_TIMES_LIMIT) {\n        harvestableCallTimes = harvestableCallTimes.slice(-CALL_TIMES_LIMIT);\n    }\n});\n\n\nexport async function createCallFactory(\n    webSocketBase: SenderInterface | undefined,\n    // The node id we are connecting to (or that connected to us)\n    nodeId: string,\n    // The node id that we were contacted on\n    localNodeId = \"\",\n): Promise<CallFactory> {\n    let niceConnectionName = nodeId;\n\n    const createWebsocket = createWebsocketFactory();\n    const registerOnce = lazy(() => registerNodeClient(callFactory));\n\n    let canReconnect = !!getNodeIdLocation(nodeId);\n\n    let pendingCalls: Map<number, {\n        data: Buffer[];\n        call: InternalCallType;\n        callback: (resultJSON: InternalReturnType) => void;\n    }> = new Map();\n    // NOTE: It is important to make this as random as possible, to prevent\n    //  reconnections dues to a process being reset causing seqNum collisions\n    //  in return calls.\n    let nextSeqNum = Date.now() + Math.random();\n\n    // NOTE: I'm not sure if this is needed, I thought it was, but... now I think\n    //  it probably isn't...\n    // if (webSocketBase?.readyState === 1 /* OPEN */ && webSocketBase.ping) {\n    //     // Heartbeat loop, otherwise onDisconnect is never called.\n    //     ((async () => {\n    //         while (webSocketBase?.readyState === 1 /* OPEN */ && webSocketBase.ping) {\n    //             await delay(1000 * 60);\n    //             webSocketBase.ping?.();\n    //         }\n    //     }))().catch(() => { });\n    // }\n\n    let lastConnectionAttempt = 0;\n\n    let callerContext: CallerContextBase = {\n        nodeId,\n        localNodeId\n    };\n\n    let disconnectCallbacks = new Set<() => void>();\n    function onNextDisconnect(callback: () => void): void {\n        disconnectCallbacks.add(callback);\n    }\n\n    let callFactory: CallFactory = {\n        nodeId,\n        lastClosed: 0,\n        connectionId: { nodeId },\n        receivedInitializeState: undefined,\n        onNextDisconnect,\n        disconnect() {\n            canReconnect = false;\n            callFactory.closedForever = true;\n            if (webSocketPromise) {\n                webSocketPromise.then(ws => ws.close()).catch(() => { });\n            }\n        },\n        async performCall(call: CallType) {\n            let seqNum = nextSeqNum++;\n            let fullCall: InternalCallType = {\n                nodeId,\n                isReturn: false,\n                args: call.args,\n                classGuid: call.classGuid,\n                functionName: call.functionName,\n                seqNum,\n            };\n            let data: Buffer[];\n            let originalArgs = call.args;\n            let time = Date.now();\n            let sendStats: CompressionStats = {\n                uncompressedSize: 0,\n                compressedSize: 0,\n            };\n            try {\n                if (callFactory.receivedInitializeState?.supportsLZ4) {\n                    let compressMode = shouldCompressCall(fullCall);\n                    // If it's undefined, then we compress it. We basically always want to compress from now on, because LZ4 is so fast. \n                    if (compressMode !== false) {\n                        fullCall.args = await compressObjLZ4(fullCall.args, sendStats) as any;\n                        fullCall.isArgsCompressed = \"LZ4\";\n                    }\n                } else {\n                    if (shouldCompressCall(fullCall)) {\n                        fullCall.args = await compressObj(fullCall.args, sendStats) as any;\n                        fullCall.isArgsCompressed = \"zip\";\n                    }\n                }\n                let dataMaybePromise = SocketFunction.WIRE_SERIALIZER.serialize(fullCall);\n                if (dataMaybePromise instanceof Promise) {\n                    data = await dataMaybePromise;\n                } else {\n                    data = dataMaybePromise;\n                }\n                if (!sendStats.compressedSize) {\n                    let totalSize = 0;\n                    for (let d of data) {\n                        totalSize += d.length;\n                    }\n                    sendStats.uncompressedSize = totalSize;\n                    sendStats.compressedSize = totalSize;\n                }\n                addSendStats(sendStats);\n            } catch (e: any) {\n                throw new Error(`Error serializing data for call ${call.classGuid}.${call.functionName}\\n${e.stack}`);\n            }\n            time = Date.now() - time;\n            let size = data.map(x => x.length).reduce((a, b) => a + b, 0);\n            if (time > SocketFunction.WIRE_WARN_TIME) {\n                console.log(red(`Slow serialize, took ${formatTime(time)} to serialize ${formatNumber(size)} bytes. For ${call.classGuid}.${call.functionName}`));\n            }\n\n            if (size > SocketFunction.MAX_MESSAGE_SIZE * 1.5) {\n                let splitArgIndex = originalArgs.findIndex(isSplitableArray);\n                if (splitArgIndex >= 0) {\n                    console.log(yellow(`Splitting large call due to large args: ${call.classGuid}.${call.functionName}`));\n                    let SPLIT_GROUPS = 10;\n                    let splitArg = originalArgs[splitArgIndex] as unknown[];\n                    let subCalls = list(SPLIT_GROUPS).map(index => {\n                        let start = Math.floor(index / SPLIT_GROUPS * splitArg.length);\n                        let end = Math.floor((index + 1) / SPLIT_GROUPS * splitArg.length);\n                        return splitArg.slice(start, end);\n                    }).filter(x => x.length > 0);\n\n                    let calls = subCalls.map(async splitList => {\n                        let subCall = { ...call };\n                        subCall.args = subCall.args.slice();\n                        subCall.args[splitArgIndex] = markArrayAsSplitable(splitList);\n                        await callFactory.performCall(subCall);\n                    });\n                    await Promise.allSettled(calls);\n                    await Promise.all(calls);\n                    // Eh... we COULD return the array of results, but... then the result would sometimes be an array,\n                    //  some times not, so, it is better to return a string which will make it more clear why it sometimes varies.\n                    return \"CALLS_SPLIT_DUE_TO_LARGE_ARGS\";\n                }\n\n                throw new Error(`Call too large to send (${call.classGuid}.${call.functionName}, size: ${formatNumber(size)} > ${formatNumber(SocketFunction.MAX_MESSAGE_SIZE)}). If you need to handle very large static data use some external service, such as Backblaze B2 or AWS S3. Or consider fragmenting data at an application level, because sending large data will cause large lag spikes for other clients using this server. Or, if absolutely required, set SocketFunction.MAX_MESSAGE_SIZE to a higher value.`);\n            }\n\n            let resultPromise = new Promise((resolve, reject) => {\n                let startTime = Date.now();\n                pendingCallCount++;\n                let callback = (result: InternalReturnType) => {\n                    pendingCallCount--;\n                    pendingCalls.delete(seqNum);\n                    harvestableCallTimes.push({ start: startTime, end: Date.now(), });\n\n                    if (result.error) {\n                        reject(convertErrorStackToError(result.error));\n                    } else {\n                        resolve(result.result);\n                    }\n                };\n                pendingCalls.set(seqNum, { callback, data, call: fullCall });\n            });\n\n            {\n                let resultSize = data.map(x => x.length).reduce((a, b) => a + b, 0);\n                for (let callback of SocketFunction.trackMessageSizes.upload) {\n                    callback(resultSize);\n                }\n                if (SocketFunction.logMessages) {\n                    let fncHack = \"\";\n                    if (call.functionName === \"addCall\") {\n                        let arg = originalArgs[0] as any;\n                        fncHack = `.${arg.DomainName}.${arg.ModuleId}.${arg.FunctionId}`;\n                    }\n                    console.log(`SIZE\\t${(formatNumberSuffixed(resultSize) + `B`).padEnd(4, \" \")}\\t${formatNumber(data.length)} buffers\\tREMOTE CALL\\t${call.classGuid}.${call.functionName}${fncHack} at ${Date.now()}`);\n                }\n            }\n            // If sending OR resultPromise throws, we want to error out. This solves some issues with resultPromise\n            //      erroring out first, which is before we await it, which makes NodeJS angry (unhandled promise rejection).\n            //      Also, technically, we could receive the result before we finish sending, in which case, we might\n            //      as well return it immediately.\n            await Promise.race([send(data), resultPromise]);\n            return await resultPromise;\n        }\n    };\n\n    let webSocketPromise: Promise<SenderInterface> | undefined;\n    let hasEverConnected = false;\n    if (webSocketBase) {\n        webSocketPromise = Promise.resolve(webSocketBase);\n        await initializeWebsocket(webSocketBase);\n    }\n\n    async function initializeWebsocket(newWebSocket: SenderInterface, skipCloseHandling = false) {\n        registerOnce();\n        callFactory.receivedInitializeState = undefined;\n\n        function onClose(error: string) {\n            // 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.\n            if (skipCloseHandling && !hasEverConnected) {\n                return;\n            }\n\n            callFactory.connectionId = { nodeId };\n            callFactory.lastClosed = Date.now();\n            callFactory.isConnected = false;\n            webSocketPromise = undefined;\n            if (!canReconnect) {\n                callFactory.closedForever = true;\n            }\n            for (let [key, call] of pendingCalls) {\n                harvestableFailedCalls++;\n                pendingCalls.delete(key);\n                call.callback({\n                    isReturn: true,\n                    result: undefined,\n                    error: error,\n                    seqNum: call.call.seqNum,\n                });\n            }\n\n            let callbacks = disconnectCallbacks;\n            disconnectCallbacks = new Set();\n            for (let callback of callbacks) {\n                try {\n                    callback();\n                } catch { }\n            }\n        }\n\n        newWebSocket.addEventListener(\"error\", e => {\n            // NOTE: No more logging, as we throw, so the caller should be logging the\n            //  error (or swallowing it, if that is what it wants to do).\n            //console.log(`Websocket error for ${niceConnectionName}`, e.message);\n            onClose(new Error(`Connection error for ${niceConnectionName}: ${e.message}`).stack!);\n        });\n\n        newWebSocket.addEventListener(\"close\", async () => {\n            //console.log(`Websocket closed ${niceConnectionName}`);\n            onClose(new Error(`Connection closed to ${niceConnectionName}`).stack!);\n        });\n\n        newWebSocket.addEventListener(\"message\", onMessage);\n\n\n        if (newWebSocket.readyState === 0 /* CONNECTING */) {\n            await new Promise<void>(resolve => {\n                newWebSocket.addEventListener(\"open\", () => {\n                    if (!SocketFunction.silent) {\n                        console.log(`Connection established to ${niceConnectionName}`);\n                    }\n                    callFactory.isConnected = true;\n                    hasEverConnected = true;\n                    resolve();\n                });\n                newWebSocket.addEventListener(\"close\", () => resolve());\n                newWebSocket.addEventListener(\"error\", () => resolve());\n            });\n        } else if (newWebSocket.readyState === 1 /* OPEN */) {\n            callFactory.isConnected = true;\n            hasEverConnected = true;\n        } else {\n            onClose(new Error(`Websocket received in closed state`).stack!);\n        }\n\n        if (callFactory.lastClosed && callFactory.isConnected) {\n            console.log(`Successfully reconnected to ${nodeId}, which has been closed for ${formatTime(Date.now() - callFactory.lastClosed)}`, { nodeId });\n        }\n\n        if (callFactory.isConnected && newWebSocket.protocol) {\n            let decoded = decodeProtocol(newWebSocket.protocol);\n            if (decoded) {\n                callFactory.receivedInitializeState = {\n                    supportsLZ4: decoded.flags.serverLZ4,\n                };\n                callFactory.protocolNegotiated = true;\n                if (SocketFunction.logMessages) {\n                    console.log(green(`Negotiated protocol with ${niceConnectionName}: target=${decoded.target}, clientLZ4=${decoded.flags.clientLZ4}, serverLZ4=${decoded.flags.serverLZ4}`));\n                }\n            }\n        }\n    }\n\n    const BASE_LENGTH_OFFSET = 324_432_461_592_612;\n    type MessageHeader = {\n        type: \"serialized\";\n        bufferCount: number;\n    } | {\n        type: \"Buffer[]\" | \"Buffer\";\n        bufferCount: number;\n        bufferLengths?: number[];\n        metadata: Omit<InternalReturnType, \"result\">;\n    };\n    let sendInSerial = runInSerial(async (val: () => Promise<void>) => val());\n    async function sendRaw(data: (string | Buffer)[]) {\n        if (!webSocketPromise) {\n            if (canReconnect) {\n                webSocketPromise = tryToReconnect();\n            } else {\n                throw new Error(`Cannot send data to ${niceConnectionName} as the connection has closed`);\n            }\n        }\n        let webSocket = await webSocketPromise;\n        await sendInSerial(async () => {\n            for (let d of data) {\n                if (d.length > 1000 * 1000 * 10) {\n                    console.log(`Sending large packet ${formatNumber(d.length)}B to ${nodeId} at ${Date.now()}`);\n                }\n\n                // NOTE: If our latency is 500ms, with 10MB/s, then we need a high water\n                //  mark of at least 5MB, otherwise our connection is slowed down.\n                //  - Using the actual high water mark is too difficult, as we receive incoming connections.\n                //      This is also easier to configure, and we can dynamically change it if we have to.\n                // NOTE: In practice we only hit this when sending large Buffers (~30MB), so low values\n                //  are equivalent to waiting for drain. We want to avoid waiting for drain, so we use a high value.\n                const maxWriteBuffer = 128 * 1024 * 1024;\n                webSocket.send(d);\n\n                let socket = webSocket._socket;\n                if (socket) {\n                    while (socket.writableLength > maxWriteBuffer) {\n                        // NOTE: Waiting 1ms probably waits more like 16ms.\n                        await new Promise(r => setTimeout(r, 1));\n                    }\n                }\n            }\n        });\n    }\n    async function send(data: Buffer[]) {\n        await sendRaw([\n            (data.length + BASE_LENGTH_OFFSET).toString(),\n            ...data,\n        ]);\n    }\n    async function sendWithHeader(data: Buffer[], header: MessageHeader) {\n        if (data.some(x => x.length > SocketFunction.MAX_MESSAGE_SIZE * 1.5)) {\n            if (header.type === \"Buffer\" || header.type === \"Buffer[]\") {\n                header.bufferLengths = data.map(x => x.length);\n                let fitBuffers: Buffer[] = [];\n                for (let buf of data) {\n                    if (buf.length > SocketFunction.MAX_MESSAGE_SIZE) {\n                        let offset = 0;\n                        while (offset < buf.length) {\n                            fitBuffers.push(buf.slice(offset, offset + SocketFunction.MAX_MESSAGE_SIZE));\n                            offset += SocketFunction.MAX_MESSAGE_SIZE;\n                        }\n                    } else {\n                        fitBuffers.push(buf);\n                    }\n                }\n                data = fitBuffers;\n                header.bufferCount = fitBuffers.length;\n            } else {\n                throw new Error(`Cannot send large amounts of data unless we are returning Buffer or Buffer[]`);\n            }\n        }\n        // if (totalResultSize > SocketFunction.MAX_MESSAGE_SIZE * 1.5) {\n        // Split up Buffer[] if they are too large\n        await sendRaw([\n            JSON.stringify(header),\n            ...data,\n        ]);\n    }\n    // IMPORTANT! NEVER allow for reconnection of client ids. A lot of code depends on the fact that clients will reconnect with a new client node id when they disconnect!\n    async function tryToReconnect(): Promise<SenderInterface> {\n        // Don't try to reconnect too often!\n        let timeSinceLastAttempt = Date.now() - lastConnectionAttempt;\n        if (timeSinceLastAttempt < MIN_RETRY_DELAY) {\n            await new Promise(r => setTimeout(r, MIN_RETRY_DELAY - timeSinceLastAttempt));\n        }\n        lastConnectionAttempt = Date.now();\n\n        // Try alternates, and if any work, use them.\n        try {\n            let alternates = await SocketFunction.GET_ALTERNATE_NODE_IDS(nodeId);\n            if (alternates) {\n                for (let alternateNodeId of alternates) {\n                    let newWebSocket = createWebsocket(alternateNodeId, proposeProtocols(isNode() ? nodeId : undefined, { lz4: true }));\n                    await initializeWebsocket(newWebSocket, true);\n\n                    if (callFactory.isConnected) {\n                        return newWebSocket;\n                    }\n                }\n            }\n        } catch (e) {\n            console.error(\"Error getting alternate node IDs\", e);\n        }\n\n        let newWebSocket = createWebsocket(nodeId, proposeProtocols(!SocketFunction.isClient() ? nodeId : undefined, { lz4: true }));\n        await initializeWebsocket(newWebSocket);\n\n        return newWebSocket;\n    }\n\n    let pendingCall: MessageHeader & {\n        buffers: Buffer[];\n        firstReceivedTime?: number;\n    } | undefined;\n\n    async function processPendingCall() {\n        if (!pendingCall) throw new Error(`No pending call`);\n        let currentCall = pendingCall;\n        pendingCall = undefined;\n        let currentBuffers = currentCall.buffers;\n        let call: InternalCallType | InternalReturnType;\n        let resultSize: number;\n        let time = Date.now();\n        if (currentCall.type === \"Buffer\" || currentCall.type === \"Buffer[]\") {\n            let result: Buffer | Buffer[] = currentBuffers;\n            if (currentCall.bufferLengths) {\n                let pendingBuffers = currentBuffers;\n                function takeBuffer(len: number) {\n                    let lenLeft = len;\n                    let buffers: Buffer[] = [];\n                    while (lenLeft > 0) {\n                        let buf = currentBuffers.shift();\n                        if (!buf) {\n                            throw new Error(`Not enough buffers received.`);\n                        }\n                        if (buf.length > lenLeft) {\n                            buffers.push(buf.slice(0, lenLeft));\n                            currentBuffers.unshift(buf.slice(lenLeft));\n                            break;\n                        } else {\n                            buffers.push(buf);\n                            lenLeft -= buf.length;\n                        }\n                    }\n                    if (buffers.length === 1) {\n                        return buffers[0];\n                    }\n                    return Buffer.concat(buffers);\n                }\n                result = currentCall.bufferLengths.map(takeBuffer);\n                if (pendingBuffers.length > 0) {\n                    throw new Error(`Received too many buffers.`);\n                }\n            }\n            resultSize = result.map(x => x.length).reduce((a, b) => a + b, 0);\n            if (currentCall.type === \"Buffer\") {\n                if (result.length === 1) {\n                    result = result[0];\n                } else {\n                    result = Buffer.concat(result);\n                }\n            }\n            call = {\n                ...currentCall.metadata,\n                result,\n            };\n        } else {\n            resultSize = currentBuffers.map(x => x.length).reduce((a, b) => a + b, 0);\n            call = await SocketFunction.WIRE_SERIALIZER.deserialize(currentBuffers) as InternalCallType | InternalReturnType;\n        }\n        let parseTime = Date.now() - time;\n        for (let callback of SocketFunction.trackMessageSizes.download) {\n            callback(resultSize);\n        }\n\n        let receiveStats: CompressionStats = {\n            uncompressedSize: resultSize,\n            compressedSize: resultSize,\n        };\n        let sendStats: CompressionStats = {\n            uncompressedSize: 0,\n            compressedSize: 0,\n        };\n\n        if (call.isReturn) {\n            // Tolerate the legacy initialize packet from old peers — silently\n            // ignore so it doesn't get logged as an unknown call. Our actual\n            // initialize state comes from Sec-WebSocket-Protocol negotiation.\n            if (call.seqNum === INITIALIZE_STATE_SEQ_NUM) {\n                return;\n            }\n            let callbackObj = pendingCalls.get(call.seqNum);\n            if (parseTime > SocketFunction.WIRE_WARN_TIME) {\n                console.log(red(`Slow parse, took ${parseTime}ms to parse ${resultSize} bytes, for receiving result of call to ${callbackObj?.call.classGuid}.${callbackObj?.call.functionName}`));\n            }\n            if (!callbackObj) {\n                console.log(blue(`Got return for unknown call ${call.seqNum} (created at time ${new Date(call.seqNum)}), ${nodeId} / ${localNodeId}`));\n                return;\n            }\n            if (SocketFunction.logMessages) {\n                let call = callbackObj.call;\n                console.log(`SIZE\\t${(formatNumberSuffixed(resultSize) + \"B\").padEnd(4, \" \")}\\t${formatNumber(currentBuffers.length)} buffers\\tRETURN\\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);\n            }\n            if (call.isResultCompressed === \"LZ4\") {\n                call.result = await decompressObjLZ4(call.result as Buffer[], receiveStats);\n                call.isResultCompressed = undefined;\n            } else if (call.isResultCompressed === \"zip\" || call.isResultCompressed === true) {\n                call.result = await decompressObj(call.result as Buffer, receiveStats);\n                call.isResultCompressed = undefined;\n            }\n            callbackObj.callback(call);\n        } else {\n            if (call.isArgsCompressed === \"LZ4\") {\n                call.args = await decompressObjLZ4(call.args as any as Buffer[], sendStats) as any;\n                call.isArgsCompressed = undefined;\n            } else if (call.isArgsCompressed === \"zip\" || call.isArgsCompressed === true) {\n                call.args = await decompressObj(call.args as any as Buffer, sendStats) as any;\n                call.isArgsCompressed = undefined;\n            }\n            if (SocketFunction.logMessages) {\n                console.log(`SIZE\\t${(formatNumberSuffixed(resultSize) + \"B\").padEnd(4, \" \")}\\tEVALUATE\\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);\n            }\n            if (parseTime > SocketFunction.WIRE_WARN_TIME) {\n                console.log(red(`Slow parse, took ${parseTime}ms to parse ${resultSize} bytes, for call to ${call.classGuid}.${call.functionName}`));\n            }\n\n            let response: InternalReturnType;\n            try {\n                SocketFunction.TOTAL_CALLS++;\n                let result = await performLocalCall({ call, caller: callerContext });\n                response = {\n                    isReturn: true,\n                    result,\n                    seqNum: call.seqNum,\n                };\n                if (SocketFunction.logMessages) {\n                    let timeTaken = Date.now() - time;\n                    console.log(`DUR\\t${(formatTime(timeTaken)).padEnd(6, \" \")}\\tFINISH\\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);\n                }\n                if (callFactory.receivedInitializeState?.supportsLZ4) {\n                    let compressMode = shouldCompressCall(call);\n                    if (compressMode !== false) {\n                        response.result = await compressObjLZ4(response.result, sendStats);\n                        response.isResultCompressed = \"LZ4\";\n                    }\n                } else {\n                    if (shouldCompressCall(call)) {\n                        response.result = await compressObj(response.result, sendStats);\n                        response.isResultCompressed = \"zip\";\n                    }\n                }\n            } catch (e: any) {\n                response = {\n                    isReturn: true,\n                    result: undefined,\n                    seqNum: call.seqNum,\n                    error: e.stack,\n                };\n            }\n            {\n                let start = time;\n                let end = Date.now();\n                for (let fnc of SocketFunction.trackMessageSizes.callTimes) {\n                    fnc({ start, end });\n                }\n            }\n\n            let size = 0;\n\n            if (response.result instanceof Buffer) {\n                let { result, ...remaining } = response;\n                size = result.length;\n                await sendWithHeader([result], { type: \"Buffer\", bufferCount: 1, metadata: remaining });\n            } else if (Array.isArray(response.result) && response.result.every(x => x instanceof Buffer)) {\n                let { result, ...remaining } = response;\n                for (let r of result) {\n                    size += r.length;\n                }\n                await sendWithHeader(result, { type: \"Buffer[]\", bufferCount: result.length, metadata: remaining });\n            } else {\n                const LIMIT = getCallFlags(call)?.responseLimit || SocketFunction.MAX_MESSAGE_SIZE * 1.5;\n                let result: Buffer[] = await SocketFunction.WIRE_SERIALIZER.serialize(response);\n                let totalResultSize = result.map(x => x.length).reduce((a, b) => a + b, 0);\n                if (totalResultSize > LIMIT) {\n                    response = {\n                        isReturn: true,\n                        result: undefined,\n                        seqNum: call.seqNum,\n                        error: new Error(`Response too large to send. Return Buffer[] to exceed the limits, or set responseLimit when registering the collection. ${call.classGuid}.${call.functionName}, size: ${formatNumber(totalResultSize)} > ${formatNumber(SocketFunction.MAX_MESSAGE_SIZE)}. If you need to handle very large static data use some external service, such as Backblaze B2 or AWS S3. Or, if absolutely required, set SocketFunction.MAX_MESSAGE_SIZE to a higher value.`).stack,\n                    };\n                    result = await SocketFunction.WIRE_SERIALIZER.serialize(response);\n                }\n                for (let r of result) {\n                    size += r.length;\n                }\n                await send(result);\n            }\n\n            // If we have no size, then it's probably uncompressed\n            if (!sendStats.compressedSize) {\n                sendStats.compressedSize = size;\n                sendStats.uncompressedSize = size;\n            }\n        }\n\n        addSendStats(sendStats);\n        addReceiveStats(receiveStats);\n    }\n\n    let clientsideSerial = runInSerial(async <T>(val: Promise<T>) => val);\n    async function onMessage(message: ws.RawData | ws.MessageEvent | string) {\n        try {\n            if (typeof message === \"object\" && \"data\" in message) {\n                message = message.data;\n            }\n            // Extra clienside parsing is required\n            if (!isNode()) {\n                // Immediately start the arrayBuffer conversion. This should be fast, but...\n                //  maybe we will add more here, and so doing it in parallel might be useful.\n                let fixMessageBlob = (async () => {\n                    if (message instanceof Blob) {\n                        message = Buffer.from(await message.arrayBuffer());\n                    }\n                })();\n                // We need to force the results to be in serial, otherwise strings leapfrog\n                //  ahead of buffers, which breaks things.\n                await clientsideSerial(fixMessageBlob);\n            }\n            if (typeof message === \"string\") {\n                if (message.startsWith(\"{\")) {\n                    let obj = JSON.parse(message);\n                    pendingCall = {\n                        ...obj,\n                        buffers: [],\n                    };\n                } else {\n                    let count = parseInt(message);\n                    if (isNaN(count)) {\n                        throw new Error(`Invalid message count ${message}`);\n                    }\n                    if (count < BASE_LENGTH_OFFSET) {\n                        throw new Error(`Invalid message count ${message}`);\n                    }\n                    count -= BASE_LENGTH_OFFSET;\n                    if (count > 1000 * 1000) {\n                        throw new Error(`Invalid message count ${count}`);\n                    }\n                    pendingCall = {\n                        buffers: [],\n                        bufferCount: count,\n                        type: \"serialized\",\n                    };\n                }\n                if (pendingCall?.bufferCount === 0) {\n                    await processPendingCall();\n                }\n                return;\n            }\n            if (message instanceof Buffer) {\n                if (!pendingCall) {\n                    throw new Error(`Received data without size ${message.byteLength}B, first 100 bytes: ${message.slice(0, 100).toString(\"hex\")}`);\n                }\n                let totalSize = message.byteLength + pendingCall.buffers.reduce((a, b) => a + b.length, 0);\n                if (totalSize > 1000 * 1000 * 10 || pendingCall.bufferCount > 1000 && (pendingCall.buffers.length % 100 === 0)) {\n                    if (pendingCall.buffers.length === 0) {\n                        console.log(`Received large/many packets ${formatNumber(totalSize)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) at ${Date.now()}`);\n                    } else {\n                        let elapsed = Date.now() - (pendingCall.firstReceivedTime || 0);\n                        console.log(`Received large/many packets ${formatNumber(totalSize)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) after ${formatTime(elapsed)}`);\n                    }\n                }\n                if (pendingCall.buffers.length === 0) {\n                    pendingCall.firstReceivedTime = Date.now();\n                }\n                pendingCall.buffers.push(message);\n                if (pendingCall.buffers.length !== pendingCall.bufferCount) {\n                    return;\n                }\n\n                await processPendingCall();\n                return;\n            }\n            throw new Error(`Unhandled data type ${typeof message}`);\n        } catch (e: any) {\n            let err = e.stack || e.message || e;\n            // NOTE: I'm looking for all types of errors here (specifically, .send errors), in case\n            //  there are errors I should be handling.\n            if (err.startsWith(\"Error: Cannot send data to\") && err.includes(\"as the connection has closed\")) {\n                // This is fine, just ignore it\n            } 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.\")) {\n                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.`);\n            } else {\n                console.error(e.stack);\n            }\n        }\n    }\n\n\n    return callFactory;\n}\n\n\nlet uncompressedSent = 0;\nlet compressedSent = 0;\nlet uncompressedReceived = 0;\nlet compressedReceived = 0;\n\nlet sendCount = 0;\nlet receiveCount = 0;\n\nfunction addSendStats(stats: CompressionStats) {\n    uncompressedSent += stats.uncompressedSize;\n    compressedSent += stats.compressedSize;\n    sendCount++;\n}\nfunction addReceiveStats(stats: CompressionStats) {\n    uncompressedReceived += stats.uncompressedSize;\n    compressedReceived += stats.compressedSize;\n    receiveCount++;\n}\nexport function getStats() {\n    return {\n        uncompressedSent,\n        compressedSent,\n        uncompressedReceived,\n        compressedReceived,\n        sendCount,\n        receiveCount,\n    };\n}\n// Register this late as I don't want it to appear before the memory register info, which is use more useful than the network one. \nsetImmediate(() => {\n    registerMeasureInfo(() => `NET => ${formatNumber(compressedSent)}B (${formatNumber(uncompressedSent)}B/${formatNumber(sendCount)}) / <= ${formatNumber(compressedReceived)}B (${formatNumber(uncompressedReceived)}B/${formatNumber(receiveCount)})`);\n});\n\ntype CompressionStats = {\n    uncompressedSize: number;\n    compressedSize: number;\n};\n\nconst compressObj = measureWrap(async function wireCallCompress(obj: unknown, stats: CompressionStats): Promise<Buffer> {\n    let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);\n    if (buffers.length > 1) {\n        throw new Error(\"Legacy CompressObj only supports single buffer\");\n    }\n    let lengthBuffer = Buffer.from((new Float64Array(buffers.map(x => x.length))).buffer);\n    let buffer = Buffer.concat([lengthBuffer, ...buffers]);\n    stats.uncompressedSize += buffer.length;\n    let result = await Zip.gzip(buffer);\n    stats.compressedSize += result.length;\n    return result;\n});\n// Assumes the caller already added the obj.length to both the uncompressedSize and compressedSize, and is just looking to update the uncompressedSize to be larger according to the size after we uncompress\nconst decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer, stats: CompressionStats): Promise<unknown> {\n    let buffer = await Zip.gunzip(obj);\n    stats.uncompressedSize += buffer.length - obj.length;\n    let lengthBuffer = buffer.slice(0, 8);\n    let lengths = new Float64Array(lengthBuffer.buffer, lengthBuffer.byteOffset, lengthBuffer.byteLength / 8);\n    let buffers: Buffer[] = [];\n    let offset = 8;\n    for (let length of lengths) {\n        buffers.push(buffer.slice(offset, offset + length));\n        offset += length;\n    }\n    let result = await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);\n    return result;\n});\n\nconst compressObjLZ4 = measureWrap(async function wireCallCompressLZ4(obj: unknown, stats: CompressionStats): Promise<Buffer[]> {\n    const { LZ4 } = await import(\"./lz4/LZ4\");\n    let headerParts: number[];\n    let dataBuffers: Buffer[];\n\n    if (obj instanceof Buffer) {\n        headerParts = [1];\n        dataBuffers = [obj];\n    } else if (Array.isArray(obj) && obj.every((x: any) => x instanceof Buffer)) {\n        let bufferArray = obj as Buffer[];\n        const TARGET_SIZE = 50 * 1024 * 1024;\n        const MIN_INDIVIDUAL_SIZE = 10 * 1024 * 1024;\n        const MAX_UNSPLIT_SIZE = 100 * 1024 * 1024;\n\n        let outputBuffers: Buffer[] = [];\n        let outputDescriptors: number[][] = [];\n        let currentGroup: Buffer[] = [];\n        let currentGroupSize = 0;\n\n        function flushCurrentGroup() {\n            if (currentGroup.length > 0) {\n                outputBuffers.push(Buffer.concat(currentGroup));\n                outputDescriptors.push(currentGroup.map(b => b.length));\n                currentGroup = [];\n                currentGroupSize = 0;\n            }\n        }\n\n        for (let buf of bufferArray) {\n            if (buf.length >= MIN_INDIVIDUAL_SIZE) {\n                flushCurrentGroup();\n\n                if (buf.length > MAX_UNSPLIT_SIZE) {\n                    let offset = 0;\n                    while (offset < buf.length) {\n                        let chunkSize = Math.min(TARGET_SIZE, buf.length - offset);\n                        outputBuffers.push(buf.slice(offset, offset + chunkSize));\n                        outputDescriptors.push([chunkSize]);\n                        offset += chunkSize;\n                    }\n                } else {\n                    outputBuffers.push(buf);\n                    outputDescriptors.push([buf.length]);\n                }\n            } else {\n                currentGroup.push(buf);\n                currentGroupSize += buf.length;\n\n                if (currentGroupSize >= TARGET_SIZE) {\n                    flushCurrentGroup();\n                }\n            }\n        }\n\n        flushCurrentGroup();\n\n        headerParts = [2, outputBuffers.length];\n        for (let descriptor of outputDescriptors) {\n            headerParts.push(descriptor.length, ...descriptor);\n        }\n        dataBuffers = outputBuffers;\n    } else {\n        let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);\n        headerParts = [3, buffers.length];\n        dataBuffers = buffers;\n    }\n\n    let headerBuffer = Buffer.from((new Float64Array(headerParts)).buffer);\n    let allBuffers = [headerBuffer, ...dataBuffers];\n\n    stats.uncompressedSize += allBuffers.reduce((sum, buf) => sum + buf.length, 0);\n\n    let compressed: Buffer[] = [];\n    let startTime = Date.now();\n    let lastWarnTime = startTime;\n    let currentUncompressedSize = 0;\n    let currentCompressedSize = 0;\n\n    function logIfSlow(i: number) {\n        let now = Date.now();\n        if (now - lastWarnTime > 500) {\n            let elapsed = now - startTime;\n            console.log(`Slow LZ4 compress (${formatTime(elapsed)}: ${i + 1}/${allBuffers.length} buffers, ${formatNumber(currentUncompressedSize)}B => ${formatNumber(currentCompressedSize)}B`);\n            lastWarnTime = now;\n        }\n    }\n\n    for (let i = 0; i < allBuffers.length; i++) {\n        let buf = allBuffers[i];\n        currentUncompressedSize += buf.length;\n        let compressedBuf = LZ4.compress(buf);\n        compressed.push(compressedBuf);\n        currentCompressedSize += compressedBuf.length;\n\n        logIfSlow(i);\n    }\n    logIfSlow(allBuffers.length);\n\n    stats.compressedSize += currentCompressedSize;\n\n    return compressed;\n});\n\nconst decompressObjLZ4 = measureWrap(async function wireCallDecompressLZ4(obj: Buffer[], stats: CompressionStats): Promise<unknown> {\n\n    const { LZ4 } = await import(\"./lz4/LZ4\");\n    stats.compressedSize += obj.reduce((sum, buf) => sum + buf.length, 0);\n\n    let decompressed: Buffer[] = [];\n    let startTime = Date.now();\n    let lastWarnTime = startTime;\n    let currentCompressedSize = 0;\n    let currentUncompressedSize = 0;\n    function logIfSlow(i: number) {\n        let now = Date.now();\n        if (now - lastWarnTime > 500) {\n            let elapsed = now - startTime;\n            console.log(`Slow LZ4 decompress (${formatTime(elapsed)}): ${i + 1}/${obj.length} buffers, ${formatNumber(currentCompressedSize)}B => ${formatNumber(currentUncompressedSize)}B`);\n            lastWarnTime = now;\n        }\n    }\n\n    for (let i = 0; i < obj.length; i++) {\n        let buf = obj[i];\n        currentCompressedSize += buf.length;\n        let decompressedBuf = LZ4.decompress(buf);\n        decompressed.push(decompressedBuf);\n        currentUncompressedSize += decompressedBuf.length;\n\n        logIfSlow(i);\n    }\n    logIfSlow(obj.length);\n\n    stats.uncompressedSize += currentUncompressedSize;\n\n    let headerBuffer = decompressed[0];\n    let dataBuffers = decompressed.slice(1);\n\n    let typeBuffer = headerBuffer.slice(0, 8);\n    let type = new Float64Array(typeBuffer.buffer, typeBuffer.byteOffset, 1)[0];\n\n    if (type === 1) {\n        return dataBuffers[0];\n    }\n\n    if (type === 2) {\n        let headerData = new Float64Array(headerBuffer.buffer, headerBuffer.byteOffset, headerBuffer.byteLength / 8);\n        let outputBufferCount = headerData[1];\n\n        let buffers: Buffer[] = [];\n        let headerIndex = 2;\n\n        for (let i = 0; i < outputBufferCount; i++) {\n            let inputBufferCount = headerData[headerIndex++];\n            let sizes: number[] = [];\n            for (let j = 0; j < inputBufferCount; j++) {\n                sizes.push(headerData[headerIndex++]);\n            }\n\n            let outputBuffer = dataBuffers[i];\n            let offset = 0;\n            for (let size of sizes) {\n                buffers.push(outputBuffer.slice(offset, offset + size));\n                offset += size;\n            }\n        }\n\n        return buffers;\n    }\n\n    if (type === 3) {\n        let result = await SocketFunction.WIRE_SERIALIZER.deserialize(dataBuffers);\n        return result;\n    }\n\n    throw new Error(`Unknown compression type ${type}`);\n});"]}
+ /* _JS_SOURCE_HASH = "c820da5d99596a319d37e9cb71d1bd23c38c5f13285953febf1fb51ed2b0b578"; */