visaljs 0.0.3 → 0.0.4

package/README.md

@@ -9,7 +9,9 @@ visaljs build app.js -o app
 ./app
 ```
 
-Needs Node 22 or later and a C compiler (`cc`, `gcc` or `clang`). Linux and macOS for now; on Windows, run it under WSL.
+Needs Node 22 or later and a C compiler (`cc`, `gcc` or `clang`). Linux and macOS; on Windows,
+a clang-family compiler: [Zig](https://ziglang.org/) (`winget install zig.zig`) or LLVM-MinGW
+(MSVC isn't supported yet).
 The C runtime is built on first use and cached in `~/.cache/visaljs`.
 
 `visaljs build` reports each step as it goes:

package/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { isBuiltin } from "node:module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import ts from "typescript";
 import { rolldown } from "rolldown";
@@ -113,7 +113,7 @@ function parse(text, file, module, map, entry, hostPrimitives = {}) {
 function locAt(sf, pos, map) {
 	const { line, character } = sf.getLineAndCharacterOfPosition(pos);
 	const loc = {
-		file: sf.fileName,
+		file: normalize(sf.fileName),
 		line: line + 1,
 		column: character + 1
 	};
@@ -248,7 +248,7 @@ var Converter = class {
 		return {
 			type: "Program",
 			loc: {
-				file: this.sf.fileName,
+				file: normalize(this.sf.fileName),
 				line: 1,
 				column: 1
 			},
@@ -6982,9 +6982,15 @@ function boringsslLibrary() {
 		name: "boringssl",
 		sources: [...parts.flatMap((p) => [...p.srcs, ...p.asm]).map(at), join(RUNTIME_DIR, "src", "boringssl_support.cc")],
 		headers: parts.flatMap((p) => [...p.hdrs ?? [], ...p.internal_hdrs ?? []]).map(at),
-		flags: [`-I${join(BORINGSSL, "include")}`]
+		flags: [`-I${join(BORINGSSL, "include")}`, ...process.platform === "win32" ? BORINGSSL_WINDOWS : []]
 	};
 }
+const BORINGSSL_WINDOWS = [
+	"-DWIN32_LEAN_AND_MEAN",
+	"-DNOMINMAX",
+	"-D_HAS_EXCEPTIONS=0",
+	...process.arch === "x64" ? ["-DOPENSSL_NO_ASM"] : []
+];
 /** The runtime's libraries, in link order: libjsrt, then the libraries it uses. */
 function runtimeLibraries() {
 	return [runtimeLibrary(), boringsslLibrary()];
@@ -7590,38 +7596,84 @@ const UV_UNIX = [
 	"tty",
 	"udp",
 	"proctitle"
-];
+].map((f) => `unix/${f}`);
 const UV_PLATFORM = {
 	linux: {
-		sources: [
+		sources: [...UV_UNIX, ...[
 			"linux",
 			"procfs-exepath",
 			"random-getrandom",
 			"random-sysctl-linux"
-		],
+		].map((f) => `unix/${f}`)],
 		defines: ["_GNU_SOURCE", "_POSIX_C_SOURCE=200112"]
 	},
 	darwin: {
-		sources: [
+		sources: [...UV_UNIX, ...[
 			"random-getentropy",
 			"darwin-proctitle",
 			"darwin",
 			"fsevents",
 			"bsd-ifaddrs",
 			"kqueue"
-		],
+		].map((f) => `unix/${f}`)],
 		defines: ["_DARWIN_UNLIMITED_SELECT=1", "_DARWIN_USE_64_BIT_INODE=1"]
+	},
+	win32: {
+		sources: [
+			"async",
+			"core",
+			"detect-wakeup",
+			"dl",
+			"error",
+			"fs",
+			"fs-event",
+			"getaddrinfo",
+			"getnameinfo",
+			"handle",
+			"loop-watcher",
+			"pipe",
+			"thread",
+			"poll",
+			"process",
+			"process-stdio",
+			"signal",
+			"snprintf",
+			"stream",
+			"tcp",
+			"tty",
+			"udp",
+			"util",
+			"winapi",
+			"winsock"
+		].map((f) => `win/${f}`),
+		defines: [
+			"WIN32_LEAN_AND_MEAN",
+			"_WIN32_WINNT=0x0A00",
+			"_CRT_DECLARE_NONSTDC_NAMES=0"
+		],
+		link: [
+			"psapi",
+			"user32",
+			"advapi32",
+			"iphlpapi",
+			"userenv",
+			"ws2_32",
+			"dbghelp",
+			"ole32",
+			"shell32"
+		]
 	}
 };
 /** The C libraries to build and link (before libjsrt, which they use). */
 function libraries(runtimeInclude) {
 	const uv = UV_PLATFORM[process.platform];
-	const uvSources = uv ? [...UV_COMMON.map((f) => join(UV, "src", `${f}.c`)), ...[...UV_UNIX, ...uv.sources].map((f) => join(UV, "src", "unix", `${f}.c`))] : [];
+	const uvSources = uv ? [...UV_COMMON, ...uv.sources].map((f) => join(UV, "src", `${f}.c`)) : [];
 	const uvHeaders = [
 		join(UV, "include"),
 		join(UV, "include", "uv"),
 		join(UV, "src"),
-		join(UV, "src", "unix")
+		join(UV, "src", "unix"),
+		join(UV, "src", "win")
 	].flatMap((d) => files(d, ".h"));
 	return [{
 		name: "jsnode",
@@ -7651,7 +7703,8 @@ function libraries(runtimeInclude) {
 			...(uv?.defines ?? []).map((d) => `-D${d}`),
 			`-I${join(UV, "include")}`,
 			`-I${join(UV, "src")}`
-		]
+		],
+		link: uv?.link ?? []
 	}];
 }
 //#endregion
@@ -7673,7 +7726,7 @@ function hostPrimitives(hosts) {
 /** A bundling failure, already formatted as `file:line:col: Kind: message` lines. */
 var BundleError = class extends Error {};
 /** Bundles `entry` with the ADR 0009 configuration, `node:*` imports resolved to the host
-*  packages' modules. Warnings go to `warn`. */
+*  packages' modules. Warnings go to `warn`, with their location ("file:line:col: ", or ""). */
 async function bundle(entry, hosts, warn) {
 	try {
 		const build = await rolldown({
@@ -7681,7 +7734,7 @@ async function bundle(entry, hosts, warn) {
 			cwd: dirname(resolve(entry)),
 			platform: "node",
 			logLevel: "warn",
-			onLog: (_level, log) => warn(formatLog(log, "warning")),
+			onLog: (_level, log) => log.code !== "EVAL" && warn(logText(log), logWhere(log)),
 			plugins: [hostModules(hosts)]
 		});
 		try {
@@ -7751,8 +7804,14 @@ module.exports = m;
 const REQUIRED = "\0visaljs-require:";
 /** rolldown's messages carry ANSI colors and a code frame: keep the first line, without the `[CODE]` tag. */
 function formatLog(log, kind) {
-	const text = log.message.replace(/\x1b\[[0-9;]*m/g, "").split("\n")[0].replace(/^\[[A-Z_]+\] /, "").trim();
-	return `${log.loc ? `${log.loc.file ?? log.id}:${log.loc.line}:${log.loc.column + 1}: ` : log.id ? `${log.id}: ` : ""}${kind}: ${text}`;
+	return `${logWhere(log)}${kind}: ${logText(log)}`;
+}
+function logText(log) {
+	return log.message.replace(/\x1b\[[0-9;]*m/g, "").split("\n")[0].replace(/^\[[A-Z_]+\] /, "").trim();
+}
+/** "file:line:col: ", "file: ", or "". */
+function logWhere(log) {
+	return log.loc ? `${log.loc.file ?? log.id}:${log.loc.line}:${log.loc.column + 1}: ` : log.id ? `${log.id}: ` : "";
 }
 //#endregion
 //#region cli/src/cc.ts
@@ -7979,9 +8038,11 @@ function regexpCompiler(cc) {
 	return tool;
 }
 /** A program's archives, in link order: the host packages' libraries, then libjsrt (which they
-*  use). Each is built the first time; `building` hears about it. */
+*  use), then the system libraries they need (-l…). Each is built the first time; `building`
+*  hears about it. */
 function programArchives(tc, hosts, building) {
-	return [...hosts.flatMap((h) => h.libraries(RUNTIME_INCLUDE)).filter((l) => l.sources.length), ...runtimeLibraries()].map((l) => libraryArchive(tc, l, building));
+	const libraries = [...hosts.flatMap((h) => h.libraries(RUNTIME_INCLUDE)).filter((l) => l.sources.length), ...runtimeLibraries()];
+	return [...libraries.map((l) => libraryArchive(tc, l, building)), ...libraries.flatMap((l) => l.link ?? []).map((l) => `-l${l}`)];
 }
 /** Compiles program.c and links it with `archives` (programArchives). The linker takes only
 *  what the program reaches: a program without I/O links no libuv. The libraries keep their
@@ -8030,6 +8091,68 @@ function scratchDir() {
 	return dir;
 }
 //#endregion
+//#region cli/src/eval.ts
+/** Calls of the global eval that may get source text, and of the global Function (with or
+*  without new), in source order. Aliases (`const F = Function`) aren't followed. */
+function evalCalls(program, info) {
+	const out = [];
+	const global = (callee, name) => callee.type === "Identifier" && callee.name === name && info.references.get(callee)?.binding === null;
+	const walk = (node) => {
+		if (Array.isArray(node)) {
+			for (const x of node) walk(x);
+			return;
+		}
+		if (node === null || typeof node !== "object") return;
+		const n = node;
+		if (n.type === "CallExpression" || n.type === "NewExpression") {
+			if (global(n.callee, "Function")) out.push({
+				kind: "Function",
+				loc: n.loc
+			});
+			else if (n.type === "CallExpression" && global(n.callee, "eval") && mayBeString(n.arguments[0])) out.push({
+				kind: "eval",
+				loc: n.loc
+			});
+		}
+		for (const [key, value] of Object.entries(node)) if (key !== "loc" && value !== null && typeof value === "object") walk(value);
+	};
+	walk(program.body);
+	return out;
+}
+function mayBeString(arg) {
+	if (!arg) return false;
+	switch (arg.type) {
+		case "Literal": return typeof arg.value === "string";
+		case "BigIntLiteral":
+		case "ObjectExpression":
+		case "ArrayExpression":
+		case "FunctionExpression": return false;
+		default: return true;
+	}
+}
+/** The warning's message (null: no calls), and with `verbose` a line per call. */
+function evalWarning(calls, verbose) {
+	if (calls.length === 0) return null;
+	const n = (kind) => calls.filter((c) => c.kind === kind).length;
+	const places = (k) => `${k} ${k === 1 ? "place" : "places"}`;
+	const parts = [];
+	if (n("eval")) parts.push(`eval() of source text in ${places(n("eval"))}`);
+	if (n("Function")) parts.push(`new Function() in ${places(n("Function"))}`);
+	const owners = [...new Set(calls.map((c) => packageOf(c.loc.file) ?? "your code"))];
+	let text = `the program uses ${parts.join(" and ")} (in ${owners.join(", ")}): compiled code can't evaluate source text, so ${calls.length === 1 ? "it throws" : "they throw"} a TypeError if reached`;
+	if (verbose) text += calls.map((c) => `\n  ${c.loc.file}:${c.loc.line}:${c.loc.column}: ${c.kind === "eval" ? "eval()" : "new Function()"}`).join("");
+	else text += "\n  (--verbose lists them)";
+	return text;
+}
+/** The npm package a file belongs to: the last node_modules/<name> (or @scope/name) in its path. */
+function packageOf(file) {
+	const parts = file.split(/[\\/]/);
+	const i = parts.lastIndexOf("node_modules");
+	if (i < 0 || i + 1 >= parts.length) return null;
+	const name = parts[i + 1];
+	return name.startsWith("@") && i + 2 < parts.length ? `${name}/${parts[i + 2]}` : name;
+}
+//#endregion
 //#region cli/src/regexp.ts
 /** The program's regex literals, in source order. */
 function regexpLiterals(program) {
@@ -8066,7 +8189,7 @@ function compileRegExps(cc, literals) {
 		maxBuffer: 1 << 30
 	});
 	if (run.status !== 0) throw new Error(`regexp-compile failed: ${run.stderr || run.error?.message}`);
-	const lines = run.stdout.split("\n");
+	const lines = run.stdout.split(/\r?\n/);
 	let i = 0;
 	for (const [key, lit] of todo) {
 		const line = lines[i++] ?? "";
@@ -8141,6 +8264,10 @@ var Report = class {
 		this.#write(`${text}\n`);
 		if (this.#live && this.#running) this.#draw();
 	}
+	/** A warning, after its location (`where`, if any): printed even when quiet, its label in yellow. */
+	warn(message, where = "") {
+		this.note(`${where}${this.#paint("1;33", "warning:")} ${message}`);
+	}
 	/** The last line, given the whole build's time. */
 	finish(icon, text) {
 		if (this.#style) this.#write(`\n ${icon} ${this.#paint("1", text(since(this.#start)))}\n`);
@@ -8189,7 +8316,7 @@ function lineCount(text) {
 }
 //#endregion
 //#region cli/src/main.ts
-const VERSION = "0.0.3";
+const VERSION = "0.0.4";
 const USAGE = `usage: visaljs build <entry.js> [options]
 
 options:
@@ -8203,6 +8330,7 @@ options:
   --no-bundle        skip the bundler: the input is one ES module (a bundle)
   --script           compile as a classic script (sloppy mode, no bundler)
   -q, --quiet        don't report each step of the build
+  --verbose          list each place a warning is about
   --version          print the version
   --help             print this help
 `;
@@ -8230,6 +8358,7 @@ async function main(argv, io) {
 					type: "boolean",
 					short: "q"
 				},
+				verbose: { type: "boolean" },
 				version: { type: "boolean" },
 				help: {
 					type: "boolean",
@@ -8250,10 +8379,6 @@ async function main(argv, io) {
 		io.stdout(USAGE);
 		return values.help ? 0 : 2;
 	}
-	if ((io.platform ?? process.platform) === "win32") {
-		io.stderr("visaljs: Windows is not supported yet; use Linux or macOS (on Windows, WSL works)\n");
-		return 1;
-	}
 	const [command, ...rest] = positionals;
 	switch (command) {
 		case "build":
@@ -8291,7 +8416,7 @@ async function build(entry, options, io) {
 	const bundled = !script && options["no-bundle"] !== true;
 	let map;
 	if (bundled) try {
-		const b = await report.step("📦", "Rolling the modules into a single file", () => bundle(entry, hosts, (message) => report.note(message)), (b) => `Rolled ${count(b.modules, "module")} into a single file (${size(Buffer.byteLength(b.code))})`);
+		const b = await report.step("📦", "Rolling the modules into a single file", () => bundle(entry, hosts, (message, where) => report.warn(message, where)), (b) => `Rolled ${count(b.modules, "module")} into a single file (${size(Buffer.byteLength(b.code))})`);
 		source = b.code;
 		if (b.map) map = new SourceMap(b.map, displayPath);
 	} catch (e) {
@@ -8307,6 +8432,8 @@ async function build(entry, options, io) {
 			return 0;
 		}
 		const info = analyze(ast);
+		const evalWarn = evalWarning(evalCalls(ast, info), options.verbose === true);
+		if (evalWarn) report.warn(evalWarn);
 		const literals = regexpLiterals(ast);
 		const regexps = literals.length ? await report.step("🧩", "Compiling the regular expressions", () => withCompiler(compilers ??= findCompilers(), report, (cc) => compileRegExps(cc, literals)), () => `Compiled ${count(literals.length, "regular expression")}`) : /* @__PURE__ */ new Map();
 		const unsupported = firstUnsupported(ast);
@@ -8337,7 +8464,8 @@ async function build(entry, options, io) {
 		report.finish("📂", (time) => `Wrote ${displayPath(resolve(options["emit-c"], "program.c"))} in ${time}`);
 		return 0;
 	}
-	const output = options.output ?? basename(entry).replace(/\.[cm]?js$/, "");
+	let output = options.output ?? basename(entry).replace(/\.[cm]?js$/, "");
+	if (process.platform === "win32" && !extname(output)) output += ".exe";
 	const opt = options.debug ? ["-O0"] : ["-O2"];
 	const dir = scratchDir();
 	try {
@@ -8398,7 +8526,7 @@ async function withCompiler(compilers, report, run) {
 function displayPath(source) {
 	if (source.startsWith("\0")) return source.slice(1);
 	const rel = relative(process.cwd(), source);
-	return rel.startsWith("..") || isAbsolute(rel) ? source : rel;
+	return rel.startsWith("..") || isAbsolute(rel) ? normalize(source) : rel;
 }
 //#endregion
 //#region cli/src/cli.ts

package/node/include/js_node.h

@@ -14,6 +14,8 @@ JSValue js_host_fs_exists(JSContext *ctx, JSValue callee, JSValue this_val, uint
 JSValue js_host_fs_unlink(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 
 /* host_sys.c */
+/* A C errno as the libuv error code Node reports (-ENOENT on POSIX; UV_ENOENT, -4058, on Windows). */
+int js_node_uv_error(int e);
 JSValue js_host_errno_name(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_timer_unref(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_tty_isatty(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);

package/node/prelude/internal/tls/wrap.js

@@ -7,7 +7,7 @@
 // to the transport. The transport is a net.Socket's handle, taken over as Node's TLSWrap takes
 // it (its events come to the TLSSocket), or any Duplex stream (Node's JSStreamSocket case).
 import {
-  netReadStart, netReadStop, netShutdown, netWrite, tlsExportKeyingMaterial, tlsFinished, tlsInfo, tlsNew, tlsPeerCerts,
+  errnoName, netReadStart, netReadStop, netShutdown, netWrite, tlsExportKeyingMaterial, tlsFinished, tlsInfo, tlsNew, tlsPeerCerts,
   tlsRootCertificates, tlsRun, tlsSession, tlsSetNoRenegotiation, tlsShutdown, tlsVerifyError,
 } from "visaljs:host";
 import { codeError, invalidArgType, outOfRange, validateFunction, validateString } from "../errors.js";
@@ -31,9 +31,12 @@ const kPendingSession = Symbol("pendingSession");
 
 const connReset = (message) => codeError(Error, "ECONNRESET", message);
 
+/** `read ECONNRESET`: a read fails so on Windows, where the peer's reset isn't an end first */
 function errnoException(errno, syscall) {
-  const e = new Error(syscall + " " + errno);
+  const code = errnoName(errno);
+  const e = new Error(syscall + " " + code);
   e.errno = errno;
+  e.code = code;
   e.syscall = syscall;
   return e;
 }

package/node/prelude/net.js

@@ -23,7 +23,6 @@ export { BlockList, isIP, isIPv4, isIPv6, SocketAddress };
 const NET_CONNECTION = 0, NET_READ = 1, NET_CONNECT = 2, NET_WRITE = 3, NET_SHUTDOWN = 4, NET_CLOSE = 5;
 const UV_EOF = -4095;
 const UV_EINVAL = -22;
-const UV_ENOTCONN = -107;
 const TIMEOUT_MAX = 2 ** 31 - 1;
 
 /* a monotonic clock in ms */
@@ -506,7 +505,7 @@ export class Socket extends Duplex {
       return;
     }
     const err = netShutdown(this._handle);
-    if (err === UV_ENOTCONN) cb();
+    if (err < 0 && errnoName(err) === "ENOTCONN") cb();  /* by name: libuv's code differs by platform */
     else if (err < 0) cb(errnoException(err, "shutdown"));
     else this._shutdownCallback = () => cb();
   }

package/node/prelude/os.js

@@ -12,8 +12,8 @@ const check = (result, syscall) => {
 };
 const uname = () => check(osUname(), "uv_os_uname");
 
-export const EOL = "\n";
-export const devNull = "/dev/null";
+export const EOL = process.platform === "win32" ? "\r\n" : "\n";
+export const devNull = process.platform === "win32" ? "\\\\.\\nul" : "/dev/null";
 
 export function arch() {
   return process.arch;

package/node/src/host_fs.c

@@ -16,6 +16,7 @@
 
 #ifdef _WIN32
 #include <io.h>
+#include <sys/stat.h>
 #define access _access
 #define unlink _unlink
 #define F_OK 0
@@ -40,7 +41,7 @@ char *js_host_path_arg(JSContext *ctx, uint32_t argc, const JSValue *argv, uint3
 }
 
 static JSValue errno_result(int e) {
-    return js_int32(-(e ? e : EIO));
+    return js_int32(js_node_uv_error(e ? e : EIO));
 }
 
 /* fsReadFile(path, bytes): the file's contents as a Buffer when `bytes`, else decoded as UTF-8
@@ -51,8 +52,15 @@ JSValue js_host_fs_read_file(JSContext *ctx, JSValue callee, JSValue this_val, u
     char *path = js_host_path_arg(ctx, argc, argv, 0);
     if (!path) return JS_EXCEPTION;
     FILE *f = fopen(path, "rb");
+    int e = errno;
+#ifdef _WIN32
+    /* Windows won't open a directory as a file (EACCES); elsewhere the open succeeds and the read
+     * fails with EISDIR, which Node reports on Windows too */
+    struct _stat st;
+    if (!f && e == EACCES && _stat(path, &st) == 0 && (st.st_mode & _S_IFDIR)) e = EISDIR;
+#endif
     free(path);
-    if (!f) return errno_result(errno);
+    if (!f) return errno_result(e);
     size_t length = 0, cap = 4096;
     char *buf = malloc(cap);
     if (!buf) js_fatal("out of memory");

package/node/src/host_sys.c

@@ -1,11 +1,13 @@
 /* Host primitives shared by the prelude modules (ADR 0012): error names and messages for
  * -errno results, as libuv words them (Node's err.code and message). The working directory
  * (cwd) is the runtime's, for process.cwd(). */
+#define _POSIX_C_SOURCE 200809L  /* libuv's headers (the UV_E* codes): pthread_rwlock_t */
 #include "js_node.h"
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#include <uv.h>
 #ifdef _WIN32
 #include <io.h>
 #else
@@ -16,37 +18,47 @@
 #include "js_jobs.h"
 #include "jsstring.h"
 
-static const struct { int code; const char *name, *message; } ERRORS[] = {
-    { EPERM, "EPERM", "operation not permitted" },
-    { ENOENT, "ENOENT", "no such file or directory" },
-    { EIO, "EIO", "i/o error" },
-    { EBADF, "EBADF", "bad file descriptor" },
-    { EACCES, "EACCES", "permission denied" },
-    { EBUSY, "EBUSY", "resource busy or locked" },
-    { EEXIST, "EEXIST", "file already exists" },
-    { ENOTDIR, "ENOTDIR", "not a directory" },
-    { EISDIR, "EISDIR", "illegal operation on a directory" },
-    { EINVAL, "EINVAL", "invalid argument" },
-    { EMFILE, "EMFILE", "too many open files" },
-    { EFBIG, "EFBIG", "file too large" },
-    { ENOSPC, "ENOSPC", "no space left on device" },
-    { EROFS, "EROFS", "read-only file system" },
-    { ENAMETOOLONG, "ENAMETOOLONG", "name too long" },
-    { ENOTEMPTY, "ENOTEMPTY", "directory not empty" },
-    { ELOOP, "ELOOP", "too many symbolic links encountered" },
-    { EADDRINUSE, "EADDRINUSE", "address already in use" },
-    { EADDRNOTAVAIL, "EADDRNOTAVAIL", "address not available" },
-    { ECONNRESET, "ECONNRESET", "connection reset by peer" },
-    { ECONNREFUSED, "ECONNREFUSED", "connection refused" },
-    { EPIPE, "EPIPE", "broken pipe" },
-    { EAFNOSUPPORT, "EAFNOSUPPORT", "address family not supported" },
-    { ENOTCONN, "ENOTCONN", "socket is not connected" },
-    { ECONNABORTED, "ECONNABORTED", "software caused connection abort" },
-    { ETIMEDOUT, "ETIMEDOUT", "connection timed out" },
-    { ENETUNREACH, "ENETUNREACH", "network is unreachable" },
-    { EHOSTUNREACH, "EHOSTUNREACH", "host is unreachable" },
-    { ECANCELED, "ECANCELED", "operation canceled" },
+/* Each error by its C errno and its libuv code: the same number on POSIX, but on Windows libuv
+ * has codes of its own (UV_ECONNREFUSED is -4078) while the C library's errno has the C values. */
+#define E(name, message) { name, -UV_##name, #name, message }
+static const struct { int code, uv; const char *name, *message; } ERRORS[] = {
+    E(EPERM, "operation not permitted"),
+    E(ENOENT, "no such file or directory"),
+    E(EIO, "i/o error"),
+    E(EBADF, "bad file descriptor"),
+    E(EACCES, "permission denied"),
+    E(EBUSY, "resource busy or locked"),
+    E(EEXIST, "file already exists"),
+    E(ENOTDIR, "not a directory"),
+    E(EISDIR, "illegal operation on a directory"),
+    E(EINVAL, "invalid argument"),
+    E(EMFILE, "too many open files"),
+    E(EFBIG, "file too large"),
+    E(ENOSPC, "no space left on device"),
+    E(EROFS, "read-only file system"),
+    E(ENAMETOOLONG, "name too long"),
+    E(ENOTEMPTY, "directory not empty"),
+    E(ELOOP, "too many symbolic links encountered"),
+    E(EADDRINUSE, "address already in use"),
+    E(EADDRNOTAVAIL, "address not available"),
+    E(ECONNRESET, "connection reset by peer"),
+    E(ECONNREFUSED, "connection refused"),
+    E(EPIPE, "broken pipe"),
+    E(EAFNOSUPPORT, "address family not supported"),
+    E(ENOTCONN, "socket is not connected"),
+    E(ECONNABORTED, "software caused connection abort"),
+    E(ETIMEDOUT, "connection timed out"),
+    E(ENETUNREACH, "network is unreachable"),
+    E(EHOSTUNREACH, "host is unreachable"),
+    E(ECANCELED, "operation canceled"),
 };
+#undef E
+
+int js_node_uv_error(int e) {
+    for (size_t i = 0; i < sizeof ERRORS / sizeof ERRORS[0]; i++)
+        if (ERRORS[i].code == e) return -ERRORS[i].uv;
+    return -e;
+}
 
 static int errno_arg(uint32_t argc, const JSValue *argv) {
     return argc > 0 && js_is_int32(argv[0]) ? -js_as_int32(argv[0]) : 0;
@@ -58,7 +70,7 @@ JSValue js_host_errno_name(JSContext *ctx, JSValue callee, JSValue this_val, uin
     (void)callee, (void)this_val, (void)new_target;
     int e = errno_arg(argc, argv);
     for (size_t i = 0; i < sizeof ERRORS / sizeof ERRORS[0]; i++)
-        if (ERRORS[i].code == e) return js_new_string_cstr(ctx, ERRORS[i].name);
+        if (ERRORS[i].code == e || ERRORS[i].uv == e) return js_new_string_cstr(ctx, ERRORS[i].name);
     return js_new_string_cstr(ctx, "UNKNOWN");
 }
 
@@ -68,7 +80,7 @@ JSValue js_host_errno_message(JSContext *ctx, JSValue callee, JSValue this_val,
     (void)callee, (void)this_val, (void)new_target;
     int e = errno_arg(argc, argv);
     for (size_t i = 0; i < sizeof ERRORS / sizeof ERRORS[0]; i++)
-        if (ERRORS[i].code == e) return js_new_string_cstr(ctx, ERRORS[i].message);
+        if (ERRORS[i].code == e || ERRORS[i].uv == e) return js_new_string_cstr(ctx, ERRORS[i].message);
     return js_new_string_cstr(ctx, "unknown error");
 }