@tsrs/wasm 0.0.0-bootstrap.1 → 0.16.0-ts7.1.0-dev.20260929

package/core.d.ts

@@ -0,0 +1,105 @@
+/** Request flag: reply with the diagnostics as JSON (`DiagnosticResponse[]`) instead of printing them. */
+export declare const REQUEST_JSON_DIAGNOSTICS: 1;
+/** Request flag: the host file system is case-insensitive. */
+export declare const REQUEST_CASE_INSENSITIVE: 2;
+/** Request flag: stdout is a terminal (the default for `--pretty`). */
+export declare const REQUEST_TTY: 4;
+/** Exit status of a crashed run (a panic, or a trap such as a stack overflow or running out of memory); tsc's own are 0-4. */
+export declare const EXIT_CRASHED: 5;
+
+/** A compiled `WebAssembly.Module`, typed structurally so that these declarations need neither lib dom nor @types/node. */
+export type WasmModule = object;
+
+/** The module's `WasmMemory`. */
+export interface WasmMemory {
+    readonly buffer: ArrayBuffer;
+}
+
+export declare class WasiExit extends Error {
+    code: number;
+    constructor(code: number);
+}
+
+/** Thrown by a HostFileSystem method for a missing path. */
+export declare class NotFoundError extends Error {}
+
+export interface FileStat {
+    kind: "f" | "d" | "o";
+    size: number | bigint;
+    mtimeNs: bigint;
+}
+
+/** The file system the module reads and writes through. Paths are absolute, with `/` separators. */
+export interface HostFileSystem {
+    readFile(path: string): Uint8Array;
+    stat(path: string): FileStat;
+    /** [kind, name] pairs; kind "l" is a symbolic link (followed by a later stat). */
+    readDir(path: string): Array<["f" | "d" | "l" | "o", string]>;
+    realpath(path: string): string;
+    writeFile(path: string, data: Uint8Array, append: boolean): void;
+    remove(path: string): void;
+    chtimes(path: string, atimeNs: bigint, mtimeNs: bigint): void;
+}
+
+export interface Request {
+    cwd: string;
+    args: string[];
+    flags: number;
+}
+
+export interface RunIO {
+    env?: Record<string, string | undefined>;
+    stdout?(chunk: Uint8Array): void;
+    stderr?(chunk: Uint8Array): void;
+    beforeRun?(memory: WasmMemory): void;
+    afterRun?(memory: WasmMemory): void;
+}
+
+export interface RunResult {
+    exitCode: number;
+    reply: Uint8Array;
+    /** Linear memory at the end of the run (it never shrinks, so this is the peak). */
+    memoryBytes: number;
+}
+
+/** Runs one tsc invocation in a fresh instance of `module`. A trap gives exitCode `EXIT_CRASHED` and a message on stderr. */
+export declare function runTsc(module: WasmModule, request: Request, host: HostFileSystem, io?: RunIO): RunResult;
+
+/** `runTsc` with an asynchronous instantiation (browsers forbid a synchronous one of a large module on the page). */
+export declare function runTscAsync(module: WasmModule, request: Request, host: HostFileSystem, io?: RunIO): Promise<RunResult>;
+
+export declare function makeRequest(args: string[], options: { cwd: string; json?: boolean; caseInsensitive?: boolean; tty?: boolean }): Request;
+
+export interface MemoryFileSystem extends HostFileSystem {
+    /** Files the compiler wrote: path -> text (UTF-8, BOM kept). */
+    written: Map<string, string>;
+}
+
+/** An in-memory file system over absolute path -> contents; directories are implied by the paths below them. */
+export declare function memoryFileSystem(files?: Record<string, string | Uint8Array>, options?: { caseInsensitive?: boolean }): MemoryFileSystem;
+
+export interface DiagnosticPosition {
+    line: number;
+    character: number;
+}
+
+/** The TypeScript API's diagnostic shape; positions are UTF-16 offsets. */
+export interface Diagnostic {
+    fileName?: string;
+    pos: number;
+    end: number;
+    startPosition?: DiagnosticPosition;
+    endPosition?: DiagnosticPosition;
+    sourceLines?: Array<{ line: number; text: string }>;
+    code: number;
+    /** 0 warning, 1 error, 2 suggestion, 3 message */
+    category: 0 | 1 | 2 | 3;
+    source?: string;
+    text: string;
+    reportsUnnecessary?: boolean;
+    reportsDeprecated?: boolean;
+    messageChain?: Diagnostic[];
+    relatedInformation?: Diagnostic[];
+}
+
+export declare function parseReply(reply: Uint8Array): Diagnostic[];

package/core.js

@@ -0,0 +1,356 @@
+// Runtime-agnostic host for tsrs.wasm (crates/tsrs_wasm): a small WASI preview1 shim (clocks, random, stdout/stderr,
+// environ, proc_exit; no file system), the host file-system bridge (`tsrs_host.fs` / `tsrs_host.fs_take`), and
+// `runTsc`. Node (node.js) and browsers (browser.js) build on it. No dependencies.
+
+export const REQUEST_JSON_DIAGNOSTICS = 1;
+export const REQUEST_CASE_INSENSITIVE = 2;
+export const REQUEST_TTY = 4;
+
+/**
+ * The exit status of a run that crashed: a Rust panic (the module exits with it, as native tsrs does for a panicked
+ * driver thread) or a trap (`runTsc` maps it). tsc's own statuses are 0-4.
+ */
+export const EXIT_CRASHED = 5;
+
+const OP_READ = 0;
+const OP_STAT = 1;
+const OP_READ_DIR = 2;
+const OP_REALPATH = 3;
+const OP_WRITE = 4;
+const OP_APPEND = 5;
+const OP_REMOVE = 6;
+const OP_CHTIMES = 7;
+
+const ESUCCESS = 0;
+const EBADF = 8;
+const EINVAL = 28;
+const ENOSYS = 52;
+
+/** Thrown by the shim's `proc_exit`; `runTsc` turns it into the exit code. */
+export class WasiExit extends Error {
+    constructor(code) {
+        super(`exit ${code}`);
+        this.code = code;
+    }
+}
+
+/** Raised by a HostFileSystem method for a missing path (maps to "not found" in the module). */
+export class NotFoundError extends Error {}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+
+function nowNs(realtime) {
+    const ms = realtime ? performance.timeOrigin + performance.now() : performance.now();
+    return BigInt(Math.round(ms * 1e6));
+}
+
+// The imports for one run, and `start(instance)`, which runs the request in that instance.
+function prepare(module, request, host, io) {
+    let instance;
+    let memory;
+    const view = () => new DataView(memory.buffer);
+    const bytes = () => new Uint8Array(memory.buffer);
+    const env = Object.entries(io.env ?? {}).map(([k, v]) => encoder.encode(`${k}=${v}\0`));
+    const stdout = io.stdout ?? (() => {});
+    const stderr = io.stderr ?? (() => {});
+    const tty = (request.flags & REQUEST_TTY) !== 0;
+    let staged = new Uint8Array(0);
+
+    const wasi = {
+        args_sizes_get(argc, size) {
+            view().setUint32(argc, 0, true);
+            view().setUint32(size, 0, true);
+            return ESUCCESS;
+        },
+        args_get() {
+            return ESUCCESS;
+        },
+        environ_sizes_get(count, size) {
+            view().setUint32(count, env.length, true);
+            view().setUint32(size, env.reduce((n, e) => n + e.length, 0), true);
+            return ESUCCESS;
+        },
+        environ_get(ptrs, buf) {
+            let p = buf;
+            env.forEach((e, i) => {
+                view().setUint32(ptrs + i * 4, p, true);
+                bytes().set(e, p);
+                p += e.length;
+            });
+            return ESUCCESS;
+        },
+        clock_time_get(id, _precision, out) {
+            view().setBigUint64(out, nowNs(id === 0), true);
+            return ESUCCESS;
+        },
+        clock_res_get(_id, out) {
+            view().setBigUint64(out, 1000n, true);
+            return ESUCCESS;
+        },
+        random_get(ptr, len) {
+            for (let off = 0; off < len; off += 65536) {
+                crypto.getRandomValues(new Uint8Array(memory.buffer, ptr + off, Math.min(65536, len - off)));
+            }
+            return ESUCCESS;
+        },
+        fd_write(fd, iovs, count, written) {
+            if (fd !== 1 && fd !== 2) {
+                return EBADF;
+            }
+            let total = 0;
+            for (let i = 0; i < count; i++) {
+                const ptr = view().getUint32(iovs + i * 8, true);
+                const len = view().getUint32(iovs + i * 8 + 4, true);
+                const chunk = bytes().slice(ptr, ptr + len);
+                (fd === 1 ? stdout : stderr)(chunk);
+                total += len;
+            }
+            view().setUint32(written, total, true);
+            return ESUCCESS;
+        },
+        fd_fdstat_get(fd, out) {
+            if (fd > 2) {
+                return EBADF;
+            }
+            // filetype: 2 = character device (a tty), 0 = unknown.
+            const v = view();
+            for (let i = 0; i < 24; i++) {
+                v.setUint8(out + i, 0);
+            }
+            v.setUint8(out, fd === 1 && tty ? 2 : 0);
+            return ESUCCESS;
+        },
+        fd_prestat_get() {
+            return EBADF;
+        },
+        fd_prestat_dir_name() {
+            return EBADF;
+        },
+        fd_close() {
+            return EBADF;
+        },
+        proc_exit(code) {
+            throw new WasiExit(code);
+        },
+        sched_yield() {
+            return ESUCCESS;
+        },
+        poll_oneoff() {
+            return ESUCCESS;
+        },
+    };
+
+    const text = (ptr, len) => decoder.decode(bytes().subarray(ptr, ptr + len));
+    const splitNul = (ptr, len) => {
+        const b = bytes().subarray(ptr, ptr + len);
+        const i = b.indexOf(0);
+        return [decoder.decode(b.subarray(0, i < 0 ? len : i)), b.slice(i < 0 ? len : i + 1)];
+    };
+    const stage = (data) => {
+        staged = typeof data === "string" ? encoder.encode(data) : data;
+        return staged.length;
+    };
+    const fsCall = (op, ptr, len) => {
+        try {
+            switch (op) {
+                case OP_READ:
+                    return stage(host.readFile(text(ptr, len)));
+                case OP_STAT: {
+                    const s = host.stat(text(ptr, len));
+                    return stage(`${s.kind} ${s.size} ${s.mtimeNs}`);
+                }
+                case OP_READ_DIR:
+                    return stage(host.readDir(text(ptr, len)).map(([kind, name]) => `${kind}${name}\0`).join(""));
+                case OP_REALPATH:
+                    return stage(host.realpath(text(ptr, len)));
+                case OP_WRITE:
+                case OP_APPEND: {
+                    const [path, data] = splitNul(ptr, len);
+                    host.writeFile(path, data, op === OP_APPEND);
+                    return stage("");
+                }
+                case OP_REMOVE:
+                    host.remove(text(ptr, len));
+                    return stage("");
+                case OP_CHTIMES: {
+                    const [path, rest] = splitNul(ptr, len);
+                    const [atime, mtime] = decoder.decode(rest).split("\0").map(BigInt);
+                    host.chtimes(path, atime, mtime);
+                    return stage("");
+                }
+                default:
+                    return -2 - stage(`unknown op ${op}`);
+            }
+        } catch (e) {
+            if (e instanceof NotFoundError) {
+                return -1;
+            }
+            return -2 - stage(String(e?.message ?? e));
+        }
+    };
+
+    const imports = { tsrs_host: { fs: fsCall, fs_take: (ptr) => bytes().set(staged, ptr) }, wasi_snapshot_preview1: {} };
+    for (const imp of WebAssembly.Module.imports(module)) {
+        if (imp.module === "wasi_snapshot_preview1") {
+            imports.wasi_snapshot_preview1[imp.name] = wasi[imp.name] ?? (() => ENOSYS);
+        }
+    }
+    const start = (inst) => {
+        instance = inst;
+        memory = instance.exports.memory;
+        return finish();
+    };
+    return { imports, start };
+
+    function finish() {
+    let exitCode;
+    let reply = new Uint8Array(0);
+    try {
+        instance.exports._initialize?.();
+        const fields = [request.cwd, String(request.flags ?? 0), ...request.args];
+        const req = encoder.encode(fields.join("\0"));
+        const ptr = instance.exports.tsrs_input(req.length);
+        bytes().set(req, ptr);
+        io.beforeRun?.(memory);
+        exitCode = instance.exports.tsrs_run();
+        const out = instance.exports.tsrs_output();
+        reply = bytes().slice(out, out + instance.exports.tsrs_output_len());
+    } catch (e) {
+        if (e instanceof WasiExit) {
+            exitCode = e.code;
+        } else if (isTrap(e)) {
+            stderr(encoder.encode(`error: tsrs.wasm trapped (${e.name}: ${e.message}); a stack overflow on deeply nested code or running out of memory are the usual causes\n`));
+            exitCode = EXIT_CRASHED;
+        } else {
+            throw e;
+        }
+    }
+    io.afterRun?.(memory);
+    return { exitCode, reply, memoryBytes: memory.buffer.byteLength };
+    }
+}
+
+// A trap ends the run without proc_exit: a shadow-stack overflow (the stack is first in memory, so it faults as an
+// out-of-bounds access), an allocation failure (Rust aborts with `unreachable`), or the engine's own stack running
+// out (V8 throws a RangeError there).
+function isTrap(e) {
+    return e instanceof WebAssembly.RuntimeError || (e instanceof RangeError && /call stack/i.test(e.message));
+}
+
+/**
+ * Runs one tsc invocation in a fresh instance of `module` (a compiled WebAssembly.Module).
+ * request: { cwd, args, flags }; host: a HostFileSystem; io: { env, stdout(bytes), stderr(bytes), beforeRun(memory),
+ * afterRun(memory) } (the run hooks let a harness inspect linear memory, e.g. the shadow-stack census).
+ * Returns { exitCode, reply (Uint8Array), memoryBytes }. A trap returns exitCode EXIT_CRASHED with a message on stderr.
+ */
+export function runTsc(module, request, host, io = {}) {
+    const run = prepare(module, request, host, io);
+    return run.start(new WebAssembly.Instance(module, run.imports));
+}
+
+/** `runTsc` with an asynchronous instantiation (browsers forbid a synchronous one of a large module on the page). */
+export async function runTscAsync(module, request, host, io = {}) {
+    const run = prepare(module, request, host, io);
+    return run.start(await WebAssembly.instantiate(module, run.imports));
+}
+
+/** The tsc argument list plus the request flags, as `runTsc` takes them. */
+export function makeRequest(args, { cwd, json = false, caseInsensitive = false, tty = false }) {
+    let flags = 0;
+    if (json) flags |= REQUEST_JSON_DIAGNOSTICS;
+    if (caseInsensitive) flags |= REQUEST_CASE_INSENSITIVE;
+    if (tty) flags |= REQUEST_TTY;
+    return { cwd, args, flags };
+}
+
+function normalize(path) {
+    const parts = [];
+    for (const part of path.replace(/\\/g, "/").split("/")) {
+        if (part === "" || part === ".") continue;
+        if (part === "..") parts.pop();
+        else parts.push(part);
+    }
+    return "/" + parts.join("/");
+}
+
+/**
+ * An in-memory HostFileSystem over a map of absolute path -> contents (string or Uint8Array). Directories are implied
+ * by the paths below them. `written` collects every file the compiler writes (decoded as UTF-8, BOM kept). With
+ * `caseInsensitive`, lookups ignore case (as on macOS's default file system) and names keep the case they were
+ * written with.
+ */
+export function memoryFileSystem(files = {}, { caseInsensitive = false } = {}) {
+    const fold = caseInsensitive ? (p) => p.toLowerCase() : (p) => p;
+    const map = new Map(); // folded path -> { path, data }
+    const put = (p, data) => map.set(fold(p), { path: p, data });
+    for (const [path, data] of Object.entries(files)) {
+        put(normalize(path), typeof data === "string" ? encoder.encode(data) : data);
+    }
+    const written = new Map();
+    const isDir = (folded) => {
+        if (folded === "/") return true;
+        const prefix = folded + "/";
+        for (const key of map.keys()) {
+            if (key.startsWith(prefix)) return true;
+        }
+        return false;
+    };
+    return {
+        written,
+        files: map,
+        readFile(path) {
+            const entry = map.get(fold(normalize(path)));
+            if (entry === undefined) throw new NotFoundError(path);
+            return entry.data;
+        },
+        stat(path) {
+            const p = fold(normalize(path));
+            const entry = map.get(p);
+            if (entry !== undefined) return { kind: "f", size: entry.data.length, mtimeNs: 0n };
+            if (isDir(p)) return { kind: "d", size: 0, mtimeNs: 0n };
+            throw new NotFoundError(path);
+        },
+        readDir(path) {
+            const p = fold(normalize(path));
+            if (!isDir(p)) throw new NotFoundError(path);
+            const prefix = p === "/" ? "/" : p + "/";
+            const entries = new Map();
+            for (const [key, entry] of map) {
+                if (!key.startsWith(prefix)) continue;
+                const rest = entry.path.slice(prefix.length);
+                const slash = rest.indexOf("/");
+                if (slash < 0) entries.set(rest, "f");
+                else entries.set(rest.slice(0, slash), "d");
+            }
+            return [...entries].map(([name, kind]) => [kind, name]);
+        },
+        realpath(path) {
+            return normalize(path);
+        },
+        writeFile(path, data, append) {
+            const p = normalize(path);
+            const prev = append ? map.get(fold(p))?.data ?? new Uint8Array(0) : new Uint8Array(0);
+            const next = new Uint8Array(prev.length + data.length);
+            next.set(prev);
+            next.set(data, prev.length);
+            put(map.get(fold(p))?.path ?? p, next);
+            written.set(map.get(fold(p)).path, decoder.decode(next));
+        },
+        remove(path) {
+            const p = fold(normalize(path));
+            for (const [key, entry] of [...map]) {
+                if (key === p || key.startsWith(p + "/")) {
+                    map.delete(key);
+                    written.delete(entry.path);
+                }
+            }
+        },
+        chtimes() {},
+    };
+}
+
+/** Parses the JSON reply of a REQUEST_JSON_DIAGNOSTICS run. */
+export function parseReply(reply) {
+    return reply.length === 0 ? [] : JSON.parse(decoder.decode(reply));
+}

package/index.d.ts

@@ -0,0 +1,42 @@
+import type { Diagnostic, WasmModule } from "./core.js";
+
+export type { Diagnostic, HostFileSystem, MemoryFileSystem, WasmModule } from "./core.js";
+
+export interface TscOptions {
+    /** The current directory (Node: process.cwd() on the real file system; "/" with `files`). */
+    cwd?: string;
+    /** Run over these in-memory files (absolute path -> contents) instead of the real file system. */
+    files?: Record<string, string | Uint8Array>;
+    /** Environment variables the compiler sees (none by default). */
+    env?: Record<string, string | undefined>;
+    /** "json": return the diagnostics as `diagnostics` instead of printing them (not with --build). */
+    diagnostics?: "text" | "json";
+    /** stdout is a terminal (the default for --pretty). */
+    tty?: boolean;
+    /** Node: "inherit" writes to this process's fd 1 / fd 2; collected into the result otherwise. */
+    stdout?: "inherit" | "collect";
+    stderr?: "inherit" | "collect";
+    caseInsensitive?: boolean;
+    /** Node: the worker's stack in MB (default 256). */
+    stackSizeMb?: number;
+    /** Browser: an already compiled module, or where to fetch tsrs.wasm from. */
+    module?: WasmModule;
+    url?: string | { readonly href: string };
+}
+
+export interface TscResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    diagnostics?: Diagnostic[];
+    /** With `files`: what the compiler wrote, path -> text. */
+    files?: Record<string, string>;
+    /** Linear memory at the end of the run, in bytes (the peak; it never shrinks). */
+    memoryBytes: number;
+}
+
+/** Runs tsc with these arguments. Each call uses a fresh module instance. */
+export declare function tsc(args: string[], options?: TscOptions): Promise<TscResult>;
+
+/** Node: the compiled module. Browser: loads and compiles it (from `url`, default ./tsrs.wasm next to browser.js). */
+export declare function loadModule(url?: string | { readonly href: string }): WasmModule | Promise<WasmModule>;

package/node-fs.js

@@ -0,0 +1,117 @@
+// The real file system as a HostFileSystem for core.js, matching native tsrs's osvfs: write errors are Rust's
+// `io::Error` texts ("<strerror> (os error N)"), realpath is the kernel's on Linux and a symlink walk elsewhere,
+// writes create missing parent directories, remove is recursive and ignores a missing path.
+
+import fs from "node:fs";
+import path from "node:path";
+import { NotFoundError } from "./core.js";
+
+const STRERROR = {
+    EACCES: "Permission denied",
+    ENOENT: "No such file or directory",
+    ENOTDIR: "Not a directory",
+    EISDIR: "Is a directory",
+    EEXIST: "File exists",
+    ENOSPC: "No space left on device",
+    EROFS: "Read-only file system",
+    ELOOP: "Too many levels of symbolic links",
+    ENAMETOOLONG: "File name too long",
+    EPERM: "Operation not permitted",
+    ENOTEMPTY: "Directory not empty",
+    EBUSY: "Resource busy",
+};
+
+/** Rust's `io::Error` display for a Node error. */
+export function osErrorText(e) {
+    if (typeof e?.errno === "number" && STRERROR[e.code]) {
+        return `${STRERROR[e.code]} (os error ${-e.errno})`;
+    }
+    return String(e?.message ?? e);
+}
+
+function rethrow(e) {
+    throw new Error(osErrorText(e));
+}
+
+const realpath = process.platform === "linux" ? fs.realpathSync.native : fs.realpathSync;
+
+function write(p, data, append) {
+    if (append) fs.appendFileSync(p, data);
+    else fs.writeFileSync(p, data);
+}
+
+/** Whether the file system holding Node's executable is case-insensitive (osvfs probes its own executable). */
+export function isCaseInsensitive() {
+    const exe = process.execPath;
+    const swapped = [...exe].map((c) => (c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase())).join("");
+    return swapped !== exe && fs.existsSync(swapped);
+}
+
+export function nodeFileSystem() {
+    return {
+        readFile(p) {
+            try {
+                return fs.readFileSync(p);
+            } catch (e) {
+                if (e.code === "ENOENT") throw new NotFoundError(p);
+                rethrow(e);
+            }
+        },
+        stat(p) {
+            let s;
+            try {
+                s = fs.statSync(p, { bigint: true, throwIfNoEntry: false });
+            } catch (e) {
+                rethrow(e);
+            }
+            if (!s) throw new NotFoundError(p);
+            return { kind: s.isDirectory() ? "d" : s.isFile() ? "f" : "o", size: s.size, mtimeNs: s.mtimeNs };
+        },
+        readDir(p) {
+            let entries;
+            try {
+                entries = fs.readdirSync(p, { withFileTypes: true });
+            } catch (e) {
+                if (e.code === "ENOENT") throw new NotFoundError(p);
+                rethrow(e);
+            }
+            return entries.map((d) => [d.isDirectory() ? "d" : d.isFile() ? "f" : d.isSymbolicLink() ? "l" : "o", d.name]);
+        },
+        realpath(p) {
+            return realpath(p);
+        },
+        writeFile(p, data, append) {
+            try {
+                write(p, data, append);
+                return;
+            } catch {
+                // As osvfs: create the directory, then write again; errors come from those two steps.
+            }
+            try {
+                fs.mkdirSync(path.dirname(p), { recursive: true });
+                write(p, data, append);
+            } catch (e) {
+                rethrow(e);
+            }
+        },
+        remove(p) {
+            let s;
+            try {
+                s = fs.lstatSync(p, { throwIfNoEntry: false });
+                if (!s) return;
+                // unlink for a symlink: rmSync throws EISDIR on a symlink to a directory (Node 24).
+                if (s.isDirectory()) fs.rmSync(p, { recursive: true, force: true });
+                else fs.unlinkSync(p);
+            } catch (e) {
+                rethrow(e);
+            }
+        },
+        chtimes(p, atimeNs, mtimeNs) {
+            try {
+                fs.utimesSync(p, Number(atimeNs) / 1e9, Number(mtimeNs) / 1e9);
+            } catch (e) {
+                rethrow(e);
+            }
+        },
+    };
+}

package/node-run.js

@@ -0,0 +1,55 @@
+// One tsc run on the current thread: the request, the file system (real or in-memory) and the output streams.
+import fs from "node:fs";
+import { makeRequest, memoryFileSystem, parseReply, runTsc } from "./core.js";
+import { isCaseInsensitive, nodeFileSystem } from "./node-fs.js";
+
+const SLEEP = new Int32Array(new SharedArrayBuffer(4));
+
+/** Writes all of `chunk` to `fd`, waiting out EAGAIN (a non-blocking pipe) and dropping the rest on EPIPE. */
+export function writeAll(fd, chunk) {
+    let off = 0;
+    while (off < chunk.length) {
+        try {
+            off += fs.writeSync(fd, chunk, off, chunk.length - off);
+        } catch (e) {
+            if (e.code === "EAGAIN") {
+                Atomics.wait(SLEEP, 0, 0, 1);
+                continue;
+            }
+            if (e.code === "EPIPE") return;
+            throw e;
+        }
+    }
+}
+
+function sink(mode, fd, chunks) {
+    if (mode === "inherit") return (chunk) => writeAll(fd, chunk);
+    return (chunk) => chunks.push(chunk);
+}
+
+/** hooks: { beforeRun(memory), afterRun(memory) } (see core.js runTsc). */
+export function run(module, options, hooks = {}) {
+    const caseInsensitive = options.caseInsensitive ?? (options.files ? false : isCaseInsensitive());
+    const memory = options.files ? memoryFileSystem(options.files, { caseInsensitive }) : null;
+    const host = memory ?? nodeFileSystem();
+    const cwd = options.cwd ?? (memory ? "/" : process.cwd());
+    const json = options.diagnostics === "json";
+    const out = [];
+    const err = [];
+    const request = makeRequest(options.args, { cwd, json, caseInsensitive, tty: !!options.tty });
+    const result = runTsc(module, request, host, {
+        env: options.env ?? {},
+        stdout: sink(options.stdout, 1, out),
+        stderr: sink(options.stderr, 2, err),
+        ...hooks,
+    });
+    const text = (chunks) => Buffer.concat(chunks).toString("utf8");
+    return {
+        exitCode: result.exitCode,
+        stdout: text(out),
+        stderr: text(err),
+        diagnostics: json ? parseReply(result.reply) : undefined,
+        files: memory ? Object.fromEntries(memory.written) : undefined,
+        memoryBytes: result.memoryBytes,
+    };
+}

package/node-worker.js

@@ -0,0 +1,5 @@
+// Runs one tsc request in a worker thread (node.js posts the compiled module and the options).
+import { parentPort, workerData } from "node:worker_threads";
+import { run } from "./node-run.js";
+
+parentPort.postMessage(run(workerData.module, workerData.options));