Enhance compile to optimize; build minimal deno executable

[guest271314]

Let's say I have an algorithm that I have written in several programming langauges.

With the C and C++ versions I can use gcc, g++, clang to compile an executable correspoding to the includes and actual code used.

Node.js itself has no such capability https://github.com/nodejs/single-executable/blob/main/blog/2022-08-05-an-overview-of-the-current-state.md and interestingly deno compile is not listed in existing solutions https://github.com/nodejs/single-executable/blob/main/docs/existing-solutions.md.

I have written Deno and Node.js specific versions of the algorithm, shared here #16206, using deno the complete code is

#!/usr/bin/env -S ./deno run --v8-flags="--expose-gc,--jitless"
// Deno Native Messaging host
// guest271314
async function getMessage() {
  const header = new Uint32Array(1);
  await Deno.stdin.read(header);
  const output = new Uint8Array(header[0]);
  await Deno.stdin.read(output);
  return output;
}

async function sendMessage(message) {
  const header = Uint32Array.from(
    {
      length: 4,
    },
    (_, index) => (message.length >> (index * 8)) & 0xff
  );
  const output = new Uint8Array(header.length + message.length);
  output.set(header, 0);
  output.set(message, 4);
  await Deno.stdout.write(output.buffer);
}

async function main() {
  while (true) {
    const message = await getMessage();
    await sendMessage(message);
    gc();
  }
}

try {
  main();
} catch (e) {
  Deno.exit();
}

It would be helpful if there was a way to identify only the source code necessary to

On *nix with

./deno compile --v8-flags="--expose-gc,--jitless" -o nm_deno nm_deno.js

I still get a 96.4MB executable.

To me it makes sense for compile to be able to read a prospective --optimize-compile flag to first analyze the code to be compiled, then import only the modules needed to compile the single executable, so that the resulting standalone executable is not carrying around code that will never be used.

--

Further, it would be useful to start with the JavaScript source code analyzation, then build the deno executable from that source code to do that one standalone task that compile outputs as an executable (QuickJS has qjsc); to avoid carrying around upwards of 80-90MB of source code baked into the standard executable that will never be used in this case.

The simpler of the two is how to analyze the JavaScript code I am using to identify the files I can delete from fork of deno, to build deno executable with only the source necessary to execute the above code (possibly with compile - so that when compile is executed only the minimal deno executed is compiled therein)?