socket-function 1.2.14 → 1.2.16

package/SocketFunction.d.ts

@@ -1,5 +1,6 @@
 /// <reference path="require/RequireController.d.ts" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
 import { SocketServerConfig } from "./src/webSocketServer";
 import { Args, MaybePromise } from "./src/types";
@@ -36,6 +37,7 @@ export declare class SocketFunction {
      */
     static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
     static WIRE_WARN_TIME: number;
+    static DISABLE_COMPRESSION: boolean;
     private static onMountCallbacks;
     private static exposedClassesSingleton;
     static get exposedClasses(): Set<string>;

package/SocketFunction.ts

@@ -98,6 +98,9 @@ export class SocketFunction {
 
     public static WIRE_WARN_TIME = 100;
 
+    // Process-wide compression kill switch. When set before connections are established, LZ4 is left out of the protocol negotiation entirely (both for connections we initiate and ones we accept), so NEITHER side compresses — the wire format stays the plain backwards-compatible one. Overrides per-function `compress` flags.
+    public static DISABLE_COMPRESSION = false;
+
     // Shared across copies of this package, so onMount callbacks registered through one copy still
     //  fire when another copy mounts. See createSingleton.
     private static onMountCallbacks = createSingleton("SocketFunction.onMountCallbacks", 1, () => new Map<string, (() => MaybePromise<void>)[]>()).get();
@@ -197,6 +200,8 @@ export class SocketFunction {
 
             for (let value of Object.values(shape)) {
                 if (!value) continue;
+                value.noClientHooks = value.noClientHooks ?? defaultHooks?.noClientHooks;
+                value.noDefaultHooks = value.noDefaultHooks ?? defaultHooks?.noDefaultHooks;
                 if (!value.noClientHooks) {
                     value.clientHooks = [...(defaultHooks?.clientHooks || []), ...(value.clientHooks || [])];
                 }

package/index.d.ts

@@ -9,6 +9,7 @@ declare module "socket-function/SetProcessVariables" {
 declare module "socket-function/SocketFunction" {
     /// <reference path="require/RequireController.d.ts" />
     /// <reference types="node" />
+    /// <reference types="node" />
     import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "socket-function/SocketFunctionTypes";
     import { SocketServerConfig } from "socket-function/src/webSocketServer";
     import { Args, MaybePromise } from "socket-function/src/types";
@@ -45,6 +46,7 @@ declare module "socket-function/SocketFunction" {
          */
         static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
         static WIRE_WARN_TIME: number;
+        static DISABLE_COMPRESSION: boolean;
         private static onMountCallbacks;
         private static exposedClassesSingleton;
         static get exposedClasses(): Set<string>;
@@ -315,6 +317,7 @@ declare module "socket-function/require/CSSShim" {
 declare module "socket-function/require/RequireController" {
     /// <reference path="../../typenode/index.d.ts" />
     /// <reference types="node" />
+    /// <reference types="node" />
     declare global {
         namespace NodeJS {
             interface Module {
@@ -444,6 +447,7 @@ declare module "socket-function/require/compileFlags" {
 }
 
 declare module "socket-function/require/extMapper" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export declare function getExtContentType(ext: string): string;
     export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;
@@ -469,6 +473,7 @@ declare module "socket-function/require/require" {
 }
 
 declare module "socket-function/src/CallFactory" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import { CallType } from "socket-function/SocketFunctionTypes";
@@ -527,6 +532,7 @@ declare module "socket-function/src/CallFactory" {
 }
 
 declare module "socket-function/src/JSONLACKS/JSONLACKS" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export interface JSONLACKS_ParseConfig {
         extended?: boolean;
@@ -562,6 +568,7 @@ declare module "socket-function/src/JSONLACKS/JSONLACKS.generated.js" {
 }
 
 declare module "socket-function/src/Zip" {
+    /// <reference types="node" />
     /// <reference types="node" />
     import { MaybePromise } from "socket-function/src/types";
     export declare class Zip {
@@ -649,6 +656,7 @@ declare module "socket-function/src/batching" {
 }
 
 declare module "socket-function/src/bits" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
      *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
@@ -675,6 +683,7 @@ declare module "socket-function/src/bits" {
 }
 
 declare module "socket-function/src/buffers" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
     export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
@@ -752,6 +761,7 @@ declare module "socket-function/src/caching" {
 }
 
 declare module "socket-function/src/callHTTPHandler" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import http from "http";
@@ -806,6 +816,7 @@ declare module "socket-function/src/callManager" {
 }
 
 declare module "socket-function/src/certStore" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /** Must be populated before the server starts */
     export declare function trustCertificate(cert: string | Buffer): void;
@@ -971,6 +982,7 @@ declare module "socket-function/src/getUniqueTime" {
 }
 
 declare module "socket-function/src/https" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
         headers?: {
@@ -982,6 +994,7 @@ 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;
@@ -1049,6 +1062,7 @@ declare module "socket-function/src/lz4/lz4_wasm_nodejs_bg.wasm" {
 }
 
 declare module "socket-function/src/misc" {
+    /// <reference types="node" />
     /// <reference types="node" />
     import { MaybePromise } from "socket-function/src/types";
     export declare const timeInSecond = 1000;
@@ -1479,6 +1493,7 @@ declare module "socket-function/src/storagePath" {
 }
 
 declare module "socket-function/src/tlsParsing" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export declare function parseTLSHello(buffer: Buffer): {
         extensions: {
@@ -1508,6 +1523,7 @@ declare module "socket-function/src/upreal" {
 }
 
 declare module "socket-function/src/webSocketServer" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import https from "https";

package/package.json

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

package/require/RequireController.d.ts

@@ -1,5 +1,6 @@
 /// <reference path="../../typenode/index.d.ts" />
 /// <reference types="node" />
+/// <reference types="node" />
 declare global {
     namespace NodeJS {
         interface Module {

package/require/extMapper.d.ts

@@ -1,3 +1,4 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export declare function getExtContentType(ext: string): string;
 export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;

package/src/CallFactory.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { CallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
 import * as tls from "tls";

package/src/CallFactory.ts

@@ -21,6 +21,13 @@ import { Zip } from "./Zip";
 import { decodeProtocol, proposeProtocols } from "./protocolNegotiation";
 setImmediate(() => import("./lz4/LZ4"));
 
+// Cached in a plain variable because even though require/import caches modules, the lookup is still measurably slow on a hot path — and once cached the caller doesn't even need to await.
+let lz4Cached: typeof import("./lz4/LZ4").LZ4 | undefined;
+function getLZ4(): MaybePromise<typeof import("./lz4/LZ4").LZ4> {
+    if (lz4Cached) return lz4Cached;
+    return import("./lz4/LZ4").then(module => lz4Cached = module.LZ4);
+}
+
 setFlag(require, "pako", "allowclient", true);
 
 // NOTE: If it is too low, and too many servers disconnect, we can easily spend 100% of our time
@@ -192,9 +199,10 @@ export async function createCallFactory(
                 compressedSize: 0,
             };
             try {
-                if (callFactory.receivedInitializeState?.supportsLZ4) {
+                if (SocketFunction.DISABLE_COMPRESSION) {
+                } else 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 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";
@@ -488,7 +496,7 @@ export async function createCallFactory(
             let alternates = await SocketFunction.GET_ALTERNATE_NODE_IDS(nodeId);
             if (alternates) {
                 for (let alternateNodeId of alternates) {
-                    let newWebSocket = createWebsocket(alternateNodeId, proposeProtocols(nodeId, { lz4: true }));
+                    let newWebSocket = createWebsocket(alternateNodeId, proposeProtocols(nodeId, { lz4: !SocketFunction.DISABLE_COMPRESSION }));
                     await initializeWebsocket(newWebSocket, true);
 
                     if (callFactory.isConnected) {
@@ -500,7 +508,7 @@ export async function createCallFactory(
             console.error("Error getting alternate node IDs", e);
         }
 
-        let newWebSocket = createWebsocket(nodeId, proposeProtocols(nodeId, { lz4: true }));
+        let newWebSocket = createWebsocket(nodeId, proposeProtocols(nodeId, { lz4: !SocketFunction.DISABLE_COMPRESSION }));
         await initializeWebsocket(newWebSocket);
 
         return newWebSocket;
@@ -635,7 +643,8 @@ 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 (callFactory.receivedInitializeState?.supportsLZ4) {
+                if (SocketFunction.DISABLE_COMPRESSION) {
+                } else if (callFactory.receivedInitializeState?.supportsLZ4) {
                     let compressMode = shouldCompressCall(call);
                     if (compressMode !== false) {
                         response.result = await compressObjLZ4(response.result, sendStats);
@@ -865,7 +874,7 @@ const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer,
 });
 
 const compressObjLZ4 = measureWrap(async function wireCallCompressLZ4(obj: unknown, stats: CompressionStats): Promise<Buffer[]> {
-    const { LZ4 } = await import("./lz4/LZ4");
+    const LZ4 = await getLZ4();
     let headerParts: number[];
     let dataBuffers: Buffer[];
 
@@ -968,8 +977,10 @@ const compressObjLZ4 = measureWrap(async function wireCallCompressLZ4(obj: unkno
 });
 
 const decompressObjLZ4 = measureWrap(async function wireCallDecompressLZ4(obj: Buffer[], stats: CompressionStats): Promise<unknown> {
-
-    const { LZ4 } = await import("./lz4/LZ4");
+    let LZ4 = getLZ4();
+    if (LZ4 instanceof Promise) {
+        LZ4 = await LZ4;
+    }
     stats.compressedSize += obj.reduce((sum, buf) => sum + buf.length, 0);
 
     let decompressed: Buffer[] = [];

package/src/JSONLACKS/JSONLACKS.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export interface JSONLACKS_ParseConfig {
     extended?: boolean;
     discardMissingReferences?: boolean;

package/src/Zip.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { MaybePromise } from "./types";
 export declare class Zip {
     static gzip(buffer: Buffer, level?: number): Promise<Buffer>;

package/src/bits.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 /** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
  *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
  */

package/src/buffers.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
 export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
 export declare function cloneBuffer(data: Buffer): Buffer;

package/src/callHTTPHandler.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import http from "http";
 import { CallType } from "../SocketFunctionTypes";
 export declare function setDefaultHTTPCall(call: CallType): void;

package/src/callManager.ts

@@ -128,6 +128,7 @@ export function unregisterGlobalClientHook(hook: SocketFunctionClientHook) {
     }
 }
 
+let startupTime = Date.now();
 export const runClientHooks = measureWrap(async function runClientHooks(
     callType: FullCallType,
     hooks: Exclude<SocketExposedShape[""], undefined>,
@@ -149,8 +150,9 @@ export const runClientHooks = measureWrap(async function runClientHooks(
         await measureBlock(async () => {
             await hook(context);
         }, `clientHook|${hook.name || hook.toString().slice(0, 100)}`);
-        time = Date.now() - time;
-        if (time > 500) {
+        let now = Date.now();
+        time = now - time;
+        if (time > 500 && now - startupTime > 60_000) {
             console.warn(`Slow (${formatTime(time)}) client hook: ${JSON.stringify(hook.name || hook.toString().slice(0, 100))} for ${callType.classGuid}.${callType.functionName}(...)`);
         }
         // NOTE: See ClientHookContext.overrideResult for why we break here
@@ -171,8 +173,9 @@ export const runServerHooks = measureWrap(async function runServerHooks(
     for (let hook of globalHooks.concat(hooks.hooks || [])) {
         let time = Date.now();
         await _setSocketContext(caller, () => hook(hookContext));
-        time = Date.now() - time;
-        if (time > 500) {
+        let now = Date.now();
+        time = now - time;
+        if (time > 500 && now - startupTime > 60_000) {
             console.warn(`Slow (${formatTime(time)}) server hook: ${JSON.stringify(hook.name || hook.toString().slice(0, 100))} for ${callType.classGuid}.${callType.functionName}(...)`);
         }
         // NOTE: See HookContext.overrideResult for why we don't break here

package/src/certStore.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 /** Must be populated before the server starts */
 export declare function trustCertificate(cert: string | Buffer): void;
 export declare function getTrustedCertificates(): string[];

package/src/https.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
     headers?: {
         [key: string]: string | undefined;

package/src/lz4/LZ4.d.ts

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

package/src/misc.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { MaybePromise } from "./types";
 export declare const timeInSecond = 1000;
 export declare const timeInMinute: number;

package/src/protocolNegotiation.ts

@@ -78,7 +78,8 @@ export function proposeProtocols(target: string | undefined, clientCapabilities:
     }
     let out: string[] = [];
     let clientLZ4Options = clientCapabilities.lz4 ? [true, false] : [false];
-    let serverLZ4Options = [true, false];
+    // When we don't want LZ4 we must not propose serverLZ4=1 at all — the server picks the first proposal it can serve, and the echoed serverLZ4 bit is what BOTH sides read as "this connection uses LZ4".
+    let serverLZ4Options = clientCapabilities.lz4 ? [true, false] : [false];
     let encodedTarget = target ?? WILDCARD_TARGET;
     for (let clientLZ4 of clientLZ4Options) {
         for (let serverLZ4 of serverLZ4Options) {

package/src/tlsParsing.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export declare function parseTLSHello(buffer: Buffer): {
     extensions: {
         type: number;

package/src/webSocketServer.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import https from "https";
 import { Watchable } from "./misc";
 export type SocketServerConfig = (https.ServerOptions & {

package/src/webSocketServer.ts

@@ -82,7 +82,7 @@ export async function startSocketServer(
         handleProtocols: (protocols, request) => {
             const ourNodeId = SocketFunction.mountedNodeId;
             const proposed = Array.from(protocols);
-            const chosen = chooseProtocol(proposed, ourNodeId, { lz4: true });
+            const chosen = chooseProtocol(proposed, ourNodeId, { lz4: !SocketFunction.DISABLE_COMPRESSION });
             if (!chosen) {
                 const proposedDecoded = proposed.map(p => decodeProtocol(p));
                 let target = proposedDecoded[0]?.target;