visaljs 0.0.7 → 0.0.9

package/node/prelude/internal/perf_histogram.js

@@ -0,0 +1,435 @@
+// perf_hooks' createHistogram and monitorEventLoopDelay: histograms as Node's, on HdrHistogram's
+// buckets (HdrHistogram_c's arithmetic, ported): values kept to `figures` significant digits, min
+// and max, mean and stddev from each bucket's median, percentiles as HdrHistogram's iterator gives
+// them. Linked into programs that name them (internal/features.js).
+// HdrHistogram_c's arithmetic is public domain (CC0), or BSD 2-clause:
+// node/third_party/hdrhistogram/LICENSE.
+import { codeError, invalidArgType } from "./errors.js";
+import { features } from "./features.js";
+
+const INT64_MAX = 2 ** 63;  /* HdrHistogram's INT64_MAX, as a double (Node shows 9223372036854776000) */
+const MAX_SAFE = Number.MAX_SAFE_INTEGER;
+
+/* an integer's bit length, exactly (Math.log2 rounds near powers of two above 2^31) */
+function bitLength(x) {
+  const high = Math.floor(x / 4294967296);
+  return high > 0 ? 64 - Math.clz32(high) : 32 - Math.clz32(x);
+}
+
+const outOfRange = (name, range, value) =>
+  codeError(RangeError, "ERR_OUT_OF_RANGE", `The value of "${name}" is out of range. It must be ${range}. Received ${value}`);
+
+/* HdrHistogram's state: its geometry and counts */
+class Hdr {
+  constructor(lowest, highest, figures) {
+    const largestSingleUnit = 2 * 10 ** figures;
+    const subBucketCountMagnitude = Math.ceil(Math.log2(largestSingleUnit));
+    this.subBucketHalfCountMagnitude = Math.max(subBucketCountMagnitude, 1) - 1;
+    this.unitMagnitude = Math.floor(Math.log2(lowest));
+    this.subBucketCount = 2 ** (this.subBucketHalfCountMagnitude + 1);
+    this.subBucketHalfCount = this.subBucketCount / 2;
+    this.subBucketMask = (this.subBucketCount - 1) * 2 ** this.unitMagnitude;
+    let smallestUntrackable = this.subBucketCount * 2 ** this.unitMagnitude;
+    let bucketsNeeded = 1;
+    while (smallestUntrackable <= highest) {
+      if (smallestUntrackable > MAX_SAFE / 2) {
+        bucketsNeeded++;
+        break;
+      }
+      smallestUntrackable *= 2;
+      bucketsNeeded++;
+    }
+    this.countsLen = (bucketsNeeded + 1) * this.subBucketHalfCount;
+    this.counts = new Float64Array(this.countsLen);
+    this.lowest = lowest;
+    this.highest = highest;
+    this.reset();
+  }
+
+  reset() {
+    this.counts.fill(0);
+    this.totalCount = 0;
+    this.minValue = INT64_MAX;
+    this.maxValue = 0;
+  }
+
+  /* the bucket of a value: its bit length above the sub-buckets' */
+  bucketIndex(value) {
+    const v = Math.max(value, 0) + 0;
+    const withMask = v > this.subBucketMask ? v : this.subBucketMask;  /* v | mask: the mask is all ones below its top */
+    const pow2ceiling = bitLength(withMask);
+    return pow2ceiling - this.unitMagnitude - (this.subBucketHalfCountMagnitude + 1);
+  }
+
+  subBucketIndex(value, bucketIndex) {
+    return Math.floor(value / 2 ** (bucketIndex + this.unitMagnitude));
+  }
+
+  countsIndex(bucketIndex, subBucketIndex) {
+    return (bucketIndex + 1) * 2 ** this.subBucketHalfCountMagnitude + (subBucketIndex - this.subBucketHalfCount);
+  }
+
+  indexOf(value) {
+    const b = this.bucketIndex(value);
+    return this.countsIndex(b, this.subBucketIndex(value, b));
+  }
+
+  valueAtIndex(index) {
+    let bucketIndex = Math.floor(index / 2 ** this.subBucketHalfCountMagnitude) - 1;
+    let subBucketIndex = (index % this.subBucketHalfCount) + this.subBucketHalfCount;
+    if (bucketIndex < 0) {
+      subBucketIndex -= this.subBucketHalfCount;
+      bucketIndex = 0;
+    }
+    return subBucketIndex * 2 ** (bucketIndex + this.unitMagnitude);
+  }
+
+  sizeOfRange(value) {
+    const b = this.bucketIndex(value);
+    const s = this.subBucketIndex(value, b);
+    return 2 ** (this.unitMagnitude + (s >= this.subBucketCount ? b + 1 : b));
+  }
+
+  lowestEquivalent(value) {
+    const b = this.bucketIndex(value);
+    return this.subBucketIndex(value, b) * 2 ** (b + this.unitMagnitude);
+  }
+
+  highestEquivalent(value) {
+    return this.lowestEquivalent(value) + this.sizeOfRange(value) - 1;
+  }
+
+  medianEquivalent(value) {
+    return this.lowestEquivalent(value) + Math.floor(this.sizeOfRange(value) / 2);
+  }
+
+  /** false when the value is beyond the histogram's range */
+  record(value, count = 1) {
+    if (value < 0) return false;
+    const index = this.indexOf(value);
+    if (index < 0 || index >= this.countsLen) return false;
+    this.counts[index] += count;
+    this.totalCount += count;
+    if (value < this.minValue && value !== 0) this.minValue = value;
+    if (value > this.maxValue) this.maxValue = value;
+    return true;
+  }
+
+  min() {
+    return this.totalCount === 0 ? INT64_MAX : this.lowestEquivalent(this.minValue);
+  }
+
+  max() {
+    return this.maxValue === 0 ? 0 : this.highestEquivalent(this.maxValue);
+  }
+
+  /* each recorded value's index and count */
+  *recorded() {
+    for (let i = 0; i < this.countsLen; i++) if (this.counts[i] !== 0) yield [this.valueAtIndex(i), this.counts[i]];
+  }
+
+  mean() {
+    let total = 0;
+    for (const [value, count] of this.recorded()) total += count * this.medianEquivalent(value);
+    return total / this.totalCount;
+  }
+
+  stddev() {
+    const mean = this.mean();
+    let total = 0;
+    for (const [value, count] of this.recorded()) {
+      const dev = this.medianEquivalent(value) - mean;
+      total += dev * dev * count;
+    }
+    return Math.sqrt(total / this.totalCount);
+  }
+
+  /* Node 24's skewness and excess kurtosis: the standardized third and fourth moments over each
+     bucket's median, 0 below 3 (4) values or with no variance */
+  moment(order) {
+    if (this.totalCount < order) return 0;
+    const mean = this.mean();
+    let m2 = 0, mk = 0;
+    for (const [value, count] of this.recorded()) {  /* Node's histogram.cc, operation for operation */
+      const dev = this.medianEquivalent(value) - mean;
+      const d2 = dev * dev;
+      m2 += count * d2;
+      mk += order === 3 ? count * d2 * dev : count * d2 * d2;
+    }
+    const n = this.totalCount;
+    const variance = m2 / n;
+    if (variance === 0) return 0;
+    return order === 3 ? (mk / n) / (variance * Math.sqrt(variance)) : (mk / n) / (variance * variance) - 3;
+  }
+
+  valueAtPercentile(percentile) {
+    const requested = Math.min(percentile, 100);
+    let countAtPercentile = Math.trunc((requested / 100) * this.totalCount + 0.5);
+    countAtPercentile = Math.max(countAtPercentile, 1);
+    let value = 0, seen = 0;
+    for (let i = 0; i < this.countsLen; i++) {
+      seen += this.counts[i];
+      if (seen >= countAtPercentile) {
+        value = this.valueAtIndex(i);
+        break;
+      }
+    }
+    return percentile === 0 ? this.lowestEquivalent(value) : this.highestEquivalent(value);
+  }
+
+  /* HdrHistogram's percentile iterator (one tick per half distance): [percentile, value] */
+  percentiles() {
+    const out = [];
+    let countsIndex = -1, cumulative = 0, count = 0, value = 0;
+    let toIterateTo = 0, seenLast = false;
+    const hasNext = () => cumulative < this.totalCount;
+    const moveNext = () => {
+      countsIndex++;
+      if (countsIndex >= this.countsLen) return false;
+      count = this.counts[countsIndex];
+      cumulative += count;
+      value = this.valueAtIndex(countsIndex);
+      return true;
+    };
+    const basicNext = () => (hasNext() && countsIndex < this.countsLen ? moveNext() : false);
+    for (;;) {
+      if (!hasNext()) {
+        if (seenLast) break;
+        seenLast = true;
+        out.push([100, value]);
+        continue;
+      }
+      if (countsIndex === -1 && !basicNext()) break;
+      let found = false;
+      do {
+        const current = (100 * cumulative) / this.totalCount;
+        if (count !== 0 && toIterateTo <= current) {
+          out.push([toIterateTo, value]);
+          const temp = Math.trunc(Math.log(100 / (100 - toIterateTo)) / Math.log(2)) + 1;
+          if (!Number.isFinite(temp)) return out;
+          toIterateTo += 100 / 2 ** temp;
+          found = true;
+          break;
+        }
+      } while (basicNext());
+      if (!found && !hasNext()) continue;
+    }
+    return out;
+  }
+}
+
+const kHdr = Symbol("kHdr");
+const kRecord = Symbol("kRecord");
+
+/** A histogram's figures (Node's Histogram). */
+class Histogram {
+  /* Node 24's exponentially weighted moving average of what's recorded, when a half-life is set:
+     alpha = 1 - 2^(-1/halfLife); with a threshold, the share above it too */
+  #ewma = { alpha: 0, threshold: 0, initialized: false, mean: 0, variance: 0, errorRate: 0 };
+
+  constructor(hdr, halfLife = 0, threshold = 0) {
+    this[kHdr] = hdr;
+    this.exceedsCount = 0;
+    if (halfLife > 0) this.#ewma.alpha = 1 - Math.exp(-Math.log(2) / halfLife);
+    this.#ewma.threshold = threshold;
+  }
+
+  /** Records a value (count times), counting it as exceeding when out of range. */
+  [kRecord](value, count = 1) {
+    if (!this[kHdr].record(value, count)) {
+      this.exceedsCount += count;
+      return;
+    }
+    const e = this.#ewma;
+    if (e.alpha <= 0) return;
+    if (!e.initialized) {
+      e.initialized = true;
+      e.mean = value;
+      e.variance = 0;
+      if (e.threshold > 0) e.errorRate = value > e.threshold ? 1 : 0;
+      return;
+    }
+    const diff = value - e.mean;
+    e.mean += e.alpha * diff;
+    e.variance = (1 - e.alpha) * (e.variance + e.alpha * diff * diff);
+    if (e.threshold > 0) e.errorRate += e.alpha * ((value > e.threshold ? 1 : 0) - e.errorRate);
+  }
+
+  get ewmaMean() {
+    return this.#ewma.initialized ? this.#ewma.mean : 0;
+  }
+  get ewmaStddev() {
+    return this.#ewma.initialized ? Math.sqrt(this.#ewma.variance) : 0;
+  }
+  get ewmaErrorRate() {
+    return this.#ewma.initialized ? this.#ewma.errorRate : 0;
+  }
+  get kurtosis() {
+    return this[kHdr].moment(4);
+  }
+  get skewness() {
+    return this[kHdr].moment(3);
+  }
+
+  get count() {
+    return this[kHdr].totalCount;
+  }
+  get countBigInt() {
+    return BigInt(this.count);
+  }
+  get min() {
+    return this[kHdr].min();
+  }
+  get minBigInt() {
+    return this[kHdr].totalCount === 0 ? 9223372036854775807n : BigInt(this.min);
+  }
+  get max() {
+    return this[kHdr].max();
+  }
+  get maxBigInt() {
+    return BigInt(this.max);
+  }
+  get mean() {
+    return this[kHdr].mean();
+  }
+  get stddev() {
+    return this[kHdr].stddev();
+  }
+  get exceeds() {
+    return this.exceedsCount;
+  }
+  get exceedsBigInt() {
+    return BigInt(this.exceedsCount);
+  }
+  get percentiles() {
+    return new Map(this[kHdr].percentiles());
+  }
+  get percentilesBigInt() {
+    return new Map(this[kHdr].percentiles().map(([p, v]) => [p, BigInt(v)]));
+  }
+
+  percentile(percentile) {
+    if (typeof percentile !== "number") throw invalidArgType("percentile", "of type number", percentile);
+    if (!(percentile > 0 && percentile <= 100)) throw outOfRange("percentile", "> 0 && <= 100", percentile);
+    return this[kHdr].valueAtPercentile(percentile);
+  }
+
+  percentileBigInt(percentile) {
+    return BigInt(this.percentile(percentile));
+  }
+
+  reset() {
+    this[kHdr].reset();
+    this.exceedsCount = 0;
+    Object.assign(this.#ewma, { initialized: false, mean: 0, variance: 0, errorRate: 0 });
+  }
+
+  toJSON() {
+    return {
+      count: this.count, min: this.min, max: this.max, mean: this.mean, exceeds: this.exceeds, stddev: this.stddev,
+      skewness: this.skewness, kurtosis: this.kurtosis, ewmaMean: this.ewmaMean, ewmaStddev: this.ewmaStddev,
+      ewmaErrorRate: this.ewmaErrorRate, percentiles: Object.fromEntries(this.percentiles),
+    };
+  }
+}
+
+/** createHistogram's: record values, deltas, other histograms. */
+class RecordableHistogram extends Histogram {
+  #previous = 0;
+
+  record(val) {
+    if (typeof val === "bigint") val = Number(val);
+    else if (typeof val !== "number") throw invalidArgType("val", "of type number", val);
+    if (!(val >= 1 && val <= MAX_SAFE)) throw outOfRange("val", ">= 1 && <= 9007199254740991", val);
+    this[kRecord](val);
+  }
+
+  /** The time since the last call (ns): nothing on the first. */
+  recordDelta() {
+    const [s, ns] = process.hrtime();
+    const now = s * 1e9 + ns;
+    if (this.#previous !== 0) {
+      const delta = now - this.#previous;
+      if (delta >= 1) this[kRecord](delta);
+    }
+    this.#previous = now;
+  }
+
+  add(other) {
+    if (!(other instanceof Histogram)) throw invalidArgType("other", "an instance of RecordableHistogram", other);
+    for (const [value, count] of other[kHdr].recorded()) {
+      if (!this[kHdr].record(value, count)) this.exceedsCount += count;
+    }
+    if (other[kHdr].totalCount > 0) {
+      this[kHdr].minValue = Math.min(this[kHdr].minValue, other[kHdr].minValue);
+      this[kHdr].maxValue = Math.max(this[kHdr].maxValue, other[kHdr].maxValue);
+    }
+  }
+}
+
+function integerOption(options, name, fallback, min) {
+  const value = options[name] ?? fallback;
+  if (typeof value !== "number" && typeof value !== "bigint") throw invalidArgType(`options.${name}`, "of type number", value);
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < min || n > MAX_SAFE) throw outOfRange(`options.${name}`, `>= ${min} && <= 9007199254740991`, value);
+  return n;
+}
+
+/** createHistogram({ lowest = 1, highest = Number.MAX_SAFE_INTEGER, figures = 3, halfLife = 0, threshold = 0 }). */
+function createHistogram(options = {}) {
+  if (options === null || typeof options !== "object") throw invalidArgType("options", "of type object", options);
+  const lowest = integerOption(options, "lowest", 1, 1);
+  const highest = integerOption(options, "highest", MAX_SAFE, 2 * lowest);
+  const figures = options.figures ?? 3;
+  if (typeof figures !== "number") throw invalidArgType("options.figures", "of type number", figures);
+  if (!Number.isInteger(figures) || figures < 1 || figures > 5) throw outOfRange("options.figures", ">= 1 && <= 5", figures);
+  /* Node 24: the moving average's half-life (in values) and threshold */
+  const { halfLife = 0, threshold = 0 } = options;
+  if (typeof halfLife !== "number") throw invalidArgType("options.halfLife", "of type number", halfLife);
+  if (halfLife < 0) throw outOfRange("options.halfLife", ">= 0", halfLife);
+  if (typeof threshold !== "number") throw invalidArgType("options.threshold", "of type number", threshold);
+  if (threshold < 0) throw outOfRange("options.threshold", ">= 0", threshold);
+  return new RecordableHistogram(new Hdr(lowest, highest, figures), halfLife, threshold);
+}
+
+/** monitorEventLoopDelay's: the event loop's delay sampled every resolution ms, in ns. */
+class IntervalHistogram extends Histogram {
+  #timer = null;
+  #resolution;
+  #previous = 0;
+
+  constructor(hdr, resolution) {
+    super(hdr);
+    this.#resolution = resolution;
+  }
+
+  enable() {
+    if (this.#timer !== null) return false;
+    this.#previous = 0;
+    this.#timer = globalThis.setInterval(() => {
+      const [s, ns] = process.hrtime();
+      const now = s * 1e9 + ns;
+      if (this.#previous !== 0) this[kRecord](now - this.#previous);
+      this.#previous = now;
+    }, this.#resolution);
+    this.#timer.unref?.();
+    return true;
+  }
+
+  disable() {
+    if (this.#timer === null) return false;
+    globalThis.clearInterval(this.#timer);
+    this.#timer = null;
+    return true;
+  }
+}
+
+class ELDHistogram extends IntervalHistogram {}
+
+function monitorEventLoopDelay(options = {}) {
+  if (options === null || typeof options !== "object") throw invalidArgType("options", "of type object", options);
+  const resolution = integerOption(options, "resolution", 10, 1);
+  return new ELDHistogram(new Hdr(1, MAX_SAFE, 3), resolution);
+}
+
+Object.assign(features, { createHistogram, monitorEventLoopDelay });

package/node/prelude/internal/perf_observe.js

@@ -0,0 +1,125 @@
+// perf_hooks' PerformanceObserver, PerformanceObserverEntryList and PerformanceResourceTiming, as
+// Node's: marks and measures go to the observers of their type, delivered together in a later
+// setImmediate, sorted by start time; buffered gives an observer the entries made before it.
+// Linked into programs that name them (internal/features.js).
+import {
+  PerformanceObserver as ObserverWrapper, PerformanceObserverEntryList as ListWrapper, PerformanceResourceTiming as ResourceWrapper,
+  PerformanceEntry, performance,
+} from "../perf_hooks.js";
+import { codeError, invalidArgType } from "./errors.js";
+import { features, provideClass } from "./features.js";
+
+const kConstruct = Symbol("construct");
+const supportedEntryTypes = Object.freeze(["dns", "function", "gc", "http", "http2", "mark", "measure", "net", "quic", "resource"]);  /* Node 24's */
+const observers = new Set();
+
+const byStartTime = (entries) => entries.slice().sort((a, b) => a.startTime - b.startTime);
+
+class PerformanceObserverEntryList {
+  #entries;
+
+  constructor(key, entries) {
+    if (key !== kConstruct) throw codeError(TypeError, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
+    this.#entries = byStartTime(entries);
+  }
+
+  getEntries() {
+    return this.#entries.slice();
+  }
+
+  getEntriesByType(type) {
+    return this.#entries.filter((e) => e.entryType === `${type}`);
+  }
+
+  getEntriesByName(name, type) {
+    return this.#entries.filter((e) => e.name === `${name}` && (type === undefined || e.entryType === `${type}`));
+  }
+}
+
+class PerformanceObserver {
+  #callback;
+  #types = new Set();
+  #pending = [];
+  #scheduled = false;
+
+  constructor(callback) {
+    if (typeof callback !== "function") throw invalidArgType("callback", "of type function", callback);
+    this.#callback = callback;
+  }
+
+  static get supportedEntryTypes() {
+    return supportedEntryTypes;
+  }
+
+  /** observe({ entryTypes }) or observe({ type, buffered }). */
+  observe(options = {}) {
+    if (options === null || typeof options !== "object") throw invalidArgType("options", "of type object", options);
+    const { entryTypes, type, buffered } = options;
+    if (entryTypes === undefined && type === undefined) {
+      throw codeError(TypeError, "ERR_MISSING_ARGS", 'The "options.entryTypes" and "options.type" arguments must be specified');
+    }
+    if (entryTypes !== undefined && type !== undefined) {
+      throw codeError(TypeError, "ERR_INVALID_ARG_VALUE", "The argument 'options.entryTypes' can not be used with 'options.type'");
+    }
+    if (entryTypes !== undefined) {
+      if (!Array.isArray(entryTypes)) throw invalidArgType("options.entryTypes", "an instance of Array", entryTypes);
+      this.#types = new Set(entryTypes.filter((t) => supportedEntryTypes.includes(t)));
+    } else {
+      if (!supportedEntryTypes.includes(type)) return;
+      this.#types.add(type);
+      if (buffered) for (const entry of performance.getEntriesByType(type)) this._enqueue(entry);
+    }
+    if (this.#types.size > 0) observers.add(this);
+    else this.disconnect();
+  }
+
+  disconnect() {
+    observers.delete(this);
+    this.#types.clear();
+    this.#pending = [];
+  }
+
+  takeRecords() {
+    const records = this.#pending;
+    this.#pending = [];
+    return records;
+  }
+
+  _observes(type) {
+    return this.#types.has(type);
+  }
+
+  /* an entry for the callback, which runs once in a later setImmediate with all of them */
+  _enqueue(entry) {
+    this.#pending.push(entry);
+    if (this.#scheduled) return;
+    this.#scheduled = true;
+    setImmediate(() => {
+      this.#scheduled = false;
+      const entries = this.takeRecords();
+      if (entries.length) this.#callback(new PerformanceObserverEntryList(kConstruct, entries), this);
+    });
+  }
+}
+
+/** A fetch's timing: made by Node's fetch, which a compiled program's fetch doesn't record. */
+class PerformanceResourceTiming extends PerformanceEntry {
+  constructor() {
+    throw codeError(TypeError, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
+  }
+}
+
+/* whether an observer takes entries of this type: net.js times a connect only then */
+features.perfObserving = (type) => {
+  for (const observer of observers) if (observer._observes(type)) return true;
+  return false;
+};
+
+/* perf_hooks.js calls this with each mark and measure, net.js with a connect's entry */
+features.perfObserve = (entry) => {
+  for (const observer of observers) if (observer._observes(entry.entryType)) observer._enqueue(entry);
+};
+provideClass(ObserverWrapper, PerformanceObserver);
+provideClass(ListWrapper, PerformanceObserverEntryList);
+provideClass(ResourceWrapper, PerformanceResourceTiming);
+Object.defineProperty(ObserverWrapper, "supportedEntryTypes", { get: () => supportedEntryTypes, configurable: true });

package/node/prelude/internal/performance_global.js

@@ -0,0 +1,19 @@
+// Node's performance globals: node:perf_hooks' performance and its classes. A program that may
+// use them gets this module first (implicitModules in node/index.ts). As in Node, `performance`
+// is an accessor (an assignment changes what it gives), and the classes are non-enumerable.
+import { Performance, PerformanceEntry, PerformanceMark, PerformanceMeasure, performance } from "../perf_hooks.js";
+
+let current = performance;
+Object.defineProperty(globalThis, "performance", {
+  get() {
+    return current;
+  },
+  set(value) {
+    current = value;
+  },
+  enumerable: true,
+  configurable: true,
+});
+for (const [name, value] of Object.entries({ Performance, PerformanceEntry, PerformanceMark, PerformanceMeasure })) {
+  Object.defineProperty(globalThis, name, { value, writable: true, enumerable: false, configurable: true });
+}

package/node/prelude/internal/process_events.js

@@ -1,7 +1,8 @@
-// process as an EventEmitter (ADR 0012): the runtime's process, in every binary, is a plain
+// process as an EventEmitter: the runtime's process, in every binary, is a plain
 // object. A program that may call its emitter methods gets this module first (the driver adds it:
 // implicitModules in node/index.ts), and the runtime emits process's events through its emit.
 import { EventEmitter } from "../events.js";
+import { invalidArgType, validateString } from "./errors.js";
 
 const p = globalThis.process;
 
@@ -12,3 +13,50 @@ process.prototype = Object.create(EventEmitter.prototype, {
 });
 Object.setPrototypeOf(p, process.prototype);
 EventEmitter.init.call(p);
+
+/* emitWarning, as Node's (lib/internal/process/warning.js): the warning as an Error (name the
+ * type, code, detail), printed by the runtime's emitWarning (Node's own 'warning' listener), and
+ * emitted as 'warning' on the next tick */
+const printWarning = p.emitWarning;
+p.emitWarning = function emitWarning(warning, type, code, ctor) {
+  if (p.noDeprecation && type === "DeprecationWarning") return;
+  let detail;
+  if (type !== null && typeof type === "object" && !Array.isArray(type)) {
+    ctor = type.ctor;
+    code = type.code;
+    if (typeof type.detail === "string") detail = type.detail;
+    type = type.type || "Warning";
+  } else if (typeof type === "function") {
+    ctor = type;
+    code = undefined;
+    type = "Warning";
+  }
+  if (type !== undefined) validateString(type, "type");
+  if (typeof code === "function") {
+    ctor = code;
+    code = undefined;
+  } else if (code !== undefined) {
+    validateString(code, "code");
+  }
+  if (typeof warning === "string") {
+    warning = new Error(warning);
+    warning.name = String(type || "Warning");
+    if (code !== undefined) warning.code = code;
+    if (detail !== undefined) warning.detail = detail;
+    if (typeof Error.captureStackTrace === "function") Error.captureStackTrace(warning, ctor || p.emitWarning);
+  } else if (!(warning instanceof Error)) {
+    throw invalidArgType("warning", "of type string or an instance of Error", warning);
+  }
+  if (warning.name === "DeprecationWarning") {
+    if (p.noDeprecation) return;
+    if (p.throwDeprecation) {
+      p.nextTick(() => {
+        throw warning;
+      });
+      return;
+    }
+  }
+  const text = typeof warning.detail === "string" ? `${warning.message}\n${warning.detail}` : warning.message;
+  printWarning.call(p, text, String(warning.name), warning.code === undefined ? undefined : String(warning.code));
+  p.nextTick(() => p.emit("warning", warning));
+};

package/node/prelude/internal/process_memory.js

@@ -0,0 +1,14 @@
+// process.memoryUsage(): added to the runtime's process when the program may call it
+// (implicitModules in node/index.ts), since it links libuv. heapTotal and heapUsed are the GC
+// heap's; a compiled program has no separate external or ArrayBuffer accounting (0).
+import { processMemory } from "visaljs:host";
+
+function memoryUsage() {
+  const [rss, heapTotal, heapUsed] = processMemory();
+  return { rss, heapTotal, heapUsed, external: 0, arrayBuffers: 0 };
+}
+memoryUsage.rss = function rss() {
+  return processMemory()[0];
+};
+
+Object.defineProperty(globalThis.process, "memoryUsage", { value: memoryUsage, writable: true, enumerable: true, configurable: true });