Compile JavaScript to WASM with no networking involved - just reading STDIN and writing to STDOUT

[guest271314]

I've built Native Messaging hosts using several JavaScript to WASM toolchains, or just executed the WASM inside of the JavaScript engine compiled to WASM in the case of QuickJS.

Here's the protocol and documentation published by Chrome, MDN, Edge, Opera, Safari https://github.com/guest271314/NativeMessagingHosts#native-messaging-documentation. In pertinent part

Chrome starts each native messaging host in a separate process and communicates with it using standard input (stdin) and standard output (stdout). The same format is used to send messages in both directions; each message is serialized using JSON, UTF-8 encoded and is preceded with 32-bit message length in native byte order. The maximum size of a single message from the native messaging host is 1 MB, mainly to protect Chrome from misbehaving native applications. The maximum size of the message sent to the native messaging host is 64 MiB.

Note, that the IPC communication is not a TTY.

Several examples of JavaScript compiled to WASM and/or embedded and executed within a JavaScript engine compiled to WASM can be found here

• Javy https://github.com/guest271314/native-messaging-webassembly/blob/main/nm_javy.js
• qjs-wasi.wasm https://github.com/guest271314/native-messaging-webassembly/blob/main/nm_qjs_wasi.js
• js2wasm https://github.com/guest271314/native-messaging-webassembly/blob/main/nm_js2wasm.js

to the extent applicable and comparable to JavaScript or TypeScript,

• AssemblyScript https://github.com/guest271314/native-messaging-webassembly/blob/main/nm_assemblyscript.ts

I was referred to StarlingMonkey over here #general > Embedding JavaScript into QuickJS before compiling to WASM.

To be clear, I am not looking for "a" or "the" JavaScript to WASM toolchain; I'm actively testing, breaking, and vetting JavaScript to WASM toolchains and novel implementations, for research and comparative analysis purposes; without any biases or preferences for any. They all get tested until they break, witout rancor, and without exception or handicap.

Assume

• I have basically zero experience writing WIT
• There is zero networking involved in the JavaScript source code
• I just need to read STDIN and write to STDOUT

Questions:

• In node world there is process.stdin and process.stdout, and even readFileSync point to 0 or /dev/stdin or /proc/self/fd/0, and /dev/stdout or /proc/self/fd/1, respectively. STDOUT !== WHATWG Console's console. What are the specific I/O interfaces StarlingMonkey has implemented?

• The Component Model has the WIT thing - it's own syntax and bassically an entire language itself. What is the minimal WIT that Component Model compilers expect just to read STDIN and write to STDOUT?

• How to compile generic JavaScript that expects to done only read STDIN and write to STDOUT (neither specified in ECMA-262) - with absolutely no networking involved, no ServiceWorker-like fetch() handler at all, using StarlingMokey's starling.wasm or starling-raw.wasm?

[guest271314]

I was able to do this downstream using componentize-js and/or jco https://github.com/guest271314/native-messaging-componentize-js.

bun install --cache-dir ./.bun-cache @bytecodealliance/componentize-js

cargo bininstall wkg
wkg wit fetch -d . --cache ./.wit-cache

bun x jco componentize nm_componentize_js.js --wit . --world-name native-messaging-componentize-js -d http -d fetch-event --out nm_jco.wasm

#!/usr/bin/env -S wasmtime run -W component-model-async=y /ABSOLUTE/PATH/TO/native-messaging-componentize-js/nm_jco.wasm 

//! componentize-js Native Messaging host
//! guest271314, andreiltd (https://github.com/andreiltd), 6-13-2026
//! Based on nm_componentize_qjs.js
//! https://github.com/andreiltd/componentize-qjs/issues/1

import { getStdin } from "wasi:cli/stdin@0.2.10";
import { getStdout } from "wasi:cli/stdout@0.2.10";

addEventListener("fetch", event => {
  event.respondWith(new Response("Hello, world!"));
});

const WRITE_CHUNK = 4096;
const FRAME = 1024 * 1024;
const COMMA = 0x2c,
  OPEN = 0x5b,
  CLOSE = 0x5d;

function readExact(input, n) {
  const out = new Uint8Array(n);
  let off = 0;
  while (off < n) {
    try {
      const chunk = input.blockingRead(BigInt(n - off));      
      if (!chunk || chunk.length === 0) {
        return null;
      }     
      out.set(chunk, off);
      off += chunk.length;
    } catch (error) {
      return null;
    }
  }
  return out;
}

function readMessage(input) {
  const header = readExact(input, 4);
  if (header === null) return null;
  
  const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
  const len = view.getUint32(0, true);
  
  return len === 0 ? new Uint8Array(0) : readExact(input, len);
}

function writeAll(output, data) {
  for (let off = 0; off < data.length; off += WRITE_CHUNK) {
    output.blockingWriteAndFlush(data.subarray(off, off + WRITE_CHUNK));
  }
}

function writeFrame(output, body) {
  const frame = new Uint8Array(4 + body.length);
  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
  view.setUint32(0, body.length, true);
  frame.set(body, 4);
  writeAll(output, frame);
}

function sendMessage(output, msg) {
  if (msg.length <= FRAME) {
    writeFrame(output, msg);
    return;
  }
  // Handle 64 MiB JSON Array message input, 1 MiB JSON Array output
  for (let i = 1, end = msg.length - 1; i < end;) {
    let j = i + FRAME - 16;
    if (j >= end) j = end;
    else {
      const c = msg.indexOf(COMMA, j);
      j = c === -1 ? end : c;
    }
    const body = new Uint8Array(2 + (j - i));
    body[0] = OPEN;
    body.set(msg.subarray(i, j), 1);
    body[body.length - 1] = CLOSE;
    writeFrame(output, body);
    i = j + 1;
  }
}

export const run = {
  run() {
    const input = getStdin();
    const output = getStdout();
    
    for (let msg; (msg = readMessage(input)) !== null;) {
      sendMessage(output, msg);
    }  
    return;
  },
};

I have not been able to do this using componentize.sh, after including the fetch event handler in the code.

/media/user/x/StarlingMonkey/cmake-build-release/componentize.sh nm_componentize_js.js -o sm.wasm
Componentizing nm_componentize_js.js into sm.wasm
Error: failed to run main module `/media/user/x/StarlingMonkey/cmake-build-release/starling-raw.wasm`

Caused by:
    no func export named `wizer-initialize` found

error: failed to read from `sm.wasm`

Caused by:
    0: No such file or directory (os error 2)

No idea what wizer-initialize is expected to do.

[guest271314]

Did I mention the WAT for the ComponentizeJS version output by wasm-tools/jco print is 170 MiB?!