visaljs 0.0.0-stage → 0.0.2

package/node/include/js_node.h

@@ -0,0 +1,46 @@
+/* js_node.h — the Node platform's host primitives (ADR 0012): the C side of node/prelude.
+ * Prelude modules import them from "visaljs:host"; node/index.ts lists them for the
+ * compiler, which makes each a function object. Failures return -errno as a number, which the
+ * prelude turns into Node's error; only bad arguments throw here. */
+#ifndef JS_NODE_H
+#define JS_NODE_H
+
+#include "js_runtime.h"
+
+/* host_fs.c */
+JSValue js_host_fs_read_file(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_fs_write_file(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_fs_exists(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_fs_unlink(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* host_sys.c */
+JSValue js_host_errno_name(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);
+JSValue js_host_errno_message(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* host_http.c: TCP servers on libuv, requests parsed by llhttp (node:http) */
+JSValue js_host_http_listen(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_http_address(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_http_close_server(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_http_write(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_http_date(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_http_end(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* host_os.c: node:os through libuv */
+JSValue js_host_os_uname(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_hostname(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_homedir(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_tmpdir(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_memory(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_uptime(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_loadavg(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_parallelism(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_cpus(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_user_info(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_os_constants(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* A string argument as a NUL-terminated UTF-8 path (malloc'd; the caller frees it), or NULL
+ * with a TypeError pending. */
+char *js_host_path_arg(JSContext *ctx, uint32_t argc, const JSValue *argv, uint32_t i);
+
+#endif /* JS_NODE_H */

package/node/prelude/async_hooks.js

@@ -0,0 +1,88 @@
+// node:async_hooks (ADR 0012, layer 3): AsyncResource, which libraries use to keep a callback's
+// async context (on-finished, raw-body). visaljs keeps no async context: running "in" a resource
+// is calling the function, and hooks never fire. AsyncLocalStorage, which needs the context
+// carried through promises and timers, isn't provided yet.
+import { notSupported, validateFunction, validateString } from "./internal/errors.js";
+
+let nextAsyncId = 2;  /* 1 is the main program's, as in Node */
+
+export class AsyncResource {
+  #asyncId;
+  #triggerAsyncId;
+
+  constructor(type, opts = {}) {
+    validateString(type, "type");
+    this.#asyncId = nextAsyncId++;
+    this.#triggerAsyncId = typeof opts === "number" ? opts : (opts.triggerAsyncId ?? 1);
+  }
+
+  runInAsyncScope(fn, thisArg, ...args) {
+    return Reflect.apply(fn, thisArg, args);
+  }
+
+  emitDestroy() {
+    return this;
+  }
+
+  asyncId() {
+    return this.#asyncId;
+  }
+
+  triggerAsyncId() {
+    return this.#triggerAsyncId;
+  }
+
+  bind(fn, thisArg) {
+    validateFunction(fn, "fn");
+    const run = (self, args) => this.runInAsyncScope(fn, self, ...args);
+    const bound = thisArg === undefined
+      ? function (...args) {
+        return run(this, args);
+      }
+      : (...args) => run(thisArg, args);
+    Object.defineProperties(bound, {
+      length: { configurable: true, enumerable: false, value: fn.length, writable: false },
+      asyncResource: { configurable: true, enumerable: true, value: this, writable: true },
+    });
+    return bound;
+  }
+
+  static bind(fn, type, thisArg) {
+    type = type || fn.name || "bound-anonymous-fn";
+    return new AsyncResource(type).bind(fn, thisArg);
+  }
+}
+
+export function executionAsyncId() {
+  return 1;
+}
+
+export function triggerAsyncId() {
+  return 0;
+}
+
+export function executionAsyncResource() {
+  return {};
+}
+
+/** A hook that never fires: visaljs has no async resources to report. */
+export function createHook() {
+  return {
+    enable() {
+      return this;
+    },
+    disable() {
+      return this;
+    },
+  };
+}
+
+export class AsyncLocalStorage {
+  constructor() {
+    throw notSupported("AsyncLocalStorage");
+  }
+}
+
+export const asyncWrapProviders = Object.freeze({ __proto__: null });
+
+export default { AsyncResource, AsyncLocalStorage, createHook, executionAsyncId, triggerAsyncId, executionAsyncResource, asyncWrapProviders };

package/node/prelude/buffer.js

@@ -0,0 +1,31 @@
+// node:buffer (ADR 0012, layer 3): the globals Node also exports from the module (Buffer, Blob,
+// File, atob, btoa; Buffer is the buffer component's, in C) and the module's constants.
+export const Buffer = globalThis.Buffer;
+export const Blob = globalThis.Blob;
+export const File = globalThis.File;
+export const atob = globalThis.atob;
+export const btoa = globalThis.btoa;
+
+export const INSPECT_MAX_BYTES = 50;
+export const kMaxLength = 9007199254740991;
+export const kStringMaxLength = 536870888;
+export const constants = { MAX_LENGTH: kMaxLength, MAX_STRING_LENGTH: kStringMaxLength };
+
+export function isUtf8(input) {
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isAscii(input) {
+  const bytes = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  for (let i = 0; i < bytes.length; i++) if (bytes[i] > 127) return false;
+  return true;
+}
+
+export const SlowBuffer = Buffer;
+
+export default { Buffer, Blob, File, atob, btoa, INSPECT_MAX_BYTES, kMaxLength, kStringMaxLength, constants, isUtf8, isAscii, SlowBuffer };

package/node/prelude/crypto.js

@@ -0,0 +1,114 @@
+// node:crypto (ADR 0018, layer 3): Node's API over the runtime's crypto primitives (C, on
+// BearSSL), which Web Crypto (the `crypto` global, a runtime component) shares. What isn't
+// provided yet throws ERR_VISALJS_UNSUPPORTED when called.
+import { cryptoTimingSafeEqual } from "visaljs:host";
+import { codeError, notSupported } from "./internal/errors.js";
+import {
+  createECDH, createSign, createVerify, diffieHellman, ECDH, getCurves, privateDecrypt, privateEncrypt, publicDecrypt, publicEncrypt, Sign,
+  sign, Verify, verify,
+} from "./internal/crypto/asym.js";
+import { Cipheriv, createCipheriv, createDecipheriv, Decipheriv, getCipherInfo, getCiphers } from "./internal/crypto/cipher.js";
+import { createHash, createHmac, getHashes, Hash, hash, Hmac } from "./internal/crypto/hash.js";
+import {
+  createPrivateKey, createPublicKey, createSecretKey, generateKey, generateKeyPair, generateKeyPairSync, generateKeySync, KeyObject,
+} from "./internal/crypto/keys.js";
+import { hkdf, hkdfSync, pbkdf2, pbkdf2Sync, scrypt, scryptSync } from "./internal/crypto/kdf.js";
+import { randomBytes, randomFill, randomFillSync, randomInt, randomUUID } from "./internal/crypto/random.js";
+import { isAnyArrayBuffer, isArrayBufferView } from "./internal/crypto/util.js";
+
+export { createHash, createHmac, getHashes, Hash, hash, Hmac, randomBytes, randomFill, randomFillSync, randomInt, randomUUID };
+export { hkdf, hkdfSync, pbkdf2, pbkdf2Sync, scrypt, scryptSync };
+export { createPrivateKey, createPublicKey, createSecretKey, generateKey, generateKeyPair, generateKeyPairSync, generateKeySync, KeyObject };
+export { createECDH, createSign, createVerify, diffieHellman, ECDH, getCurves, privateDecrypt, privateEncrypt, publicDecrypt, publicEncrypt };
+export { Sign, sign, Verify, verify };
+export { Cipheriv, createCipheriv, createDecipheriv, Decipheriv, getCipherInfo, getCiphers };
+
+export const webcrypto = globalThis.crypto;
+export const subtle = webcrypto.subtle;
+
+export function getRandomValues(array) {
+  return webcrypto.getRandomValues(array);
+}
+
+export function timingSafeEqual(buf1, buf2) {
+  const check = (v, name) => {
+    if (!isAnyArrayBuffer(v) && !isArrayBufferView(v)) {
+      throw codeError(TypeError, "ERR_INVALID_ARG_TYPE", `The "${name}" argument must be an instance of ArrayBuffer, Buffer, TypedArray, or DataView.`);
+    }
+  };
+  check(buf1, "buf1");
+  check(buf2, "buf2");
+  if (buf1.byteLength !== buf2.byteLength) throw codeError(RangeError, "ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH", "Input buffers must have the same byte length");
+  return cryptoTimingSafeEqual(buf1, buf2);
+}
+
+const CIPHER_LIST =
+  "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:" +
+  "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:" +
+  "ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:" +
+  "DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA";
+
+/* Node's (OpenSSL's) values: the RSA paddings and point formats are what the APIs here take */
+export const constants = {
+  OPENSSL_VERSION_NUMBER: 810549328, SSL_OP_ALL: 2147485776, SSL_OP_ALLOW_NO_DHE_KEX: 1024,
+  SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: 262144, SSL_OP_CIPHER_SERVER_PREFERENCE: 4194304, SSL_OP_CISCO_ANYCONNECT: 32768,
+  SSL_OP_COOKIE_EXCHANGE: 8192, SSL_OP_CRYPTOPRO_TLSEXT_BUG: 2147483648, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: 2048,
+  SSL_OP_LEGACY_SERVER_CONNECT: 4, SSL_OP_NO_COMPRESSION: 131072, SSL_OP_NO_ENCRYPT_THEN_MAC: 524288, SSL_OP_NO_QUERY_MTU: 4096,
+  SSL_OP_NO_RENEGOTIATION: 1073741824, SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: 65536, SSL_OP_NO_SSLv2: 0,
+  SSL_OP_NO_SSLv3: 33554432, SSL_OP_NO_TICKET: 16384, SSL_OP_NO_TLSv1: 67108864, SSL_OP_NO_TLSv1_1: 268435456,
+  SSL_OP_NO_TLSv1_2: 134217728, SSL_OP_NO_TLSv1_3: 536870912, SSL_OP_PRIORITIZE_CHACHA: 2097152, SSL_OP_TLS_ROLLBACK_BUG: 8388608,
+  ENGINE_METHOD_RSA: 1, ENGINE_METHOD_DSA: 2, ENGINE_METHOD_DH: 4, ENGINE_METHOD_RAND: 8, ENGINE_METHOD_EC: 2048,
+  ENGINE_METHOD_CIPHERS: 64, ENGINE_METHOD_DIGESTS: 128, ENGINE_METHOD_PKEY_METHS: 512, ENGINE_METHOD_PKEY_ASN1_METHS: 1024,
+  ENGINE_METHOD_ALL: 65535, ENGINE_METHOD_NONE: 0, DH_CHECK_P_NOT_SAFE_PRIME: 2, DH_CHECK_P_NOT_PRIME: 1,
+  DH_UNABLE_TO_CHECK_GENERATOR: 4, DH_NOT_SUITABLE_GENERATOR: 8, RSA_PKCS1_PADDING: 1, RSA_NO_PADDING: 3,
+  RSA_PKCS1_OAEP_PADDING: 4, RSA_X931_PADDING: 5, RSA_PKCS1_PSS_PADDING: 6, RSA_PSS_SALTLEN_DIGEST: -1,
+  RSA_PSS_SALTLEN_MAX_SIGN: -2, RSA_PSS_SALTLEN_AUTO: -2, defaultCoreCipherList: CIPHER_LIST, TLS1_VERSION: 769,
+  TLS1_1_VERSION: 770, TLS1_2_VERSION: 771, TLS1_3_VERSION: 772, POINT_CONVERSION_COMPRESSED: 2,
+  POINT_CONVERSION_UNCOMPRESSED: 4, POINT_CONVERSION_HYBRID: 6, defaultCipherList: CIPHER_LIST,
+};
+
+export function getFips() {
+  return 0;
+}
+
+export function setFips(value) {
+  if (value) throw codeError(Error, "ERR_CRYPTO_FIPS_FORCED", "Cannot set FIPS mode in a non-FIPS build.");
+}
+
+export function secureHeapUsed() {
+  return { total: 0, used: 0, utilization: 0, min: 0 };
+}
+
+export function setEngine() {
+  throw notSupported("crypto.setEngine");
+}
+
+/* not provided yet */
+const unsupported = (name) =>
+  function () {
+    throw notSupported("crypto." + name);
+  };
+export const Certificate = unsupported("Certificate");
+export const Cipher = unsupported("Cipher");
+export const Decipher = unsupported("Decipher");
+export const DiffieHellman = unsupported("DiffieHellman");
+export const DiffieHellmanGroup = unsupported("DiffieHellmanGroup");
+export const X509Certificate = unsupported("X509Certificate");
+export const checkPrime = unsupported("checkPrime");
+export const checkPrimeSync = unsupported("checkPrimeSync");
+export const createDiffieHellman = unsupported("createDiffieHellman");
+export const createDiffieHellmanGroup = unsupported("createDiffieHellmanGroup");
+export const generatePrime = unsupported("generatePrime");
+export const generatePrimeSync = unsupported("generatePrimeSync");
+export const getDiffieHellman = unsupported("getDiffieHellman");
+
+export default {
+  Certificate, Cipher, Cipheriv, Decipher, Decipheriv, DiffieHellman, DiffieHellmanGroup, ECDH, Hash, Hmac, KeyObject, Sign,
+  Verify, X509Certificate, checkPrime, checkPrimeSync, constants, createCipheriv, createDecipheriv, createDiffieHellman,
+  createDiffieHellmanGroup, createECDH, createHash, createHmac, createPrivateKey, createPublicKey, createSecretKey, createSign,
+  createVerify, diffieHellman, generateKey, generateKeyPair, generateKeyPairSync, generateKeySync, generatePrime,
+  generatePrimeSync, getCipherInfo, getCiphers, getCurves, getDiffieHellman, getFips, getHashes, getRandomValues, hash, hkdf,
+  hkdfSync, pbkdf2, pbkdf2Sync, privateDecrypt, privateEncrypt, publicDecrypt, publicEncrypt, randomBytes, randomFill,
+  randomFillSync, randomInt, randomUUID, scrypt, scryptSync, secureHeapUsed, setEngine, setFips, sign, subtle, timingSafeEqual,
+  verify, webcrypto,
+};

package/node/prelude/events.js

@@ -0,0 +1,227 @@
+// node:events (ADR 0012, layer 3): EventEmitter, Node's semantics for the common API:
+// listeners in order (prepend first), once wrappers, 'newListener' and 'removeListener', an
+// 'error' with no listener thrown, and the max-listeners warning.
+const kCapture = Symbol("kCapture");
+
+function checkListener(listener) {
+  if (typeof listener !== "function") {
+    const e = new TypeError('The "listener" argument must be of type function. Received ' + describe(listener));
+    e.code = "ERR_INVALID_ARG_TYPE";
+    throw e;
+  }
+}
+
+function describe(v) {
+  if (v === null || v === undefined) return String(v);
+  if (typeof v === "object") return "an instance of " + (v.constructor && v.constructor.name ? v.constructor.name : "Object");
+  return "type " + typeof v + " (" + (typeof v === "string" ? "'" + v + "'" : String(v)) + ")";
+}
+
+export function EventEmitter(opts) {
+  EventEmitter.init.call(this, opts);
+}
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+let defaultMaxListeners = 10;
+Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+  enumerable: true,
+  get() {
+    return defaultMaxListeners;
+  },
+  set(n) {
+    defaultMaxListeners = n;
+  },
+});
+
+EventEmitter.init = function (opts) {
+  if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) {
+    this._events = Object.create(null);
+    this._eventsCount = 0;
+  }
+  this._maxListeners = this._maxListeners || undefined;
+  if (opts && opts.captureRejections) this[kCapture] = true;
+};
+
+EventEmitter.prototype.setMaxListeners = function (n) {
+  this._maxListeners = n;
+  return this;
+};
+
+EventEmitter.prototype.getMaxListeners = function () {
+  return this._maxListeners === undefined ? defaultMaxListeners : this._maxListeners;
+};
+
+EventEmitter.prototype.emit = function (type, ...args) {
+  const events = this._events;
+  if (type === "error" && (events === undefined || events.error === undefined)) {
+    const er = args[0];
+    if (er instanceof Error) throw er;
+    const e = new Error("Unhandled error. (" + String(er) + ")");
+    e.code = "ERR_UNHANDLED_ERROR";
+    e.context = er;
+    throw e;
+  }
+  if (events === undefined) return false;
+  const handler = events[type];
+  if (handler === undefined) return false;
+  if (typeof handler === "function") {
+    handler.apply(this, args);
+  } else {
+    const listeners = handler.slice();
+    for (let i = 0; i < listeners.length; i++) listeners[i].apply(this, args);
+  }
+  return true;
+};
+
+function addListener(target, type, listener, prepend) {
+  checkListener(listener);
+  let events = target._events;
+  if (events === undefined) {
+    events = target._events = Object.create(null);
+    target._eventsCount = 0;
+  } else if (events.newListener !== undefined) {
+    target.emit("newListener", type, listener.listener ? listener.listener : listener);
+    events = target._events;
+  }
+  const existing = events[type];
+  if (existing === undefined) {
+    events[type] = listener;
+    target._eventsCount++;
+  } else {
+    const list = typeof existing === "function" ? (events[type] = prepend ? [listener, existing] : [existing, listener]) : existing;
+    if (typeof existing !== "function") {
+      if (prepend) list.unshift(listener);
+      else list.push(listener);
+    }
+    const max = target.getMaxListeners();
+    if (max > 0 && list.length > max && !list.warned) {
+      list.warned = true;
+      process.emitWarning(
+        "Possible EventEmitter memory leak detected. " + list.length + " " + String(type) + " listeners added to " +
+          (target.constructor && target.constructor.name ? "[" + target.constructor.name + "]" : "[EventEmitter]") +
+          ". MaxListeners is " + max + ". Use emitter.setMaxListeners() to increase limit",
+        "MaxListenersExceededWarning",
+      );
+    }
+  }
+  return target;
+}
+
+EventEmitter.prototype.addListener = function (type, listener) {
+  return addListener(this, type, listener, false);
+};
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+EventEmitter.prototype.prependListener = function (type, listener) {
+  return addListener(this, type, listener, true);
+};
+
+function onceWrapper(target, type, listener) {
+  const state = { fired: false, target, type, listener };
+  function wrapped(...args) {
+    if (!state.fired) {
+      state.target.removeListener(state.type, wrapped);
+      state.fired = true;
+      return state.listener.apply(state.target, args);
+    }
+  }
+  wrapped.listener = listener;
+  return wrapped;
+}
+
+EventEmitter.prototype.once = function (type, listener) {
+  checkListener(listener);
+  this.on(type, onceWrapper(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.prependOnceListener = function (type, listener) {
+  checkListener(listener);
+  this.prependListener(type, onceWrapper(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.removeListener = function (type, listener) {
+  checkListener(listener);
+  const events = this._events;
+  if (events === undefined) return this;
+  const list = events[type];
+  if (list === undefined) return this;
+  if (list === listener || list.listener === listener) {
+    if (--this._eventsCount === 0) this._events = Object.create(null);
+    else delete events[type];
+    if (events.removeListener) this.emit("removeListener", type, list.listener || listener);
+  } else if (typeof list !== "function") {
+    let position = -1;
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i] === listener || list[i].listener === listener) {
+        position = i;
+        break;
+      }
+    }
+    if (position < 0) return this;
+    list.splice(position, 1);
+    if (list.length === 1) events[type] = list[0];
+    if (events.removeListener !== undefined) this.emit("removeListener", type, listener);
+  }
+  return this;
+};
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners = function (type) {
+  const events = this._events;
+  if (events === undefined) return this;
+  if (arguments.length === 0) {
+    this._events = Object.create(null);
+    this._eventsCount = 0;
+  } else if (events[type] !== undefined) {
+    if (--this._eventsCount === 0) this._events = Object.create(null);
+    else delete events[type];
+  }
+  return this;
+};
+
+function listenersOf(target, type, unwrap) {
+  const events = target._events;
+  if (events === undefined || events[type] === undefined) return [];
+  const l = events[type];
+  if (typeof l === "function") return unwrap ? [l.listener || l] : [l];
+  return l.map((f) => (unwrap ? f.listener || f : f));
+}
+
+EventEmitter.prototype.listeners = function (type) {
+  return listenersOf(this, type, true);
+};
+EventEmitter.prototype.rawListeners = function (type) {
+  return listenersOf(this, type, false);
+};
+EventEmitter.prototype.listenerCount = function (type) {
+  const l = this._events !== undefined ? this._events[type] : undefined;
+  return l === undefined ? 0 : typeof l === "function" ? 1 : l.length;
+};
+EventEmitter.prototype.eventNames = function () {
+  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+};
+
+EventEmitter.EventEmitter = EventEmitter;
+
+/** events.once(emitter, name): a promise of the next event's arguments. */
+export function once(emitter, name) {
+  return new Promise((resolve, reject) => {
+    const onError = (err) => {
+      emitter.removeListener(name, onEvent);
+      reject(err);
+    };
+    const onEvent = (...args) => {
+      if (name !== "error") emitter.removeListener("error", onError);
+      resolve(args);
+    };
+    emitter.once(name, onEvent);
+    if (name !== "error") emitter.once("error", onError);
+  });
+}
+EventEmitter.once = once;
+
+export default EventEmitter;

package/node/prelude/fs.js

@@ -0,0 +1,79 @@
+// node:fs (ADR 0012, layer 3): the synchronous file API, over the host primitives. Contents are
+// Buffers without an encoding, else strings in any of Buffer's encodings.
+import { errnoName, fsExists, fsReadFile, fsUnlink, fsWriteFile } from "visaljs:host";
+import { codeError, invalidArgType, invalidArgValue, notSupported, systemError } from "./internal/errors.js";
+
+function validatePath(path) {
+  if (typeof path !== "string") {
+    if (typeof path === "number") throw notSupported("A file descriptor as a path");
+    if (typeof URL === "function" && path instanceof URL) throw notSupported("A file: URL as a path");
+    throw invalidArgType("path", "of type string or an instance of Buffer or URL", path);
+  }
+  if (path.indexOf("\u0000") !== -1) throw invalidArgValue("path", "must be a string without null bytes", path);
+}
+
+function encodingOf(options) {
+  if (options == null) return undefined;
+  if (typeof options === "string") return options;
+  if (typeof options === "object") return options.encoding ?? undefined;
+  throw invalidArgType("options", "one of type string or an instance of Object", options);
+}
+
+function isUtf8(encoding) {
+  return encoding === "utf8" || encoding === "utf-8" || encoding === "UTF8" || encoding === "UTF-8";
+}
+
+function check(result, syscall, path) {
+  if (typeof result === "number") throw systemError(result, syscall, path);
+  return result;
+}
+
+function validateEncodingName(encoding) {
+  if (encoding !== undefined && encoding !== "buffer" && !Buffer.isEncoding(encoding)) {
+    throw codeError(TypeError, "ERR_INVALID_ARG_VALUE", "The argument 'encoding' is invalid encoding. Received '" + encoding + "'");
+  }
+}
+
+export function readFileSync(path, options) {
+  validatePath(path);
+  const encoding = encodingOf(options);
+  validateEncodingName(encoding);
+  const asText = encoding !== undefined && isUtf8(encoding);
+  const result = fsReadFile(path, !asText);
+  /* opening a directory succeeds; reading it fails: Node reports that read, without a path */
+  if (typeof result === "number" && errnoName(result) === "EISDIR") throw systemError(result, "read");
+  const contents = check(result, "open", path);
+  return asText || encoding === undefined || encoding === "buffer" ? contents : contents.toString(encoding);
+}
+
+function write(path, data, options, append) {
+  validatePath(path);
+  if (typeof data !== "string" && !ArrayBuffer.isView(data)) {
+    throw invalidArgType("data", "of type string or an instance of Buffer, TypedArray, or DataView", data);
+  }
+  const encoding = encodingOf(options);
+  validateEncodingName(encoding);
+  if (typeof data === "string" && encoding !== undefined && encoding !== "buffer" && !isUtf8(encoding)) data = Buffer.from(data, encoding);
+  const flag = options != null && typeof options === "object" ? options.flag : undefined;
+  check(fsWriteFile(path, data, append || flag === "a"), "open", path);
+}
+
+export function writeFileSync(path, data, options) {
+  write(path, data, options, false);
+}
+
+export function appendFileSync(path, data, options) {
+  write(path, data, options, true);
+}
+
+export function existsSync(path) {
+  if (typeof path !== "string" || path.indexOf("\u0000") !== -1) return false;
+  return fsExists(path);
+}
+
+export function unlinkSync(path) {
+  validatePath(path);
+  check(fsUnlink(path), "unlink", path);
+}
+
+export default { readFileSync, writeFileSync, appendFileSync, existsSync, unlinkSync };