socket-function 1.2.28 → 1.2.30

package/SocketFunction.d.ts

@@ -5,15 +5,12 @@ import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, S
 import { SocketServerConfig } from "./src/webSocketServer";
 import { Args, MaybePromise } from "./src/types";
 import "./SetProcessVariables";
-/** 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: {
+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: {
         upload: ((size: number, nodeId: string) => void)[];
         download: ((size: number, nodeId: string) => void)[];
         callTimes: ((obj: {
@@ -22,48 +19,24 @@ export interface SocketFunctionConfig {
             nodeId: string;
         }) => void)[];
     };
-    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: {
+    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 readonly 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.
      */
-    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 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;

package/SocketFunction.ts

@@ -45,86 +45,69 @@ const socketContext = createSingleton("SocketFunction.socketContext", 1, () => (
     caller: undefined as CallerContext | undefined,
 }));
 
-/** 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)[];
+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 {
+
+
+    // #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)[],
+        download: [] as ((size: number, nodeId: string) => void)[],
+        callTimes: [] as ((obj: { start: number; end: number; nodeId: string; }) => void)[],
     };
 
-    MAX_MESSAGE_SIZE: number;
+    public static MAX_MESSAGE_SIZE = 1024 * 1024 * 32;
 
-    HTTP_ETAG_CACHE: boolean;
-    silent: boolean;
+    public static HTTP_ETAG_CACHE = false;
+    public static silent = true;
 
-    HTTP_COMPRESS: boolean;
+    public static HTTP_COMPRESS = false;
 
-    /** 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;
+    // 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";
 
-    TOTAL_CALLS: number;
+    public static TOTAL_CALLS = 0;
 
-    ENABLE_CLIENT_MODE: boolean;
+    public static ENABLE_CLIENT_MODE = false;
 
     // 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).
-    WIRE_SERIALIZER: {
-        serialize: (obj: unknown) => MaybePromise<Buffer[]>;
-        deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
+    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"),
     };
 
     /** 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.
      */
-    GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
+    public static GET_ALTERNATE_NODE_IDS = (nodeId: string): MaybePromise<string[] | undefined> => undefined;
 
-    WIRE_WARN_TIME: number;
+    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;
+    // #endregion Shared config statics.
 
-    /** 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 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"];
 
     // 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; }
@@ -541,29 +524,22 @@ 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,
-}));
+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

@@ -14,15 +14,12 @@ declare module "socket-function/SocketFunction" {
     import { SocketServerConfig } from "socket-function/src/webSocketServer";
     import { Args, MaybePromise } from "socket-function/src/types";
     import "./SetProcessVariables";
-    /** 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: {
+    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: {
             upload: ((size: number, nodeId: string) => void)[];
             download: ((size: number, nodeId: string) => void)[];
             callTimes: ((obj: {
@@ -31,48 +28,24 @@ declare module "socket-function/SocketFunction" {
                 nodeId: string;
             }) => void)[];
         };
-        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: {
+        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 readonly 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.
          */
-        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 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;
@@ -876,17 +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>;
-    /** 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.
+    /** 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: object, name: string, version: string | number, getDefaults: () => T): Singleton<T>;
+    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.28",
+	"version": "1.2.30",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.ts

@@ -316,7 +316,7 @@ export async function createCallFactory(
         registerOnce();
         callFactory.receivedInitializeState = undefined;
 
-        function onClose(error: string) {
+        function onClose(message: string) {
             // We try various connections, and if they fail, we will just try other node IDs until we finally do connect, and then we stick with that nodeId, and when it disconnects we need to handle disconnections normally.
             if (skipCloseHandling && !hasEverConnected) {
                 return;
@@ -335,7 +335,7 @@ export async function createCallFactory(
                 call.callback({
                     isReturn: true,
                     result: undefined,
-                    error: error,
+                    error: `Call failed for ${call.call.classGuid}.${call.call.functionName}: ${message}`,
                     seqNum: call.call.seqNum,
                 });
             }
@@ -353,12 +353,12 @@ export async function createCallFactory(
             // NOTE: No more logging, as we throw, so the caller should be logging the
             //  error (or swallowing it, if that is what it wants to do).
             //console.log(`Websocket error for ${niceConnectionName}`, e.message);
-            onClose(new Error(`Connection error for ${niceConnectionName}: ${e.message}`).stack!);
+            onClose(`Connection error for ${niceConnectionName}: ${e.message}`);
         });
 
         newWebSocket.addEventListener("close", async () => {
             //console.log(`Websocket closed ${niceConnectionName}`);
-            onClose(new Error(`Connection closed to ${niceConnectionName}`).stack!);
+            onClose(`Connection closed to ${niceConnectionName}`);
         });
 
         newWebSocket.addEventListener("message", onMessage);
@@ -381,7 +381,7 @@ export async function createCallFactory(
             callFactory.isConnected = true;
             hasEverConnected = true;
         } else {
-            onClose(new Error(`Websocket received in closed state`).stack!);
+            onClose(`Websocket received in closed state`);
         }
 
         if (callFactory.lastClosed && callFactory.isConnected) {

package/src/JSONLACKS/JSONLACKS.ts

@@ -45,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 declare static EXTENDED_PARSER: boolean;
-    public declare static IGNORE_MISSING_REFERENCES: boolean;
+    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);
@@ -300,10 +305,10 @@ export class JSONLACKS {
     }
 }
 
-defineSingletonConfig(JSONLACKS, "JSONLACKS.config", 1, () => ({
-    EXTENDED_PARSER: false,
-    IGNORE_MISSING_REFERENCES: false,
-}));
+defineSingletonConfig(JSONLACKS, "JSONLACKS.config", 1, [
+    "EXTENDED_PARSER",
+    "IGNORE_MISSING_REFERENCES",
+]);
 
 async function benchmark() {
     const loops = 1000 * 100;

package/src/createSingleton.d.ts

@@ -17,14 +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>;
-/** 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.
+/** 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: object, name: string, version: string | number, getDefaults: () => T): Singleton<T>;
+export declare function defineSingletonConfig<T extends object>(target: T, name: string, version: string | number, keys: (keyof T & string)[]): void;

package/src/createSingleton.ts

@@ -75,39 +75,35 @@ 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.
+/** 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: object,
+    target: T,
     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];
+    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 (singleton.get() as { [key: string]: unknown })[key];
+                return store[key];
             },
             set(value: unknown) {
-                (singleton.get() as { [key: string]: unknown })[key] = value;
+                store[key] = value;
             },
             enumerable: true,
             configurable: true,
         });
     }
-    return singleton;
 }

package/src/misc.ts

@@ -15,7 +15,11 @@ export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
 export function convertErrorStackToError(error: string): Error {
     let errorObj = new Error();
     errorObj.stack = String(error);
-    errorObj.message = String(error).split("\n")[0].slice("Error: ".length);
+    let message = String(error).split("\n")[0];
+    if (message.startsWith("Error: ")) {
+        message = message.slice("Error: ".length);
+    }
+    errorObj.message = message;
     return errorObj;
 }