Are reading from stdin, writing to stdout and WASI targets supported?

[guest271314]

Are reading from stdin, writing to stdout and WASI targets supported?

[ASDAlexander77]

stdout — yes. print(...) and console.log(...) write to stdout.

stdin — there is no built-in readline yet, but you can call libc directly with a declare function. For example, reading lines until end of input:

declare function getchar(): i32;

// reads one line from stdin (without the line break); null at end of input
function readLine(): string | null {
    let buffer: char[] = [];
    let c = getchar();
    if (c == -1) return null;
    while (c != -1 && c != 10) {
        if (c != 13) buffer.push(<char>c);
        c = getchar();
    }
    buffer.push(<char>0);
    return <string><Opaque>Ref(buffer[0]);
}

function main() {
    let line: string | null = null;
    while ((line = readLine()) != null) {
        console.log(`> ${line}`);
    }
}

printf "Alice\nBob\n" | tslang --emit=jit stdin.ts
> Alice
> Bob

It works the same with --emit=exe. Any other C function (fgets, fread, …) can be declared the same way, or generated from a header with tsbindgen.

WASM / WASI — WASM is supported, WASI is not a target yet. -mtriple=wasm32-unknown-unknown (use -mm=none) builds a .wasm module with no libc. Its imports (puts, malloc, strlen, …) come from the host through the env object, as in the run.html loader in the README ("Compiling as WASM"). So output goes wherever the host's puts sends it, and there is no stdin in that mode. There is also an experimental -mtriple=wasm32-pc-emscripten path (point --emsdk-sysroot-path / EMSDK_SYSROOT_PATH at the emsdk sysroot) that links Emscripten's standalone-wasm runtime, but it is not tested under WASI runtimes such as wasmtime. A proper wasm32-wasi target, linked against wasi-libc so fd_read/fd_write give real stdin/stdout, isn't implemented yet.

[ASDAlexander77]

Update: the default library now has both of these built in (ASDAlexander77/TypeScriptCompilerDefaultLib#68), so the getchar() workaround above is no longer needed once you are on a build that includes it:

function main() {
    let line: string | null = null;
    while ((line = console.readLine()) != null) {
        console.log(`> ${line}`);
    }

    console.log(String.fromCharCode(72, 105, 33)); // Hi!
}

• console.readLine() returns the next line of stdin without its line break (\n or \r\n), or null at the end of input.
• String.fromCharCode(...codes) writes each code as UTF-8 (a surrogate pair becomes one character).

It is on the default library's main now and will be in the next release package. WASI is still not a target.

[guest271314]

I've dealth with readline() in V8's d8 and SpiderMonkey's js. It's only intended to be text, not binary. I had to add binary I/O to d8 myself https://github.com/guest271314/v8/blob/main/src/d8/d8.cc#L5749-L5887.

I do the getChar() thing using Static Hermes https://gist.github.com/guest271314/fec412134903e50521c12370edc88ef3, https://github.com/guest271314/native-messaging-shermes/blob/main/nm_shermes.h.

I would say make sure binary I/O is there.

[ASDAlexander77]

Agreed, binary I/O matters, and readLine() is text only. There's no built-in byte API yet: no readBytes/writeBytes, no TextEncoder/TextDecoder. You can already do it by declaring the C runtime's file-descriptor functions and reading straight into a u8[]. Ref(buffer[i]) gives you a pointer into the array's storage.

Here is a native-messaging echo host (a 32-bit little-endian length, then the message), Windows version:

declare function _read(fd: s32, buffer: Opaque, count: u32): s32;
declare function _write(fd: s32, buffer: Opaque, count: u32): s32;
declare function _setmode(fd: s32, mode: s32): s32;

const O_BINARY = 0x8000;

// reads exactly count bytes into bytes (from index 0); false at the end of input
function readExactly(bytes: u8[], count: int): boolean {
    let done = 0;
    while (done < count) {
        const n = _read(0, <Opaque>Ref(bytes[done]), <u32>(count - done));
        if (n <= 0) return false;
        done += n;
    }
    return true;
}

// a buffer of count zero bytes
function bytes(count: int): u8[] {
    const buffer: u8[] = [];
    for (let i = 0; i < count; i++) buffer.push(0);
    return buffer;
}

function main() {
    // no \r\n translation on Windows
    _setmode(0, O_BINARY);
    _setmode(1, O_BINARY);

    const header = bytes(4);
    while (readExactly(header, 4)) {
        const length = header[0] | (header[1] << 8) | (header[2] << 16) | (header[3] << 24);
        const message = bytes(length);
        if (length > 0 && !readExactly(message, length)) break;

        // echo it back the same way
        _write(1, <Opaque>Ref(header[0]), 4);
        if (length > 0) _write(1, <Opaque>Ref(message[0]), <u32>length);
    }
}

On Linux, use read/write with the same signatures and drop the _setmode calls.

I checked it by piping in two framed messages, one containing \r\n, \0 and \xff bytes. The output was byte-identical to the input with v0.0-pre-alpha119 on Windows (JIT and --emit=exe, in gc, rc and none) and on Linux.

To get the message as a string (JSON text, say), push a terminating 0 and cast: <string><Opaque>Ref(message[0]). This stops at the first \0, so keep binary payloads as u8[].

Built-in byte I/O for stdin/stdout (and TextEncoder/TextDecoder) is a good addition for the default library, and I'll put it on the list.

[guest271314]

I tried on tslang version v0.0-pre-alpha92. Got

./tslang --emit=exe --opt -o ~/bin/nm_tslang ./nm_tslang.ts
/media/user/x/TypeScriptCompiler/nm_tslang.ts:2:1: error: 'write' is declared again with another signature: a declared function is one external symbol, so it can't have overloads. Declare it once, with optional or union parameters, or give each signature a name of its own and bind them with @linkname
declare function write(fd: s32, buffer: Opaque, count: u32): s32;
^
/media/user/x/TypeScriptCompiler/nm_tslang.ts:2:1: error: failed statement
declare function write(fd: s32, buffer: Opaque, count: u32): s32;

[ASDAlexander77]

Thanks for trying it, and sorry: my note above was wrong. "Use read/write with the same signatures" doesn't work on Linux when the default library is in use, and I reproduced your error with the alpha117 Linux package.

The default library already declares write itself, with a different signature (write(fileNo: int, s: string, count: int)). A declared function is one external symbol, so yours is rejected. read isn't declared there, which is why only line 2 failed. On Windows the example used _write, so it never met this.

With the release you have, give your declaration its own name and bind it to the symbol with @linkname, as the error suggests:

declare function read(fd: s32, buffer: Opaque, count: u32): s32;

@linkname("write")
declare function writeBytes(fd: s32, buffer: Opaque, count: u32): s32;

Then call writeBytes(1, <Opaque>Ref(header[0]), 4) where the example calls _write, and read where it calls _read, without the _setmode lines. write can write fewer bytes than asked for, so a host handling large messages should loop until it has written them all.

I tested that on Linux with the alpha117 package and your flags (--emit=exe --opt), piping in framed messages containing \r\n, \0, \xff and \x1a, a 76,800-byte message and an empty one. The output was byte-identical to the input. I haven't tried alpha92 itself, so if it behaves differently there, a newer release is the first thing to try.

Built-in binary I/O, which you asked for, is now in the default library, so none of the declarations are needed. It will be in v0.0-pre-alpha120, which is being built now. Stdio.read fills the buffer unless the input ends first, and on Windows it switches the stream to binary mode for the call:

function main() {
    const header = new Uint8Array(4);
    while (Stdio.read(header) == 4) {
        const length = header[0] | (header[1] << 8) | (header[2] << 16) | (header[3] << 24);
        const message = new Uint8Array(length);
        if (Stdio.read(message) != length) break;

        Stdio.write(header);
        Stdio.write(message);
    }
}

The same input came back byte-identical on Linux under -mm=gc, rc, none and own, on a development build with that library. There are also Stdio.readAll(), Stdio.writeError(bytes), TextEncoder and TextDecoder, so a message can become a string without stopping at the first \0.

[guest271314]

I'll try testing with 120 later today or tomorrow.

FYI this is what I use to test on the command line https://github.com/guest271314/NativeMessagingHosts/blob/main/nm_standalone_test.js, e.g.,

~/bin/nm_standalone_test.js ./nm_js2wasm.sh

~/bin/nm_standalone_test.js wasmtime ./output/nm_scriptc_sync_stream.wasm

~/bin/nm_standalone_test.js wasmtime ./output/nm_perry_sync_stream.wasm

~/bin/nm_standalone_test.js wasmtime ./output/nm_jz_sync_stream.wasm

[guest271314]

Right now I'm testing the same source code compiled using jz, js2wasm, perry, scriptc. Bun's --aot is quite useful for AOT static analyzation of code

bun check --aot --explain nm_bun_sync_stream.ts
note: Untyped code works, but runs slower. 2 causes:

24 |     const res: number = readSync(fd, view, offset, len, null);
                             ^
note: 1. unknown-callee: The callee isn't known at build time, so the result has no type.
   at nm_bun_sync_stream.ts:24:25

note: 1 indirect call
note: 1 of these runs in a loop
note: in function 'read'
note: fix: call the function directly, or narrow the result.
note: https://bun.com/docs/compiler/explain#unknown-callee

29 |     const res: number = writeSync(fd, view, offset, len);
                             ^
note: 2. unknown-callee: The callee isn't known at build time, so the result has no type.
   at nm_bun_sync_stream.ts:29:25

note: 1 indirect call
note: 1 of these runs in a loop
note: in function 'write'
note: fix: call the function directly, or narrow the result.
note: https://bun.com/docs/compiler/explain#unknown-callee

note: All property accesses, including dependencies:
  17  free: one load or store at a fixed offset
   0  tested: a test of its own, then a load or store at a fixed offset
   0  by name: looked up by name
Calls: 366 direct, 440 indirect
100% of property accesses are one load: 17 free, 0 tested, 0 by name (17)
✓ No type errors in 1 file, compiled 279 lines in 0.30 s (908 lines/s)

[guest271314]

Here's the code I've so far successfully compiled to WASM with WASI support using the above. Next up compile all to native executable.

#!/home/user/bin/bun -b
//! Bun Native Messaging host, synchronous streaming fs I/O (AOT experiment)
//! bun check --aot --explain nm_bun_sync_stream.ts
//! 100.0% of property accesses are one load
//! ✓ No type errors in 1 file

import { readSync, writeSync } from "node:fs";

const STDIN_FD: number = 0;
const STDOUT_FD: number = 1;
const STDERR_FD: number = 2;
const HEADER_SIZE: number = 4;
const COMMA: number = 44;
const OPEN_BRACKET: number = 91;
const CLOSE_BRACKET: number = 93;
const NO_BYTE: number = -1;

const CHUNK_SIZE: number = 1024 * 1024;
const STREAM_BUFFER_SIZE: number = CHUNK_SIZE * 2;
const UTILITY_BUFFER_SIZE: number = 4096;

class SystemIO {
  static read(fd: number, view: Uint8Array, offset: number, len: number): number {
    const res: number = readSync(fd, view, offset, len, null);
    if (typeof res === "number") return res;
    return 0;
  }
  static write(fd: number, view: Uint8Array, offset: number, len: number): number {
    const res: number = writeSync(fd, view, offset, len);
    if (typeof res === "number") return res;
    return 0;
  }
}

class NativeHostPipeline {
  body: Uint8Array = new Uint8Array(STREAM_BUFFER_SIZE);
  header: Uint8Array = new Uint8Array(HEADER_SIZE);
  out: Uint8Array = new Uint8Array(HEADER_SIZE + STREAM_BUFFER_SIZE + 2);
  util: Uint8Array = new Uint8Array(UTILITY_BUFFER_SIZE);

  readLengthFromHeader(): number {
    const h: Uint8Array = this.header;
    const s0: number = h[0];
    const s1: number = h[1];
    const s2: number = h[2];
    const s3: number = h[3];
    return ((s0 | (s1 << 8) | (s2 << 16) | (s3 << 24)) >>> 0);
  }

  writeBuffer(fd: number, u8: Uint8Array, length: number): void {
    let offset: number = 0;
    while (offset < length) {
      const n: number = SystemIO.write(fd, u8, offset, length - offset);
      if (n === 0) throw new Error("write returned 0");
      
      if (typeof n === "number") {
        offset = offset + n;
      }
    }
  }

  readExactBody(offset: number, length: number): void {
    let filled: number = 0;
    const view: Uint8Array = this.body;
    while (filled < length) {
      const n: number = SystemIO.read(STDIN_FD, view, offset + filled, length - filled);
      if (n === 0) throw new Error("stdin closed prematurely");
      
      if (typeof n === "number") {
        filled = filled + n;
      }
    }
  }

  emit(from: number, to: number, prepend: number, append: number): void {
    const bodyLength: number = to - from;
    const payload: number =
      bodyLength + (prepend !== NO_BYTE ? 1 : 0) + (append !== NO_BYTE ? 1 : 0);
    const total: number = HEADER_SIZE + payload;
    const out: Uint8Array = this.out;
    const body: Uint8Array = this.body;

    out[0] = payload & 255;
    out[1] = (payload >> 8) & 255;
    out[2] = (payload >> 16) & 255;
    out[3] = (payload >> 24) & 255;

    let cursor: number = HEADER_SIZE;
    if (prepend !== NO_BYTE) {
      out[cursor] = prepend;
      cursor++;
    }

    let src: number = from;
    for (let i: number = 0; i < bodyLength; i++) {
      out[cursor] = body[src];
      cursor++;
      src++;
    }

    if (append !== NO_BYTE) {
      out[cursor] = append;
      cursor++;
    }

    this.writeBuffer(STDOUT_FD, out, total);
  }

  sendChunk(fromIndex: number, toIndex: number): void {
    const body: Uint8Array = this.body;
    const startByte: number = body[fromIndex];
    const endByte: number = body[toIndex - 1];

    let actualFrom: number = fromIndex;
    let prepend: number = NO_BYTE;
    let append: number = NO_BYTE;

    if (startByte === OPEN_BRACKET && endByte !== CLOSE_BRACKET) {
      append = CLOSE_BRACKET;
    } else if (startByte === COMMA) {
      actualFrom = fromIndex + 1;
      prepend = OPEN_BRACKET;
      if (endByte !== CLOSE_BRACKET) {
        append = CLOSE_BRACKET;
      }
    }
    this.emit(actualFrom, toIndex, prepend, append);
  }

  streamIncomingMessage(totalIncomingBytes: number): void {
    let remainingBytes: number = totalIncomingBytes;
    let bufferPopulation: number = 0;
    const body: Uint8Array = this.body;

    while (remainingBytes > 0 || bufferPopulation > 0) {
      const spaceAvailable: number = STREAM_BUFFER_SIZE - bufferPopulation;
      const amountToRead: number =
        spaceAvailable < remainingBytes ? spaceAvailable : remainingBytes;

      if (amountToRead > 0) {
        this.readExactBody(bufferPopulation, amountToRead);
        
        if (typeof amountToRead === "number") {
          bufferPopulation = bufferPopulation + amountToRead;
          remainingBytes = remainingBytes - amountToRead;
        }
      }

      if (bufferPopulation <= CHUNK_SIZE) {
        if (remainingBytes === 0) {
          if (bufferPopulation > 0) {
            this.sendChunk(0, bufferPopulation);
            bufferPopulation = 0;
          }
          break;
        }
        continue;
      }

      const chunkBacktrack: number = CHUNK_SIZE - 8;
      const searchStart: number = chunkBacktrack < bufferPopulation ? chunkBacktrack : 0;
      
      let foundComma: number = -1;
      for (let i: number = searchStart; i < bufferPopulation; i++) {
        if (body[i] === COMMA) {
          foundComma = i;
          break;
        }
      }

      const splitIndex: number = foundComma !== -1 ? foundComma : CHUNK_SIZE;

      this.sendChunk(0, splitIndex);

      const remainingInWindow: number = bufferPopulation - splitIndex;
      for (let i: number = 0; i < remainingInWindow; i++) {
        body[i] = body[splitIndex + i];
      }
      bufferPopulation = remainingInWindow;
    }
  }

  writeStringToUtilBuffer(str: string): number {
    const len: number = str.length;
    const u: Uint8Array = this.util;
    for (let i: number = 0; i < len; i++) {
      const cp: number = str.charCodeAt(i);
      u[i] = cp;
    }
    return len;
  }

  writeManualErrorJson(msg: string): number {
    const u: Uint8Array = this.util;
    let cursor: number = 0;
    u[cursor++] = 123; // {
    u[cursor++] = 34;  // "
    u[cursor++] = 101; // e
    u[cursor++] = 114; // r
    u[cursor++] = 114; // r
    u[cursor++] = 111; // o
    u[cursor++] = 114; // r
    u[cursor++] = 34;  // "
    u[cursor++] = 58;  // :
    u[cursor++] = 34;  // "

    const msgLen: number = msg.length;
    for (let i: number = 0; i < msgLen; i++) {
      const cp: number = msg.charCodeAt(i);
      if (cp === 34 || cp === 92) {
        u[cursor++] = 92;
      }
      u[cursor++] = cp;
    }

    u[cursor++] = 34;  // "
    u[cursor++] = 125; // }
    return cursor;
  }

  handleCrash(msg: string): never {
    const len: number = this.writeManualErrorJson(msg);
    this.writeBuffer(STDERR_FD, this.util, len);

    const body: Uint8Array = this.body;
    const u: Uint8Array = this.util;
    for (let i: number = 0; i < len; i++) {
      body[i] = u[i];
    }
    this.sendChunk(0, len);
    
    // satisfies jz WASI runtime mapping
    process.exit(1);
    
    // Explicit scalar fallback guarantees a strict 'never' return type bounds context
    throw msg;
  }

  mainProcessingLoop(): number {
    const header: Uint8Array = this.header;
    for (;;) {
      let bytesRead: number = 0;
      let filled: number = 0;
      while (filled < HEADER_SIZE) {
        const n: number = SystemIO.read(STDIN_FD, header, filled, HEADER_SIZE - filled);
        if (n === 0) {
          bytesRead = filled;
          break;
        }
        
        if (typeof n === "number") {
          filled = filled + n;
        }
        bytesRead = filled;
      }

      if (bytesRead === 0) return 0;
      if (bytesRead < HEADER_SIZE) return 1;

      const totalIncomingBytes: number = this.readLengthFromHeader();
      this.streamIncomingMessage(totalIncomingBytes);
    }
  }
}

function run(): void {
  const pipeline: NativeHostPipeline = new NativeHostPipeline();
  const initMessage: string = '"TypeScript Native Messaging streaming host"';

  const initLen: number = pipeline.writeStringToUtilBuffer(initMessage);
  pipeline.writeBuffer(STDERR_FD, pipeline.util, initLen);

  const statusCode: number = pipeline.mainProcessingLoop();
  if (statusCode === 1) {
    pipeline.handleCrash("stdin closed mid-header");
  }
}

run();

[ASDAlexander77]

Yes, it compiles with tslang (tested with v0.0-pre-alpha120 on Windows) after a few small changes:

1. node:fs is not available, so SystemIO uses the default library's stdio functions, which take a position in the array:
   • stdio_read is fread on stdin. It waits until it has len bytes or stdin ends, so it suits this program, which always asks for an exact number of bytes.
   • stdio_write_bytes(fd, ...) takes 1 for stdout and 2 for stderr. Both put the stream in binary mode on Windows.
   • view.__elementRef(offset) gives the address of an element, so reads and writes can start at an offset (a Uint8Array here is not a view over an ArrayBuffer).
2. process.exit(1) becomes exit(1), with declare function exit(code: int): void; (the C library's exit).
3. The typeof n === "number" checks are not needed and are removed.

Everything else is unchanged.

Compile it into an executable, or run it with the JIT:

tslang --emit=exe nm_tslang.ts
tslang --emit=jit nm_tslang.ts

I checked it against your original running under Node (--experimental-strip-types). Three messages went in: {"a":1}, a 2.6 MB number array (split into 1 MB chunks at commas) and [1,2,3]. The output was byte-for-byte the same. With stdin cut off after 2 header bytes, both send the same {"error":"stdin closed mid-header"} frame and exit with code 1.

// Native Messaging host, synchronous streaming stdio I/O - tslang version
// tslang --emit=exe nm_tslang.ts

const STDIN_FD: number = 0;
const STDOUT_FD: number = 1;
const STDERR_FD: number = 2;
const HEADER_SIZE: number = 4;
const COMMA: number = 44;
const OPEN_BRACKET: number = 91;
const CLOSE_BRACKET: number = 93;
const NO_BYTE: number = -1;

const CHUNK_SIZE: number = 1024 * 1024;
const STREAM_BUFFER_SIZE: number = CHUNK_SIZE * 2;
const UTILITY_BUFFER_SIZE: number = 4096;

declare function exit(code: int): void;

// node:fs readSync/writeSync with an offset, on top of the default library's stdio natives:
// stdio_read is fread on stdin (blocks until `len` bytes or the end of the input),
// stdio_write_bytes is fwrite on stdout (1) or stderr (2), both in binary mode.
class SystemIO {
  static read(fd: number, view: Uint8Array, offset: number, len: number): number {
    if (len <= 0) return 0;
    return stdio_read(<Opaque>view.__elementRef(offset), len);
  }
  static write(fd: number, view: Uint8Array, offset: number, len: number): number {
    if (len <= 0) return 0;
    return stdio_write_bytes(fd, <Opaque>view.__elementRef(offset), len);
  }
}

class NativeHostPipeline {
  body: Uint8Array = new Uint8Array(STREAM_BUFFER_SIZE);
  header: Uint8Array = new Uint8Array(HEADER_SIZE);
  out: Uint8Array = new Uint8Array(HEADER_SIZE + STREAM_BUFFER_SIZE + 2);
  util: Uint8Array = new Uint8Array(UTILITY_BUFFER_SIZE);

  readLengthFromHeader(): number {
    const h: Uint8Array = this.header;
    const s0: number = h[0];
    const s1: number = h[1];
    const s2: number = h[2];
    const s3: number = h[3];
    return ((s0 | (s1 << 8) | (s2 << 16) | (s3 << 24)) >>> 0);
  }

  writeBuffer(fd: number, u8: Uint8Array, length: number): void {
    let offset: number = 0;
    while (offset < length) {
      const n: number = SystemIO.write(fd, u8, offset, length - offset);
      if (n === 0) throw new Error("write returned 0");
      offset = offset + n;
    }
  }

  readExactBody(offset: number, length: number): void {
    let filled: number = 0;
    const view: Uint8Array = this.body;
    while (filled < length) {
      const n: number = SystemIO.read(STDIN_FD, view, offset + filled, length - filled);
      if (n === 0) throw new Error("stdin closed prematurely");
      filled = filled + n;
    }
  }

  emit(from: number, to: number, prepend: number, append: number): void {
    const bodyLength: number = to - from;
    const payload: number =
      bodyLength + (prepend !== NO_BYTE ? 1 : 0) + (append !== NO_BYTE ? 1 : 0);
    const total: number = HEADER_SIZE + payload;
    const out: Uint8Array = this.out;
    const body: Uint8Array = this.body;

    out[0] = payload & 255;
    out[1] = (payload >> 8) & 255;
    out[2] = (payload >> 16) & 255;
    out[3] = (payload >> 24) & 255;

    let cursor: number = HEADER_SIZE;
    if (prepend !== NO_BYTE) {
      out[cursor] = prepend;
      cursor++;
    }

    let src: number = from;
    for (let i: number = 0; i < bodyLength; i++) {
      out[cursor] = body[src];
      cursor++;
      src++;
    }

    if (append !== NO_BYTE) {
      out[cursor] = append;
      cursor++;
    }

    this.writeBuffer(STDOUT_FD, out, total);
  }

  sendChunk(fromIndex: number, toIndex: number): void {
    const body: Uint8Array = this.body;
    const startByte: number = body[fromIndex];
    const endByte: number = body[toIndex - 1];

    let actualFrom: number = fromIndex;
    let prepend: number = NO_BYTE;
    let append: number = NO_BYTE;

    if (startByte === OPEN_BRACKET && endByte !== CLOSE_BRACKET) {
      append = CLOSE_BRACKET;
    } else if (startByte === COMMA) {
      actualFrom = fromIndex + 1;
      prepend = OPEN_BRACKET;
      if (endByte !== CLOSE_BRACKET) {
        append = CLOSE_BRACKET;
      }
    }
    this.emit(actualFrom, toIndex, prepend, append);
  }

  streamIncomingMessage(totalIncomingBytes: number): void {
    let remainingBytes: number = totalIncomingBytes;
    let bufferPopulation: number = 0;
    const body: Uint8Array = this.body;

    while (remainingBytes > 0 || bufferPopulation > 0) {
      const spaceAvailable: number = STREAM_BUFFER_SIZE - bufferPopulation;
      const amountToRead: number =
        spaceAvailable < remainingBytes ? spaceAvailable : remainingBytes;

      if (amountToRead > 0) {
        this.readExactBody(bufferPopulation, amountToRead);
        bufferPopulation = bufferPopulation + amountToRead;
        remainingBytes = remainingBytes - amountToRead;
      }

      if (bufferPopulation <= CHUNK_SIZE) {
        if (remainingBytes === 0) {
          if (bufferPopulation > 0) {
            this.sendChunk(0, bufferPopulation);
            bufferPopulation = 0;
          }
          break;
        }
        continue;
      }

      const chunkBacktrack: number = CHUNK_SIZE - 8;
      const searchStart: number = chunkBacktrack < bufferPopulation ? chunkBacktrack : 0;

      let foundComma: number = -1;
      for (let i: number = searchStart; i < bufferPopulation; i++) {
        if (body[i] === COMMA) {
          foundComma = i;
          break;
        }
      }

      const splitIndex: number = foundComma !== -1 ? foundComma : CHUNK_SIZE;

      this.sendChunk(0, splitIndex);

      const remainingInWindow: number = bufferPopulation - splitIndex;
      for (let i: number = 0; i < remainingInWindow; i++) {
        body[i] = body[splitIndex + i];
      }
      bufferPopulation = remainingInWindow;
    }
  }

  writeStringToUtilBuffer(str: string): number {
    const len: number = str.length;
    const u: Uint8Array = this.util;
    for (let i: number = 0; i < len; i++) {
      const cp: number = str.charCodeAt(i);
      u[i] = cp;
    }
    return len;
  }

  writeManualErrorJson(msg: string): number {
    const u: Uint8Array = this.util;
    let cursor: number = 0;
    u[cursor++] = 123; // {
    u[cursor++] = 34;  // "
    u[cursor++] = 101; // e
    u[cursor++] = 114; // r
    u[cursor++] = 114; // r
    u[cursor++] = 111; // o
    u[cursor++] = 114; // r
    u[cursor++] = 34;  // "
    u[cursor++] = 58;  // :
    u[cursor++] = 34;  // "

    const msgLen: number = msg.length;
    for (let i: number = 0; i < msgLen; i++) {
      const cp: number = msg.charCodeAt(i);
      if (cp === 34 || cp === 92) {
        u[cursor++] = 92;
      }
      u[cursor++] = cp;
    }

    u[cursor++] = 34;  // "
    u[cursor++] = 125; // }
    return cursor;
  }

  handleCrash(msg: string): never {
    const len: number = this.writeManualErrorJson(msg);
    this.writeBuffer(STDERR_FD, this.util, len);

    const body: Uint8Array = this.body;
    const u: Uint8Array = this.util;
    for (let i: number = 0; i < len; i++) {
      body[i] = u[i];
    }
    this.sendChunk(0, len);

    exit(1);
    throw msg;
  }

  mainProcessingLoop(): number {
    const header: Uint8Array = this.header;
    for (;;) {
      let bytesRead: number = 0;
      let filled: number = 0;
      while (filled < HEADER_SIZE) {
        const n: number = SystemIO.read(STDIN_FD, header, filled, HEADER_SIZE - filled);
        if (n === 0) {
          bytesRead = filled;
          break;
        }
        filled = filled + n;
        bytesRead = filled;
      }

      if (bytesRead === 0) return 0;
      if (bytesRead < HEADER_SIZE) return 1;

      const totalIncomingBytes: number = this.readLengthFromHeader();
      this.streamIncomingMessage(totalIncomingBytes);
    }
  }
}

function run(): void {
  const pipeline: NativeHostPipeline = new NativeHostPipeline();
  const initMessage: string = '"TypeScript Native Messaging streaming host"';

  const initLen: number = pipeline.writeStringToUtilBuffer(initMessage);
  pipeline.writeBuffer(STDERR_FD, pipeline.util, initLen);

  const statusCode: number = pipeline.mainProcessingLoop();
  if (statusCode === 1) {
    pipeline.handleCrash("stdin closed mid-header");
  }
}

run();

[guest271314]

It works. Both of them.

Now, to get to WASM with WASI support I need to emit object file(s), or C, right?

TSLANG_LIB_PATH=/media/user/x/TypeScriptCompiler tslang --emit=exe nm_tslang.ts

595 KiB executable.

file nm_tslang
nm_tslang: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, not stripped

After strip 485.5 KiB, and still works.

To test the JIT I had to do this

#!/usr/bin/env -S TSLANG_LIB_PATH=/media/user/x/TypeScriptCompiler /home/user/bin/tslang --emit=jit ./nm_tslang.ts

native-messaging-tslang$ ~/bin/nm_standalone_test.js ./nm_tslang.sh
{ path: "./nm_tslang.sh", allowed_origin: undefined }
Testing ./nm_tslang.sh Native Messaging host

"TypeScript Native Messaging streaming host"{ messageLength: 1048576 }
{
  message: [
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
# ...
{ outputLength: 13421696, totalMessageLength: 13421760 }
{ messageLength: 321 }
{ outputLength: 13421760, totalMessageLength: 13421760 }
{ totalMessageLength: 13421760, outputLength: 13421760 }

native-messaging-tslang$ ~/bin/nm_standalone_test.js ./nm_tslang
{ path: "./nm_tslang", allowed_origin: undefined }
Testing ./nm_tslang Native Messaging host

"TypeScript Native Messaging streaming host"{ messageLength: 1048576 }
{
  message: [
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
    null, null, null, null, null, null, null, null, null, null,
# ...
{ messageLength: 1048571 }
{ outputLength: 13421696, totalMessageLength: 13421760 }
{ messageLength: 321 }
{ outputLength: 13421760, totalMessageLength: 13421760 }
{ totalMessageLength: 13421760, outputLength: 13421760 }

[guest271314]

tslang --emit=obj nm_tslang.ts

~/bin/wasi-sdk/bin/clang nm_tslang.o -L/media/user/x/TypeScriptCompiler -o nm_tslang.wasm
wasm-ld: error: unknown file type: nm_tslang.o
clang: error: linker command failed with exit code 1 (use -v to see invocation)

What's the roadmap here?

[guest271314]

Is https://github.com/ASDAlexander77/TypeScript2Cxx built in to this? If not, that would be a usefult option; Static Hermes has -emit-c.

[ASDAlexander77]

No. TypeScript2Cxx is a separate project that translates TypeScript into C++ source. tslang compiles through MLIR to LLVM and doesn't produce C. The nearest outputs are --emit=llvm (LLVM IR), --emit=bc (bitcode), --emit=asm and --emit=obj. Any of them can be built for another target with -mtriple=....

[ASDAlexander77]

updating support for wasm32 and wasm64 in next release

[guest271314]

Here's what I did/do to compile to wasm32-wasip1 right now.

#!/usr/bin/env bash
set -e

TS_DIR="$HOME/bin/TypeScriptCompiler"
WASI_LIB="$TS_DIR/wasi_lib"
WASI_CLANG="$HOME/bin/wasi-sdk/bin/clang"

if [ $# -lt 1 ]; then
    echo "Usage: $0 <input.ts> [-o <output.wasm>]"
    exit 1
fi

INPUT_TS="$1"
shift
BASE_NAME=$(basename "$INPUT_TS" .ts)
OUTPUT_WASM="${BASE_NAME}.wasm"

while getopts "o:" opt; do
    case "$opt" in
        o) OUTPUT_WASM="$OPTARG" ;;
        *) echo "Usage: $0 <input.ts> [-o <output.wasm>]"; exit 1 ;;
    esac
done

TMP_OBJ=$(mktemp /tmp/ts2wasi_XXXXXX.o)
trap 'rm -f "$TMP_OBJ"' EXIT

# 1. Emit optimized WebAssembly object file
tslang "$INPUT_TS" \
  --emit=obj \
  --opt \
  -mtriple=wasm32-unknown-unknown \
  -mm=none \
  -o "$TMP_OBJ"

# 2. Link against wasi-libc, wasi_core.c, and libtsdefault.a
"$WASI_CLANG" --target=wasm32-wasip1 \
  "$TMP_OBJ" \
  "$WASI_LIB/wasi_core.c" \
  -L"$WASI_LIB" \
  -ltsdefault \
  -Wl,--strip-all \
  -o "$OUTPUT_WASM"

echo "Built $OUTPUT_WASM ($(du -h "$OUTPUT_WASM" | cut -f1))"

wasi_core.c

/*
Satisfies the WASI _start entry point (tslang runs top-level code via 
.init_array before main()), routes binary stdio to wasi-libc, and provides C++ 
exception/RTTI stubs
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

// WASI entry point: .init_array executes tslang's top-level code before main()
int main(int argc, char** argv) {
    return 0;
}

// Binary stdio hooks expected by tslang's defaultlib
int32_t stdio_read(void* buf, int32_t len) {
    if (!buf || len <= 0) return 0;
    return (int32_t)fread(buf, 1, (size_t)len, stdin);
}

int32_t stdio_write_bytes(int32_t fd, const void* buf, int32_t len) {
    if (!buf || len <= 0) return 0;
    FILE* stream = (fd == 2) ? stderr : stdout;
    size_t written = fwrite(buf, 1, (size_t)len, stream);
    fflush(stream);
    return (int32_t)written;
}

// Minimal C++ exception & RTTI stubs for WASI
void* __cxa_allocate_exception(size_t thrown_size) {
    return malloc(thrown_size);
}

void __cxa_throw(void* thrown_exception, void* tinfo, void (*dest)(void*)) {
    fprintf(stderr, "Unhandled TypeScript exception\n");
    abort();
}

void* _ZTIPc = 0;
void* _ZTVN10__cxxabiv119__pointer_type_infoE = 0;
void* _ZTVN10__cxxabiv120__si_class_type_infoE = 0;
void* _ZTVN10__cxxabiv117__class_type_infoE = 0;

[ASDAlexander77]

v0.0-pre-alpha125 adds wasm32-unknown-unknown and wasm64-unknown-unknown. The package now ships wasm-ld and the default library built for wasm (-mm=none, rc and own; the collector behind -mm=gc has no wasm build), so one command builds the module:

tslang --emit=exe -mm=none --opt -mtriple=wasm32-unknown-unknown -o=nm_tslang.wasm nm_tslang.ts

The module has no C library. What the C library provides on other targets (malloc, printf, the time functions, stdio_read, stdio_write_bytes, ...) is imported from env. tslang/test/wasm/host.mjs implements those imports for Node and the browser, along with try/catch (wasm exception handling), async/await and threads. node run.mjs nm_tslang.wasm runs a module. The README there has the details.

There is no WASI target yet, so for wasmtime your wasi-sdk script is the way for now. A few notes on it:

• wasm-ld: unknown file type: nm_tslang.o came from --emit=obj without -mtriple: that object is x86-64 ELF. Your script passes -mtriple, which is right.
• Your __cxa_throw stub aborts on every throw, including one that a try/catch would catch. tslang's wasm code catches with wasm exception handling, which needs the __cpp_exception tag that host.mjs creates. Your program throws only on errors it doesn't recover from, so this doesn't affect it.
• Keep -mm=none (or use rc/own). gc has no wasm build.

One thing in host.mjs that matters for Native Messaging: stdio_write_bytes currently decodes the bytes as UTF-8 before writing them. Any 4-byte length header or body byte of 0x80 and up is changed, so binary stdout under host.mjs is broken. I'll fix that. Until then, your WASI build is the one to use for this host.

[guest271314]

Interesting. Node.js and browser (JIT) imports are not what I'm necessarily after when using tslang for AOT compilation. I can kinda already do the Node.js and WASM/WASI in brower thing. The idea is to not use a JIT runtime, really AOT compile TypeScript and JavaScript to different targets.

The try..catch, exception handling stuff was thrown in to avoid the program not compiling. For sure can be done differently.

I'll see what I can do with that wasm32-unknown-unknown target.

[guest271314]

This is what I wound up with for v0.0-pre-alpha125

wasi_core.cpp

/*
Satisfies the WASI _start entry point (tslang runs top-level code via
.init_array before main()), routes binary stdio to wasi-libc, and provides C++
exception/RTTI stubs
*/

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

extern "C" {

// Binary stdio hooks expected by tslang's defaultlib
int32_t stdio_read(void* buf, int32_t len) {
  if (!buf || len <= 0)
    return 0;
  return (int32_t)fread(buf, 1, (size_t)len, stdin);
}

int32_t stdio_write_bytes(int32_t fd, const void* buf, int32_t len) {
  if (!buf || len <= 0)
    return 0;
  FILE* stream = (fd == 2) ? stderr : stdout;
  size_t written = fwrite(buf, 1, (size_t)len, stream);
  fflush(stream);
  return (int32_t)written;
}

// Matches tslang's (i32) -> void signature to avoid trapping against
// wasi-libc's (i32) -> i64
void time(int32_t* t) {
  if (t)
    *t = 0;
}
}
// WASI entry point: .init_array executes tslang's top-level code before main()
int main(int argc, char** argv) {
  return 0;
}

tslang2wasi.sh

#!/usr/bin/env bash
set -e

TS_DIR="$HOME/bin/TypeScriptCompiler"
TS_DEFAULT_WASM_LIB_DIR="$TS_DIR/defaultlib/lib/wasm32/unknown/unknown/unknown/release/none"
WASI_CLANGXX="$HOME/bin/wasi-sdk/bin/clang++"

if [ $# -lt 1 ]; then
    echo "Usage: $0 <input.ts> [-o <output.wasm>]"
    exit 1
fi

INPUT_TS="$1"
shift
BASE_NAME=$(basename "$INPUT_TS" .ts)
OUTPUT_WASM="${BASE_NAME}.wasm"

while getopts "o:" opt; do
    case "$opt" in
        o) OUTPUT_WASM="$OPTARG" ;;
        *) echo "Usage: $0 <input.ts> [-o <output.wasm>]"; exit 1 ;;
    esac
done

TMP_OBJ=$(mktemp /tmp/ts2wasi_XXXXXX.o)
trap 'rm -f "$TMP_OBJ"' EXIT

# 1. Emit optimized WebAssembly object file
tslang "$INPUT_TS" \
  --emit=obj \
  --opt \
  -mtriple=wasm32-unknown-unknown \
  -mm=none \
  -o "$TMP_OBJ"

# 2. Link against wasi-libc, wasi_core.cpp, and TypeScriptDefaultLib.a
"$WASI_CLANGXX" --target=wasm32-wasip1 \
  -fwasm-exceptions \
  "$TMP_OBJ" \
  "$PWD/wasi_core.cpp" \
  -L"$TS_DEFAULT_WASM_LIB_DIR" \
  -lTypeScriptDefaultLib \
  -lunwind \
  -Wl,--strip-all \
  -o "$OUTPUT_WASM"

echo "Built $OUTPUT_WASM ($(du -h "$OUTPUT_WASM" | cut -f1))"

[guest271314]

I observed a bug that now I've encountered twice in Chromium using tslang as a Native Messaging host https://issues.chromium.org/issues/572465627#comment9.

[ASDAlexander77]

I don't think this comes from the host. "Specified native messaging host not found" is reported before Chromium starts the program, so the binary and the wasm build behave the same.

As posted in comment 9, both host manifests are not valid JSON. allowed_origins has no comma between its two entries:

"allowed_origins": [
   "chrome-extension://kljnnhaekpiooecdooakikhhijoldepe/"
   "chrome-extension://lkbccfcafplmonhenanladiplkiomlaj/"
]

The nm_d manifest in comment 1 has a trailing comma after its last entry instead. Chromium skips a manifest it cannot parse and then reports the host as not found. That fits "works with another manifest". Try jq . ~/.config/chromium/NativeMessagingHosts/nm_tslang.json: if it fails, that's the cause.

[guest271314]

Haha. Yep, invalid JSON. Too funny. Thanks.

[guest271314]

FYI https://gist.github.com/guest271314/3ead8bde5922106f6f00226cfa0bebcb