socket-function 1.1.49 → 1.2.1

package/SocketFunction.d.ts

@@ -1,6 +1,6 @@
-/// <reference path="require/RequireController.d.ts" />
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="socket-function/require/requirecontroller" />
 import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
 import { SocketServerConfig } from "./src/webSocketServer";
 import { Args, MaybePromise } from "./src/types";

package/SocketFunctionTypes.d.ts

@@ -1,4 +1,4 @@
-/// <reference path="require/RequireController.d.ts" />
+/// <reference types="socket-function/require/requirecontroller" />
 import { getCallObj } from "./src/nodeProxy";
 import { Args, MaybePromise } from "./src/types";
 export declare const socket: unique symbol;

package/dist/SetProcessVariables.ts.cache

@@ -0,0 +1,9 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+module.allowclient = true;
+const misc_1 = require("./src/misc");
+if (!(0, misc_1.isNode)()) {
+    process.env.CBOR_NATIVE_ACCELERATION_DISABLED = "true";
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2V0UHJvY2Vzc1ZhcmlhYmxlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIlNldFByb2Nlc3NWYXJpYWJsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFNLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQztBQUMxQixxQ0FBb0M7QUFFcEMsSUFBSSxDQUFDLElBQUEsYUFBTSxHQUFFLEVBQUUsQ0FBQztJQUNaLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUNBQWlDLEdBQUcsTUFBTSxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJtb2R1bGUuYWxsb3djbGllbnQgPSB0cnVlO1xuaW1wb3J0IHsgaXNOb2RlIH0gZnJvbSBcIi4vc3JjL21pc2NcIjtcblxuaWYgKCFpc05vZGUoKSkge1xuICAgIHByb2Nlc3MuZW52LkNCT1JfTkFUSVZFX0FDQ0VMRVJBVElPTl9ESVNBQkxFRCA9IFwidHJ1ZVwiO1xufSJdfQ=//=
+ /* _JS_SOURCE_HASH = "249631df8c5cbb77a37aa988d0d9d058d467b254000e31ac2a58f9161b5a8626"; */

package/dist/SocketFunction.ts.cache

@@ -0,0 +1,467 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+/// <reference path="./require/RequireController.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports._setSocketContext = exports.SocketFunction = void 0;
+const callManager_1 = require("./src/callManager");
+const webSocketServer_1 = require("./src/webSocketServer");
+const nodeCache_1 = require("./src/nodeCache");
+const nodeProxy_1 = require("./src/nodeProxy");
+const callHTTPHandler_1 = require("./src/callHTTPHandler");
+const caching_1 = require("./src/caching");
+const createSingleton_1 = require("./src/createSingleton");
+const batching_1 = require("./src/batching");
+const logColors_1 = require("./src/formatting/logColors");
+require("./SetProcessVariables");
+const cbor_x_1 = __importDefault(require("cbor-x"));
+const compileFlags_1 = require("./require/compileFlags");
+const misc_1 = require("./src/misc");
+const CallFactory_1 = require("./src/CallFactory");
+const measure_1 = require("./src/profiling/measure");
+(0, compileFlags_1.setFlag)(require, "cbor-x", "allowclient", true);
+let cborxInstance = new cbor_x_1.default.Encoder({ structuredClone: true });
+if ((0, misc_1.isNode)()) {
+    // Do not crash on unhandled errors. SocketFunction is made to run a webserver,
+    //  which will run perfectly after 99.9% of errors. Crashing the process is
+    //  not a good alternative to proper error log and notifications. Do you guys
+    //  not get automated emails when unexpected errors are logged? I do.
+    process.on("unhandledRejection", (e) => {
+        console.error("Unhandled rejection" + ((e === null || e === void 0 ? void 0 : e.stack) || e));
+    });
+    process.on("uncaughtException", (e) => {
+        console.error("Uncaught exception" + ((e === null || e === void 0 ? void 0 : e.stack) || e));
+    });
+}
+module.allowclient = true;
+// The active call's caller, plus a sequence number used to reset it synchronously (see
+//  _setSocketContext). Shared across copies of this package, so SocketFunction.getCaller()
+//  returns the right caller even when the call was set up by a different copy. See createSingleton.
+const socketContext = (0, createSingleton_1.createSingleton)("SocketFunction.socketContext", 1, () => ({
+    seqNum: 1,
+    caller: undefined,
+}));
+class SocketFunction {
+    // 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.
+    static isClient() { return !(0, misc_1.isNode)() || SocketFunction.ENABLE_CLIENT_MODE; }
+    static get exposedClasses() { return SocketFunction.exposedClassesSingleton.get(); }
+    static get callerContext() { return socketContext.get().caller; }
+    static set callerContext(value) { socketContext.get().caller = value; }
+    static getCaller() {
+        const caller = SocketFunction.callerContext;
+        if (!caller)
+            throw new Error(`Tried to access caller when not in the synchronous phase of a function call`);
+        return caller;
+    }
+    // NOTE: We use callbacks we don't run into issues with cyclic dependencies
+    //  (ex, using a hook in a controller where the hook also calls the controller).
+    /*
+        export const DiskLoggerController = SocketFunction.register(
+            // Can be anything, but should be unique amongst other controllers on your server.
+            "DiskLoggerController-f76a6fdf-3bd5-4bd4-a183-55a8be0a5a32",
+            // Contains the functions that can be exposed, which must all be async.
+            //  Only those listed below will be exposed.
+            new DiskLoggerControllerBase(),
+            () => ({
+                // Only functions listed here will be exposed
+                getRemoteLogFiles: {},
+                getRemoteLogBuffer: {
+                    compress: true,
+                    // SocketFunctionClientHook[]
+                    clientHooks: [
+                        (x) => {
+                            // If overrideResult is set, it skips the call and returns overrideResult
+                            x.overrideResult = Buffer.from(...);
+                        }
+                    ]
+                },
+            }),
+            () => ({
+                // Default hooks for all functions
+                // SocketFunctionHook[]
+                hooks: [assertIsManagementUser],
+            }),
+            {
+                // Additionaly flags
+            }
+        );
+    */
+    static register(classGuid, instance, shapeFnc, defaultHooksFnc, config) {
+        let instanceFnc = (0, caching_1.lazy)(typeof instance === "function" ? instance : () => instance);
+        void Promise.resolve().then(() => {
+            let onMount = getDefaultHooks === null || getDefaultHooks === void 0 ? void 0 : getDefaultHooks().onMount;
+            if (onMount) {
+                let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
+                if (!callbacks) {
+                    callbacks = [];
+                    SocketFunction.onMountCallbacks.set(classGuid, callbacks);
+                }
+                callbacks.push(onMount);
+            }
+        });
+        let getDefaultHooks = defaultHooksFnc && (0, caching_1.lazy)(defaultHooksFnc);
+        const getShape = (0, caching_1.lazy)(() => {
+            var _a;
+            let shape = shapeFnc();
+            let defaultHooks = getDefaultHooks === null || getDefaultHooks === void 0 ? void 0 : getDefaultHooks();
+            for (let value of Object.values(shape)) {
+                if (!value)
+                    continue;
+                if (!value.noClientHooks) {
+                    value.clientHooks = [...((defaultHooks === null || defaultHooks === void 0 ? void 0 : defaultHooks.clientHooks) || []), ...(value.clientHooks || [])];
+                }
+                if (value.noDefaultHooks) {
+                    value.hooks = [...(value.hooks || [])];
+                }
+                else {
+                    value.hooks = [...((defaultHooks === null || defaultHooks === void 0 ? void 0 : defaultHooks.hooks) || []), ...(value.hooks || [])];
+                }
+                value.dataImmutable = (_a = defaultHooks === null || defaultHooks === void 0 ? void 0 : defaultHooks.dataImmutable) !== null && _a !== void 0 ? _a : value.dataImmutable;
+            }
+            return shape;
+        });
+        // Wait, so any constants referenced by the base shapeFnc will be fully resolved
+        //  by now. This is IMPORTANT, as it allows permissions functions to be moved
+        //  to a common module, instead of all being inline.
+        void Promise.resolve().then(() => {
+            (0, callManager_1.registerClass)(classGuid, instanceFnc(), getShape(), {
+                noFunctionMeasure: config === null || config === void 0 ? void 0 : config.noFunctionMeasure,
+            });
+        });
+        let socketCaller = SocketFunction.rehydrateSocketCaller({
+            _classGuid: classGuid,
+            _internalType: null,
+        }, getShape);
+        if (!(config === null || config === void 0 ? void 0 : config.noAutoExpose)) {
+            this.expose(socketCaller);
+        }
+        return Object.assign(socketCaller, config === null || config === void 0 ? void 0 : config.statics);
+    }
+    static rehydrateSocketCaller(socketRegistered, 
+    // Shape is required for client hooks.
+    shapeFnc) {
+        let cached = this.socketCache.get(socketRegistered._classGuid);
+        if (!cached) {
+            let getShape = (0, caching_1.lazy)(() => shapeFnc === null || shapeFnc === void 0 ? void 0 : shapeFnc());
+            let classGuid = socketRegistered._classGuid;
+            let nodeProxy = (0, nodeProxy_1.getCallProxy)(classGuid, async (call) => {
+                return await SocketFunction.callFromGuid(call, classGuid, getShape());
+            });
+            cached = {
+                nodes: nodeProxy,
+                _classGuid: classGuid,
+                _internalType: null,
+            };
+            this.socketCache.set(classGuid, cached);
+        }
+        return cached;
+    }
+    static async callFromGuid(call, classGuid, shape) {
+        let nodeId = call.nodeId;
+        let functionName = call.functionName;
+        let time = Date.now();
+        if (SocketFunction.logMessages) {
+            console.log(`START\t\t\t${classGuid}.${functionName} at ${Date.now()}`);
+        }
+        try {
+            let callFactory = await (0, nodeCache_1.getCreateCallFactory)(nodeId);
+            let shapeObj = shape === null || shape === void 0 ? void 0 : shape[functionName];
+            if (!shapeObj) {
+                shapeObj = {};
+            }
+            // NOTE: Actually... this just means the client doesn't have a definition for it. The server
+            //  might, so call it, and let them throw if it is unrecognized.
+            // if (!shapeObj) {
+            //     throw new Error(`Function ${functionName} is not in shape`);
+            // }
+            let hookResult = await (0, callManager_1.runClientHooks)(call, shapeObj, callFactory.connectionId);
+            if ("overrideResult" in hookResult) {
+                for (let callback of hookResult.onResult) {
+                    await callback(hookResult.overrideResult);
+                }
+                if ("overrideResult" in hookResult) {
+                    return hookResult.overrideResult;
+                }
+            }
+            let result = await callFactory.performCall(call);
+            for (let callback of hookResult.onResult) {
+                await callback(result);
+            }
+            if ("overrideResult" in hookResult) {
+                return hookResult.overrideResult;
+            }
+            return result;
+        }
+        finally {
+            time = Date.now() - time;
+            if (SocketFunction.logMessages) {
+                console.log(`FINISHED\t${time}ms\t${classGuid}.${functionName} at ${Date.now()}`);
+            }
+        }
+    }
+    /** Will dedupe callbacks, so if you call with the same callback it won't call it multiple times (otherwise it's difficult to manage this, as this only calls on the NEXT callback).
+        IMPORTANT! Client node ids will NEVER reconnect, so this can full cleanup. However full nodeIds might if we try to use that nodeId again, so this cannot fully clean them up.
+    */
+    static onNextDisconnect(nodeId, callback, 
+    // NOTE: It's important to know that unlike client ids, server ids (a nodeId YOU connect to, instead of connecting to you), might be alive again, and so you need some kind of logic to try it again or in some way reconnect. For clients you don't need to, as it's their job to reconnect to you, and they will reconnect with a NEW nodeId.
+    noServerNodeIdWarning) {
+        if (!(0, nodeCache_1.isClientNodeId)(nodeId) && !noServerNodeIdWarning) {
+            console.error(`Watching for disconnections of ${nodeId}. This is a server nodeId and may be alive again after disconnection. Please set the noServerNodeIdWarning flag in this argument to confirm you are handling reconnecting if the server becomes available again.`);
+        }
+        (async () => {
+            let factory = await (0, nodeCache_1.getCallFactory)(nodeId);
+            if (!factory) {
+                for (let i = 0; i < 30; i++) {
+                    await (0, batching_1.delay)(1000);
+                    factory = await (0, nodeCache_1.getCallFactory)(nodeId);
+                    if (factory)
+                        break;
+                }
+                if (!factory) {
+                    console.error(`Failed to get call factory for ${nodeId} after 30 seconds, giving up.`);
+                    callback();
+                    return;
+                }
+            }
+            factory.onNextDisconnect(callback);
+        })().catch(() => {
+            callback();
+        });
+    }
+    static getLastDisconnectTime(nodeId) {
+        let factory = (0, nodeCache_1.getCallFactory)(nodeId);
+        if (!factory) {
+            return undefined;
+        }
+        if (factory instanceof Promise) {
+            return undefined;
+        }
+        return factory.lastClosed;
+    }
+    static isNodeConnected(nodeId) {
+        let factory = (0, nodeCache_1.getCallFactory)(nodeId);
+        if (!factory) {
+            return false;
+        }
+        if (factory instanceof Promise) {
+            return false;
+        }
+        return !!factory.isConnected;
+    }
+    /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,
+     *      as we have no way of knowing how to contain a nodeId).
+     *  */
+    static getHTTPCallLink(call) {
+        let location = (0, nodeCache_1.getNodeIdLocation)(call.nodeId);
+        if (!location) {
+            throw new Error(`Cannot find call location for nodeId, and so do not know where call location is. NodeId ${call.nodeId}`);
+        }
+        let url = new URL(`https://${location.address}:${location.port}`);
+        url.searchParams.set("classGuid", call.classGuid);
+        url.searchParams.set("functionName", call.functionName);
+        url.searchParams.set("args", JSON.stringify(call.args));
+        return url.toString();
+    }
+    static async ignoreExposeCalls(code) {
+        SocketFunction.ignoreExposeCount.get().count++;
+        try {
+            return await code();
+        }
+        finally {
+            SocketFunction.ignoreExposeCount.get().count--;
+        }
+    }
+    /** Expose should be called before your mounting occurs. It mostly just exists to ensure you include the class type,
+     *      so the class type's module construction runs, which should trigger register. Otherwise you would have
+     *      to add additional imports to ensure the register call runs.
+     */
+    static expose(socketRegistered) {
+        if (SocketFunction.ignoreExposeCount.get().count > 0)
+            return;
+        if (!socketRegistered._classGuid) {
+            throw new Error("SocketFunction.expose must be called with a classGuid");
+        }
+        console.log(`Exposing Controller ${(0, logColors_1.blue)(socketRegistered._classGuid)}`);
+        (0, callManager_1.exposeClass)(socketRegistered);
+        this.exposedClasses.add(socketRegistered._classGuid);
+        if (SocketFunction.mountState.get().hasMounted) {
+            let mountCallbacks = SocketFunction.onMountCallbacks.get(socketRegistered._classGuid);
+            for (let onMount of mountCallbacks || []) {
+                Promise.resolve(onMount()).catch(e => {
+                    console.error("Error in onMount callback exposed after mount", e);
+                });
+            }
+        }
+    }
+    static get mountedNodeId() { return SocketFunction.mountState.get().mountedNodeId; }
+    static set mountedNodeId(value) { SocketFunction.mountState.get().mountedNodeId = value; }
+    static isMounted() { return !!this.mountedNodeId; }
+    static get mountedIP() { return SocketFunction.mountState.get().mountedIP; }
+    static set mountedIP(value) { SocketFunction.mountState.get().mountedIP = value; }
+    static get mountPromise() { return SocketFunction.mountState.get().mountPromise; }
+    static async mount(config) {
+        if (this.mountedNodeId) {
+            throw new Error("SocketFunction already mounted, mounting twice in one thread is not allowed.");
+        }
+        this.mountedIP = config.public ? "0.0.0.0" : "127.0.0.1";
+        if (config.ip) {
+            this.mountedIP = config.ip;
+        }
+        const { waitForFirstTimeSync, shimDateNow } = await Promise.resolve().then(() => __importStar(require("./time/trueTimeShim")));
+        shimDateNow();
+        await waitForFirstTimeSync();
+        // Wait for any additionals functions to expose themselves
+        await (0, batching_1.delay)("immediate");
+        this.mountedNodeId = await (0, webSocketServer_1.startSocketServer)(config);
+        SocketFunction.mountState.get().hasMounted = true;
+        for (let classGuid of SocketFunction.exposedClasses) {
+            let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
+            if (!callbacks)
+                continue;
+            for (let callback of callbacks) {
+                await callback();
+            }
+        }
+        SocketFunction.mountState.get().mountResolve();
+        return this.mountedNodeId;
+    }
+    /** Sets the default call when an http request is made, but no classGuid is set.
+     *      NOTE: All other calls should be endpoint calls, even if those endpoints return a static file with an HTML content type.
+     *          - However, to load new content, you should probably just use `require("./example.ts")`, which works on any files
+     *              clientside that have also been required serverside (and whitelisted with module.allowclient = true,
+     *              or with an `allowclient.flag` file in the directory or parent directory).
+    */
+    static setDefaultHTTPCall(registered, functionName, ...args) {
+        (0, callHTTPHandler_1.setDefaultHTTPCall)({
+            classGuid: registered._classGuid,
+            functionName,
+            args,
+        });
+    }
+    static connect(location) {
+        return (0, nodeCache_1.getNodeId)(location.address, location.port);
+    }
+    static browserNodeId() {
+        if ((0, misc_1.isNode)()) {
+            throw new Error("Cannot get browser nodeId on server");
+        }
+        let edgeNode = getBootedEdgeNode();
+        if (edgeNode) {
+            return edgeNode.host;
+        }
+        return SocketFunction.connect({ address: location.hostname, port: +location.port || 443 });
+    }
+    static getBrowserNodeId() {
+        return this.browserNodeId();
+    }
+    static addGlobalHook(hook) {
+        (0, callManager_1.registerGlobalHook)(hook);
+    }
+    static addGlobalClientHook(hook) {
+        (0, callManager_1.registerGlobalClientHook)(hook);
+    }
+}
+exports.SocketFunction = SocketFunction;
+SocketFunction.logMessages = false;
+SocketFunction.trackMessageSizes = {
+    upload: [],
+    download: [],
+    callTimes: [],
+};
+SocketFunction.MAX_MESSAGE_SIZE = 1024 * 1024 * 32;
+SocketFunction.HTTP_ETAG_CACHE = false;
+SocketFunction.silent = true;
+SocketFunction.HTTP_COMPRESS = false;
+// If you have HTTP resources that require cookies you might to set `SocketFunction.COEP = "require-corp"`
+//  - Cross-origin-resource-policy.
+SocketFunction.COEP = "credentialless";
+// NOTE: This COOP and COEP defaults are required so window.crossOriginIsolated will be true.
+SocketFunction.COOP = "same-origin";
+SocketFunction.TOTAL_CALLS = 0;
+SocketFunction.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).
+SocketFunction.WIRE_SERIALIZER = {
+    serialize: (0, measure_1.measureWrap)((obj) => [cborxInstance.encode(obj)], "WIRE_SERIALIZER|serialize"),
+    deserialize: (0, measure_1.measureWrap)((buffers) => 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.
+ */
+SocketFunction.GET_ALTERNATE_NODE_IDS = (nodeId) => undefined;
+SocketFunction.WIRE_WARN_TIME = 100;
+// Shared across copies of this package, so onMount callbacks registered through one copy still
+//  fire when another copy mounts. See createSingleton.
+SocketFunction.onMountCallbacks = (0, createSingleton_1.createSingleton)("SocketFunction.onMountCallbacks", 1, () => new Map()).get();
+// Shared across copies of this package, so the set of exposed classes is consistent regardless
+//  of which copy a class was exposed through. See createSingleton.
+SocketFunction.exposedClassesSingleton = (0, createSingleton_1.createSingleton)("SocketFunction.exposedClasses", 1, () => new Set());
+SocketFunction.harvestFailedCallCount = () => (0, CallFactory_1.harvestFailedCallCount)();
+SocketFunction.getPendingCallCount = () => (0, CallFactory_1.getPendingCallCount)();
+SocketFunction.harvestCallTimes = () => (0, CallFactory_1.harvestCallTimes)();
+// Shared across copies of this package, so a given classGuid resolves to one canonical caller
+//  regardless of which copy rehydrated it. See createSingleton.
+SocketFunction.socketCache = (0, createSingleton_1.createSingleton)("SocketFunction.socketCache", 1, () => new Map()).get();
+// Shared across copies of this package, so suppressing expose calls in one copy also suppresses
+//  them in the others. See createSingleton.
+SocketFunction.ignoreExposeCount = (0, createSingleton_1.createSingleton)("SocketFunction.ignoreExposeCount", 1, () => ({ count: 0 }));
+// All mount state is shared across copies of this package, so a second mount (even from a
+//  different copy) is rejected, and onMount/mountPromise observers fire once across them all.
+//  See createSingleton.
+SocketFunction.mountState = (0, createSingleton_1.createSingleton)("SocketFunction.mountState", 1, () => {
+    let mountResolve;
+    let mountPromise = new Promise(resolve => mountResolve = resolve);
+    return {
+        hasMounted: false,
+        mountedNodeId: "",
+        mountedIP: "",
+        mountResolve,
+        mountPromise,
+    };
+});
+function getBootedEdgeNode() {
+    return BOOTED_EDGE_NODE;
+}
+function _setSocketContext(caller, code) {
+    let ctx = socketContext.get();
+    ctx.seqNum++;
+    let seqNum = ctx.seqNum;
+    ctx.caller = caller;
+    try {
+        return code();
+    }
+    finally {
+        if (seqNum === ctx.seqNum) {
+            ctx.caller = undefined;
+        }
+    }
+}
+exports._setSocketContext = _setSocketContext;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SocketFunction.js","sourceRoot":"","sources":["SocketFunction.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference path=\"./require/RequireController.ts\" />\n\nimport { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, CallType, FncType, SocketRegisterType } from \"./SocketFunctionTypes\";\nimport { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from \"./src/callManager\";\nimport { SocketServerConfig, startSocketServer } from \"./src/webSocketServer\";\nimport { getCallFactory, getCreateCallFactory, getNodeId, getNodeIdLocation, isClientNodeId } from \"./src/nodeCache\";\nimport { getCallProxy } from \"./src/nodeProxy\";\nimport { Args, MaybePromise } from \"./src/types\";\nimport { setDefaultHTTPCall } from \"./src/callHTTPHandler\";\nimport debugbreak from \"debugbreak\";\nimport { lazy } from \"./src/caching\";\nimport { createSingleton } from \"./src/createSingleton\";\nimport { delay } from \"./src/batching\";\nimport { blue, magenta } from \"./src/formatting/logColors\";\nimport { JSONLACKS } from \"./src/JSONLACKS/JSONLACKS\";\nimport \"./SetProcessVariables\";\nimport cborx from \"cbor-x\";\nimport { setFlag } from \"./require/compileFlags\";\nimport { isNode } from \"./src/misc\";\nimport { getPendingCallCount, harvestCallTimes, harvestFailedCallCount } from \"./src/CallFactory\";\nimport { measureWrap } from \"./src/profiling/measure\";\n\nsetFlag(require, \"cbor-x\", \"allowclient\", true);\nlet cborxInstance = new cborx.Encoder({ structuredClone: true });\nif (isNode()) {\n    // Do not crash on unhandled errors. SocketFunction is made to run a webserver,\n    //  which will run perfectly after 99.9% of errors. Crashing the process is\n    //  not a good alternative to proper error log and notifications. Do you guys\n    //  not get automated emails when unexpected errors are logged? I do.\n    process.on(\"unhandledRejection\", (e) => {\n        console.error(\"Unhandled rejection\" + ((e as any)?.stack || e));\n    });\n    process.on(\"uncaughtException\", (e) => {\n        console.error(\"Uncaught exception\" + ((e as any)?.stack || e));\n    });\n}\n\nmodule.allowclient = true;\n\n// The active call's caller, plus a sequence number used to reset it synchronously (see\n//  _setSocketContext). Shared across copies of this package, so SocketFunction.getCaller()\n//  returns the right caller even when the call was set up by a different copy. See createSingleton.\nconst socketContext = createSingleton(\"SocketFunction.socketContext\", 1, () => ({\n    seqNum: 1,\n    caller: undefined as CallerContext | undefined,\n}));\n\ntype ExtractShape<ClassType, Shape> = {\n    [key in keyof ClassType]: (\n        key extends keyof Shape\n        ? ClassType[key] extends SocketExposedInterface[\"\"]\n        ? ClassType[key]\n        : ClassType[key] extends Function ? \"All exposed function must be async (or return a Promise)\" : never\n        : \"Function has implementation but is not exposed in the SocketFunction.register call\"\n    );\n};\n\nexport class SocketFunction {\n    public static logMessages = false;\n    public static trackMessageSizes = {\n        upload: [] as ((size: number) => void)[],\n        download: [] as ((size: number) => void)[],\n        callTimes: [] as ((obj: { start: number; end: number; }) => void)[],\n    };\n\n    public static MAX_MESSAGE_SIZE = 1024 * 1024 * 32;\n\n    public static HTTP_ETAG_CACHE = false;\n    public static silent = true;\n\n    public static HTTP_COMPRESS = false;\n\n    // If you have HTTP resources that require cookies you might to set `SocketFunction.COEP = \"require-corp\"`\n    //  - Cross-origin-resource-policy.\n    public static COEP = \"credentialless\";\n    // NOTE: This COOP and COEP defaults are required so window.crossOriginIsolated will be true.\n    public static COOP = \"same-origin\";\n\n    public static TOTAL_CALLS = 0;\n\n    public static ENABLE_CLIENT_MODE = false;\n    // 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.\n    public static isClient() { return !isNode() || SocketFunction.ENABLE_CLIENT_MODE; }\n\n    // In retrospect... dynamically changing the wire serializer is a BAD idea. If any calls happen\n    //  before it is changed, things just break. Also, it needs to be changed on both sides,\n    //  or else things break. Also, it is very hard to detect when the issue is different serializers\n    // 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).\n    public static readonly WIRE_SERIALIZER = {\n        serialize: measureWrap((obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)], \"WIRE_SERIALIZER|serialize\"),\n        deserialize: measureWrap((buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]), \"WIRE_SERIALIZER|deserialize\"),\n    };\n\n    /** 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. \n     *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.\n     */\n    public static GET_ALTERNATE_NODE_IDS = (nodeId: string): MaybePromise<string[] | undefined> => undefined;\n\n    public static WIRE_WARN_TIME = 100;\n\n    // Shared across copies of this package, so onMount callbacks registered through one copy still\n    //  fire when another copy mounts. See createSingleton.\n    private static onMountCallbacks = createSingleton(\"SocketFunction.onMountCallbacks\", 1, () => new Map<string, (() => MaybePromise<void>)[]>()).get();\n    // Shared across copies of this package, so the set of exposed classes is consistent regardless\n    //  of which copy a class was exposed through. See createSingleton.\n    private static exposedClassesSingleton = createSingleton(\"SocketFunction.exposedClasses\", 1, () => new Set<string>());\n    public static get exposedClasses() { return SocketFunction.exposedClassesSingleton.get(); }\n\n    public static get callerContext(): CallerContext | undefined { return socketContext.get().caller; }\n    public static set callerContext(value: CallerContext | undefined) { socketContext.get().caller = value; }\n    public static getCaller(): CallerContext {\n        const caller = SocketFunction.callerContext;\n        if (!caller) throw new Error(`Tried to access caller when not in the synchronous phase of a function call`);\n        return caller;\n    }\n\n    public static harvestFailedCallCount = () => harvestFailedCallCount();\n    public static getPendingCallCount = () => getPendingCallCount();\n    public static harvestCallTimes = () => harvestCallTimes();\n\n    // NOTE: We use callbacks we don't run into issues with cyclic dependencies\n    //  (ex, using a hook in a controller where the hook also calls the controller).\n    /*\n        export const DiskLoggerController = SocketFunction.register(\n            // Can be anything, but should be unique amongst other controllers on your server.\n            \"DiskLoggerController-f76a6fdf-3bd5-4bd4-a183-55a8be0a5a32\",\n            // Contains the functions that can be exposed, which must all be async.\n            //  Only those listed below will be exposed.\n            new DiskLoggerControllerBase(),\n            () => ({\n                // Only functions listed here will be exposed\n                getRemoteLogFiles: {},\n                getRemoteLogBuffer: {\n                    compress: true,\n                    // SocketFunctionClientHook[]\n                    clientHooks: [\n                        (x) => {\n                            // If overrideResult is set, it skips the call and returns overrideResult\n                            x.overrideResult = Buffer.from(...);\n                        }\n                    ]\n                },\n            }),\n            () => ({\n                // Default hooks for all functions\n                // SocketFunctionHook[]\n                hooks: [assertIsManagementUser],\n            }),\n            {\n                // Additionaly flags\n            }\n        );\n    */\n    public static register<\n        ClassInstance extends object,\n        Shape extends SocketExposedShape<{\n            [key in keyof ClassInstance]: (...args: any[]) => Promise<unknown>;\n        }>,\n        Statics\n    >(\n        classGuid: string,\n        instance: ClassInstance | (() => ClassInstance),\n        shapeFnc: () => Shape,\n        defaultHooksFnc?: () => SocketExposedShape[\"\"] & {\n            onMount?: () => MaybePromise<void>;\n        },\n        config?: {\n            /** @noAutoExpose If true SocketFunction.expose(Controller) must be called explicitly. */\n            noAutoExpose?: boolean;\n            statics?: Statics;\n            /** Skip timing functions calls. Useful if a lot of functions have wait time that\n                    is unrelated to processing, and therefore their timings won't be useful.\n                    - Also useful if our auto function wrapping code is breaking functionality,\n                        such as if you have a singleton function which you compare with ===,\n                        which will breaks because we replaced it with a wrapped measure function.\n            */\n            noFunctionMeasure?: boolean;\n        }\n    ): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics {\n        let instanceFnc = lazy(typeof instance === \"function\" ? instance : () => instance);\n        void Promise.resolve().then(() => {\n            let onMount = getDefaultHooks?.().onMount;\n            if (onMount) {\n                let callbacks = SocketFunction.onMountCallbacks.get(classGuid);\n                if (!callbacks) {\n                    callbacks = [];\n                    SocketFunction.onMountCallbacks.set(classGuid, callbacks);\n                }\n                callbacks.push(onMount);\n            }\n        });\n\n        let getDefaultHooks = defaultHooksFnc && lazy(defaultHooksFnc);\n        const getShape = lazy(() => {\n            let shape = shapeFnc() as SocketExposedShape;\n            let defaultHooks = getDefaultHooks?.();\n\n            for (let value of Object.values(shape)) {\n                if (!value) continue;\n                if (!value.noClientHooks) {\n                    value.clientHooks = [...(defaultHooks?.clientHooks || []), ...(value.clientHooks || [])];\n                }\n                if (value.noDefaultHooks) {\n                    value.hooks = [...(value.hooks || [])];\n                } else {\n                    value.hooks = [...(defaultHooks?.hooks || []), ...(value.hooks || [])];\n                }\n                value.dataImmutable = defaultHooks?.dataImmutable ?? value.dataImmutable;\n            }\n            return shape as any as SocketExposedShape;\n        });\n\n        // Wait, so any constants referenced by the base shapeFnc will be fully resolved\n        //  by now. This is IMPORTANT, as it allows permissions functions to be moved\n        //  to a common module, instead of all being inline.\n        void Promise.resolve().then(() => {\n            registerClass(classGuid, instanceFnc() as SocketExposedInterface, getShape(), {\n                noFunctionMeasure: config?.noFunctionMeasure,\n            });\n        });\n\n        let socketCaller = SocketFunction.rehydrateSocketCaller({\n            _classGuid: classGuid,\n            _internalType: null as any,\n        }, getShape);\n\n        if (!config?.noAutoExpose) {\n            this.expose(socketCaller);\n        }\n        return Object.assign(socketCaller, config?.statics) as any;\n    }\n\n    // Shared across copies of this package, so a given classGuid resolves to one canonical caller\n    //  regardless of which copy rehydrated it. See createSingleton.\n    private static socketCache = createSingleton(\"SocketFunction.socketCache\", 1, () => new Map<string, SocketRegistered>()).get();\n    public static rehydrateSocketCaller<Controller>(\n        socketRegistered: SocketRegisterType<Controller>,\n        // Shape is required for client hooks.\n        shapeFnc?: () => SocketExposedShape,\n    ): SocketRegistered<Controller> {\n        let cached = this.socketCache.get(socketRegistered._classGuid);\n        if (!cached) {\n            let getShape = lazy(() => shapeFnc?.());\n            let classGuid = socketRegistered._classGuid;\n            let nodeProxy = getCallProxy(classGuid, async (call) => {\n                return await SocketFunction.callFromGuid(call, classGuid, getShape());\n            });\n\n            cached = {\n                nodes: nodeProxy,\n                _classGuid: classGuid,\n                _internalType: null as any,\n            };\n\n            this.socketCache.set(classGuid, cached);\n        }\n        return cached;\n    }\n\n    private static async callFromGuid<FncT extends FncType>(\n        call: FullCallType<FncT>,\n        classGuid: string,\n        shape?: SocketExposedShape,\n    ): Promise<ReturnType<FncType>> {\n        let nodeId = call.nodeId;\n        let functionName = call.functionName;\n        let time = Date.now();\n        if (SocketFunction.logMessages) {\n            console.log(`START\\t\\t\\t${classGuid}.${functionName} at ${Date.now()}`);\n        }\n        try {\n            let callFactory = await getCreateCallFactory(nodeId);\n\n            let shapeObj = shape?.[functionName];\n            if (!shapeObj) {\n                shapeObj = {};\n            }\n            // NOTE: Actually... this just means the client doesn't have a definition for it. The server\n            //  might, so call it, and let them throw if it is unrecognized.\n            // if (!shapeObj) {\n            //     throw new Error(`Function ${functionName} is not in shape`);\n            // }\n\n            let hookResult = await runClientHooks(call, shapeObj as Exclude<SocketExposedShape[\"\"], undefined>, callFactory.connectionId);\n\n            if (\"overrideResult\" in hookResult) {\n                for (let callback of hookResult.onResult) {\n                    await callback(hookResult.overrideResult);\n                }\n                if (\"overrideResult\" in hookResult) {\n                    return hookResult.overrideResult;\n                }\n            }\n\n            let result = await callFactory.performCall(call);\n            for (let callback of hookResult.onResult) {\n                await callback(result);\n            }\n            if (\"overrideResult\" in hookResult) {\n                return hookResult.overrideResult;\n            }\n            return result;\n        } finally {\n            time = Date.now() - time;\n            if (SocketFunction.logMessages) {\n                console.log(`FINISHED\\t${time}ms\\t${classGuid}.${functionName} at ${Date.now()}`);\n            }\n        }\n    }\n\n    /** Will dedupe callbacks, so if you call with the same callback it won't call it multiple times (otherwise it's difficult to manage this, as this only calls on the NEXT callback).\n        IMPORTANT! Client node ids will NEVER reconnect, so this can full cleanup. However full nodeIds might if we try to use that nodeId again, so this cannot fully clean them up.\n    */\n    public static onNextDisconnect(\n        nodeId: string,\n        callback: () => void,\n        // NOTE: It's important to know that unlike client ids, server ids (a nodeId YOU connect to, instead of connecting to you), might be alive again, and so you need some kind of logic to try it again or in some way reconnect. For clients you don't need to, as it's their job to reconnect to you, and they will reconnect with a NEW nodeId.\n        noServerNodeIdWarning?: \"iKnowThatServerNodeIdsMayReconnect_andIHandleReconnections\"\n    ) {\n        if (!isClientNodeId(nodeId) && !noServerNodeIdWarning) {\n            console.error(`Watching for disconnections of ${nodeId}. This is a server nodeId and may be alive again after disconnection. Please set the noServerNodeIdWarning flag in this argument to confirm you are handling reconnecting if the server becomes available again.`);\n        }\n        (async () => {\n            let factory = await getCallFactory(nodeId);\n            if (!factory) {\n                for (let i = 0; i < 30; i++) {\n                    await delay(1000);\n                    factory = await getCallFactory(nodeId);\n                    if (factory) break;\n                }\n                if (!factory) {\n                    console.error(`Failed to get call factory for ${nodeId} after 30 seconds, giving up.`);\n                    callback();\n                    return;\n                }\n            }\n\n            factory.onNextDisconnect(callback);\n        })().catch(() => {\n            callback();\n        });\n    }\n    public static getLastDisconnectTime(nodeId: string): number | undefined {\n        let factory = getCallFactory(nodeId);\n        if (!factory) {\n            return undefined;\n        }\n        if (factory instanceof Promise) {\n            return undefined;\n        }\n        return factory.lastClosed;\n    }\n    public static isNodeConnected(nodeId: string): boolean {\n        let factory = getCallFactory(nodeId);\n        if (!factory) {\n            return false;\n        }\n        if (factory instanceof Promise) {\n            return false;\n        }\n        return !!factory.isConnected;\n    }\n\n    /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,\n     *      as we have no way of knowing how to contain a nodeId).\n     *  */\n    public static getHTTPCallLink(call: FullCallType): string {\n        let location = getNodeIdLocation(call.nodeId);\n        if (!location) {\n            throw new Error(`Cannot find call location for nodeId, and so do not know where call location is. NodeId ${call.nodeId}`);\n        }\n        let url = new URL(`https://${location.address}:${location.port}`);\n        url.searchParams.set(\"classGuid\", call.classGuid);\n        url.searchParams.set(\"functionName\", call.functionName);\n        url.searchParams.set(\"args\", JSON.stringify(call.args));\n        return url.toString();\n    }\n\n    // Shared across copies of this package, so suppressing expose calls in one copy also suppresses\n    //  them in the others. See createSingleton.\n    private static ignoreExposeCount = createSingleton(\"SocketFunction.ignoreExposeCount\", 1, () => ({ count: 0 }));\n    public static async ignoreExposeCalls<T>(code: () => Promise<T>) {\n        SocketFunction.ignoreExposeCount.get().count++;\n        try {\n            return await code();\n        } finally {\n            SocketFunction.ignoreExposeCount.get().count--;\n        }\n    }\n\n    /** Expose should be called before your mounting occurs. It mostly just exists to ensure you include the class type,\n     *      so the class type's module construction runs, which should trigger register. Otherwise you would have\n     *      to add additional imports to ensure the register call runs.\n     */\n    public static expose(socketRegistered: SocketRegistered) {\n        if (SocketFunction.ignoreExposeCount.get().count > 0) return;\n        if (!socketRegistered._classGuid) {\n            throw new Error(\"SocketFunction.expose must be called with a classGuid\");\n        }\n        console.log(`Exposing Controller ${blue(socketRegistered._classGuid)}`);\n        exposeClass(socketRegistered);\n        this.exposedClasses.add(socketRegistered._classGuid);\n\n        if (SocketFunction.mountState.get().hasMounted) {\n            let mountCallbacks = SocketFunction.onMountCallbacks.get(socketRegistered._classGuid);\n            for (let onMount of mountCallbacks || []) {\n                Promise.resolve(onMount()).catch(e => {\n                    console.error(\"Error in onMount callback exposed after mount\", e);\n                });\n            }\n        }\n    }\n\n    // All mount state is shared across copies of this package, so a second mount (even from a\n    //  different copy) is rejected, and onMount/mountPromise observers fire once across them all.\n    //  See createSingleton.\n    private static mountState = createSingleton(\"SocketFunction.mountState\", 1, () => {\n        let mountResolve!: () => void;\n        let mountPromise = new Promise<void>(resolve => mountResolve = resolve);\n        return {\n            hasMounted: false,\n            mountedNodeId: \"\",\n            mountedIP: \"\",\n            mountResolve,\n            mountPromise,\n        };\n    });\n    public static get mountedNodeId() { return SocketFunction.mountState.get().mountedNodeId; }\n    public static set mountedNodeId(value: string) { SocketFunction.mountState.get().mountedNodeId = value; }\n    public static isMounted() { return !!this.mountedNodeId; }\n    public static get mountedIP() { return SocketFunction.mountState.get().mountedIP; }\n    public static set mountedIP(value: string) { SocketFunction.mountState.get().mountedIP = value; }\n    public static get mountPromise() { return SocketFunction.mountState.get().mountPromise; }\n    public static async mount(config: SocketServerConfig) {\n        if (this.mountedNodeId) {\n            throw new Error(\"SocketFunction already mounted, mounting twice in one thread is not allowed.\");\n        }\n\n        this.mountedIP = config.public ? \"0.0.0.0\" : \"127.0.0.1\";\n        if (config.ip) {\n            this.mountedIP = config.ip;\n        }\n\n        const { waitForFirstTimeSync, shimDateNow } = await import(\"./time/trueTimeShim\");\n        shimDateNow();\n        await waitForFirstTimeSync();\n\n        // Wait for any additionals functions to expose themselves\n        await delay(\"immediate\");\n\n        this.mountedNodeId = await startSocketServer(config);\n        SocketFunction.mountState.get().hasMounted = true;\n        for (let classGuid of SocketFunction.exposedClasses) {\n            let callbacks = SocketFunction.onMountCallbacks.get(classGuid);\n            if (!callbacks) continue;\n            for (let callback of callbacks) {\n                await callback();\n            }\n        }\n        SocketFunction.mountState.get().mountResolve();\n        return this.mountedNodeId;\n    }\n\n    /** Sets the default call when an http request is made, but no classGuid is set.\n     *      NOTE: All other calls should be endpoint calls, even if those endpoints return a static file with an HTML content type.\n     *          - However, to load new content, you should probably just use `require(\"./example.ts\")`, which works on any files\n     *              clientside that have also been required serverside (and whitelisted with module.allowclient = true,\n     *              or with an `allowclient.flag` file in the directory or parent directory).\n    */\n    public static setDefaultHTTPCall<\n        Registered extends SocketRegistered,\n        FunctionName extends keyof Registered[\"nodes\"][\"\"] & string,\n    >(\n        registered: Registered,\n        functionName: FunctionName,\n        ...args: Args<Registered[\"nodes\"][\"\"][FunctionName]>\n    ) {\n        setDefaultHTTPCall({\n            classGuid: registered._classGuid,\n            functionName,\n            args,\n        });\n    }\n\n    public static connect(location: { address: string, port: number }): string {\n        return getNodeId(location.address, location.port);\n    }\n\n    public static browserNodeId() {\n        if (isNode()) {\n            throw new Error(\"Cannot get browser nodeId on server\");\n        }\n        let edgeNode = getBootedEdgeNode();\n        if (edgeNode) {\n            return edgeNode.host;\n        }\n        return SocketFunction.connect({ address: location.hostname, port: +location.port || 443 });\n    }\n    public static getBrowserNodeId() {\n        return this.browserNodeId();\n    }\n\n    public static addGlobalHook(hook: SocketFunctionHook) {\n        registerGlobalHook(hook as SocketFunctionHook);\n    }\n    public static addGlobalClientHook(hook: SocketFunctionClientHook) {\n        registerGlobalClientHook(hook as SocketFunctionClientHook);\n    }\n}\n\ndeclare global {\n    var BOOTED_EDGE_NODE: { host: string } | undefined;\n}\n\nfunction getBootedEdgeNode() {\n    return BOOTED_EDGE_NODE as { host: string } | undefined;\n}\n\n\nexport function _setSocketContext<T>(\n    caller: CallerContext,\n    code: () => T,\n) {\n    let ctx = socketContext.get();\n    ctx.seqNum++;\n    let seqNum = ctx.seqNum;\n    ctx.caller = caller;\n    try {\n        return code();\n    } finally {\n        if (seqNum === ctx.seqNum) {\n            ctx.caller = undefined;\n        }\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "bd19d5b73ff44d3238ed0108b3100b0ced158e36641aa6c1960f52513f69e0a8"; */

package/hot/HotReloadController.d.ts

@@ -1,5 +1,5 @@
-/// <reference path="../../typenode/index.d.ts" />
-/// <reference path="../require/RequireController.d.ts" />
+/// <reference types="typenode" />
+/// <reference types="socket-function/require/requirecontroller" />
 /** Enables some hot reload functionality.
  *      - Triggers a refresh clientside
  *      - Triggers a reload server, for modules marked with `module.hotreload`
@@ -28,7 +28,7 @@ export declare function isHotReloading(): boolean;
 export declare function hotReloadingGuard(): true;
 export declare function setExternalHotReloading(value: boolean): void;
 export declare function onHotReload(callback: (modules: NodeJS.Module[]) => void): void;
-export declare const HotReloadController: import("../SocketFunctionTypes").SocketRegistered<{
+export declare const HotReloadController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
     watchFiles: () => Promise<void>;
     fileUpdated: (files: string[], changeTime: number) => Promise<void>;
 }>;