visaljs 0.0.7 → 0.0.8

package/node/prelude/module.js

@@ -1,13 +1,17 @@
-// node:module (ADR 0009, 0012): createRequire, which the bundler's code uses for a require() it
+// node:module: createRequire, which the bundler's code uses for a require() it
 // couldn't resolve at build time. A compiled program can't load new code: such a require gives
 // a package the bundler found the program may ask for and bundled (the require table), else
-// throws as Node's does for a module it can't find (as a computed import() rejects).
+// throws as Node's does for a module it can't find (as a computed import() rejects). A JSON file
+// is data, not code: a path ending in .json is read and parsed when asked for, as Node does
+// (yargs's --config, a package.json found at run time).
 // builtinModules and isBuiltin list Node's built-in modules.
 //
-// It imports nothing: the bundler's own runtime imports it, and so runs it before any helper the
+// It imports only the host primitives: the bundler's own runtime imports it, and so runs it before any helper the
 // bundler would wrap an imported module in. The bundler's runtime has its own copy, so the table
 // isn't this module's: the module the bundler generates puts it on globalThis, under this
 // symbol (name → a function giving the module's exports; cli/src/bundle.ts).
+import { fsReadFile, fsStat } from "visaljs:host";
+
 export const REQUIRE_TABLE = Symbol.for("visaljs.requireTable");
 
 export const builtinModules = [
@@ -21,9 +25,12 @@ export const builtinModules = [
   "wasi", "worker_threads", "zlib",
 ];
 
+/* the built-ins only named with the node: scheme (`test` alone is an npm package's name) */
+const schemeOnly = ["node:sea", "node:sqlite", "node:test", "node:test/reporters"];
+
 export function isBuiltin(moduleName) {
   const name = String(moduleName);
-  return builtinModules.includes(name.startsWith("node:") ? name.slice(5) : name);
+  return schemeOnly.includes(name) || builtinModules.includes(name.startsWith("node:") ? name.slice(5) : name);
 }
 
 function withCode(error, code) {
@@ -37,15 +44,26 @@ function notFound(id) {
   return e;
 }
 
+/* require.extensions and Module._extensions (deprecated, still read: a hook saves the old one): a
+ * compiled program has no files to load, so each loader says so */
+const extensions = { __proto__: null };
+for (const ext of [".js", ".json", ".node"]) {
+  extensions[ext] = function (module, filename) {
+    throw withCode(new Error(`Cannot load ${filename}: a compiled program has no files to load at run time`), "ERR_UNKNOWN_FILE_EXTENSION");
+  };
+}
+
 export function createRequire(filename) {
   if (typeof filename !== "string" && !(typeof URL === "function" && filename instanceof URL)) {
     throw withCode(new TypeError("The argument 'filename' must be a file URL object, file URL string, or absolute path string. Received " +
       String(filename)), "ERR_INVALID_ARG_VALUE");
   }
+  const base = pathOf(filename);
   const require = (id) => {
     const load = globalThis[REQUIRE_TABLE]?.get(id);
-    if (load === undefined) throw notFound(id);
-    return load();
+    if (load !== undefined) return load();
+    if (typeof id === "string" && id.endsWith(".json") && /^(?:\.\.?\/|\/)/.test(id)) return requireJSON(require.cache, id, base);
+    throw notFound(id);
   };
   require.resolve = (id) => {
     throw notFound(id);
@@ -53,9 +71,43 @@ export function createRequire(filename) {
   require.resolve.paths = () => null;
   require.cache = { __proto__: null };
   require.main = undefined;
+  require.extensions = extensions;
   return require;
 }
 
+function pathOf(filename) {
+  const s = typeof filename === "string" ? filename : filename.href;
+  return s.startsWith("file:") ? decodeURIComponent(new URL(s).pathname) : s;
+}
+
+/* an absolute path without its . and .. segments (node:path's normalize, which this module can't import) */
+function normalize(path) {
+  const out = [];
+  for (const part of path.split("/")) {
+    if (part === "..") out.pop();
+    else if (part !== "." && part !== "") out.push(part);
+  }
+  return "/" + out.join("/");
+}
+
+/** A JSON file, by a path absolute or relative to the requiring file's directory: parsed once,
+ *  then from require.cache, as Node's loader does. */
+function requireJSON(cache, id, from) {
+  const path = normalize(id.startsWith("/") ? id : from.slice(0, from.lastIndexOf("/") + 1) + id);
+  if (path in cache) return cache[path].exports;
+  const text = fsReadFile(path, false);
+  if (typeof text !== "string") throw notFound(id);
+  let exports;
+  try {
+    exports = JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text);
+  } catch (e) {
+    e.message = `${path}: ${e.message}`;
+    throw e;
+  }
+  cache[path] = { id: path, filename: path, loaded: true, exports };
+  return exports;
+}
+
 /* internal/errors.js's, here: this module imports nothing */
 function notSupported(what) {
   return withCode(new Error(`${what} is not supported by visaljs`), "ERR_VISALJS_UNSUPPORTED");
@@ -66,4 +118,139 @@ export function register() {
   throw notSupported("module.register()");
 }
 
-export default { builtinModules, createRequire, isBuiltin, register };
+export function registerHooks() {
+  throw notSupported("module.registerHooks()");
+}
+
+export function runMain() {
+  throw notSupported("module.runMain() (loading a program)");
+}
+
+/** Type stripping needs TypeScript's parser at run time, which a compiled program doesn't carry. */
+export function stripTypeScriptTypes() {
+  throw notSupported("module.stripTypeScriptTypes()");
+}
+
+/** Node's live binding refresh for built-ins' ES module exports: they're always in step here. */
+export function syncBuiltinESMExports() {}
+
+/* ---- the compile cache: a compiled program has nothing to compile, so it's disabled ---------------- */
+
+export const constants = Object.freeze({ compileCacheStatus: Object.freeze({ FAILED: 0, ENABLED: 1, ALREADY_ENABLED: 2, DISABLED: 3 }) });
+
+export function enableCompileCache() {
+  return { status: constants.compileCacheStatus.DISABLED, message: "Disabled: a compiled program has no source to compile" };
+}
+
+export function getCompileCacheDir() {
+  return undefined;
+}
+
+export function flushCompileCache() {}
+
+/* ---- source maps -------------------------------------------------------------------------------- */
+
+let sourceMapsSupport = { enabled: false, nodeModules: false, generatedCode: false };
+
+export function getSourceMapsSupport() {
+  return { ...sourceMapsSupport };
+}
+
+export function setSourceMapsSupport(enabled, options = {}) {
+  if (typeof enabled !== "boolean") throw withCode(new TypeError(`The "enabled" argument must be of type boolean.`), "ERR_INVALID_ARG_TYPE");
+  sourceMapsSupport = { enabled, nodeModules: Boolean(enabled && options.nodeModules), generatedCode: Boolean(enabled && options.generatedCode) };
+}
+
+/** The source map a loaded module carries: none are loaded at run time. */
+export function findSourceMap() {
+  return undefined;
+}
+
+/** SourceMap: internal/source_map.js, linked when the program names it. */
+export function SourceMap(payload, options) {
+  const Impl = globalThis[Symbol.for("visaljs.SourceMap")];
+  if (Impl === undefined) throw notSupported("module.SourceMap (named only at run time)");
+  if (!new.target) throw new TypeError("Class constructor SourceMap cannot be invoked without 'new'");
+  return Reflect.construct(Impl, [payload, options], new.target === SourceMap ? Impl : new.target);
+}
+
+/* ---- findPackageJSON ------------------------------------------------------------------------------- */
+
+const isDir = (path) => {
+  const st = fsStat(path, true);
+  return typeof st !== "number" && (st[0] & 0o170000) === 0o040000;
+};
+const exists = (path) => typeof fsStat(path, true) !== "number";
+const dirOf = (path) => path.slice(0, Math.max(path.lastIndexOf("/"), 0)) || "/";
+
+/** findPackageJSON(specifier[, base]): the package.json closest to what the specifier resolves to
+ *  (a path or file: URL, relative to base; or a package, from base's node_modules), or undefined. */
+export function findPackageJSON(specifier, base) {
+  const spec = specifier instanceof URL ? specifier.href : String(specifier);
+  const baseText = base instanceof URL ? base.href : base === undefined ? undefined : String(base);
+  const unresolved = () => withCode(new TypeError(`Failed to resolve module specifier "${spec}" from "${baseText}": ` +
+    "Invalid relative URL or base scheme is not hierarchical."), "ERR_UNSUPPORTED_RESOLVE_REQUEST");
+  const basePath = baseText === undefined ? undefined : baseText.startsWith("file:") ? pathOf(baseText) : baseText;
+  let target;
+  if (spec.startsWith("file:")) target = pathOf(spec);
+  else if (spec.startsWith("/")) target = normalize(spec);
+  else if (spec.startsWith("./") || spec.startsWith("../")) {
+    if (basePath === undefined) throw unresolved();
+    const from = baseText.endsWith("/") ? basePath : dirOf(basePath);
+    target = normalize(`${from}/${spec}`);
+  } else {
+    /* a package: its directory under the closest node_modules that has it */
+    if (basePath === undefined) throw unresolved();
+    const name = spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0];
+    for (let dir = baseText.endsWith("/") ? normalize(basePath) : dirOf(normalize(basePath)); ; dir = dirOf(dir)) {
+      const candidate = `${dir === "/" ? "" : dir}/node_modules/${name}/package.json`;
+      if (exists(candidate)) return candidate;
+      if (dir === "/") throw withCode(new Error(`Cannot find package '${name}' imported from ${basePath}`), "ERR_MODULE_NOT_FOUND");
+    }
+  }
+  for (let dir = isDir(target) ? target : dirOf(target); ; dir = dirOf(dir)) {
+    const candidate = `${dir === "/" ? "" : dir}/package.json`;
+    if (exists(candidate)) return candidate;
+    if (dir === "/") return undefined;
+  }
+}
+
+/* ---- Module ---------------------------------------------------------------------------------------- */
+
+/** Module: Node's CommonJS module record, with its helpers; the module's default export is it. */
+function Module(id = "", parent) {
+  this.id = id;
+  this.path = id ? dirOf(id) : ".";
+  this.exports = {};
+  this.filename = null;
+  this.loaded = false;
+  this.children = [];
+  this.paths = [];
+  void parent;
+}
+
+export const globalPaths = [];
+const wrapper = ["(function (exports, require, module, __filename, __dirname) { ", "\n});"];
+
+/* in a pure call, so a program that doesn't use node:module (the bundler's runtime has a copy of it
+ * in every program) drops it all */
+const ModuleWithHelpers = /* @__PURE__ */ Object.assign(Module, {
+  builtinModules, createRequire, isBuiltin, register, registerHooks, runMain, stripTypeScriptTypes, syncBuiltinESMExports, constants,
+  enableCompileCache, getCompileCacheDir, flushCompileCache, getSourceMapsSupport, setSourceMapsSupport, findSourceMap, SourceMap,
+  findPackageJSON, globalPaths, Module, wrapper,
+  wrap: (script) => wrapper[0] + script + wrapper[1],
+  _cache: { __proto__: null },
+  _extensions: extensions,
+  /* a built-in resolves to itself; a compiled program has no files to resolve to */
+  _resolveFilename(request) {
+    if (isBuiltin(request)) return request;
+    const e = withCode(new Error(`Cannot find module '${request}'`), "MODULE_NOT_FOUND");
+    e.requireStack = [];
+    throw e;
+  },
+  _load(request) {
+    return createRequire("/")(request);
+  },
+});
+
+export { ModuleWithHelpers as Module, ModuleWithHelpers as default };

package/node/prelude/net.js

@@ -1,4 +1,4 @@
-// node:net (ADR 0012, layer 3): TCP and Unix domain socket servers and sockets over the host
+// node:net: TCP and Unix domain socket servers and sockets over the host
 // primitives of node/src/host_net.c (libuv), following Node's lib/net.js: a Socket is a Duplex
 // whose reads start and stop with backpressure, whose end() shuts the write side down, and which
 // closes once both sides are done (allowHalfOpen: false ends the write side when the peer's
@@ -6,6 +6,7 @@
 // for autoSelectFamilyAttemptTimeout ms (happy eyeballs, as Node's). Socket timeouts are
 // unref'd timers, refreshed by activity. SocketAddress and BlockList are in
 // internal/socketaddress.js.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   errnoMessage, errnoName, netAddress, netBind, netCallback, netChmod, netClose, netConnect, netGuessHandle, netKeepAlive, netListen,
   netNoDelay, netOpen, netOpenFd, netReadStart, netReadStop, netRef, netReset, netShutdown, netWrite, timerUnref,

package/node/prelude/os.js

@@ -1,13 +1,26 @@
-// node:os (ADR 0012, layer 3): the system's facts through libuv, as Node's lib/os.js gets them,
-// and the constants of the platform the program was built for. Not provided yet:
-// networkInterfaces, getPriority and setPriority (ERR_VISALJS_UNSUPPORTED).
+// node:os: the system's facts through libuv, as Node's lib/os.js gets them,
+// and the constants of the platform the program was built for.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
-  osConstants, osCpus, osHomedir, osHostname, osLoadavg, osMemory, osParallelism, osTmpdir, osUname, osUptime, osUserInfo,
+  errnoMessage, errnoName, osConstants, osCpus, osGetPriority, osHomedir, osHostname, osInterfaces, osLoadavg, osMemory, osParallelism,
+  osSetPriority, osTmpdir, osUname, osUptime, osUserInfo,
 } from "visaljs:host";
-import { notSupported, systemError } from "./internal/errors.js";
+import { codeError, invalidArgType } from "./internal/errors.js";
+
+/* Node's SystemError (ERR_SYSTEM_ERROR): "A system error occurred: uv_os_getpriority returned ESRCH
+ * (no such process)", with errno, code, syscall and info */
+function osError(errno, syscall) {
+  const code = errnoName(errno), message = errnoMessage(errno);
+  const e = codeError(Error, "ERR_SYSTEM_ERROR", `A system error occurred: ${syscall} returned ${code} (${message})`);
+  e.name = "SystemError";
+  e.errno = errno;
+  e.syscall = syscall;
+  e.info = { errno, code, message, syscall };
+  return e;
+}
 
 const check = (result, syscall) => {
-  if (typeof result === "number" && result < 0) throw systemError(result, syscall);
+  if (typeof result === "number" && result < 0) throw osError(result, syscall);
   return result;
 };
 const uname = () => check(osUname(), "uv_os_uname");
@@ -89,16 +102,80 @@ export function userInfo(options) {
   return { uid, gid, username: enc(username), homedir: enc(home), shell: enc(shell) };
 }
 
+/* the prefix length of a contiguous netmask, else null (Node's getCIDR) */
+function cidrOf(address, netmask, family) {
+  let ones = 0, run = true;
+  if (family === "IPv4") {
+    for (const part of netmask.split(".")) {
+      for (let bit = 7; bit >= 0; bit--) {
+        if ((Number(part) >> bit) & 1) {
+          if (!run) return null;
+          ones++;
+        } else run = false;
+      }
+    }
+  } else {
+    const groups = expandIPv6(netmask);
+    for (const group of groups) {
+      for (let bit = 15; bit >= 0; bit--) {
+        if ((group >> bit) & 1) {
+          if (!run) return null;
+          ones++;
+        } else run = false;
+      }
+    }
+  }
+  return `${address}/${ones}`;
+}
+
+/* an IPv6 address's eight groups, :: expanded */
+function expandIPv6(address) {
+  const [head, tail] = address.includes("::") ? address.split("::") : [address, undefined];
+  const parse = (s) => (s ? s.split(":").map((g) => parseInt(g, 16)) : []);
+  const left = parse(head), right = parse(tail);
+  return tail === undefined ? left : [...left, ...new Array(8 - left.length - right.length).fill(0), ...right];
+}
+
+/** The network interfaces and their addresses: name → [{ address, netmask, family, mac, internal,
+ *  cidr, scopeid (IPv6) }], as libuv lists them. */
 export function networkInterfaces() {
-  throw notSupported("os.networkInterfaces");
+  const flat = check(osInterfaces(), "uv_interface_addresses");
+  const result = {};
+  for (let i = 0; i < flat.length; i += 7) {
+    const [name, address, netmask, family, mac, internal, scopeid] = flat.slice(i, i + 7);
+    const entry = { address, netmask, family: family === 4 ? "IPv4" : "IPv6", mac, internal, cidr: null };
+    entry.cidr = cidrOf(address, netmask, entry.family);
+    if (family === 6) entry.scopeid = scopeid;
+    (result[name] ??= []).push(entry);
+  }
+  return result;
+}
+
+function validatePid(pid) {
+  if (typeof pid !== "number") throw invalidArgType("pid", "of type number", pid);
+  if (!Number.isInteger(pid) || pid < -2147483648 || pid > 2147483647) {
+    throw codeError(RangeError, "ERR_OUT_OF_RANGE", `The value of "pid" is out of range. It must be an integer. Received ${pid}`);
+  }
 }
 
-export function getPriority() {
-  throw notSupported("os.getPriority");
+/** A process's scheduling priority (0: this one). */
+export function getPriority(pid = 0) {
+  validatePid(pid);
+  return check(osGetPriority(pid), "uv_os_getpriority");
 }
 
-export function setPriority() {
-  throw notSupported("os.setPriority");
+/** setPriority([pid,] priority): -20 (highest) to 19 (lowest). */
+export function setPriority(pid, priority) {
+  if (priority === undefined) {
+    priority = pid;
+    pid = 0;
+  }
+  validatePid(pid);
+  if (typeof priority !== "number") throw invalidArgType("priority", "of type number", priority);
+  if (!Number.isInteger(priority) || priority < -20 || priority > 19) {
+    throw codeError(RangeError, "ERR_OUT_OF_RANGE", `The value of "priority" is out of range. It must be >= -20 && <= 19. Received ${priority}`);
+  }
+  check(osSetPriority(pid, priority), "uv_os_setpriority");
 }
 
 function nameTable(flat) {

package/node/prelude/path.js

@@ -1,9 +1,11 @@
-// node:path (ADR 0012, layer 3): Node's lib/path.js (MIT; Node v22), both its win32 and its
+// node:path: Node's lib/path.js (MIT; Node v22), both its win32 and its
 // posix halves, ported: primordials are the methods they stand for, the working directory is the
-// host's, and matchesGlob (minimatch, which visaljs doesn't bundle) is a stub. Results match Node's
+// host's, and matchesGlob is fs.glob's matcher (internal/fs_glob.js). Results match Node's
 // byte for byte; the default export is win32 on Windows, posix elsewhere, as Node's.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { cwd as hostCwd } from "visaljs:host";
-import { invalidArgType, notSupported, validateString } from "./internal/errors.js";
+import { invalidArgType, validateString } from "./internal/errors.js";
+import { feature } from "./internal/features.js";
 
 const CHAR_UPPERCASE_A = 65, CHAR_LOWERCASE_A = 97, CHAR_UPPERCASE_Z = 90, CHAR_LOWERCASE_Z = 122;
 const CHAR_DOT = 46, CHAR_FORWARD_SLASH = 47, CHAR_BACKWARD_SLASH = 92, CHAR_COLON = 58, CHAR_QUESTION_MARK = 63;
@@ -1162,8 +1164,9 @@ const win32 = {
     return ret;
   },
 
-  matchesGlob(_path, _pattern) {
-    throw notSupported('path.matchesGlob');
+  /* internal/fs_glob.js's, linked when the program names it */
+  matchesGlob(path, pattern) {
+    return feature("matchesGlob")(path, pattern);
   },
 
   sep: '\\',
@@ -1644,8 +1647,9 @@ const posix = {
     return ret;
   },
 
-  matchesGlob(_path, _pattern) {
-    throw notSupported('path.matchesGlob');
+  /* internal/fs_glob.js's, linked when the program names it */
+  matchesGlob(path, pattern) {
+    return feature("matchesGlob")(path, pattern);
   },
 
   sep: '/',

package/node/prelude/path_posix.js

@@ -1,4 +1,4 @@
-// node:path/posix (ADR 0012, layer 3): path.posix, on every platform.
+// node:path/posix: path.posix, on every platform.
 import { posix } from "./path.js";
 
 export const {

package/node/prelude/path_win32.js

@@ -1,4 +1,4 @@
-// node:path/win32 (ADR 0012, layer 3): path.win32, on every platform.
+// node:path/win32: path.win32, on every platform.
 import { win32 } from "./path.js";
 
 export const {

package/node/prelude/perf_hooks.js

@@ -0,0 +1,147 @@
+// node:perf_hooks: `performance`'s clock, marks and measures. The clock is
+// process.hrtime's, from when this module loads: timeOrigin is that time on the epoch clock.
+// PerformanceObserver and the histograms are modules of their own (internal/perf_observe.js,
+// internal/perf_histogram.js), linked when the program names them.
+import { codeError, invalidArgType } from "./internal/errors.js";
+import { features, lazyClass, lazyFunction } from "./internal/features.js";
+
+const hrMs = () => {
+  const [s, ns] = process.hrtime();
+  return s * 1e3 + ns / 1e6;
+};
+const origin = hrMs();
+const timeOrigin = Date.now();
+const now = () => hrMs() - origin;
+
+const kConstruct = Symbol("construct");
+
+export class PerformanceEntry {
+  constructor(key, name, entryType, startTime, duration, detail) {
+    if (key !== kConstruct) throw codeError(TypeError, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
+    this.name = name;
+    this.entryType = entryType;
+    this.startTime = startTime;
+    this.duration = duration;
+    this.detail = detail;
+  }
+
+  toJSON() {
+    return { name: this.name, entryType: this.entryType, startTime: this.startTime, duration: this.duration, detail: this.detail };
+  }
+}
+
+export class PerformanceMark extends PerformanceEntry {
+  constructor(name, options) {
+    if (name === undefined) throw codeError(TypeError, "ERR_MISSING_ARGS", 'The "name" argument must be specified');
+    const startTime = options?.startTime ?? now();
+    if (typeof startTime !== "number") throw invalidArgType("options.startTime", "of type number", startTime);
+    super(kConstruct, String(name), "mark", startTime, 0, options?.detail ?? null);
+  }
+}
+
+export class PerformanceMeasure extends PerformanceEntry {
+  constructor(key, name, startTime, duration, detail) {
+    super(key, name, "measure", startTime, duration, detail);
+  }
+}
+
+/* marks and measures, in the order they were made */
+const entries = [];
+
+/** A mark's time: a number as is, else the latest mark of that name. */
+function markTime(mark) {
+  if (typeof mark === "number") return mark;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].entryType === "mark" && entries[i].name === mark) return entries[i].startTime;
+  }
+  throw new globalThis.DOMException('The "' + mark + '" performance mark has not been set', "SyntaxError");
+}
+
+export class Performance {
+  constructor(key) {
+    if (key !== kConstruct) throw codeError(TypeError, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
+  }
+
+  get timeOrigin() {
+    return timeOrigin;
+  }
+
+  now() {
+    return now();
+  }
+
+  mark(name, options) {
+    const mark = new PerformanceMark(name, options);
+    entries.push(mark);
+    features.perfObserve?.(mark);
+    return mark;
+  }
+
+  /** measure(name, startMark?, endMark?) or measure(name, { start, end, duration, detail }). */
+  measure(name, startOrOptions, endMark) {
+    let start = 0, end, detail = null;
+    if (startOrOptions !== null && typeof startOrOptions === "object") {
+      const { start: s, end: e, duration, detail: d } = startOrOptions;
+      if (s !== undefined) start = markTime(s);
+      end = e !== undefined ? markTime(e) : duration !== undefined ? start + duration : now();
+      detail = d ?? null;
+    } else {
+      if (startOrOptions !== undefined) start = markTime(startOrOptions);
+      end = endMark !== undefined ? markTime(endMark) : now();
+    }
+    const measure = new PerformanceMeasure(kConstruct, String(name), start, end - start, detail);
+    entries.push(measure);
+    features.perfObserve?.(measure);
+    return measure;
+  }
+
+  clearMarks(name) {
+    clear("mark", name);
+  }
+
+  clearMeasures(name) {
+    clear("measure", name);
+  }
+
+  getEntries() {
+    return entries.slice().sort((a, b) => a.startTime - b.startTime);
+  }
+
+  getEntriesByName(name, type) {
+    return this.getEntries().filter((e) => e.name === name && (type === undefined || e.entryType === type));
+  }
+
+  getEntriesByType(type) {
+    return this.getEntries().filter((e) => e.entryType === type);
+  }
+
+  toJSON() {
+    return { timeOrigin };
+  }
+}
+
+function clear(type, name) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].entryType === type && (name === undefined || entries[i].name === name)) entries.splice(i, 1);
+  }
+}
+
+export const performance = new Performance(kConstruct);
+
+export const constants = {
+  NODE_PERFORMANCE_GC_MAJOR: 4, NODE_PERFORMANCE_GC_MINOR: 1, NODE_PERFORMANCE_GC_INCREMENTAL: 8, NODE_PERFORMANCE_GC_WEAKCB: 16,
+  NODE_PERFORMANCE_GC_FLAGS_NO: 0, NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED: 2, NODE_PERFORMANCE_GC_FLAGS_FORCED: 4,
+  NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING: 8, NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE: 16,
+  NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY: 32, NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE: 64,
+};
+
+export const PerformanceObserver = lazyClass("PerformanceObserver");
+export const PerformanceObserverEntryList = lazyClass("PerformanceObserverEntryList");
+export const PerformanceResourceTiming = lazyClass("PerformanceResourceTiming");
+export const createHistogram = lazyFunction("createHistogram");
+export const monitorEventLoopDelay = lazyFunction("monitorEventLoopDelay");
+
+export default {
+  Performance, PerformanceEntry, PerformanceMark, PerformanceMeasure, PerformanceObserver, PerformanceObserverEntryList, PerformanceResourceTiming,
+  performance, constants, createHistogram, monitorEventLoopDelay,
+};

package/node/prelude/process.js

@@ -1,4 +1,4 @@
-// node:process (ADR 0012, layer 3): the process global, as a module.
+// node:process: the process global, as a module.
 const p = globalThis.process;
 
 export const argv = p.argv;
@@ -9,6 +9,8 @@ export const execPath = p.execPath;
 export const pid = p.pid;
 export const platform = p.platform;
 export const stderr = p.stderr;
+/* made when read, by the module the driver adds when the program names it */
+export const stdin = p.stdin;
 export const stdout = p.stdout;
 export const version = p.version;
 export const versions = p.versions;
@@ -18,6 +20,39 @@ export const exit = (...args) => p.exit(...args);
 export const hrtime = p.hrtime;
 export const nextTick = (...args) => p.nextTick(...args);
 export const kill = (...args) => p.kill(...args);
+/* the members of internal/process_more.js, which the driver adds when the program names them:
+ * called through process, so a program that imports node:process links none of them */
+export const chdir = (...args) => p.chdir(...args);
+export const umask = (...args) => p.umask(...args);
+export const memoryUsage = (...args) => p.memoryUsage(...args);
+export const uptime = (...args) => p.uptime(...args);
+export const cpuUsage = (...args) => p.cpuUsage(...args);
+export const threadCpuUsage = (...args) => p.threadCpuUsage(...args);
+export const resourceUsage = (...args) => p.resourceUsage(...args);
+export const availableMemory = (...args) => p.availableMemory(...args);
+export const constrainedMemory = (...args) => p.constrainedMemory(...args);
+export const setuid = (...args) => p.setuid(...args);
+export const setgid = (...args) => p.setgid(...args);
+export const seteuid = (...args) => p.seteuid(...args);
+export const setegid = (...args) => p.setegid(...args);
+export const getgroups = (...args) => p.getgroups(...args);
+export const setgroups = (...args) => p.setgroups(...args);
+export const initgroups = (...args) => p.initgroups(...args);
+export const abort = (...args) => p.abort(...args);
+export const reallyExit = (...args) => p.reallyExit(...args);
+export const execve = (...args) => p.execve(...args);
+export const getBuiltinModule = (...args) => p.getBuiltinModule(...args);
+export const loadEnvFile = (...args) => p.loadEnvFile(...args);
+export const hasUncaughtExceptionCaptureCallback = (...args) => p.hasUncaughtExceptionCaptureCallback(...args);
+export const setUncaughtExceptionCaptureCallback = (...args) => p.setUncaughtExceptionCaptureCallback(...args);
+export const setSourceMapsEnabled = (...args) => p.setSourceMapsEnabled(...args);
+export const getActiveResourcesInfo = (...args) => p.getActiveResourcesInfo(...args);
+export const openStdin = (...args) => p.openStdin(...args);
+export const ref = (...args) => p.ref(...args);
+export const unref = (...args) => p.unref(...args);
+export const assert = (...args) => p.assert(...args);
+export const binding = (...args) => p.binding(...args);
+export const dlopen = (...args) => p.dlopen(...args);
 /* using it gets the driver to add process's events (node/index.ts) */
 export const emit = (...args) => p.emit(...args);