socket-function 1.2.27 → 1.2.29

package/.claude/settings.local.json

@@ -5,7 +5,8 @@
       "Bash(cp -r 'C:/Users/quent/AppData/Local/BraveSoftware/Brave-Browser/User Data/Default/Local Extension Settings/dhdgffkkebhmkfjojejmpbldmpobfkfo' C:/Users/quent/AppData/Local/Temp/claude/D--repos-socket-function/117d10bd-31c6-4c68-938d-1fff47788fa6/scratchpad/tm-recover/LocalExtSettings)",
       "Bash(yarn test-dns-claude *)",
       "Bash(yarn type *)",
-      "Bash(yarn test *)"
+      "Bash(yarn test *)",
+      "PowerShell(yarn type *)"
     ]
   }
 }

package/SocketFunction.d.ts

@@ -27,7 +27,6 @@ export declare class SocketFunction {
     static COOP: string;
     static TOTAL_CALLS: number;
     static ENABLE_CLIENT_MODE: boolean;
-    static isClient(): boolean;
     static readonly WIRE_SERIALIZER: {
         serialize: (obj: unknown) => MaybePromise<Buffer[]>;
         deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
@@ -38,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;
+    static isClient(): boolean;
     private static onMountCallbacks;
     private static exposedClassesSingleton;
     static get exposedClasses(): Set<string>;

package/SocketFunction.ts

@@ -9,7 +9,7 @@ import { Args, MaybePromise } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
 import debugbreak from "debugbreak";
 import { lazy } from "./src/caching";
-import { createSingleton } from "./src/createSingleton";
+import { createSingleton, defineSingletonConfig } from "./src/createSingleton";
 import { delay } from "./src/batching";
 import { blue, magenta } from "./src/formatting/logColors";
 import { JSONLACKS } from "./src/JSONLACKS/JSONLACKS";
@@ -56,6 +56,12 @@ type ExtractShape<ClassType, Shape> = {
 };
 
 export class SocketFunction {
+
+
+    // #region Shared config statics. EVERYTHING in this region (and nothing outside it) is redefined
+    //  below the class by defineSingletonConfig, which replaces each property (via defineProperty)
+    //  with accessors onto a singleton shared by every copy of this package - the inline values here
+    //  are just the defaults.
     public static logMessages = false;
     public static trackMessageSizes = {
         upload: [] as ((size: number, nodeId: string) => void)[],
@@ -79,8 +85,6 @@ export class SocketFunction {
     public static TOTAL_CALLS = 0;
 
     public static ENABLE_CLIENT_MODE = false;
-    // Places where we decide if we want to act as a client. Most places we check for is node, but some places it's not, depending on if we're in Node.js or not, it's depending on if we're a client or not.
-    public static isClient() { return !isNode() || SocketFunction.ENABLE_CLIENT_MODE; }
 
     // In retrospect... dynamically changing the wire serializer is a BAD idea. If any calls happen
     //  before it is changed, things just break. Also, it needs to be changed on both sides,
@@ -91,7 +95,7 @@ export class SocketFunction {
         deserialize: measureWrap((buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]), "WIRE_SERIALIZER|deserialize"),
     };
 
-    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID. 
+    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
      *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
      */
     public static GET_ALTERNATE_NODE_IDS = (nodeId: string): MaybePromise<string[] | undefined> => undefined;
@@ -100,6 +104,13 @@ export class SocketFunction {
 
     // 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;
+    // #endregion Shared config statics.
+
+
+
+
+    // Places where we decide if we want to act as a client. Most places we check for is node, but some places it's not, depending on if we're in Node.js or not, it's depending on if we're a client or not.
+    public static isClient() { return !isNode() || SocketFunction.ENABLE_CLIENT_MODE; }
 
     // Shared across copies of this package, so onMount callbacks registered through one copy still
     //  fire when another copy mounts. See createSingleton.
@@ -513,6 +524,23 @@ export class SocketFunction {
     }
 }
 
+defineSingletonConfig(SocketFunction, "SocketFunction.config", 1, [
+    "logMessages",
+    "trackMessageSizes",
+    "MAX_MESSAGE_SIZE",
+    "HTTP_ETAG_CACHE",
+    "silent",
+    "HTTP_COMPRESS",
+    "COEP",
+    "COOP",
+    "TOTAL_CALLS",
+    "ENABLE_CLIENT_MODE",
+    "WIRE_SERIALIZER",
+    "GET_ALTERNATE_NODE_IDS",
+    "WIRE_WARN_TIME",
+    "DISABLE_COMPRESSION",
+]);
+
 declare global {
     var BOOTED_EDGE_NODE: { host: string } | undefined;
 }

package/index.d.ts

@@ -36,7 +36,6 @@ declare module "socket-function/SocketFunction" {
         static COOP: string;
         static TOTAL_CALLS: number;
         static ENABLE_CLIENT_MODE: boolean;
-        static isClient(): boolean;
         static readonly WIRE_SERIALIZER: {
             serialize: (obj: unknown) => MaybePromise<Buffer[]>;
             deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
@@ -47,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;
+        static isClient(): boolean;
         private static onMountCallbacks;
         private static exposedClassesSingleton;
         static get exposedClasses(): Set<string>;
@@ -849,6 +849,16 @@ declare module "socket-function/src/createSingleton" {
      *      get()/set() at each access so every copy sees the latest.
      */
     export declare function createSingleton<T>(name: string, version: string | number, getDefault: () => T): Singleton<T>;
+    /** Redefines the given (already initialized) properties of target as accessors onto a singleton, so
+     *      `Target.SOME_SETTING = x` configures every copy of the package instead of only the copy the
+     *      caller happened to import (which is otherwise decided by module resolution, and so is
+     *      essentially arbitrary from the caller's perspective). The properties' current values become
+     *      the defaults, so config statics stay defined inline in the class as usual - just call this
+     *      below the class with the list of statics to share.
+     *  - Same versioning rules as createSingleton, except that adding a property is not a shape change:
+     *      a copy that knows about a property older copies don't backfills it below.
+     */
+    export declare function defineSingletonConfig<T extends object>(target: T, name: string, version: string | number, keys: (keyof T & string)[]): void;
 
 }
 

package/package.json

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

package/src/JSONLACKS/JSONLACKS.ts

@@ -9,6 +9,7 @@ import parser from "./JSONLACKS.generated.js";
 import { recursiveFreeze } from "../misc";
 import { canHaveChildren } from "../types";
 import { delay } from "../batching";
+import { defineSingletonConfig } from "../createSingleton";
 
 const SERIALIZE_OBJECT_BATCH_COUNT = 1000;
 const PARSE_BYTE_CHUNK_SIZE = 1024 * 1024 * 10;
@@ -44,9 +45,14 @@ interface HydrateState {
 export class JSONLACKS {
     public static readonly LACKS_KEY = "__JSONLACKS__98cfb4a05fa34d828661cae15b8779ce__";
 
+    // #region Shared config statics. EVERYTHING in this region (and nothing outside it) is redefined
+    //  below the class by defineSingletonConfig, which replaces each property (via defineProperty)
+    //  with accessors onto a singleton shared by every copy of this package - the inline values here
+    //  are just the defaults.
     /** If set to true parses non-quoted field names, comments, trailing commas, etc */
     public static EXTENDED_PARSER = false;
     public static IGNORE_MISSING_REFERENCES = false;
+    // #endregion Shared config statics.
 
     public static stringify(obj: unknown, config?: JSONLACKS_StringifyConfig): string {
         let serialized = JSONLACKS.escapeSpecialObjects(obj, config);
@@ -299,6 +305,11 @@ export class JSONLACKS {
     }
 }
 
+defineSingletonConfig(JSONLACKS, "JSONLACKS.config", 1, [
+    "EXTENDED_PARSER",
+    "IGNORE_MISSING_REFERENCES",
+]);
+
 async function benchmark() {
     const loops = 1000 * 100;
     let inputs: string[] = [];

package/src/createSingleton.d.ts

@@ -17,3 +17,13 @@ export interface Singleton<T> {
  *      get()/set() at each access so every copy sees the latest.
  */
 export declare function createSingleton<T>(name: string, version: string | number, getDefault: () => T): Singleton<T>;
+/** Redefines the given (already initialized) properties of target as accessors onto a singleton, so
+ *      `Target.SOME_SETTING = x` configures every copy of the package instead of only the copy the
+ *      caller happened to import (which is otherwise decided by module resolution, and so is
+ *      essentially arbitrary from the caller's perspective). The properties' current values become
+ *      the defaults, so config statics stay defined inline in the class as usual - just call this
+ *      below the class with the list of statics to share.
+ *  - Same versioning rules as createSingleton, except that adding a property is not a shape change:
+ *      a copy that knows about a property older copies don't backfills it below.
+ */
+export declare function defineSingletonConfig<T extends object>(target: T, name: string, version: string | number, keys: (keyof T & string)[]): void;

package/src/createSingleton.ts

@@ -74,3 +74,36 @@ export function createSingleton<T>(
         },
     };
 }
+
+/** Redefines the given (already initialized) properties of target as accessors onto a singleton, so
+ *      `Target.SOME_SETTING = x` configures every copy of the package instead of only the copy the
+ *      caller happened to import (which is otherwise decided by module resolution, and so is
+ *      essentially arbitrary from the caller's perspective). The properties' current values become
+ *      the defaults, so config statics stay defined inline in the class as usual - just call this
+ *      below the class with the list of statics to share.
+ *  - Same versioning rules as createSingleton, except that adding a property is not a shape change:
+ *      a copy that knows about a property older copies don't backfills it below.
+ */
+export function defineSingletonConfig<T extends object>(
+    target: T,
+    name: string,
+    version: string | number,
+    keys: (keyof T & string)[],
+): void {
+    const store = createSingleton<{ [key: string]: unknown }>(name, version, () => Object.create(null)).get();
+    for (const key of keys) {
+        if (!(key in store)) {
+            store[key] = target[key];
+        }
+        Object.defineProperty(target, key, {
+            get() {
+                return store[key];
+            },
+            set(value: unknown) {
+                store[key] = value;
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    }
+}