sliftutils 1.7.7 → 1.7.9

package/bundler/bundleEntry.ts

@@ -12,15 +12,26 @@ async function main() {
     if (!outputFolder) {
         throw new Error("No output folder provided. Please use the --outputFolder option.");
     }
-    // We prefer production, as this is what the bundler uses internally. This ensures that in the build and when run, we will have the same environment, which will result in the same requires being called. 
+    // We prefer production, as this is what the bundler uses internally. This ensures that in the build and when run, we will have the same environment, which will result in the same requires being called.
     process.env.NODE_ENV = process.env.NODE_ENV || "production";
     require(entryPoint);
 
+    // Warm pass: this process only exists to compile the entry's whole graph
+    // (and this bundler's own modules, compiled at our startup) into typenode's
+    // on-disk cache, then exit. The caller runs a SECOND, fresh process for the
+    // real bundle — that process reads everything from the warm cache and so
+    // never has typenode lazy-load the TypeScript compiler. Without this, a
+    // cold-cache build (e.g. a fresh CI/server checkout, or an entry whose files
+    // no other entry imports) leaves `typescript` in require.cache and the
+    // bundler serializes the entire 9 MB+ compiler into the output bundle.
+    if (process.argv[4] === "--warm") {
+        return;
+    }
+
     let name = path.basename(entryPoint);
     if (name.endsWith(".ts") || name.endsWith(".tsx")) {
         name = name.split(".").slice(0, -1).join(".");
     }
-    name += ".js";
 
     let modules = Object.values(require.cache).filter(x => x?.id !== module.id);
 
@@ -30,16 +41,21 @@ async function main() {
         entryPoints: [entryPoint],
     });
 
-    let finalPath = `${outputFolder}/${name}`;
-    let tempPath = `${finalPath}.tmp`;
-
-    try {
-        await fs.promises.writeFile(tempPath, bundled.bundle);
-        await fs.promises.rename(tempPath, finalPath);
-    } finally {
+    // Two artifacts: `name.js` without the sourcemap (the sourcemap is usually bigger than the code
+    // itself, so this is what production serves) and `name.debug.js` with the inline sourcemap
+    // appended (serve it behind something like a ?debug query param).
+    async function write(finalPath: string, contents: string) {
+        let tempPath = `${finalPath}.tmp`;
         try {
-            await fs.promises.unlink(tempPath);
-        } catch { }
+            await fs.promises.writeFile(tempPath, contents);
+            await fs.promises.rename(tempPath, finalPath);
+        } finally {
+            try {
+                await fs.promises.unlink(tempPath);
+            } catch { }
+        }
     }
+    await write(`${outputFolder}/${name}.js`, bundled.bundle);
+    await write(`${outputFolder}/${name}.debug.js`, bundled.bundle + "\n" + bundled.sourceMapComment);
 }
 main().catch(err => { console.error(err); process.exitCode = 1; }).finally(() => process.exit());

package/bundler/bundleEntryCaller.ts

@@ -10,5 +10,13 @@ export async function bundleEntryCaller(config: {
     entryPoint = path.resolve(entryPoint).replace(/\\/g, "/");
     outputFolder = path.resolve(outputFolder).replace(/\\/g, "/");
     let bundleEntryPath = path.resolve(__dirname, "bundleEntry.ts").replace(/\\/g, "/");
-    await runPromise(`node -r ./node_modules/typenode/index.js ${JSON.stringify(bundleEntryPath)} ${JSON.stringify(entryPoint)} ${JSON.stringify(outputFolder)}`);
+    let base = `node -r ./node_modules/typenode/index.js ${JSON.stringify(bundleEntryPath)} ${JSON.stringify(entryPoint)} ${JSON.stringify(outputFolder)}`;
+    // Run twice in SEPARATE processes. The first ("--warm") only imports the
+    // entry, which compiles its whole graph into typenode's on-disk cache. The
+    // second is a fresh process that imports from that warm cache — so typenode
+    // never has to compile anything and never lazy-loads the TypeScript compiler,
+    // which would otherwise be captured in require.cache and serialized (9 MB+)
+    // into the output bundle. See bundleEntry.ts.
+    await runPromise(`${base} --warm`);
+    await runPromise(base);
 }

package/bundler/bundler.ts

@@ -9,7 +9,12 @@ export async function bundle(config: {
     rootPath: string;
     entryPoints: string[];
 }): Promise<{
+    // The runnable bundle, WITHOUT the sourcemap comment (the sourcemap is usually bigger than the
+    // code itself, so the default artifact ships without it).
     bundle: string;
+    // The trailing inline-sourcemap line comment. Append to `bundle` (with a newline) for the debug
+    // variant of the bundle.
+    sourceMapComment: string;
 }> {
     const { modules, rootPath, entryPoints } = config;
 
@@ -55,9 +60,9 @@ export async function bundle(config: {
         code += `\n;globalThis.require(${JSON.stringify(entryPoint)});`;
     }
     code += "\n;});";
-    code += "\n" + encodeSourceMapLineComment(finalizeInProgressSourceMap(inProgressSourceMap));
     return {
         bundle: code,
+        sourceMapComment: encodeSourceMapLineComment(finalizeInProgressSourceMap(inProgressSourceMap)),
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.7",
+    "version": "1.7.9",
     "main": "index.js",
     "license": "MIT",
     "files": [