socket-function 0.64.0 → 0.66.0

package/hot/HotReloadController.ts

@@ -81,7 +81,7 @@ const hotReloadModule = cache((module: NodeJS.Module) => {
                 || module.moduleContents?.includes("\nmodule.hotreload = true;" + "\n")
                 || module.moduleContents?.includes("\r\nmodule.hotreload = true;" + "\r\n")
             ) {
-                console.log(`Reloading ${module.id}`);
+                console.log(`Serverside reloading ${module.id}`);
                 isHotReloadingValue = true;
                 try {
                     module.loaded = false;

package/package.json

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

package/require/RequireController.ts

@@ -5,8 +5,9 @@ import { SocketFunction } from "../SocketFunction";
 import { getCurrentHTTPRequest, setHTTPResultHeaders } from "../src/callHTTPHandler";
 import { formatNumberSuffixed, isNode, isNodeTrue, sha256Hash, sha256HashPromise } from "../src/misc";
 import zlib from "zlib";
-import { cacheLimited } from "../src/caching";
+import { cacheLimited, lazy } from "../src/caching";
 import { formatNumber } from "../src/formatting/format";
+import { requireMain } from "./require";
 
 const COMPRESS_CACHE_SIZE = 1024 * 1024 * 128;
 
@@ -98,17 +99,21 @@ let nextModuleSeqNum = 1;
 
 const requireSeqNumProcessId = "requireSeqNumProcessId_" + Date.now() + "_" + Math.random();
 
-const htmlFile = isNodeTrue() && fs.readFileSync(__dirname + "/require.html").toString();
-const jsFile = isNodeTrue() && fs.readFileSync(__dirname + "/require.js").toString();
-const bufferShim = isNodeTrue() && fs.readFileSync(__dirname + "/buffer.js").toString();
 const BEFORE_ENTRY_TEMPLATE = "<!-- BEFORE_ENTRY_TEMPLATE -->";
 const ENTRY_TEMPLATE = "<!-- ENTRY_TEMPLATE -->";
 
-const resolvedHTMLFile = isNodeTrue() && (
-    htmlFile
-        .replace(`<script src="./buffer.js"></script>`, `<script>${bufferShim}</script>`)
-        .replace(`<script src="./require.js"></script>`, `<script>${jsFile}</script>`)
-);
+const resolvedHTMLFile = lazy(() => {
+    const bufferShim = fs.readFileSync(__dirname + "/buffer.js").toString();
+    return fs.readFileSync(__dirname + "/require.html").toString()
+        .replace(BEFORE_ENTRY_TEMPLATE,
+            `
+                <script>${bufferShim}</script>
+                <script>(${requireMain.toString()})()</script>
+
+                ${BEFORE_ENTRY_TEMPLATE}
+            `
+        );
+});
 
 let beforeEntryText: (string | (() => Promise<string>))[] = [];
 function injectHTMLBeforeStartup(text: string | (() => Promise<string>)) {
@@ -116,7 +121,7 @@ function injectHTMLBeforeStartup(text: string | (() => Promise<string>)) {
 }
 
 type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
-type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
+export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
 let mapGetModules: {
     remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>
 }[] = [];
@@ -131,7 +136,7 @@ class RequireControllerBase {
         requireCalls?: string[];
     }) {
         let { requireCalls } = config || {};
-        let result = resolvedHTMLFile;
+        let result = resolvedHTMLFile();
         if (beforeEntryText.length > 0) {
             let resolved: string[] = [];
             for (let text of beforeEntryText) {
@@ -164,13 +169,6 @@ class RequireControllerBase {
         return setHTTPResultHeaders(Buffer.from(result), { "Content-Type": "text/html" });
     }
 
-    public async bufferJS() {
-        return setHTTPResultHeaders(Buffer.from(bufferShim), { "Content-Type": "text/javascript" });
-    }
-    public async requireJS() {
-        return setHTTPResultHeaders(Buffer.from(jsFile), { "Content-Type": "text/javascript" });
-    }
-
     public async getModules(
         pathRequests: string[],
         alreadyHave?: {
@@ -349,8 +347,14 @@ class RequireControllerBase {
                 }]),
             };
             let key = sha256Hash(JSON.stringify(simplifiedResult));
-            let buffer = await compressCached(key, () => Buffer.from(JSON.stringify(result)));
-            setHTTPResultHeaders(buffer, { "Content-Type": "application/json", "Content-Encoding": "gzip" });
+            let uncompressedBuffer = Buffer.from(JSON.stringify(result));
+            let buffer = await compressCached(key, () => uncompressedBuffer);
+            setHTTPResultHeaders(buffer, {
+                "Content-Type": "application/json",
+                "Content-Encoding": "gzip",
+                "Content-Length": buffer.length.toString(),
+                "X-Uncompressed-Content-Length": uncompressedBuffer.length.toString(),
+            });
             return buffer as any;
         }
 

package/require/require.html

@@ -6,9 +6,6 @@
     <body>
         <div id="main"></div>
 
-        <script src="./buffer.js"></script>
-        <script src="./require.js"></script>
-
         <!-- BEFORE_ENTRY_TEMPLATE -->
         <!-- ENTRY_TEMPLATE -->
     </body>

package/require/{require.js → require.ts}

@@ -1,11 +1,89 @@
-(function () {
-    //# sourceURL=require.js
+import { GetModulesArgs, SerializedModule } from "./RequireController";
 
+
+declare global {
+    var onProgressHandler: undefined | ((progress: {
+        type: string;
+        addValue: number;
+        addMax: number;
+    }) => void);
+    var onErrorHandler: undefined | ((error: string) => void);
+
+
+    var BOOT_TIME: number;
+    var builtInModuleExports: {
+        [key: string]: unknown;
+    };
+}
+
+export function requireMain() {
+    async function requestText(endpoint: string, values: any) {
+        let url = new URL(endpoint);
+
+        let json = JSON.stringify(values);
+        let response: Response;
+        if (json.length < 6000) {
+            // NOTE: Try to use a GET, as GETs can be cached! However, if the data is too large,
+            //  we have to use a post, or else the request url will be too large
+            for (let key in values) {
+                url.searchParams.set(key, JSON.stringify(values[key]));
+            }
+            response = await fetch(url.toString(), {
+                method: "GET",
+                credentials: "include",
+            });
+        } else {
+            response = await fetch(url.toString(), {
+                method: "POST",
+                body: json,
+                credentials: "include",
+            });
+        }
+
+        let compressionRatio = 1;
+        let uncompressedLength = response.headers.get("X-Uncompressed-Content-Length");
+        let compressedLength = response.headers.get("Content-Length");
+        if (uncompressedLength && compressedLength) {
+            compressionRatio = +uncompressedLength / +compressedLength;
+        }
+        let totalLength = +(uncompressedLength || compressedLength || 0);
+        if (totalLength) {
+            globalThis.onProgressHandler?.({
+                type: "Download",
+                addValue: 0,
+                addMax: Math.floor(totalLength / compressionRatio),
+            });
+        }
+
+        // If it's an error, set requestError
+        if (!response.ok) {
+            globalThis.onErrorHandler?.(response.statusText);
+        }
+
+        // Stream it, so we can get progrss
+        let reader = response.body!.getReader();
+        let result = "";
+        while (true) {
+            let { done, value } = await reader.read();
+            if (done) break;
+            result += new TextDecoder().decode(value);
+            let cur = (value?.length || 0) / compressionRatio;
+            globalThis.onProgressHandler?.({
+                type: "Download",
+                addValue: cur,
+                addMax: 0,
+            });
+        }
+
+        return result;
+    }
+
+    const g = globalThis as any;
     let startTime = Date.now();
     globalThis.BOOT_TIME = startTime;
 
-    Symbol.dispose = Symbol.dispose || Symbol("dispose");
-    Symbol.asyncDispose = Symbol.asyncDispose || Symbol("asyncDispose");
+    (Symbol as any).dispose = Symbol.dispose || Symbol("dispose");
+    (Symbol as any).asyncDispose = Symbol.asyncDispose || Symbol("asyncDispose");
 
     // Globals
     Object.assign(window, {
@@ -17,11 +95,11 @@
             },
             versions: {},
         },
-        setImmediate(callback) {
+        setImmediate(callback: () => void) {
             setTimeout(callback, 0);
         },
         // Ignore flags for now, even though they should work fine if we just hardcoded compileFlags.ts here.
-        setFlag() {},
+        setFlag() { },
         global: window,
     });
 
@@ -32,7 +110,7 @@
         },
         util: {
             // https://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor
-            inherits(constructor, superConstructor) {
+            inherits(constructor: any, superConstructor: any) {
                 Object.setPrototypeOf(constructor.prototype, superConstructor.prototype);
             },
             TextDecoder: TextDecoder,
@@ -41,8 +119,8 @@
         buffer: { Buffer },
         stream: {
             // HACK: Needed to get SAX JS to work correctly.
-            Stream: function () {},
-            Transform: function () {},
+            Stream: function () { },
+            Transform: function () { },
         },
         timers: {
             // TODO: Add all members of timers
@@ -51,7 +129,8 @@
         child_process: {},
         events: {},
     };
-    global.builtInModuleExports = builtInModuleExports;
+    globalThis.builtInModuleExports = globalThis.builtInModuleExports || {};
+    Object.assign(globalThis.builtInModuleExports, builtInModuleExports);
 
     let lastTime = 0;
     function nextTime() {
@@ -88,23 +167,42 @@
     }} */
     let serializedModules = Object.create(null);
 
-    let moduleCache = Object.create(null);
-    let alreadyHave = undefined;
+    type ModuleType = {
+        id: string;
+        filename: string;
+        exports: unknown;
+        children: ModuleType[];
+        flags: { [key: string]: boolean };
+        load: () => void;
+        loaded: boolean;
+        isPreloading: boolean;
+        evalStartTime: number;
+        evalEndTime: number;
+        source: string;
+        allowclient: boolean;
+        size: number;
+    };
+
+    let moduleCache: { [id: string]: ModuleType } = Object.create(null);
+    let alreadyHave: {
+        requireSeqNumProcessId: string;
+        seqNums: { [seqNum: string]: true | 1 | 0 | undefined };
+    } | undefined;
 
     let rootResolveCache = Object.create(null);
 
     rootRequire.cache = moduleCache;
     // Expose require for debugging, not so it can be called
-    window.require = rootRequire;
-    window.import = rootRequire;
+    g.require = rootRequire;
+    g.import = rootRequire;
 
-    window.r = function r(text) {
+    g.r = function r(text: string) {
         text = text.toLowerCase();
         return Object.values(moduleCache).filter((x) => x.filename.toLowerCase().includes(text))[0].exports;
     };
 
-    let requireBatch;
-    function rootRequire(request, batch) {
+    let requireBatch: { [request: string]: (() => void)[] } | undefined;
+    function rootRequire(request: string, batch?: boolean): unknown {
         if (!batch) {
             if (request in rootResolveCache) {
                 let resolvedRequest = rootResolveCache[request];
@@ -119,16 +217,16 @@
         }
 
         if (request in builtInModuleExports) {
-            return builtInModuleExports[request];
+            return builtInModuleExports[request as keyof typeof builtInModuleExports];
         }
         if (batch) {
             if (!requireBatch) {
-                requireBatch = requireBatch || {};
                 setTimeout(() => {
+                    requireBatch = requireBatch || {};
                     let requests = Object.keys(requireBatch);
                     let callbacks = Object.values(requireBatch).reduce((a, b) => a.concat(b), []);
                     requireBatch = undefined;
-                    void rootRequireMultiple(requests, true).then(
+                    void rootRequireMultiple(requests).then(
                         () => {
                             for (let callback of callbacks) {
                                 callback();
@@ -140,7 +238,8 @@
                     );
                 }, 0);
             }
-            return new Promise((resolve) => {
+            return new Promise<void>((resolve) => {
+                if (!requireBatch) throw new Error("Impossible");
                 requireBatch[request] = requireBatch[request] || [];
                 requireBatch[request].push(resolve);
             });
@@ -148,7 +247,7 @@
             return rootRequireMultiple([request]).then((x) => x[0].exports);
         }
     }
-    async function rootRequireMultiple(requests) {
+    async function rootRequireMultiple(requests: string[]) {
         console.log(`%cimport(${requests.join(", ")}) at ${Date.now() - startTime}ms`, "color: orange");
 
         let time = Date.now();
@@ -157,7 +256,7 @@
         if (alreadyHave) {
             let seqNums = Object.keys(alreadyHave.seqNums).map((x) => +x);
             seqNums.sort((a, b) => a - b);
-            let seqNumRanges = [];
+            let seqNumRanges: { s: number; e?: number }[] = [];
             alreadyHaveRanges = { requireSeqNumProcessId: alreadyHave.requireSeqNumProcessId, seqNumRanges };
             for (let seqNum of seqNums) {
                 let prev = seqNumRanges[seqNumRanges.length - 1];
@@ -174,17 +273,40 @@
             }
         }
 
-        let args = [requests, alreadyHaveRanges];
+        let domainOrigin = "";
+        let originalRequests = requests;
+        if (requests.some(x => x.startsWith("https://"))) {
+            requests = requests.map((request) => {
+                if (!request.startsWith("https://")) {
+                    throw new Error(`Mixed domains with non-domain requests is not supported presently. Requests: ${requests.join(" | ")}`);
+                }
+                let url = new URL(request);
+                if (domainOrigin && domainOrigin !== url.origin) {
+                    // TODO: If this happens, we can probably just split the call up into multiple calls?
+                    throw new Error(`Mixed domains in require call is not supported presently. Requests: ${requests.join(" | ")}`);
+                }
+                domainOrigin = url.origin + "/";
+                // By stripping by length, we can turn https://example.com/./test => "./test"
+                //  (where as if we used pathname, it would turn into "/test"
+                return request.slice(domainOrigin.length);
+            });
+        }
+
+        let args: GetModulesArgs = [requests, alreadyHaveRanges];
         // We have to add hardcoded support for droppermissions, because... this call
         //  doesn't have the conventional persisted code sending code, because... it's
         //  all on its own.
-        if (new URL(location).searchParams.get("droppermissions") !== null) {
+        let searchParams = new URLSearchParams(location.search);
+        if (searchParams.get("droppermissions") !== null) {
             args.push(true);
         }
-        let requestUrl =
-            location.origin +
-            location.pathname +
-            `?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules`;
+
+        let requestUrlBase = location.origin + location.pathname;
+        if (domainOrigin) {
+            requestUrlBase = domainOrigin;
+        }
+        let requestUrl = requestUrlBase + `?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules`;
+
         let remapImportRequestsClientside = globalThis.remapImportRequestsClientside;
         if (remapImportRequestsClientside) {
             for (let fnc of remapImportRequestsClientside) {
@@ -192,7 +314,12 @@
             }
         }
         let rawText = await requestText(requestUrl, { args });
-        let resultObj;
+        let resultObj: {
+            modules: { [id: string]: SerializedModule };
+            requestsResolvedPaths: string[];
+            requireSeqNumProcessId: string;
+            error?: string;
+        };
         try {
             resultObj = JSON.parse(rawText);
         } catch (e) {
@@ -207,13 +334,43 @@
             throw errorObj;
         }
 
+
+        if (Object.keys(modules).length === 1 && "" in modules) {
+            eval(modules[""].source || "");
+            throw new Error(`Failed to find modules for ${originalRequests.join(", ")} (mapped to ${requests.join(", ")})`);
+        }
+
+
+        if (domainOrigin) {
+            function fixDomain(request: string) {
+                if (!request) return request;
+                return domainOrigin + request;
+            }
+            requests = requests.map(fixDomain);
+            for (let [id, module] of Object.entries(modules)) {
+                delete modules[id];
+                modules[fixDomain(id)] = module;
+                module.filename = fixDomain(module.filename);
+                module.requests = Object.fromEntries(Object.entries(module.requests).map(([k, v]) => [k, fixDomain(v)]));
+                module.originalId = fixDomain(module.originalId);
+            }
+            requestsResolvedPaths = requestsResolvedPaths.map(fixDomain);
+        }
+
+
         for (let i = 0; i < requests.length; i++) {
             rootResolveCache[requests[i]] = requestsResolvedPaths[i];
         }
 
+        globalThis.onProgressHandler?.({
+            type: "Compile",
+            addValue: 0,
+            addMax: Object.keys(modules).length,
+        });
+
         // Store the function, so we only call it if it exists BEFORE we import
         //  (which means we already have something loading, so this is likely hot reloading...)
-        let observerOnHotReload = global.observerOnHotReload;
+        let observerOnHotReload = g.observerOnHotReload;
         setTimeout(() => {
             if (observerOnHotReload) {
                 observerOnHotReload();
@@ -225,17 +382,18 @@
         let requireModuleCount = Object.values(modules).filter((x) => !x.source).length;
         let dependenciesOnlyText = requireModuleCount ? ` (+${requireModuleCount} dependencies only)` : "";
         console.log(
-            `%cimport(${requests.join(", ")}) finished download ${time}ms, ${Math.ceil(
+            `%cimport(${requests.join(", ")}) finished download ${time.toFixed(0)}ms, ${Math.ceil(
                 rawText.length / 1024
-            )}KB, ${moduleCount} modules${dependenciesOnlyText} at ${Date.now() - startTime}ms`,
-            "color: green"
+            )}KB, ${moduleCount} modules${dependenciesOnlyText} at ${(Date.now() - startTime).toFixed(0)}ms`,
+            "color: lightgreen"
         );
 
-        time = Date.now();
+
 
         if (alreadyHave?.requireSeqNumProcessId !== requireSeqNumProcessId) {
-            alreadyHave = { requireSeqNumProcessId, seqNums: {} };
+            alreadyHave = undefined;
         }
+        alreadyHave = alreadyHave || { requireSeqNumProcessId, seqNums: {} };
 
         for (let id in modules) {
             let module = modules[id];
@@ -243,28 +401,51 @@
             serializedModules[id] = module;
         }
 
+        time = Date.now();
+        let lastWaitTime = time;
+        for (let key of Object.keys(modules)) {
+            getModule(key, "preload");
+            // Wait, so we can render progress (and in generals, so the UI remains somewhat responsive)
+            if (Date.now() - lastWaitTime > 10) {
+                await new Promise(resolve => setTimeout(resolve, 0));
+                lastWaitTime = Date.now();
+            }
+        }
+
+        time = Date.now() - time;
+        console.log(
+            `%cimport(${requests.join(", ")}) finished compile ${time.toFixed(0)}ms (${moduleCount} modules) at ${(Date.now() - startTime).toFixed(0)}ms`,
+            "color: hotpink"
+        );
+
+
+        globalThis.onProgressHandler?.({
+            type: "Evaluate",
+            addValue: 0,
+            addMax: Object.keys(modules).length,
+        });
+
+        time = Date.now();
         try {
             return requestsResolvedPaths.map((x) => getModule(x));
         } finally {
             time = Date.now() - time;
             console.log(
-                `%cimport(${requests.join(", ")}) finished evaluate ${time}ms (${moduleCount} modules) at ${
-                    Date.now() - startTime
-                }ms`,
+                `%cimport(${requests.join(", ")}) finished evaluate ${time.toFixed(0)}ms (${moduleCount} modules) at ${(Date.now() - startTime).toFixed(0)}ms`,
                 "color: lightblue"
             );
         }
     }
 
-    function createRequire(module, serializedModule, asyncIsFineOuter) {
+    function createRequire(module: ModuleType, serializedModule: SerializedModule, asyncIsFineOuter?: boolean) {
         require.cache = moduleCache;
-        require.resolve = function (request) {
+        require.resolve = function (request: string) {
             // TODO: Maybe do a request, making this async, if it isn't found?
             return serializedModule.requests[request];
         };
         let moduleFolder = module.filename.replace(/\\/g, "/").split("/").slice(0, -1).join("/") + "/";
         return require;
-        function require(request, asyncIsFine) {
+        function require(request: string, asyncIsFine?: boolean) {
             if (asyncIsFineOuter) {
                 asyncIsFine = true;
             }
@@ -275,7 +456,7 @@
                 asyncIsFine = true;
             }
             if (request in builtInModuleExports) {
-                return builtInModuleExports[request];
+                return builtInModuleExports[request as keyof typeof builtInModuleExports];
             }
 
             let resolvedPath;
@@ -317,12 +498,11 @@
                         "color: red",
                         "color: unset"
                     );
-                    debugger;
                 }
                 return rootRequire(resolvedPath);
             }
 
-            let exportsOverride = undefined;
+            let exportsOverride: unknown | undefined;
             if (resolvedPath === "NOTALLOWEDCLIENTSIDE" || !serializedModules[resolvedPath].allowclient) {
                 let childId = resolvedPath === "NOTALLOWEDCLIENTSIDE" ? request : resolvedPath;
                 if (serializedModules[resolvedPath]?.serveronly) {
@@ -336,7 +516,7 @@
                                 if (property === "default") return exportsOverride;
 
                                 throw new Error(
-                                    `Module ${childId} is serverside only. Tried to access ${property} from ${module.id}`
+                                    `Module ${childId} is serverside only. Tried to access ${String(property)} from ${module.id}`
                                 );
                             },
                         }
@@ -354,8 +534,7 @@
                                 console.warn(
                                     `Accessed non-whitelisted module %c${childId}%c, specifically property %c${String(
                                         property
-                                    )}%c.\n\tAdd %cmodule.allowclient = true%c to the file to allow access.\n\t(IF it is a 3rd party library, use the global "setFlag" helper (in the file you imported the module) to set properties on other modules (it can even recursively set properties)).\n\n\tFrom ${
-                                        module.id
+                                    )}%c.\n\tAdd %cmodule.allowclient = true%c to the file to allow access.\n\t(IF it is a 3rd party library, use the global "setFlag" helper (in the file you imported the module) to set properties on other modules (it can even recursively set properties)).\n\n\tFrom ${module.id
                                     }`,
                                     "color: red",
                                     "color: unset",
@@ -395,10 +574,10 @@
      *      and has code equal to contents.
      *      - filename is just for debugging / stack traces
      */
-    function wrapSafe(filename, contents) {
+    function wrapSafe(filename: string, contents: string) {
         // TODO: Have the serverside inform us of the correct loader, or... have it actually emit a .json loader.
         if (filename.endsWith(".json")) {
-            return (exports, require, module) => (module.exports = contents && JSON.parse(contents));
+            return (exports: unknown, require: unknown, module: ModuleType) => (module.exports = contents && JSON.parse(contents));
         }
 
         // NOTE: debugName only matters during module evaluation. After that the sourcemap should work.
@@ -419,14 +598,19 @@
 
     const unloadedModule = Symbol("unloadedModule");
 
-    let currentModuleEvaluationStack = [];
+    let currentModuleEvaluationStack: string[] = [];
     // See https://nodejs.org/api/modules.html
-    function getModule(resolvedId) {
+    function getModule(resolvedId: string, preload?: "preload") {
         if (resolvedId === "") {
             return {};
         }
         if (resolvedId in moduleCache) {
-            return moduleCache[resolvedId];
+            let module = moduleCache[resolvedId];
+            if (!preload && !module.loaded) {
+                module.loaded = true;
+                module.load();
+            }
+            return module;
         }
 
         let serializedModule = serializedModules[resolvedId];
@@ -439,15 +623,27 @@
         module.exports.default = module.exports;
         module.children = [];
         for (let key in serializedModule.flags || {}) {
+            if (key === "loaded") continue;
             module[key] = true;
         }
 
         module.load = load;
 
-        module.loaded = true;
-        module.load();
+        let originalSource = serializedModule.source;
+        let moduleFnc = wrapSafe(module.id, originalSource);
+
+        globalThis.onProgressHandler?.({
+            type: "Compile",
+            addValue: 1,
+            addMax: 0,
+        });
 
-        function load(filename) {
+        if (!preload) {
+            module.loaded = true;
+            module.load();
+        }
+
+        function load() {
             let serializedModule = serializedModules[resolvedId];
             if (!module.loaded) {
                 if (alreadyHave) {
@@ -486,7 +682,10 @@
             module.size = source.length;
             module.source = source;
 
-            let moduleFnc = wrapSafe(module.id, source);
+            if (source !== originalSource) {
+                originalSource = source;
+                moduleFnc = wrapSafe(module.id, originalSource);
+            }
 
             let dirname = module.filename.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
 
@@ -500,11 +699,11 @@
                     {
                         // NOTE: Adding __importStar to the module causes typescript to use our implementation,
                         //  which checks for unloadedModule and returns undefined in that case.
-                        __importStar(mod) {
+                        __importStar(mod: any) {
                             if (mod[unloadedModule]) return undefined;
                             return mod;
                         },
-                        __importDefault(mod) {
+                        __importDefault(mod: any) {
                             return mod.default ? mod : { default: mod };
                         },
                     },
@@ -523,34 +722,15 @@
             } finally {
                 module.isPreloading = false;
                 currentModuleEvaluationStack.pop();
+
+                globalThis.onProgressHandler?.({
+                    type: "Evaluate",
+                    addValue: 1,
+                    addMax: 0,
+                });
             }
         }
 
         return module;
     }
-
-    async function requestText(endpoint, values) {
-        let url = new URL(endpoint);
-
-        let json = JSON.stringify(values);
-        if (json.length < 6000) {
-            // NOTE: Try to use a GET, as GETs can be cached! However, if the data is too large,
-            //  we have to use a post, or else the request url will be too large
-            for (let key in values) {
-                url.searchParams.set(key, JSON.stringify(values[key]));
-            }
-            let response = await fetch(url.toString(), {
-                method: "GET",
-                credentials: "include",
-            });
-            return await response.text();
-        } else {
-            let response = await fetch(url.toString(), {
-                method: "POST",
-                body: json,
-                credentials: "include",
-            });
-            return await response.text();
-        }
-    }
-})();
+}

package/src/callHTTPHandler.ts

@@ -189,6 +189,7 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
                 return;
             }
         }
+        let uncompressedLength = resultBuffer.length;
         if (SocketFunction.HTTP_COMPRESS && request.headers["accept-encoding"]?.includes("gzip") && !headers?.["Content-Encoding"]) {
             // NOTE: This is a BIT slow. To speed it up, functions can use an internal cache, according to their function,
             //  and return a Buffer (which they can as any cast to make the returned type allowed, as returned Buffers will
@@ -205,6 +206,10 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
                 });
             });
         }
+        response.setHeader("Content-Length", resultBuffer.length.toString());
+        if (!response.getHeader("X-Uncompressed-Content-Length")) {
+            response.setHeader("X-Uncompressed-Content-Length", uncompressedLength.toString());
+        }
         response.write(resultBuffer);
         if (SocketFunction.logMessages) {
             console.log(`HTTP response  ${formatNumberSuffixed(resultBuffer.length)}B  (${request.method}) ${url}`);