socket-function 1.1.2 → 1.1.4

package/SocketFunction.d.ts

@@ -22,6 +22,7 @@ export declare class SocketFunction {
     static HTTP_ETAG_CACHE: boolean;
     static silent: boolean;
     static HTTP_COMPRESS: boolean;
+    static LEGACY_INITIALIZE: boolean;
     static COEP: string;
     static COOP: string;
     static readonly WIRE_SERIALIZER: {

package/SocketFunction.ts

@@ -60,6 +60,8 @@ export class SocketFunction {
 
     public static HTTP_COMPRESS = false;
 
+    public static LEGACY_INITIALIZE = false;
+
     // If you have HTTP resources that require cookies you might to set `SocketFunction.COEP = "require-corp"`
     //  - Cross-origin-resource-policy.
     public static COEP = "credentialless";

package/SocketFunctionTypes.d.ts

@@ -16,7 +16,7 @@ export type SocketExposedInterfaceClass = {
     prototype: unknown;
 };
 export type FunctionFlags = {
-    compress?: boolean;
+    compress?: boolean | "LZ4";
     /** Indicates with the same input, we give the same output, forever,
      *      independent of code changes. This only works for data storage.
      */

package/SocketFunctionTypes.ts

@@ -23,7 +23,8 @@ export type SocketExposedInterfaceClass = {
     prototype: unknown;
 };
 export type FunctionFlags = {
-    compress?: boolean;
+    // If the other side of the connection supports it, this will default to LZ4. True will also remap to LZ4, the only way to turn it off is by setting false. 
+    compress?: boolean | "LZ4";
 
     /** Indicates with the same input, we give the same output, forever,
      *      independent of code changes. This only works for data storage.

package/index.d.ts

@@ -31,6 +31,7 @@ declare module "socket-function/SocketFunction" {
         static HTTP_ETAG_CACHE: boolean;
         static silent: boolean;
         static HTTP_COMPRESS: boolean;
+        static LEGACY_INITIALIZE: boolean;
         static COEP: string;
         static COOP: string;
         static readonly WIRE_SERIALIZER: {
@@ -133,7 +134,7 @@ declare module "socket-function/SocketFunctionTypes" {
         prototype: unknown;
     };
     export type FunctionFlags = {
-        compress?: boolean;
+        compress?: boolean | "LZ4";
         /** Indicates with the same input, we give the same output, forever,
          *      independent of code changes. This only works for data storage.
          */
@@ -463,6 +464,7 @@ declare module "socket-function/src/CallFactory" {
         lastClosed: number;
         closedForever?: boolean;
         isConnected?: boolean;
+        receivedInitializeState?: InitializeState;
         performCall(call: CallType): Promise<unknown>;
         onNextDisconnect(callback: () => void): void;
         connectionId: {
@@ -482,6 +484,9 @@ declare module "socket-function/src/CallFactory" {
         readyState: number;
         ping?(): void;
     }
+    type InitializeState = {
+        supportsLZ4?: boolean;
+    };
     export declare function harvestFailedCallCount(): number;
     export declare function getPendingCallCount(): number;
     export declare function harvestCallTimes(): {
@@ -489,6 +494,7 @@ declare module "socket-function/src/CallFactory" {
         end: number;
     }[];
     export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;
+    export {};
 
 }
 
@@ -690,7 +696,7 @@ declare module "socket-function/src/callManager" {
     /// <reference path="../hot/HotReloadController.d.ts" />
     import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "socket-function/SocketFunctionTypes";
     export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
-    export declare function shouldCompressCall(call: CallType): boolean;
+    export declare function shouldCompressCall(call: CallType): boolean | "LZ4" | undefined;
     export declare function performLocalCall(config: {
         call: FullCallType;
         caller: CallerContext;
@@ -837,6 +843,74 @@ declare module "socket-function/src/https" {
 
 }
 
+declare module "socket-function/src/lz4/LZ4" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export declare class LZ4 {
+        static compress(data: Buffer): Buffer;
+        static compressUntracked(data: Buffer): Buffer;
+        static decompress(data: Buffer): Buffer;
+    }
+
+}
+
+declare module "socket-function/src/lz4/lz4_wasm_nodejs" {
+    /* tslint:disable */
+    /* eslint-disable */
+
+    /**
+     * Streaming LZ4 compressor (frame format with linked blocks).
+     * Concatenate all output chunks to form a complete LZ4 frame.
+     */
+    export class Lz4StreamCompressor {
+        free(): void;
+        [Symbol.dispose](): void;
+        compress(input: Uint8Array): Uint8Array;
+        constructor();
+    }
+
+    /**
+     * One-shot block compression with size prepended.
+     */
+    export function compress(input: Uint8Array): Uint8Array;
+
+    /**
+     * One-shot block decompression with size prepended.
+     */
+    export function decompress(input: Uint8Array): Uint8Array;
+
+    /**
+     * Decompress an LZ4 stream (frame format).
+     * Auto-injects end marker if missing. On error, returns partial data and sets a warning.
+     */
+    export function decompress_stream(input: Uint8Array): Uint8Array;
+
+    /**
+     * Get and clear the last warning from decompression.
+     */
+    export function get_last_warning(): string | undefined;
+
+}
+
+declare module "socket-function/src/lz4/lz4_wasm_nodejs_bg.wasm" {
+    /* tslint:disable */
+    /* eslint-disable */
+    export const memory: WebAssembly.Memory;
+    export const __wbg_lz4streamcompressor_free: (a: number, b: number) => void;
+    export const compress: (a: number, b: number) => [number, number];
+    export const decompress: (a: number, b: number) => [number, number, number, number];
+    export const decompress_stream: (a: number, b: number) => [number, number];
+    export const get_last_warning: () => [number, number];
+    export const lz4streamcompressor_compress: (a: number, b: number, c: number) => [number, number];
+    export const lz4streamcompressor_new: () => number;
+    export const __wbindgen_externrefs: WebAssembly.Table;
+    export const __wbindgen_malloc: (a: number, b: number) => number;
+    export const __wbindgen_free: (a: number, b: number, c: number) => void;
+    export const __externref_table_dealloc: (a: number) => void;
+    export const __wbindgen_start: () => void;
+
+}
+
 declare module "socket-function/src/misc" {
     /// <reference types="node" />
     /// <reference types="node" />

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.1.2",
+	"version": "1.1.4",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.d.ts

@@ -9,6 +9,7 @@ export interface CallFactory {
     lastClosed: number;
     closedForever?: boolean;
     isConnected?: boolean;
+    receivedInitializeState?: InitializeState;
     performCall(call: CallType): Promise<unknown>;
     onNextDisconnect(callback: () => void): void;
     connectionId: {
@@ -28,6 +29,9 @@ export interface SenderInterface {
     readyState: number;
     ping?(): void;
 }
+type InitializeState = {
+    supportsLZ4?: boolean;
+};
 export declare function harvestFailedCallCount(): number;
 export declare function getPendingCallCount(): number;
 export declare function harvestCallTimes(): {
@@ -35,3 +39,4 @@ export declare function harvestCallTimes(): {
     end: number;
 }[];
 export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;
+export {};

package/src/CallFactory.ts

@@ -8,7 +8,7 @@ import * as tls from "tls";
 import { getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCache";
 import debugbreak from "debugbreak";
 import { lazy } from "./caching";
-import { red, yellow } from "./formatting/logColors";
+import { blue, green, red, yellow } from "./formatting/logColors";
 import { isSplitableArray, markArrayAsSplitable } from "./fixLargeNetworkCalls";
 import { delay, runInfinitePoll, runInSerial } from "./batching";
 import { formatNumber, formatTime } from "./formatting/format";
@@ -18,6 +18,10 @@ import { setFlag } from "../require/compileFlags";
 import { measureFnc, measureWrap, registerMeasureInfo } from "./profiling/measure";
 import { MaybePromise } from "./types";
 import { Zip } from "./Zip";
+import { LZ4 } from "./lz4/LZ4";
+//LZ4.compress;
+//LZ4.decompress;
+
 setFlag(require, "pako", "allowclient", true);
 
 // NOTE: If it is too low, and too many servers disconnect, we can easily spend 100% of our time
@@ -28,7 +32,7 @@ const MIN_RETRY_DELAY = 5000;
 type InternalCallType = FullCallType & {
     seqNum: number;
     isReturn: false;
-    isArgsCompressed?: boolean;
+    isArgsCompressed?: boolean | "LZ4" | "zip";
 }
 
 type InternalReturnType = {
@@ -36,7 +40,7 @@ type InternalReturnType = {
     result: unknown;
     error?: string;
     seqNum: number;
-    isResultCompressed?: boolean;
+    isResultCompressed?: boolean | "LZ4" | "zip";
 };
 
 
@@ -45,6 +49,7 @@ export interface CallFactory {
     lastClosed: number;
     closedForever?: boolean;
     isConnected?: boolean;
+    receivedInitializeState?: InitializeState;
     // NOTE: May or may not have reconnection or retry logic inside of performCall.
     //  Trigger performLocalCall on the other side of the connection
     performCall(call: CallType): Promise<unknown>;
@@ -69,6 +74,12 @@ export interface SenderInterface {
     ping?(): void;
 }
 
+type InitializeState = {
+    supportsLZ4?: boolean;
+};
+
+const INITIALIZE_STATE_SEQ_NUM = -1;
+
 let pendingCallCount = 0;
 let harvestableFailedCalls = 0;
 const CALL_TIMES_LIMIT = 1000 * 1000 * 10;
@@ -145,6 +156,7 @@ export async function createCallFactory(
         nodeId,
         lastClosed: 0,
         connectionId: { nodeId },
+        receivedInitializeState: undefined,
         onNextDisconnect,
         async performCall(call: CallType) {
             let seqNum = nextSeqNum++;
@@ -164,9 +176,18 @@ export async function createCallFactory(
                 compressedSize: 0,
             };
             try {
-                if (shouldCompressCall(fullCall)) {
-                    fullCall.args = await compressObj(fullCall.args, sendStats) as any;
-                    fullCall.isArgsCompressed = true;
+                if (callFactory.receivedInitializeState?.supportsLZ4) {
+                    let compressMode = 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) as any;
+                        fullCall.isArgsCompressed = "LZ4";
+                    }
+                } else {
+                    if (shouldCompressCall(fullCall)) {
+                        fullCall.args = await compressObj(fullCall.args, sendStats) as any;
+                        fullCall.isArgsCompressed = "zip";
+                    }
                 }
                 let dataMaybePromise = SocketFunction.WIRE_SERIALIZER.serialize(fullCall);
                 if (dataMaybePromise instanceof Promise) {
@@ -268,6 +289,7 @@ export async function createCallFactory(
 
     async function initializeWebsocket(newWebSocket: SenderInterface) {
         registerOnce();
+        callFactory.receivedInitializeState = undefined;
 
         function onClose(error: string) {
             callFactory.connectionId = { nodeId };
@@ -499,101 +521,38 @@ export async function createCallFactory(
         };
 
         if (call.isReturn) {
+            if (!SocketFunction.LEGACY_INITIALIZE && call.seqNum === INITIALIZE_STATE_SEQ_NUM) {
+                callFactory.receivedInitializeState = call.result as InitializeState;
+                console.log(green(`Received initialize state: ${JSON.stringify(callFactory.receivedInitializeState)}`));
+                return;
+            }
             let callbackObj = pendingCalls.get(call.seqNum);
             if (parseTime > SocketFunction.WIRE_WARN_TIME) {
                 console.log(red(`Slow parse, took ${parseTime}ms to parse ${resultSize} bytes, for receiving result of call to ${callbackObj?.call.classGuid}.${callbackObj?.call.functionName}`));
             }
             if (!callbackObj) {
-                console.log(`Got return for unknown call ${call.seqNum} (created at time ${new Date(call.seqNum)})`);
+                console.log(blue(`Got return for unknown call ${call.seqNum} (created at time ${new Date(call.seqNum)}), ${nodeId} / ${localNodeId}`));
                 return;
             }
             if (SocketFunction.logMessages) {
                 let call = callbackObj.call;
                 console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\tRETURN\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
             }
-            if (call.isResultCompressed) {
+            if (call.isResultCompressed === "LZ4") {
+                call.result = await decompressObjLZ4(call.result as Buffer, receiveStats);
+                call.isResultCompressed = undefined;
+            } else if (call.isResultCompressed === "zip" || call.isResultCompressed === true) {
                 call.result = await decompressObj(call.result as Buffer, receiveStats);
-                call.isResultCompressed = false;
+                call.isResultCompressed = undefined;
             }
             callbackObj.callback(call);
         } else {
-            if (call.isArgsCompressed) {
+            if (call.isArgsCompressed === "LZ4") {
+                call.args = await decompressObjLZ4(call.args as any as Buffer, sendStats) as any;
+                call.isArgsCompressed = undefined;
+            } else if (call.isArgsCompressed === "zip" || call.isArgsCompressed === true) {
                 call.args = await decompressObj(call.args as any as Buffer, sendStats) as any;
-                call.isArgsCompressed = false;
-            }
-            if (call.functionName === "changeIdentity") {
-                /*
-                    TODO: Sometimes calls don't get through, even though we know the client made the call. Here are the logs from a failing case:
-                        Exposing Controller ServerController-17ea53da-bbef-4c8b-9eb0-99e263464c6f
-                        Exposing Controller HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5
-                        Exposing Controller TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976
-                        Updating websocket server options
-                        Updating websocket server trusted certificates
-                        Updating websocket server options
-                        Updating websocket server trusted certificates
-                        Updating websocket server options
-                        Updating websocket server trusted certificates
-                        Trying to listening on 127.0.0.1:4231
-                        Started Listening on planquickly.com:4231 (127.0.0.1) after 5.54s
-                        Mounted on 127-0-0-1.planquickly.com:4231
-                        Exposing Controller RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d
-                        Received TCP connection from 127.0.0.1:42105
-                        Received TCP header packet from 127.0.0.1:42105, have 1894 bytes so far, 1 packets
-                        Received TCP connection with SNI "127-0-0-1.planquickly.com". Have handlers for: planquickly.com, 127-0-0-1.planquickly.com
-                        HTTP server connection established 127.0.0.1:42105
-                        HTTP request (GET) https://127-0-0-1.planquickly.com:4231/?hot
-                        HTTP response  106KB  (GET) https://127-0-0-1.planquickly.com:4231/?hot
-                        HTTP server socket closed for 127.0.0.1:42105
-                        Received TCP connection from 127.0.0.1:42106
-                        Received TCP header packet from 127.0.0.1:42106, have 1862 bytes so far, 1 packets
-                        Received TCP connection with SNI "127-0-0-1.planquickly.com". Have handlers for: planquickly.com, 127-0-0-1.planquickly.com
-                        HTTP server connection established 127.0.0.1:42106
-                        HTTP request (GET) https://127-0-0-1.planquickly.com:4231/?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules&args=%5B%5B%22.%2Fsite%2FsiteMain%22%5D%2Cnull%5D
-                        HTTP response  10.8MB  (GET) https://127-0-0-1.planquickly.com:4231/?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules&args=%5B%5B%22.%2Fsite%2FsiteMain%22%5D%2Cnull%5D
-                        Received TCP connection from 127.0.0.1:42107
-                        Received TCP header packet from 127.0.0.1:42107, have 1894 bytes so far, 1 packets
-                        Received TCP connection with SNI "127-0-0-1.planquickly.com". Have handlers for: planquickly.com, 127-0-0-1.planquickly.com
-                        HTTP server connection established 127.0.0.1:42107
-                        HTTP server socket closed for 127.0.0.1:42106
-                        HTTP server socket closed for 127.0.0.1:42107
-                        Received TCP connection from 127.0.0.1:42108
-                        Received TCP header packet from 127.0.0.1:42108, have 1830 bytes so far, 1 packets
-                        Received TCP connection with SNI "127-0-0-1.planquickly.com". Have handlers for: planquickly.com, 127-0-0-1.planquickly.com
-                        HTTP server connection established 127.0.0.1:42108
-                        HTTP request (GET) https://127-0-0-1.planquickly.com:4231/node.cjs.map
-                        HTTP response  106KB  (GET) https://127-0-0-1.planquickly.com:4231/node.cjs.map
-                        HTTP server socket closed for 127.0.0.1:42108
-                        Received TCP connection from 127.0.0.1:42110
-                        Received TCP header packet from 127.0.0.1:42110, have 1818 bytes so far, 1 packets
-                        Received TCP connection with SNI "127-0-0-1.planquickly.com". Have handlers for: planquickly.com, 127-0-0-1.planquickly.com
-                        HTTP server connection established 127.0.0.1:42110
-                        Received TCP connection from 127.0.0.1:42111
-                        Received TCP header packet from 127.0.0.1:42111, have 1830 bytes so far, 1 packets
-                        Received TCP connection with SNI "127-0-0-1.planquickly.com". Have handlers for: planquickly.com, 127-0-0-1.planquickly.com
-                        HTTP server connection established 127.0.0.1:42111
-                        Received websocket upgrade request for 127.0.0.1:42110
-                        Connection established to client:127.0.0.1:1744150129862.296:0.4118126921519041
-                        HTTP request (GET) https://127-0-0-1.planquickly.com:4231/?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules&args=%5B%5B%22D%3A%2Frepos%2Fperspectanalytics%2Fai3%2Fnode_modules%2Fsocket-function%2Ftime%2FtrueTimeShim.ts%22%5D%2C%7B%22requireSeqNumProcessId%22%3A%22requireSeqNumProcessId_1744150120269_0.5550074391586426%22%2C%22seqNumRanges%22%3A%5B%7B%22s%22%3A1%2C%22e%22%3A892%7D%5D%7D%5D
-                        HTTP response  31.1KB  (GET) https://127-0-0-1.planquickly.com:4231/?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules&args=%5B%5B%22D%3A%2Frepos%2Fperspectanalytics%2Fai3%2Fnode_modules%2Fsocket-function%2Ftime%2FtrueTimeShim.ts%22%5D%2C%7B%22requireSeqNumProcessId%22%3A%22requireSeqNumProcessId_1744150120269_0.5550074391586426%22%2C%22seqNumRanges%22%3A%5B%7B%22s%22%3A1%2C%22e%22%3A892%7D%5D%7D%5D
-                        SIZE    171B    EVALUATE        HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5.watchFiles at 1744150129869.296
-                        SIZE    174B    EVALUATE        ServerController-17ea53da-bbef-4c8b-9eb0-99e263464c6f.testSiteFunction at 1744150129872.296
-                        HTTP server socket closed for 127.0.0.1:42111
-                        SIZE    167B    EVALUATE        TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976.getTrueTime at 1744150129893.296
-                        SIZE    167B    EVALUATE        TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976.getTrueTime at 1744150129897.296
-                        SIZE    167B    EVALUATE        TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976.getTrueTime at 1744150129899.296
-                        SIZE    167B    EVALUATE        TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976.getTrueTime at 1744150139907.0776
-                        SIZE    167B    EVALUATE        TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976.getTrueTime at 1744150139909.0776
-                        SIZE    167B    EVALUATE        TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976.getTrueTime at 1744150139911.0776
-                        Hot reloading due to change: D:/repos/perspectanalytics/ai3/node_modules/socket-function/src/webSocketServer.ts
-                    - The upgrade request finishes, at least once: Received websocket upgrade
-                        - AND, we are receiving some calls, so... that appears to work.
-                        - Maybe the time calls never finish?
-                            - We added logging for when calls finish as well, so we can tell if all the TimeController calls timed out
-                            - ALSO, added more logging to see if the calls were from the same client (which WOULD be a bug, because
-                                the client shouldn't be calling us so often), or, different clients.
-                        - We DO receive more connections than http connections closed. But not that many more...
-                */
-                console.log(red(`Call to ${call.classGuid}.${call.functionName} at ${Date.now()}`));
+                call.isArgsCompressed = undefined;
             }
             if (SocketFunction.logMessages) {
                 console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\tEVALUATE\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
@@ -614,9 +573,17 @@ export async function createCallFactory(
                     let timeTaken = Date.now() - time;
                     console.log(`DUR\t${(formatTime(timeTaken)).padEnd(6, " ")}\tFINISH\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
                 }
-                if (shouldCompressCall(call)) {
-                    response.result = await compressObj(response.result, sendStats) as any;
-                    response.isResultCompressed = true;
+                if (callFactory.receivedInitializeState?.supportsLZ4) {
+                    let compressMode = shouldCompressCall(call);
+                    if (compressMode !== false) {
+                        response.result = await compressObjLZ4(response.result, sendStats) as any;
+                        response.isResultCompressed = "LZ4";
+                    }
+                } else {
+                    if (shouldCompressCall(call)) {
+                        response.result = await compressObj(response.result, sendStats) as any;
+                        response.isResultCompressed = "zip";
+                    }
                 }
             } catch (e: any) {
                 response = {
@@ -755,6 +722,20 @@ export async function createCallFactory(
         }
     }
 
+
+    if (!SocketFunction.LEGACY_INITIALIZE) {
+        let initState: InitializeState = {
+            supportsLZ4: true,
+        };
+        let initReturn: InternalReturnType = {
+            isReturn: true,
+            result: initState,
+            seqNum: INITIALIZE_STATE_SEQ_NUM,
+        };
+        let data = await SocketFunction.WIRE_SERIALIZER.serialize(initReturn);
+        await send(data);
+    }
+
     return callFactory;
 }
 
@@ -811,4 +792,29 @@ const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer,
     }
     let result = await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
     return result;
+});
+
+const compressObjLZ4 = measureWrap(async function wireCallCompressLZ4(obj: unknown, stats: CompressionStats): Promise<Buffer> {
+    let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);
+    let lengthBuffer = Buffer.from((new Float64Array(buffers.map(x => x.length))).buffer);
+    let buffer = Buffer.concat([lengthBuffer, ...buffers]);
+    stats.uncompressedSize += buffer.length;
+    let result = LZ4.compress(buffer);
+    stats.compressedSize += result.length;
+    return result;
+});
+
+const decompressObjLZ4 = measureWrap(async function wireCallDecompressLZ4(obj: Buffer, stats: CompressionStats): Promise<unknown> {
+    let buffer = LZ4.decompress(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: Buffer[] = [];
+    let offset = 8;
+    for (let length of lengths) {
+        buffers.push(buffer.slice(offset, offset + length));
+        offset += length;
+    }
+    let result = await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
+    return result;
 });

package/src/callManager.d.ts

@@ -1,7 +1,7 @@
 /// <reference path="../hot/HotReloadController.d.ts" />
 import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
 export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
-export declare function shouldCompressCall(call: CallType): boolean;
+export declare function shouldCompressCall(call: CallType): boolean | "LZ4" | undefined;
 export declare function performLocalCall(config: {
     call: FullCallType;
     caller: CallerContext;

package/src/callManager.ts

@@ -21,7 +21,7 @@ export function getCallFlags(call: CallType): FunctionFlags | undefined {
     return classes[call.classGuid]?.shape[call.functionName];
 }
 export function shouldCompressCall(call: CallType) {
-    return !!classes[call.classGuid]?.shape[call.functionName]?.compress;
+    return classes[call.classGuid]?.shape[call.functionName]?.compress;
 }
 
 export async function performLocalCall(

package/src/lz4/LZ4.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare class LZ4 {
+    static compress(data: Buffer): Buffer;
+    static compressUntracked(data: Buffer): Buffer;
+    static decompress(data: Buffer): Buffer;
+}

package/src/lz4/LZ4.ts

@@ -0,0 +1,32 @@
+// NOTE: Even if we wanted to use the production version, we couldn't because it's not compatible with the client-side code, because they decided to do a file read to load in their WebAssembly. 
+import lz4_stream from "./lz4_wasm_nodejs";
+import { measureFnc } from "../profiling/measure";
+export class LZ4 {
+    @measureFnc
+    static compress(data: Buffer): Buffer {
+        return this.compressUntracked(data);
+    }
+    static compressUntracked(data: Buffer): Buffer {
+        try {
+            return Buffer.from(lz4_stream.compress(data));
+        } catch (e) {
+            // Rethrow non errors as properly wrapped errors
+            if (!(e && e instanceof Error)) {
+                throw new Error(`Error compressing LZ4: ${e}`);
+            }
+            throw e;
+        }
+    }
+    @measureFnc
+    static decompress(data: Buffer): Buffer {
+        try {
+            return Buffer.from(lz4_stream.decompress(data));
+        } catch (e) {
+            // Rethrow non errors as properly wrapped errors
+            if (!(e && e instanceof Error)) {
+                throw new Error(`Error decompressing LZ4: ${e}`);
+            }
+            throw e;
+        }
+    }
+}

package/src/lz4/lz4_wasm_nodejs.d.ts

@@ -0,0 +1,34 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Streaming LZ4 compressor (frame format with linked blocks).
+ * Concatenate all output chunks to form a complete LZ4 frame.
+ */
+export class Lz4StreamCompressor {
+    free(): void;
+    [Symbol.dispose](): void;
+    compress(input: Uint8Array): Uint8Array;
+    constructor();
+}
+
+/**
+ * One-shot block compression with size prepended.
+ */
+export function compress(input: Uint8Array): Uint8Array;
+
+/**
+ * One-shot block decompression with size prepended.
+ */
+export function decompress(input: Uint8Array): Uint8Array;
+
+/**
+ * Decompress an LZ4 stream (frame format).
+ * Auto-injects end marker if missing. On error, returns partial data and sets a warning.
+ */
+export function decompress_stream(input: Uint8Array): Uint8Array;
+
+/**
+ * Get and clear the last warning from decompression.
+ */
+export function get_last_warning(): string | undefined;

package/src/lz4/lz4_wasm_nodejs.js

@@ -0,0 +1,178 @@
+/* @ts-self-types="./lz4_wasm_nodejs.d.ts" */
+
+/**
+ * Streaming LZ4 compressor (frame format with linked blocks).
+ * Concatenate all output chunks to form a complete LZ4 frame.
+ */
+class Lz4StreamCompressor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Lz4StreamCompressorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lz4streamcompressor_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} input
+     * @returns {Uint8Array}
+     */
+    compress(input) {
+        const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lz4streamcompressor_compress(this.__wbg_ptr, ptr0, len0);
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    constructor() {
+        const ret = wasm.lz4streamcompressor_new();
+        this.__wbg_ptr = ret >>> 0;
+        Lz4StreamCompressorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Lz4StreamCompressor.prototype[Symbol.dispose] = Lz4StreamCompressor.prototype.free;
+exports.Lz4StreamCompressor = Lz4StreamCompressor;
+
+/**
+ * One-shot block compression with size prepended.
+ * @param {Uint8Array} input
+ * @returns {Uint8Array}
+ */
+function compress(input) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compress(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.compress = compress;
+
+/**
+ * One-shot block decompression with size prepended.
+ * @param {Uint8Array} input
+ * @returns {Uint8Array}
+ */
+function decompress(input) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decompress(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.decompress = decompress;
+
+/**
+ * Decompress an LZ4 stream (frame format).
+ * Auto-injects end marker if missing. On error, returns partial data and sets a warning.
+ * @param {Uint8Array} input
+ * @returns {Uint8Array}
+ */
+function decompress_stream(input) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decompress_stream(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.decompress_stream = decompress_stream;
+
+/**
+ * Get and clear the last warning from decompression.
+ * @returns {string | undefined}
+ */
+function get_last_warning() {
+    const ret = wasm.get_last_warning();
+    let v1;
+    if (ret[0] !== 0) {
+        v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+}
+exports.get_last_warning = get_last_warning;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./lz4_wasm_nodejs_bg.js": import0,
+    };
+}
+
+const Lz4StreamCompressorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_lz4streamcompressor_free(ptr >>> 0, 1));
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmBase64 = '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';
+const wasmBytes = Buffer.from(wasmBase64, 'base64');
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();

package/src/lz4/lz4_wasm_nodejs_bg.js

@@ -0,0 +1,94 @@
+/**
+ * @param {Uint8Array} input
+ * @returns {Uint8Array}
+ */
+export function compress(input) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compress(ptr0, len0);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * @param {Uint8Array} input
+ * @returns {Uint8Array}
+ */
+export function decompress(input) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decompress(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+}
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}

package/src/lz4/lz4_wasm_nodejs_bg.wasm.d.ts

@@ -0,0 +1,15 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_lz4streamcompressor_free: (a: number, b: number) => void;
+export const compress: (a: number, b: number) => [number, number];
+export const decompress: (a: number, b: number) => [number, number, number, number];
+export const decompress_stream: (a: number, b: number) => [number, number];
+export const get_last_warning: () => [number, number];
+export const lz4streamcompressor_compress: (a: number, b: number, c: number) => [number, number];
+export const lz4streamcompressor_new: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/src/nodeCache.ts

@@ -49,6 +49,8 @@ export function getNodeIdLocation(nodeId: string): { address: string, port: numb
     return { address, port: parseInt(port) };
 }
 
+// NOTE: This returns the full domain.
+//  - It didn't used to, but I think it also wasn't used before, and now we're using this to find the ip. 
 export function getNodeIdDomain(nodeId: string): string {
     let result = getNodeIdDomainMaybeUndefined(nodeId);
     if (result === undefined) {
@@ -61,7 +63,7 @@ export function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefine
     if (!location) {
         return undefined;
     }
-    return new URL("https://" + location.address).hostname.split(".").slice(-2).join(".");
+    return new URL("https://" + location.address).hostname;
 }
 
 // NOTE: CallFactory turns into an actual CallFactory when registerNodeClient is called