visaljs 0.0.6 → 0.0.8

package/node/prelude/internal/timers.js

@@ -1,4 +1,4 @@
-// node:timers' core (ADR 0012): Timeout and Immediate on the runtime's timers (timerStart and
+// node:timers' core: Timeout and Immediate on the runtime's timers (timerStart and
 // friends, runtime/src/jobs.c). Each object holds one native one-shot timer, armed under one id
 // (also its primitive), which an interval re-arms after its callback. node:timers and
 // node:timers/promises build on it; a program that uses them gets them as its globals too
@@ -19,15 +19,27 @@ const knownTimersById = new Map();
 /* every armed Timeout: a number that names one whose primitive wasn't taken clears nothing */
 export const armed = new Map();
 
-function emitWarning(message) {
-  if (typeof process.emitWarning === "function") process.emitWarning(message, "TimeoutOverflowWarning");
+function emitWarning(message, type) {
+  if (typeof process.emitWarning === "function") process.emitWarning(message, type);
 }
 
+/* Node 24 also warns, once each, about a negative delay and one that isn't a number */
+let warnedNegativeNumber = false;
+let warnedNotNumber = false;
+
 /* the delay as Node takes it: 1 when below 1 ms, not a number or past 2^31 - 1 */
 export function duration(after) {
   after *= 1;
   if (!(after >= 1 && after <= TIMEOUT_MAX)) {
-    if (after > TIMEOUT_MAX) emitWarning(`${after} does not fit into a 32-bit signed integer.\nTimeout duration was set to 1.`);
+    if (after > TIMEOUT_MAX) {
+      emitWarning(`${after} does not fit into a 32-bit signed integer.\nTimeout duration was set to 1.`, "TimeoutOverflowWarning");
+    } else if (after < 0 && !warnedNegativeNumber) {
+      warnedNegativeNumber = true;
+      emitWarning(`${after} is a negative number.\nTimeout duration was set to 1.`, "TimeoutNegativeWarning");
+    } else if (Number.isNaN(after) && !warnedNotNumber) {
+      warnedNotNumber = true;
+      emitWarning(`${after} is not a number.\nTimeout duration was set to 1.`, "TimeoutNaNWarning");
+    }
     after = 1;
   }
   return after;
@@ -115,6 +127,14 @@ if (typeof Symbol.dispose === "symbol") {
 function fireTimeout(timer) {
   timer[kPending] = false;
   armed.delete(timer[kId]);
+  /* listOnTimeout: a timer whose callback was taken away (an interval's _onTimeout = null) ends */
+  if (!timer._onTimeout) {
+    if (!timer._destroyed) {
+      timer._destroyed = true;
+      if (timer[kHasPrimitive]) knownTimersById.delete(timer[kId]);
+    }
+    return;
+  }
   const args = timer._timerArgs;
   try {
     if (args === undefined) timer._onTimeout();
@@ -130,11 +150,21 @@ function fireTimeout(timer) {
   }
 }
 
+/* Node 24's cleanTimer: a cancelled timer lets go of its callback and arguments */
+function cleanTimer(item) {
+  item._onTimeout = undefined;
+  item._timerArgs = undefined;
+}
+
 export function unenrollTimeout(item) {
-  if (item._destroyed) return;
+  if (item._destroyed) {
+    cleanTimer(item);
+    return;
+  }
   item._destroyed = true;
   if (item[kHasPrimitive]) knownTimersById.delete(item[kId]);
   disarm(item);
+  cleanTimer(item);
   item._idleTimeout = -1;
 }
 
@@ -225,9 +255,10 @@ export function setImmediate(callback, ...args) {
 }
 
 export function clearImmediate(immediate) {
-  if (!immediate || immediate._destroyed) return;
+  if (!immediate?._onImmediate || immediate._destroyed) return;
   immediate._destroyed = true;
   immediate[kRefed] = null;
-  immediate._onImmediate = null;
+  immediate._onImmediate = undefined;  /* Node 24's cleanImmediate */
+  immediate._argv = undefined;
   timerClear(immediate[kId]);
 }

package/node/prelude/internal/timers_global.js

@@ -1,4 +1,4 @@
-// The Node timer globals (ADR 0012): the runtime's setTimeout and friends, in every binary,
+// The Node timer globals: the runtime's setTimeout and friends, in every binary,
 // return numbers. A program that may use what Node's return (a Timeout's unref(), refresh(),
 // hasRef(), or node:timers itself, whose clearTimeout must take the globals' timers) gets this
 // module first (implicitModules in node/index.ts), so that setTimeout === timers.setTimeout.

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

@@ -1,7 +1,8 @@
-// node:tls's shared parts (ADR 0019): SecureContext and createSecureContext (Node's
+// node:tls's shared parts: SecureContext and createSecureContext (Node's
 // internal/tls/common.js and secure-context.js) over the runtime's contexts (BoringSSL's SSL_CTX);
 // protocol versions; and Node's errors for what BoringSSL reports (OpenSSL 3's codes and messages,
 // as Node shows them: BoringSSL's reasons are OpenSSL's, its numbers aren't).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   fsReadFile, tlsCiphers, tlsContextAddCA, tlsContextAddRoots, tlsContextNew, tlsContextSetCert, tlsContextSetKey,
 } from "visaljs:host";
@@ -110,11 +111,16 @@ const VERIFY_MESSAGES = {
   HOSTNAME_MISMATCH: "hostname mismatch",
 };
 
+const SYSTEM_CA_HINTED = new Set(["UNABLE_TO_VERIFY_LEAF_SIGNATURE", "DEPTH_ZERO_SELF_SIGNED_CERT", "UNABLE_TO_GET_ISSUER_CERT"]);
+
 /** A certificate verification error (Node's: message, and the code that authorizationError gets),
  *  from X509_V_ERR_* or a name */
 export function verifyError(code) {
   const name = typeof code === "number" ? VERIFY_CODES[code] ?? "CERT_REJECTED" : code;
-  const error = new Error(VERIFY_MESSAGES[name] ?? name.toLowerCase().replace(/_/g, " "));
+  let message = VERIFY_MESSAGES[name] ?? name.toLowerCase().replace(/_/g, " ");
+  /* Node 24's hint (GetValidationErrorReason), for the errors a locally installed root CA may cause */
+  if (SYSTEM_CA_HINTED.has(name)) message += "; if the root CA is installed locally, try running Node.js with --use-system-ca";
+  const error = new Error(message);
   error.code = name;
   return error;
 }

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

@@ -1,4 +1,4 @@
-// TLSSocket, tls.Server and tls.connect (ADR 0019), following Node's internal/tls/wrap.js: the
+// TLSSocket, tls.Server and tls.connect, following Node's internal/tls/wrap.js: the
 // same events and the same order ('secure', then the client's verification and 'secureConnect',
 // or the server's 'secureConnection'; errors before control is released go to the server's
 // 'tlsClientError'). Where Node's TLSWrap (C++) sits between the socket's handle and OpenSSL,
@@ -6,6 +6,7 @@
 // (tlsRun), application data comes out and is pushed; written data goes in and records come out
 // 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).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   errnoName, netReadStart, netReadStop, netShutdown, netWrite, tlsExportKeyingMaterial, tlsFinished, tlsInfo, tlsNew, tlsPeerCerts,
   tlsRootCertificates, tlsRun, tlsSession, tlsSetNoRenegotiation, tlsShutdown, tlsVerifyError,
@@ -323,23 +324,13 @@ export class TLSSocket extends Socket {
     if (state & TLS_NEW_SESSION && !this._tlsOptions.isServer) this._onNewSession();
     if (state & TLS_FAILED && !this._tlsClosed) {
       this._tlsClosed = true;
-      this._onTlsError(this._failure(err));
+      this._onTlsError(tlsFailure(err));
     } else if (state & TLS_PEER_CLOSED) {
       this._peerEnded();
     }
     return taken;
   }
 
-  /* OpenSSL 3 reads a first record that isn't TLS ("HTTP/1.1 400 …") as too long where BoringSSL
-   * sees its version: Node's code is OpenSSL's */
-  _failure(err) {
-    const b = this._firstBytes;
-    if (Array.isArray(err) && err[2] === "WRONG_VERSION_NUMBER" && !this._secureEstablished && b && b.length >= 5 && ((b[3] << 8) | b[4]) > 16384 + 2048) {
-      return sslError(0x0A0000C6, "packet length too long");
-    }
-    return tlsFailure(err);
-  }
-
   /* a session the server gave (a TLS 1.3 ticket comes after the handshake): 'session', once the
    * server is verified (Node's onnewsessionclient) */
   _onNewSession() {
@@ -408,9 +399,6 @@ export class TLSSocket extends Socket {
   _onCipher(bytes) {
     if (this.destroyed) return;
     this._unrefTimer();
-    if (!this._secureEstablished && (!this._firstBytes || this._firstBytes.length < 5)) {
-      this._firstBytes = Buffer.concat([this._firstBytes ?? Buffer.alloc(0), bytes]).subarray(0, 5);
-    }
     if (this._tlsOptions.isServer && this._conn === null) {
       this._hello = this._hello ? Buffer.concat([this._hello, bytes]) : Buffer.from(bytes);
       if (this._helloPending) return;

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

@@ -1,4 +1,4 @@
-// X.509 certificates (ADR 0019) as Node shows them: the legacy object of getPeerCertificate()
+// X.509 certificates as Node shows them: the legacy object of getPeerCertificate()
 // and X509Certificate's toLegacyObject() (OpenSSL's printing: short attribute names, "IP Address:",
 // "Oct  6 22:08:31 2026 GMT", colon-separated fingerprints), from a small DER reader of our own.
 // PEM bundles split into DER here too, for SecureContext's `ca` and `cert`.

package/node/prelude/internal/tty_read_stream.js

@@ -0,0 +1,39 @@
+// node:tty's ReadStream, for programs whose code names it, or process.stdin (it links node:net and
+// libuv, which tty.isatty alone doesn't need): a terminal read as node:net's Socket, on libuv's
+// terminal handle (ttyOpen). tty.ReadStream builds this class, and is its prototype's constructor.
+import { ttyOpen, ttySetRawMode } from "visaljs:host";
+import { errnoException } from "./errors.js";
+import { Socket } from "../net.js";
+import { ReadStream, isatty } from "../tty.js";
+import { streams } from "./tty_streams.js";
+
+/** A terminal, read: Node's, a Socket on its handle that reads once something reads from it. */
+class TTYReadStream extends Socket {
+  constructor(fd, options) {
+    if (!isatty(fd)) throw errnoException(-22, "TTY initialization");  /* EINVAL, as Node's */
+    const id = ttyOpen(fd);
+    if (id < 0) throw errnoException(id, "TTY initialization");
+    super({ readableHighWaterMark: 0, ...options, handle: id, manualStart: true });
+    this.fd = fd;
+    this.isRaw = false;
+    this.isTTY = true;
+  }
+
+  /** Keys as they're typed, unechoed (raw), or lines the terminal edits (normal). */
+  setRawMode(flag) {
+    flag = Boolean(flag);
+    const err = this._handle === null ? -9 : ttySetRawMode(this._handle, flag);
+    if (err) {
+      this.emit("error", errnoException(err, "setRawMode"));
+      return this;
+    }
+    this.isRaw = flag;
+    return this;
+  }
+}
+
+/* instanceof tty.ReadStream holds, and its constructor is tty.ReadStream */
+ReadStream.prototype = TTYReadStream.prototype;
+Object.defineProperty(TTYReadStream.prototype, "constructor", { value: ReadStream, writable: true, configurable: true });
+Object.setPrototypeOf(ReadStream, Socket);
+streams.ReadStream = TTYReadStream;

package/node/prelude/internal/tty_streams.js

@@ -0,0 +1,3 @@
+// node:tty's stream classes, set by the modules that implement them (internal/tty_read_stream.js),
+// which programs get when their code names them.
+export const streams = { ReadStream: undefined };

package/node/prelude/internal/util_debuglog.js

@@ -0,0 +1,68 @@
+// util.debuglog (util.debug): loggers for NODE_DEBUG's sections. Linked into programs that name it
+// (internal/features.js).
+import { format, formatWithOptions, inspect } from "../util.js";
+import { features } from "./features.js";
+
+/* NODE_DEBUG's sections, as a test: a comma-separated list, * a wildcard */
+let debugEnabled;
+const debugImpls = Object.create(null);
+
+function testDebugEnabled(section) {
+  if (debugEnabled === undefined) {
+    const env = process.env.NODE_DEBUG;
+    if (env) {
+      const pattern = env.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replaceAll("*", ".*").replaceAll(",", "$|^");
+      const regex = new RegExp(`^${pattern}$`, "i");
+      debugEnabled = (str) => regex.exec(str) !== null;
+    } else debugEnabled = () => false;
+  }
+  return debugEnabled(section);
+}
+
+function debuglogImpl(enabled, set) {
+  if (debugImpls[set] === undefined) {
+    if (enabled) {
+      const pid = process.pid;
+      if (set === "HTTP" || set === "HTTP2") {
+        process.emitWarning("Setting the NODE_DEBUG environment variable to '" + set.toLowerCase() +
+          "' can expose sensitive data (such as passwords, tokens and authentication headers) in the resulting log.");
+      }
+      debugImpls[set] = function debug(...args) {
+        process.stderr.write(format("%s %s: %s\n", set, inspect(pid), formatWithOptions({ colors: false }, ...args)));
+      };
+    } else debugImpls[set] = () => {};
+  }
+  return debugImpls[set];
+}
+
+/** A logger for the section, writing to stderr when NODE_DEBUG names it (decided when first
+ *  used); `enabled` says whether it does. */
+function debuglog(set, cb) {
+  let enabled;
+  const init = () => {
+    set = set.toUpperCase();
+    enabled = testDebugEnabled(set);
+  };
+  let debug = (...args) => {
+    init();
+    debug = debuglogImpl(enabled, set);
+    if (typeof cb === "function") cb(debug);
+    debug(...args);
+  };
+  let test = () => {
+    init();
+    test = () => enabled;
+    return enabled;
+  };
+  const logger = (...args) => debug(...args);
+  Object.defineProperty(logger, "enabled", {
+    get() {
+      return test();
+    },
+    configurable: true,
+    enumerable: true,
+  });
+  return logger;
+}
+
+features.debuglog = debuglog;

package/node/prelude/internal/util_diff.js

@@ -0,0 +1,63 @@
+// util.diff: the edits between two strings or arrays, by Myers's algorithm. Linked into programs
+// that name it (internal/features.js).
+import { invalidArgType } from "./errors.js";
+import { features } from "./features.js";
+
+/** The edits from expected to actual (strings by character, or arrays by element): [op, value],
+ *  op 0 for both, 1 for actual's, -1 for expected's. Myers's algorithm, as node:assert's. */
+function diff(actual, expected) {
+  if (actual === expected) return [];
+  if (typeof actual !== "string" && !Array.isArray(actual)) throw invalidArgType("actual", "of type string or an instance of Array", actual);
+  if (typeof expected !== "string" && !Array.isArray(expected)) throw invalidArgType("expected", "of type string or an instance of Array", expected);
+  const n = actual.length;
+  const m = expected.length;
+  const max = n + m;
+  const v = new Int32Array(2 * max + 1);
+  const trace = [];
+  let done = false;
+  for (let d = 0; d <= max && !done; d++) {
+    trace.push(new Int32Array(v));
+    for (let k = -d; k <= d; k += 2) {
+      const offset = k + max;
+      let x = k === -d || (k !== d && v[offset - 1] < v[offset + 1]) ? v[offset + 1] : v[offset - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && actual[x] === expected[y]) {
+        x++;
+        y++;
+      }
+      v[offset] = x;
+      if (x >= n && y >= m) {
+        done = true;
+        break;
+      }
+    }
+  }
+  /* back from the end */
+  const result = [];
+  let x = n;
+  let y = m;
+  for (let d = trace.length - 1; d >= 0; d--) {
+    const tv = trace[d];
+    const k = x - y;
+    const prevK = k === -d || (k !== d && tv[k - 1 + max] < tv[k + 1 + max]) ? k + 1 : k - 1;
+    const prevX = tv[prevK + max];
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      result.push([0, actual[x - 1]]);
+      x--;
+      y--;
+    }
+    if (d > 0) {
+      if (x > prevX) {
+        result.push([1, actual[x - 1]]);
+        x--;
+      } else {
+        result.push([-1, expected[y - 1]]);
+        y--;
+      }
+    }
+  }
+  return result.reverse();
+}
+
+features.diff = diff;

package/node/prelude/internal/util_more.js

@@ -0,0 +1,111 @@
+// node:util's rarely used functions: callbackify, aborted, toUSVString, the
+// transferable AbortController and signal, getCallSites, setTraceSigInt,
+// convertProcessSignalToExitCode, and the deprecated isArray and _extend (Node 24 removed the other
+// is* and log). Linked into programs that name them (internal/features.js).
+import { osConstants } from "visaljs:host";
+import { deprecate } from "../util.js";
+import { codeError, invalidArgType, invalidArgValue, validateFunction } from "./errors.js";
+import { features } from "./features.js";
+
+/** A function returning a promise as one taking a callback (err, value) last. */
+function callbackify(original) {
+  validateFunction(original, "original");
+  function callbackified(...args) {
+    const maybeCb = args.pop();
+    validateFunction(maybeCb, "last argument");
+    const cb = maybeCb.bind(this);
+    Reflect.apply(original, this, args).then(
+      (ret) => process.nextTick(cb, null, ret),
+      (rej) => process.nextTick(callbackifyOnRejected, rej, cb),
+    );
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(original);
+  if (typeof descriptors.length.value === "number") descriptors.length.value++;
+  if (typeof descriptors.name.value === "string") descriptors.name.value += "Callbackified";
+  for (const descriptor of Object.values(descriptors)) Object.setPrototypeOf(descriptor, null);
+  Object.defineProperties(callbackified, descriptors);
+  return callbackified;
+}
+
+/* a falsy rejection becomes an Error, which keeps the value as its reason */
+function callbackifyOnRejected(reason, cb) {
+  if (!reason) {
+    const err = codeError(Error, "ERR_FALSY_VALUE_REJECTION", "Promise was rejected with falsy value");
+    err.reason = reason;
+    reason = err;
+  }
+  return cb(reason);
+}
+
+
+/** The string with its lone surrogates replaced by U+FFFD. */
+function toUSVString(input) {
+  return `${input}`.toWellFormed();
+}
+
+function validateAbortSignal(signal, name) {
+  if (signal === null || typeof signal !== "object" || !("aborted" in signal)) throw invalidArgType(name, "an instance of AbortSignal", signal);
+}
+
+/* the resources whose signal a promise waits for: the listener goes when they do */
+const abortedListeners = new WeakMap();
+
+/** A promise resolved when the signal aborts, while the resource is alive. */
+function aborted(signal, resource) {
+  validateAbortSignal(signal, "signal");
+  if (resource === null || (typeof resource !== "object" && typeof resource !== "function")) {
+    throw invalidArgType("resource", "of type object", resource);
+  }
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    signal.addEventListener("abort", () => resolve(), { once: true });
+    abortedListeners.set(resource, resolve);
+  });
+}
+
+/** Marks a signal as transferable to workers: a compiled program has none, so it's the signal. */
+function transferableAbortSignal(signal) {
+  validateAbortSignal(signal, "signal");
+  return signal;
+}
+
+function transferableAbortController() {
+  return new AbortController();
+}
+
+/** The call sites: a compiled program has no stack frames to give. */
+function getCallSites() {
+  return [];
+}
+
+/** The exit code of a process a signal ended: 128 and the signal's number, as a shell has it. */
+function convertProcessSignalToExitCode(signalCode) {
+  const table = osConstants()[0];  /* os.constants.signals': name, number, … */
+  const at = table.indexOf(signalCode);
+  if (typeof signalCode !== "string" || at < 0 || at % 2) {
+    const names = table.filter((_, i) => i % 2 === 0);
+    throw invalidArgValue("signalCode", "must be one of: " + names.map((n) => `'${n}'`).join(", "), signalCode);
+  }
+  return 128 + table[at + 1];
+}
+
+/** Whether SIGINT prints a stack trace: a compiled program has none to print. */
+function setTraceSigInt(enable) {
+  if (typeof enable !== "boolean") throw invalidArgType("enable", "of type boolean", enable);
+}
+
+/* ---- deprecated ---------------------------------------------------------------------------- */
+
+const _extend = deprecate(function _extend(target, source) {
+  if (source === null || typeof source !== "object") return target;
+  const keys = Object.keys(source);
+  let i = keys.length;
+  while (i--) target[keys[i]] = source[keys[i]];
+  return target;
+}, "The `util._extend` API is deprecated. Please use Object.assign() instead.", "DEP0060");
+
+const isArray = deprecate(Array.isArray, "The `util.isArray` API is deprecated. Please use `Array.isArray()` instead.", "DEP0044");
+Object.assign(features, {
+  callbackify, toUSVString, aborted, transferableAbortSignal, transferableAbortController, getCallSites, setTraceSigInt,
+  convertProcessSignalToExitCode, _extend, isArray,
+});

package/node/prelude/internal/util_styles.js

@@ -0,0 +1,76 @@
+// util.styleText, and util.inspect's colors and styles: the SGR codes of each style. Linked into
+// programs that name them (internal/features.js).
+import { utilInspect } from "visaljs:host";
+import { inspect } from "../util.js";
+import { codeError, invalidArgType, validateString } from "./errors.js";
+import { features } from "./features.js";
+
+/* the styles: [open, close] SGR codes, and aliases that aren't enumerated */
+inspect.colors = Object.assign(Object.create(null), {
+  reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], blink: [5, 25], inverse: [7, 27], hidden: [8, 28],
+  strikethrough: [9, 29], doubleunderline: [21, 24], black: [30, 39], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39],
+  magenta: [35, 39], cyan: [36, 39], white: [37, 39], bgBlack: [40, 49], bgRed: [41, 49], bgGreen: [42, 49], bgYellow: [43, 49],
+  bgBlue: [44, 49], bgMagenta: [45, 49], bgCyan: [46, 49], bgWhite: [47, 49], framed: [51, 54], overlined: [53, 55], gray: [90, 39],
+  redBright: [91, 39], greenBright: [92, 39], yellowBright: [93, 39], blueBright: [94, 39], magentaBright: [95, 39], cyanBright: [96, 39],
+  whiteBright: [97, 39], bgGray: [100, 49], bgRedBright: [101, 49], bgGreenBright: [102, 49], bgYellowBright: [103, 49],
+  bgBlueBright: [104, 49], bgMagentaBright: [105, 49], bgCyanBright: [106, 49], bgWhiteBright: [107, 49],
+});
+for (const [alias, name] of [["grey", "gray"], ["blackBright", "gray"], ["bgGrey", "bgGray"], ["bgBlackBright", "bgGray"], ["faint", "dim"],
+  ["crossedout", "strikethrough"], ["strikeThrough", "strikethrough"], ["crossedOut", "strikethrough"], ["conceal", "hidden"],
+  ["swapColors", "inverse"], ["swapcolors", "inverse"], ["doubleUnderline", "doubleunderline"]]) {
+  Object.defineProperty(inspect.colors, alias, {
+    get() {
+      return this[name];
+    },
+    set(value) {
+      Object.defineProperty(this, alias, { configurable: true, enumerable: true, writable: true, value });
+    },
+    configurable: true,
+    enumerable: false,
+  });
+}
+inspect.styles = Object.assign(Object.create(null), {
+  special: "cyan", number: "yellow", bigint: "yellow", boolean: "yellow", undefined: "grey", null: "bold", string: "green",
+  symbol: "green", date: "magenta", regexp: "red", module: "underline",
+});
+
+/* whether a stream gets colors: FORCE_COLOR says, else a terminal that NO_COLOR, NODE_DISABLE_COLORS
+ * and TERM=dumb don't turn off */
+function shouldColorize(stream) {
+  const env = process.env;
+  if (env.FORCE_COLOR !== undefined) return !["0", "false"].includes(env.FORCE_COLOR);
+  if (!stream?.isTTY) return false;
+  if (typeof stream.getColorDepth === "function") return stream.getColorDepth() > 2;
+  return env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
+}
+
+/** The text in the styles (a name or an array of names from inspect.colors), when the stream
+ *  shows colors (validateStream: false always styles it). */
+function styleText(format, text, { validateStream = true, stream = process.stdout } = {}) {
+  validateString(text, "text");
+  if (typeof validateStream !== "boolean") throw invalidArgType("validateStream", "of type boolean", validateStream);
+  let skipColorize = false;
+  if (validateStream) {
+    if (stream === null || typeof stream !== "object" || (typeof stream.write !== "function" && typeof stream.getReader !== "function" && typeof stream.getWriter !== "function")) {
+      throw invalidArgType("stream", "an instance of ReadableStream, WritableStream, or Stream", stream);
+    }
+    skipColorize = !shouldColorize(stream);
+  }
+  const formats = Array.isArray(format) ? format : [format];
+  let left = "";
+  let right = "";
+  for (const key of formats) {
+    if (key === "none") continue;
+    const code = inspect.colors[key];
+    if (code === undefined) {
+      throw codeError(TypeError, "ERR_INVALID_ARG_VALUE", "The argument 'format' must be one of: " +
+        Object.keys(inspect.colors).map((k) => `'${k}'`).join(", ") + ". Received " + utilInspect(key));
+    }
+    if (skipColorize) continue;
+    left += `\u001b[${code[0]}m`;
+    right = `\u001b[${code[1]}m` + right;
+  }
+  return skipColorize ? text : `${left}${text}${right}`;
+}
+
+features.styleText = styleText;

package/node/prelude/internal/zlib_engines.js

@@ -1,4 +1,4 @@
-// node:zlib's optional libraries (ADR 0012): Brotli's and zstd's host primitives are registered
+// node:zlib's optional libraries: Brotli's and zstd's host primitives are registered
 // here by internal/zlib_brotli.js and internal/zlib_zstd.js, implicit modules a program gets when
 // its own code names them, so a program that only gzips links neither (~800 and ~600 KB).
 export const engines = { brotli: null, zstd: null };