socket-function 1.2.26 → 1.2.28

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

@@ -5,12 +5,15 @@ import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, S
 import { SocketServerConfig } from "./src/webSocketServer";
 import { Args, MaybePromise } from "./src/types";
 import "./SetProcessVariables";
-type ExtractShape<ClassType, Shape> = {
-    [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function has implementation but is not exposed in the SocketFunction.register call");
-};
-export declare class SocketFunction {
-    static logMessages: boolean;
-    static trackMessageSizes: {
+/** The values behind SocketFunction's configuration statics. They are exposed on the class as
+ *      accessors onto a singleton (see the defineSingletonConfig call at the bottom of this file), so
+ *      that configuration set through one copy of this package applies to all of them. This interface
+ *      is the single source of truth for their types - the class declares each one as
+ *      `declare static X: SocketFunctionConfig["X"]`.
+ */
+export interface SocketFunctionConfig {
+    logMessages: boolean;
+    trackMessageSizes: {
         upload: ((size: number, nodeId: string) => void)[];
         download: ((size: number, nodeId: string) => void)[];
         callTimes: ((obj: {
@@ -19,25 +22,49 @@ export declare class SocketFunction {
             nodeId: string;
         }) => void)[];
     };
-    static MAX_MESSAGE_SIZE: number;
-    static HTTP_ETAG_CACHE: boolean;
-    static silent: boolean;
-    static HTTP_COMPRESS: boolean;
-    static COEP: string;
-    static COOP: string;
-    static TOTAL_CALLS: number;
-    static ENABLE_CLIENT_MODE: boolean;
-    static isClient(): boolean;
-    static readonly WIRE_SERIALIZER: {
+    MAX_MESSAGE_SIZE: number;
+    HTTP_ETAG_CACHE: boolean;
+    silent: boolean;
+    HTTP_COMPRESS: boolean;
+    /** If you have HTTP resources that require cookies you might to set `SocketFunction.COEP = "require-corp"`
+     *      - Cross-origin-resource-policy.
+     *  NOTE: This COOP and COEP defaults are required so window.crossOriginIsolated will be true.
+     */
+    COEP: string;
+    COOP: string;
+    TOTAL_CALLS: number;
+    ENABLE_CLIENT_MODE: boolean;
+    WIRE_SERIALIZER: {
         serialize: (obj: unknown) => MaybePromise<Buffer[]>;
         deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
     };
     /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
      *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
      */
-    static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
-    static WIRE_WARN_TIME: number;
-    static DISABLE_COMPRESSION: boolean;
+    GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
+    WIRE_WARN_TIME: number;
+    /** 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. */
+    DISABLE_COMPRESSION: boolean;
+}
+type ExtractShape<ClassType, Shape> = {
+    [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function has implementation but is not exposed in the SocketFunction.register call");
+};
+export declare class SocketFunction {
+    static logMessages: SocketFunctionConfig["logMessages"];
+    static trackMessageSizes: SocketFunctionConfig["trackMessageSizes"];
+    static MAX_MESSAGE_SIZE: SocketFunctionConfig["MAX_MESSAGE_SIZE"];
+    static HTTP_ETAG_CACHE: SocketFunctionConfig["HTTP_ETAG_CACHE"];
+    static silent: SocketFunctionConfig["silent"];
+    static HTTP_COMPRESS: SocketFunctionConfig["HTTP_COMPRESS"];
+    static COEP: SocketFunctionConfig["COEP"];
+    static COOP: SocketFunctionConfig["COOP"];
+    static TOTAL_CALLS: SocketFunctionConfig["TOTAL_CALLS"];
+    static ENABLE_CLIENT_MODE: SocketFunctionConfig["ENABLE_CLIENT_MODE"];
+    static readonly WIRE_SERIALIZER: SocketFunctionConfig["WIRE_SERIALIZER"];
+    static GET_ALTERNATE_NODE_IDS: SocketFunctionConfig["GET_ALTERNATE_NODE_IDS"];
+    static WIRE_WARN_TIME: SocketFunctionConfig["WIRE_WARN_TIME"];
+    static DISABLE_COMPRESSION: SocketFunctionConfig["DISABLE_COMPRESSION"];
+    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";
@@ -45,61 +45,89 @@ const socketContext = createSingleton("SocketFunction.socketContext", 1, () => (
     caller: undefined as CallerContext | undefined,
 }));
 
-type ExtractShape<ClassType, Shape> = {
-    [key in keyof ClassType]: (
-        key extends keyof Shape
-        ? ClassType[key] extends SocketExposedInterface[""]
-        ? ClassType[key]
-        : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never
-        : "Function has implementation but is not exposed in the SocketFunction.register call"
-    );
-};
-
-export class SocketFunction {
-    public static logMessages = false;
-    public static trackMessageSizes = {
-        upload: [] as ((size: number, nodeId: string) => void)[],
-        download: [] as ((size: number, nodeId: string) => void)[],
-        callTimes: [] as ((obj: { start: number; end: number; nodeId: string; }) => void)[],
+/** The values behind SocketFunction's configuration statics. They are exposed on the class as
+ *      accessors onto a singleton (see the defineSingletonConfig call at the bottom of this file), so
+ *      that configuration set through one copy of this package applies to all of them. This interface
+ *      is the single source of truth for their types - the class declares each one as
+ *      `declare static X: SocketFunctionConfig["X"]`.
+ */
+export interface SocketFunctionConfig {
+    logMessages: boolean;
+    trackMessageSizes: {
+        upload: ((size: number, nodeId: string) => void)[];
+        download: ((size: number, nodeId: string) => void)[];
+        callTimes: ((obj: { start: number; end: number; nodeId: string; }) => void)[];
     };
 
-    public static MAX_MESSAGE_SIZE = 1024 * 1024 * 32;
+    MAX_MESSAGE_SIZE: number;
 
-    public static HTTP_ETAG_CACHE = false;
-    public static silent = true;
+    HTTP_ETAG_CACHE: boolean;
+    silent: boolean;
 
-    public static HTTP_COMPRESS = false;
+    HTTP_COMPRESS: boolean;
 
-    // If you have HTTP resources that require cookies you might to set `SocketFunction.COEP = "require-corp"`
-    //  - Cross-origin-resource-policy.
-    public static COEP = "credentialless";
-    // NOTE: This COOP and COEP defaults are required so window.crossOriginIsolated will be true.
-    public static COOP = "same-origin";
+    /** If you have HTTP resources that require cookies you might to set `SocketFunction.COEP = "require-corp"`
+     *      - Cross-origin-resource-policy.
+     *  NOTE: This COOP and COEP defaults are required so window.crossOriginIsolated will be true.
+     */
+    COEP: string;
+    COOP: string;
 
-    public static TOTAL_CALLS = 0;
+    TOTAL_CALLS: number;
 
-    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; }
+    ENABLE_CLIENT_MODE: boolean;
 
     // In retrospect... dynamically changing the wire serializer is a BAD idea. If any calls happen
     //  before it is changed, things just break. Also, it needs to be changed on both sides,
     //  or else things break. Also, it is very hard to detect when the issue is different serializers
     // NOTE: The only reason this is still exposed is in case in the future we want to intercept our traffic, and we want convenient functions to know how to decode it (although there are a still few other layers under this, for compression and Buffer[] sending efficiency).
-    public static readonly WIRE_SERIALIZER = {
-        serialize: measureWrap((obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)], "WIRE_SERIALIZER|serialize"),
-        deserialize: measureWrap((buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]), "WIRE_SERIALIZER|deserialize"),
+    WIRE_SERIALIZER: {
+        serialize: (obj: unknown) => MaybePromise<Buffer[]>;
+        deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
     };
 
-    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID. 
+    /** 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;
+    GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
+
+    WIRE_WARN_TIME: number;
+
+    /** 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. */
+    DISABLE_COMPRESSION: boolean;
+}
+
+type ExtractShape<ClassType, Shape> = {
+    [key in keyof ClassType]: (
+        key extends keyof Shape
+        ? ClassType[key] extends SocketExposedInterface[""]
+        ? ClassType[key]
+        : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never
+        : "Function has implementation but is not exposed in the SocketFunction.register call"
+    );
+};
 
-    public static WIRE_WARN_TIME = 100;
+export class SocketFunction {
+    // All of these are accessors onto a shared singleton, installed after the class declaration.
+    //  See SocketFunctionConfig for their documentation, and defineSingletonConfig for why they
+    //  cannot be plain static fields.
+    public declare static logMessages: SocketFunctionConfig["logMessages"];
+    public declare static trackMessageSizes: SocketFunctionConfig["trackMessageSizes"];
+    public declare static MAX_MESSAGE_SIZE: SocketFunctionConfig["MAX_MESSAGE_SIZE"];
+    public declare static HTTP_ETAG_CACHE: SocketFunctionConfig["HTTP_ETAG_CACHE"];
+    public declare static silent: SocketFunctionConfig["silent"];
+    public declare static HTTP_COMPRESS: SocketFunctionConfig["HTTP_COMPRESS"];
+    public declare static COEP: SocketFunctionConfig["COEP"];
+    public declare static COOP: SocketFunctionConfig["COOP"];
+    public declare static TOTAL_CALLS: SocketFunctionConfig["TOTAL_CALLS"];
+    public declare static ENABLE_CLIENT_MODE: SocketFunctionConfig["ENABLE_CLIENT_MODE"];
+    public declare static readonly WIRE_SERIALIZER: SocketFunctionConfig["WIRE_SERIALIZER"];
+    public declare static GET_ALTERNATE_NODE_IDS: SocketFunctionConfig["GET_ALTERNATE_NODE_IDS"];
+    public declare static WIRE_WARN_TIME: SocketFunctionConfig["WIRE_WARN_TIME"];
+    public declare static DISABLE_COMPRESSION: SocketFunctionConfig["DISABLE_COMPRESSION"];
 
-    // 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;
+    // 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 +541,30 @@ export class SocketFunction {
     }
 }
 
+defineSingletonConfig<SocketFunctionConfig>(SocketFunction, "SocketFunction.config", 1, () => ({
+    logMessages: false,
+    trackMessageSizes: {
+        upload: [],
+        download: [],
+        callTimes: [],
+    },
+    MAX_MESSAGE_SIZE: 1024 * 1024 * 32,
+    HTTP_ETAG_CACHE: false,
+    silent: true,
+    HTTP_COMPRESS: false,
+    COEP: "credentialless",
+    COOP: "same-origin",
+    TOTAL_CALLS: 0,
+    ENABLE_CLIENT_MODE: false,
+    WIRE_SERIALIZER: {
+        serialize: measureWrap((obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)], "WIRE_SERIALIZER|serialize"),
+        deserialize: measureWrap((buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]), "WIRE_SERIALIZER|deserialize"),
+    },
+    GET_ALTERNATE_NODE_IDS: (nodeId: string): MaybePromise<string[] | undefined> => undefined,
+    WIRE_WARN_TIME: 100,
+    DISABLE_COMPRESSION: false,
+}));
+
 declare global {
     var BOOTED_EDGE_NODE: { host: string } | undefined;
 }

package/index.d.ts

@@ -14,12 +14,15 @@ declare module "socket-function/SocketFunction" {
     import { SocketServerConfig } from "socket-function/src/webSocketServer";
     import { Args, MaybePromise } from "socket-function/src/types";
     import "./SetProcessVariables";
-    type ExtractShape<ClassType, Shape> = {
-        [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function has implementation but is not exposed in the SocketFunction.register call");
-    };
-    export declare class SocketFunction {
-        static logMessages: boolean;
-        static trackMessageSizes: {
+    /** The values behind SocketFunction's configuration statics. They are exposed on the class as
+     *      accessors onto a singleton (see the defineSingletonConfig call at the bottom of this file), so
+     *      that configuration set through one copy of this package applies to all of them. This interface
+     *      is the single source of truth for their types - the class declares each one as
+     *      `declare static X: SocketFunctionConfig["X"]`.
+     */
+    export interface SocketFunctionConfig {
+        logMessages: boolean;
+        trackMessageSizes: {
             upload: ((size: number, nodeId: string) => void)[];
             download: ((size: number, nodeId: string) => void)[];
             callTimes: ((obj: {
@@ -28,25 +31,49 @@ declare module "socket-function/SocketFunction" {
                 nodeId: string;
             }) => void)[];
         };
-        static MAX_MESSAGE_SIZE: number;
-        static HTTP_ETAG_CACHE: boolean;
-        static silent: boolean;
-        static HTTP_COMPRESS: boolean;
-        static COEP: string;
-        static COOP: string;
-        static TOTAL_CALLS: number;
-        static ENABLE_CLIENT_MODE: boolean;
-        static isClient(): boolean;
-        static readonly WIRE_SERIALIZER: {
+        MAX_MESSAGE_SIZE: number;
+        HTTP_ETAG_CACHE: boolean;
+        silent: boolean;
+        HTTP_COMPRESS: boolean;
+        /** If you have HTTP resources that require cookies you might to set `SocketFunction.COEP = "require-corp"`
+         *      - Cross-origin-resource-policy.
+         *  NOTE: This COOP and COEP defaults are required so window.crossOriginIsolated will be true.
+         */
+        COEP: string;
+        COOP: string;
+        TOTAL_CALLS: number;
+        ENABLE_CLIENT_MODE: boolean;
+        WIRE_SERIALIZER: {
             serialize: (obj: unknown) => MaybePromise<Buffer[]>;
             deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
         };
         /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
          *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
          */
-        static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
-        static WIRE_WARN_TIME: number;
-        static DISABLE_COMPRESSION: boolean;
+        GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
+        WIRE_WARN_TIME: number;
+        /** 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. */
+        DISABLE_COMPRESSION: boolean;
+    }
+    type ExtractShape<ClassType, Shape> = {
+        [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function has implementation but is not exposed in the SocketFunction.register call");
+    };
+    export declare class SocketFunction {
+        static logMessages: SocketFunctionConfig["logMessages"];
+        static trackMessageSizes: SocketFunctionConfig["trackMessageSizes"];
+        static MAX_MESSAGE_SIZE: SocketFunctionConfig["MAX_MESSAGE_SIZE"];
+        static HTTP_ETAG_CACHE: SocketFunctionConfig["HTTP_ETAG_CACHE"];
+        static silent: SocketFunctionConfig["silent"];
+        static HTTP_COMPRESS: SocketFunctionConfig["HTTP_COMPRESS"];
+        static COEP: SocketFunctionConfig["COEP"];
+        static COOP: SocketFunctionConfig["COOP"];
+        static TOTAL_CALLS: SocketFunctionConfig["TOTAL_CALLS"];
+        static ENABLE_CLIENT_MODE: SocketFunctionConfig["ENABLE_CLIENT_MODE"];
+        static readonly WIRE_SERIALIZER: SocketFunctionConfig["WIRE_SERIALIZER"];
+        static GET_ALTERNATE_NODE_IDS: SocketFunctionConfig["GET_ALTERNATE_NODE_IDS"];
+        static WIRE_WARN_TIME: SocketFunctionConfig["WIRE_WARN_TIME"];
+        static DISABLE_COMPRESSION: SocketFunctionConfig["DISABLE_COMPRESSION"];
+        static isClient(): boolean;
         private static onMountCallbacks;
         private static exposedClassesSingleton;
         static get exposedClasses(): Set<string>;
@@ -849,6 +876,17 @@ 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>;
+    /** Installs accessors on target for every key of the config object, with the values living in 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).
+     *  - Declare the properties on the class with `declare static X: Config["X"]`. `declare` emits no
+     *      field, so there is no own property to shadow the accessors installed here, and taking the
+     *      types from the config interface keeps the two from drifting apart.
+     *  - 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: object, name: string, version: string | number, getDefaults: () => T): Singleton<T>;
 
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.2.26",
+	"version": "1.2.28",
 	"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;
@@ -45,8 +46,8 @@ export class JSONLACKS {
     public static readonly LACKS_KEY = "__JSONLACKS__98cfb4a05fa34d828661cae15b8779ce__";
 
     /** If set to true parses non-quoted field names, comments, trailing commas, etc */
-    public static EXTENDED_PARSER = false;
-    public static IGNORE_MISSING_REFERENCES = false;
+    public declare static EXTENDED_PARSER: boolean;
+    public declare static IGNORE_MISSING_REFERENCES: boolean;
 
     public static stringify(obj: unknown, config?: JSONLACKS_StringifyConfig): string {
         let serialized = JSONLACKS.escapeSpecialObjects(obj, config);
@@ -299,6 +300,11 @@ export class JSONLACKS {
     }
 }
 
+defineSingletonConfig(JSONLACKS, "JSONLACKS.config", 1, () => ({
+    EXTENDED_PARSER: false,
+    IGNORE_MISSING_REFERENCES: false,
+}));
+
 async function benchmark() {
     const loops = 1000 * 100;
     let inputs: string[] = [];

package/src/callHTTPHandler.ts

@@ -13,6 +13,9 @@ import { createSingleton } from "./createSingleton";
 //  the HTTP handler of any other copy. See createSingleton.
 const defaultHTTPCall = createSingleton("callHTTPHandler.defaultHTTPCall", 1, () => ({ call: undefined as CallType | undefined }));
 
+// Statuses where the spec forbids a message body, so we must not write resultBuffer
+const BODYLESS_STATUS_CODES = new Set([204, 205, 304]);
+
 export function setDefaultHTTPCall(call: CallType) {
     defaultHTTPCall.get().call = call;
 }
@@ -253,12 +256,18 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
 
         if (headers) {
             for (let headerName in headers) {
+                // "status" is the status line, not a header, so don't emit it on the wire
+                if (headerName.toLowerCase() === "status") continue;
                 response.setHeader(headerName, headers[headerName]);
             }
-            let status = headers["status"];
+            let status = headers["status"] ?? headers["Status"];
             if (status) {
-                response.writeHead(+status);
-                return;
+                // Only set statusCode (NOT writeHead), as writeHead locks the header block, which would
+                //  drop the Content-Type / Content-Length / compression handling below
+                response.statusCode = +status;
+                if (BODYLESS_STATUS_CODES.has(+status) || +status < 200) {
+                    return;
+                }
             }
         }
         // With nosniff set, an untyped response is unusable to the browser, so results without explicit headers need their actual type (JSON) declared

package/src/createSingleton.d.ts

@@ -17,3 +17,14 @@ 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>;
+/** Installs accessors on target for every key of the config object, with the values living in 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).
+ *  - Declare the properties on the class with `declare static X: Config["X"]`. `declare` emits no
+ *      field, so there is no own property to shadow the accessors installed here, and taking the
+ *      types from the config interface keeps the two from drifting apart.
+ *  - 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: object, name: string, version: string | number, getDefaults: () => T): Singleton<T>;

package/src/createSingleton.ts

@@ -74,3 +74,40 @@ export function createSingleton<T>(
         },
     };
 }
+
+/** Installs accessors on target for every key of the config object, with the values living in 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).
+ *  - Declare the properties on the class with `declare static X: Config["X"]`. `declare` emits no
+ *      field, so there is no own property to shadow the accessors installed here, and taking the
+ *      types from the config interface keeps the two from drifting apart.
+ *  - 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: object,
+    name: string,
+    version: string | number,
+    getDefaults: () => T,
+): Singleton<T> {
+    const defaults = getDefaults();
+    const singleton = createSingleton<T>(name, version, () => defaults);
+    const values = singleton.get() as { [key: string]: unknown };
+    for (const key of Object.keys(defaults)) {
+        if (!(key in values)) {
+            values[key] = (defaults as { [key: string]: unknown })[key];
+        }
+        Object.defineProperty(target, key, {
+            get() {
+                return (singleton.get() as { [key: string]: unknown })[key];
+            },
+            set(value: unknown) {
+                (singleton.get() as { [key: string]: unknown })[key] = value;
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return singleton;
+}