visaljs 0.0.6 → 0.0.8

package/node/prelude/fs_promises.js

@@ -1,24 +1,130 @@
-// node:fs/promises (ADR 0012, layer 3): node:fs's synchronous calls, their outcome as a promise.
+// node:fs/promises: node:fs's synchronous calls, their outcome as a promise.
 // The I/O happens when the function is called, not on libuv's thread pool as in Node.
 import {
-  appendFileSync, existsSync, lstatSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync,
+  constants, accessSync, chmodSync, chownSync, closeSync, copyFileSync, fsyncSync, lchownSync, linkSync, lstatSync, lutimesSync, mkdirSync,
+  mkdtempSync, openSync, readdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, symlinkSync,
+  truncateSync, unlinkSync, utimesSync, writeFileSync, writeSync, statfsSync,
 } from "./fs.js";
+import { codeError } from "./internal/errors.js";
+import { features, lazyFunction } from "./internal/features.js";
+import { getOptions, validateStringAfterArrayBufferView } from "./internal/fs_utils.js";
+import { AbortError } from "./internal/streams/errors.js";
+import { validateAbortSignal, validateBoolean } from "./internal/streams/validators.js";
+import { resolve } from "./path.js";
 
 const promised = (fn) => async (...args) => fn(...args);
 
-export const readFile = promised(readFileSync);
-export const writeFile = promised(writeFileSync);
-export const appendFile = promised(appendFileSync);
+function checkAborted(signal) {
+  if (signal?.aborted) throw new AbortError(undefined, { cause: signal.reason });
+}
+
+/* with a signal, a turn of the event loop before the I/O, as Node's opens on its thread pool: an
+ * abort the program queues meanwhile stops it */
+async function abortable(signal) {
+  checkAborted(signal);
+  if (signal) {
+    await new Promise((resolve) => setImmediate(resolve));
+    checkAborted(signal);
+  }
+}
+
+/* a FileHandle given as the path: its own method (fs_filehandle.js) */
+const isFileHandle = (path) => features.FileHandle !== undefined && path instanceof features.FileHandle;
+
+export async function readFile(path, options) {
+  options = getOptions(options, { flag: "r" });
+  validateAbortSignal(options.signal, "options.signal");
+  if (isFileHandle(path)) return path.readFile(options);
+  await abortable(options.signal);
+  return readFileSync(path, options);
+}
+
+const isIterable = (data) =>
+  data != null && typeof data === "object" && (typeof data[Symbol.asyncIterator] === "function" || typeof data[Symbol.iterator] === "function");
+
+/** The data written: a string, bytes, or an iterable or stream of them. */
+export async function writeFile(path, data, options) {
+  options = getOptions(options, { encoding: "utf8", mode: 0o666, flag: "w", flush: false });
+  validateBoolean(options.flush ?? false, "options.flush");
+  const iterable = !ArrayBuffer.isView(data) && isIterable(data);
+  if (!ArrayBuffer.isView(data) && !iterable) {
+    validateStringAfterArrayBufferView(data, "data");
+    data = Buffer.from(data, options.encoding || "utf8");
+  }
+  validateAbortSignal(options.signal, "options.signal");
+  if (isFileHandle(path)) return path.writeFile(data, options);
+  await abortable(options.signal);
+  if (!iterable) return writeFileSync(path, data, options);
+  const fd = openSync(path, options.flag || "w", options.mode);
+  try {
+    for await (const chunk of data) {
+      checkAborted(options.signal);
+      const bytes = ArrayBuffer.isView(chunk) ? chunk : Buffer.from(chunk, options.encoding || "utf8");
+      for (let off = 0; off < bytes.byteLength;) off += writeSync(fd, bytes, off, bytes.byteLength - off, null);
+    }
+    if (options.flush) fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export async function appendFile(path, data, options) {
+  options = { ...getOptions(options, { encoding: "utf8", mode: 0o666, flag: "a" }) };
+  options.flag ||= "a";
+  return writeFile(path, data, options);
+}
 export const stat = promised(statSync);
 export const lstat = promised(lstatSync);
 export const readdir = promised(readdirSync);
 export const unlink = promised(unlinkSync);
+export const realpath = promised(realpathSync);
+export const mkdir = promised(mkdirSync);
+export const utimes = promised(utimesSync);
 
-/** Whether the path exists (the mode isn't checked). */
-export async function access(path) {
-  if (!existsSync(path)) {
-    statSync(path);  /* throws Node's ENOENT (or the error that stopped it) */
-  }
+export const access = promised(accessSync);
+export const rename = promised(renameSync);
+export const copyFile = promised(copyFileSync);
+export const link = promised(linkSync);
+export const symlink = promised(symlinkSync);
+export const readlink = promised(readlinkSync);
+export const chmod = promised(chmodSync);
+export const chown = promised(chownSync);
+export const lchown = promised(lchownSync);
+export const lutimes = promised(lutimesSync);
+export const truncate = promised(truncateSync);
+export const mkdtemp = promised(mkdtempSync);
+
+/** mkdtemp's directory with a way to remove it, and what it holds: remove(), or an `await using`
+ *  declaration (Symbol.asyncDispose). */
+export async function mkdtempDisposable(prefix, options) {
+  const path = mkdtempSync(prefix, options);
+  const fullPath = resolve(process.cwd(), `${path}`);
+  const remove = async () => rmSync(fullPath, { recursive: true, force: true });
+  return { path, remove, [Symbol.asyncDispose]() { return remove(); } };
 }
+export const rmdir = promised(rmdirSync);
+export const rm = promised(rmSync);
+
+/* read when called: fs.js and this module import each other, and fs.js's consts may not be set yet */
+export const statfs = async (...args) => statfsSync(...args);
+export { constants };
+
+/* lchmod: macOS's only, as Node's */
+export async function lchmod() {
+  throw codeError(Error, "ERR_METHOD_NOT_IMPLEMENTED", "The lchmod() method is not implemented");
+}
+
+/* their own modules, linked when the program names them (internal/features.js) */
+export const open = lazyFunction("promisesOpen", 3);
+export const opendir = lazyFunction("opendirPromise", 2);
+export const cp = lazyFunction("cpPromise", 3);
+export const glob = lazyFunction("globPromise", 2);
+export const watch = lazyFunction("watchPromise", 2);
 
-export default { readFile, writeFile, appendFile, stat, lstat, readdir, unlink, access };
+export default {
+  readFile, writeFile, appendFile, stat, lstat, readdir, unlink, realpath, mkdir, utimes, access, rename, copyFile, link, symlink, readlink,
+  chmod, chown, lchown, lutimes, truncate, mkdtemp, mkdtempDisposable, rmdir, rm, statfs, lchmod, open, opendir, cp, glob, watch,
+  get constants() {
+    return constants;
+  },
+};

package/node/prelude/http.js

@@ -1,4 +1,4 @@
-// node:http (ADR 0012, layer 3), the server side: createServer, Server, IncomingMessage and
+// node:http, the server side: createServer, Server, IncomingMessage and
 // ServerResponse. As in Node, a Server is a net.Server and a request's socket a net.Socket, whose
 // bytes llhttp parses in C (node/src/host_http.c) before JS would see them. Responses are
 // written as Node writes them: the status line, the headers in the order set, then Date,
@@ -7,7 +7,9 @@
 // upgrade (or CONNECT) hands the socket over with 'upgrade' ('connect'). Idle keep-alive
 // connections close after keepAliveTimeout; server.timeout and setTimeout are the sockets'.
 // Not yet: the client, headersTimeout and requestTimeout, trailers.
-import { httpAttach, httpDate, httpDetach, httpExpired, httpFlush, httpParsers, httpWrite, timerUnref } from "visaljs:host";
+import {
+  httpAttach, httpDate, httpDetach, httpExpired, httpFedClose, httpFedOpen, httpFeed, httpFlush, httpParsers, httpWrite, timerUnref,
+} from "visaljs:host";
 import { bindContext, currentContext, runInContext } from "./internal/async_context.js";
 import { codeError, invalidArgType, outOfRange, validateInteger, validateString } from "./internal/errors.js";
 import { Agent, globalAgent } from "./internal/http_agent.js";
@@ -75,13 +77,18 @@ export class IncomingMessage extends Readable {
     this.aborted = false;
     this.statusCode = null;
     this.statusMessage = null;
+    /* Node's: read yet, and dumped (stream utils' isServerRequest tells a request by them) */
+    this._consuming = false;
+    this._dumped = false;
   }
 
   get connection() {
     return this.socket;
   }
 
-  _read() {}
+  _read() {
+    this._consuming = true;
+  }
 
   /* a response nobody reads: its body is discarded, so the socket isn't held up */
   _dump() {
@@ -290,9 +297,23 @@ export class ServerResponse extends OutgoingMessage {
     return this;
   }
 
+  /* the head a write sends without writeHead, through writeHead as Node's: a wrapper of it runs
+   * (on-headers: compression sets Vary and Content-Encoding there). Middleware calls it too, before
+   * writing (compression). `length`: the whole body's, when end() knows it */
+  _implicitHeader(length) {
+    this._implicitLength = length;
+    try {
+      this.writeHead(this.statusCode);
+    } finally {
+      this._implicitLength = undefined;
+    }
+  }
+
   /* sends the head now: the body that follows is chunked */
   flushHeaders() {
-    if (!this.headersSent) httpWrite(this._conn, this._renderHead(undefined));
+    if (!this.headersSent && Object.hasOwn(this, "writeHead")) this._implicitHeader(undefined);  /* a wrapper sees it */
+    const head = this._takeHead(undefined);
+    if (head) httpWrite(this._conn, head);
   }
 
   destroy(error) {
@@ -331,7 +352,7 @@ export class ServerResponse extends OutgoingMessage {
     }
     /* Node renders the head now (sent with the first write): without a known length, the body
      * is chunked even when end() brings all of it */
-    if (!this.headersSent) this._pendingHead = this._renderHead(undefined);
+    if (!this.headersSent) this._pendingHead = this._renderHead(this._implicitLength);
     return this;
   }
 
@@ -347,7 +368,8 @@ export class ServerResponse extends OutgoingMessage {
   _renderHead(length) {
     const status = this.statusCode;
     const noBody = status === 204 || status === 304 || (status >= 100 && status < 200);
-    let head = "HTTP/1.1 " + status + " " + (this.statusMessage ?? STATUS_CODES[status] ?? "unknown") + "\r\n";
+    /* an empty statusMessage gets the standard one, as in Node (Next.js's route handlers set "") */
+    let head = "HTTP/1.1 " + status + " " + (this.statusMessage || STATUS_CODES[status] || "unknown") + "\r\n";
     for (const [, [name, value]] of this._headers) {
       if (Array.isArray(value)) for (const v of value) head += name + ": " + v + "\r\n";
       else head += name + ": " + value + "\r\n";
@@ -385,11 +407,14 @@ export class ServerResponse extends OutgoingMessage {
     if (this.writableEnded || this.destroyed) {
       const e = new Error(this.destroyed ? "Cannot call write after a stream was destroyed" : "write after end");
       e.code = this.destroyed ? "ERR_STREAM_DESTROYED" : "ERR_STREAM_WRITE_AFTER_END";
-      queueMicrotask(() => this.emit("error", e));
+      /* Node's emitErrorNt: none on a destroyed response (its client went away) */
+      if (!this.destroyed) queueMicrotask(() => this.emit("error", e));
       if (typeof callback === "function") queueMicrotask(() => callback(e));
       return false;
     }
     if (typeof chunk === "string" && typeof encoding === "string" && encoding !== "utf8" && encoding !== "utf-8") chunk = Buffer.from(chunk, encoding);
+    /* a writeHead of the response's own (a wrapper) sees the implicit head, as in Node */
+    if (!this.headersSent && Object.hasOwn(this, "writeHead")) this._implicitHeader(undefined);
     const head = this._takeHead(undefined);
     if (head) httpWrite(this._conn, head);
     if (chunk !== undefined && chunk !== null && chunkLength(chunk) > 0 && !this._head) {
@@ -414,6 +439,7 @@ export class ServerResponse extends OutgoingMessage {
     }
     if (this.writableEnded) return this;
     if (typeof chunk === "string" && typeof encoding === "string" && encoding !== "utf8" && encoding !== "utf-8") chunk = Buffer.from(chunk, encoding);
+    if (!this.headersSent && Object.hasOwn(this, "writeHead")) this._implicitHeader(chunk !== undefined && chunk !== null ? chunkLength(chunk) : 0);
     if (!this.headersSent) {
       const hasChunk = chunk !== undefined && chunk !== null;
       const length = hasChunk ? chunkLength(chunk) : 0;
@@ -455,23 +481,29 @@ const requestTimeoutResponse = "HTTP/1.1 408 Request Timeout\r\nConnection: clos
 
 function noop() {}
 
+/** (options, requestListener) or (requestListener): the options an object. */
+function serverArguments(options, requestListener) {
+  if (typeof options === "function") return [{}, options];
+  if (options === undefined || options === null) return [{}, requestListener];
+  if (typeof options !== "object") throw invalidArgType("options", "of type object", options);
+  return [options, requestListener];
+}
+
 export class Server extends NetServer {
   constructor(options, requestListener) {
-    if (typeof options === "function") {
-      requestListener = options;
-      options = {};
-    } else if (options === undefined || options === null) {
-      options = {};
-    } else if (typeof options !== "object") {
-      throw invalidArgType("options", "of type object", options);
-    }
+    [options, requestListener] = serverArguments(options, requestListener);
     super({ allowHalfOpen: true, noDelay: options.noDelay ?? true, keepAlive: options.keepAlive, keepAliveInitialDelay: options.keepAliveInitialDelay });
+    this._initHttp(options, requestListener, "connection");
+  }
+
+  /* Node's storeHTTPOptions and the server's timeouts, and its sockets' requests: those of each
+   * 'connection' (https.Server's: of each 'secureConnection') */
+  _initHttp(options, requestListener, connectionEvent) {
     if (typeof requestListener === "function") this.on("request", requestListener);
     this.httpAllowHalfOpen = false;
     this.timeout = 0;
     this.maxHeadersCount = null;
     this.maxRequestsPerSocket = 0;
-    /* Node's storeHTTPOptions and the server's timeouts */
     const integer = (name, fallback) => {
       const value = options[name];
       if (value === undefined) return fallback;
@@ -499,7 +531,7 @@ export class Server extends NetServer {
     this._checking = null;  /* the connections-checking timer, unref'd, while listening */
     this._parsers = -1;
     this._states = new Map();  /* connection → { socket, req, res, keepAliveTimeoutSet } */
-    this.on("connection", (socket) => this._onSocket(socket));
+    this.on(connectionEvent, (socket) => this._onSocket(socket));
     this.on("listening", () => this._checkConnectionsLater());
   }
 
@@ -544,7 +576,7 @@ export class Server extends NetServer {
   /* a connection: its bytes go to llhttp; its end, timeout, errors and close are the requests' */
   _onSocket(socket) {
     if (this._parsers === -1) {
-      /* in the async context of the connection's (ADR 0020), as the server's sockets' callbacks */
+      /* in the async context of the connection's, as the server's sockets' callbacks */
       this._parsers = httpParsers(...[
         (conn, method, url, raw, major, minor, keepAlive, upgrade) => this._onRequest(conn, method, url, raw, major, minor, keepAlive, upgrade),
         (conn, chunk) => this._states.get(conn)?.req?._push(chunk),
@@ -571,7 +603,7 @@ export class Server extends NetServer {
         },
       ].map(bindContext));
     }
-    const conn = socket._handle;
+    const conn = connOf(socket);
     if (conn === null) return;
     const state = { socket, conn, req: null, res: null, keepAliveTimeoutSet: false, listeners: null };
     this._states.set(conn, state);
@@ -658,6 +690,7 @@ export class Server extends NetServer {
     this._states.delete(conn);
     for (const [event, fn] of Object.entries(state.listeners)) socket.removeListener(event, fn);
     if (socket.listenerCount("error") === 0) socket.on("error", noop);
+    unfeed(socket);
     /* what the socket reads next goes to its stream, buffered until someone reads it */
     socket._readableState.flowing = null;
     const bodyHead = Buffer.from(head.buffer, head.byteOffset, head.byteLength);
@@ -667,13 +700,53 @@ export class Server extends NetServer {
   }
 }
 
+/* ---- Connections: llhttp on a socket's handle, or fed --------------------------------------- */
+
+/* A socket whose bytes aren't its handle's: a TLSSocket's handle carries ciphertext, a Duplex
+ * has none. llhttp parses what it reads ('data') and writes through it (write()). */
+const isFed = (socket) => socket.encrypted === true || socket._handle === undefined;
+const kFed = Symbol("kFed");
+
+/** The socket's connection for llhttp: its net handle's id (the parser reads the handle in C), or a
+ *  fed connection, made the first time; null for a net socket without a handle yet. */
+function connOf(socket) {
+  if (!isFed(socket)) return socket._handle;
+  const fed = socket[kFed];
+  if (fed) return fed.conn;
+  const conn = httpFedOpen((bytes) => {
+    if (!socket.destroyed) socket.write(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+  });
+  const onData = (chunk) => httpFeed(conn, typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  const onEnd = () => httpFeed(conn, null);
+  const onClose = () => unfeed(socket);
+  socket[kFed] = { conn, onData, onEnd, onClose };
+  socket.on("data", onData);
+  socket.on("end", onEnd);
+  socket.on("close", onClose);
+  return conn;
+}
+
+/** A socket's connection if it has one: its handle's id, or its fed connection's. */
+const connKey = (socket) => (isFed(socket) ? socket[kFed]?.conn : socket._handle);
+
+/* the socket's bytes stop going to llhttp: it upgraded, or closed */
+function unfeed(socket) {
+  const fed = socket[kFed];
+  if (!fed) return;
+  socket[kFed] = undefined;
+  socket.removeListener("data", fed.onData);
+  socket.removeListener("end", fed.onEnd);
+  socket.removeListener("close", fed.onClose);
+  httpFedClose(fed.conn);
+}
+
 /* Node's socketOnError: 'clientError', or a 400 (when nothing was written yet) and the end */
 function socketOnError(e) {
   this.removeListener("error", socketOnError);
   if (this.listenerCount("error") === 0) this.on("error", noop);
   const server = this.server;
   if (!server.emit("clientError", e, this)) {
-    const state = server._states.get(this._handle);
+    const state = server._states.get(connKey(this));
     const res = state?.res;
     if (this.writable && (!res || !res.headersSent)) {
       if (state) httpFlush(state.conn);
@@ -702,11 +775,11 @@ function urlToHttpOptions(url) {
   return options;
 }
 
-/* the sockets whose responses llhttp parses: handle id → socket */
+/* the sockets whose responses llhttp parses: connection → socket */
 const clientSockets = new Map();
 let clientParsers = -1;
 
-/* the async context a request was made in (ADR 0020): its response's callbacks run in it, as in
+/* the async context a request was made in: its response's callbacks run in it, as in
  * Node, whichever request's the socket was */
 const kAsyncContext = Symbol("kAsyncContext");
 const inRequestContext = (fn) => (conn, ...args) =>
@@ -776,12 +849,15 @@ const statusIsInformational = (status) => status < 200 && status >= 100 && statu
 /* the socket's bytes go to a response parser: now, or once it has connected */
 function attachParser(socket, req) {
   const attach = () => {
-    if (socket._httpMessage !== req || socket._handle === null) return;
-    clientSockets.set(socket._handle, socket);
-    socket._clientConn = socket._handle;
-    httpAttach(socket._handle, clientParsersId(), true, req.maxHeaderSize ?? maxHeaderSize);
+    if (socket._httpMessage !== req) return;
+    const conn = connOf(socket);
+    if (conn === null) return;
+    clientSockets.set(conn, socket);
+    socket._clientConn = conn;
+    httpAttach(conn, clientParsersId(), true, req.maxHeaderSize ?? maxHeaderSize);
   };
-  if (socket.connecting || socket._handle === null) socket.once("connect", attach);
+  /* a net socket's handle is its once connected; a fed socket's bytes come as they come */
+  if (!isFed(socket) && (socket.connecting || socket._handle === null)) socket.once("connect", attach);
   else attach();
 }
 
@@ -833,6 +909,7 @@ function clientUpgrade(req, socket, head) {
   if (req.timeoutCb) socket.removeListener("timeout", req.timeoutCb);
   socket.removeListener("timeout", responseOnTimeout);
   freeParser(socket);
+  unfeed(socket);
   const bodyHead = Buffer.from(head.buffer, head.byteOffset, head.byteLength);
   const eventName = req.method === "CONNECT" ? "connect" : "upgrade";
   if (req.listenerCount(eventName) > 0) {

package/node/prelude/http2.js

@@ -1,4 +1,4 @@
-// node:http2 (ADR 0012, layer 3): only what code that supports both HTTP versions touches when it
+// node:http2: only what code that supports both HTTP versions touches when it
 // runs on HTTP/1 — the request and response classes (for instanceof checks, which never match
 // here) and the constants. Servers and sessions aren't provided: creating one throws.
 import { notSupported } from "./internal/errors.js";

package/node/prelude/https.js

@@ -0,0 +1,148 @@
+// node:https (Node's lib/https.js): HTTP over TLS. Server is a tls.Server whose secure connections
+// get http.Server's requests (llhttp fed the decrypted bytes: http.js's fed connections); Agent is
+// http.Agent connecting with tls.connect, reusing TLS sessions by origin; request and get are
+// http's, with https's agent and port 443.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { Agent as HttpAgent, ClientRequest, Server as HttpServer } from "./http.js";
+import { invalidArgType } from "./internal/errors.js";
+import { Server as TlsServer, connect as tlsConnect } from "./tls.js";
+import { urlToHttpOptions } from "./url.js";
+
+/* ---- Server ------------------------------------------------------------------------------------- */
+
+export class Server extends TlsServer {
+  constructor(options, requestListener) {
+    if (typeof options === "function") {
+      requestListener = options;
+      options = {};
+    } else if (options === undefined || options === null) {
+      options = {};
+    } else if (typeof options !== "object") {
+      throw invalidArgType("options", "of type object", options);
+    }
+    super({ noDelay: true, ALPNProtocols: ["http/1.1"], ...options });
+    this._initHttp(options, requestListener, "secureConnection");
+    /* a handshake that fails is the client's error, as a request that does */
+    this.on("tlsClientError", (err, conn) => {
+      if (!this.emit("clientError", err, conn)) conn.destroy(err);
+    });
+  }
+}
+
+/* http.Server's methods: its requests, timeouts and connections */
+for (const key of Object.getOwnPropertyNames(HttpServer.prototype)) {
+  if (key === "constructor" || Object.hasOwn(Server.prototype, key)) continue;
+  Object.defineProperty(Server.prototype, key, Object.getOwnPropertyDescriptor(HttpServer.prototype, key));
+}
+
+export function createServer(options, requestListener) {
+  return new Server(options, requestListener);
+}
+
+/* ---- Agent -------------------------------------------------------------------------------------- */
+
+/* tls.connect with the agent's options, resuming the origin's last session */
+function createConnection(port, host, options) {
+  if (port !== null && typeof port === "object") options = port;
+  else if (host !== null && typeof host === "object") options = { ...host };
+  else if (options === null || typeof options !== "object") options = {};
+  else options = { ...options };
+  if (typeof port === "number") options.port = port;
+  if (typeof host === "string") options.host = host;
+  if (options._agentKey) {
+    const session = this._getSession(options._agentKey);
+    if (session) options = { session, ...options };
+  }
+  const socket = tlsConnect(options);
+  if (options._agentKey) {
+    socket.on("session", (session) => this._cacheSession(options._agentKey, session));
+    socket.once("close", (err) => {
+      if (err) this._evictSession(options._agentKey);
+    });
+  }
+  return socket;
+}
+
+/** http.Agent over TLS: port 443, and the TLS options in each origin's name. */
+export function Agent(options) {
+  if (!(this instanceof Agent)) return new Agent(options);
+  HttpAgent.call(this, options);
+  this.defaultPort = 443;
+  this.protocol = "https:";
+  this.maxCachedSessions = this.options.maxCachedSessions;
+  if (this.maxCachedSessions === undefined) this.maxCachedSessions = 100;
+  this._sessionCache = { map: {}, list: [] };
+}
+Object.setPrototypeOf(Agent.prototype, HttpAgent.prototype);
+Object.setPrototypeOf(Agent, HttpAgent);
+Agent.prototype.createConnection = createConnection;
+
+/* the origin with what makes its TLS connections differ: sockets aren't shared across them */
+const nameOptions = ["ca", "cert", "clientCertEngine", "ciphers", "key", "pfx", "rejectUnauthorized", "servername", "minVersion",
+  "maxVersion", "secureProtocol", "crl", "honorCipherOrder", "ecdhCurve", "dhparam", "secureOptions", "sessionIdContext", "sigalgs",
+  "privateKeyIdentifier", "privateKeyEngine"];
+
+Agent.prototype.getName = function getName(options = {}) {
+  let name = HttpAgent.prototype.getName.call(this, options);
+  for (const key of nameOptions) {
+    name += ":";
+    const value = options[key];
+    if (key === "rejectUnauthorized") {
+      if (value !== undefined) name += value;
+    } else if (key === "servername") {
+      if (value && value !== options.host) name += value;
+    } else if (value) {
+      name += value;
+    }
+  }
+  return name;
+};
+
+Agent.prototype._getSession = function _getSession(key) {
+  return this._sessionCache.map[key];
+};
+
+Agent.prototype._cacheSession = function _cacheSession(key, session) {
+  if (this.maxCachedSessions === 0) return;
+  if (this._sessionCache.map[key]) {
+    this._sessionCache.map[key] = session;
+    return;
+  }
+  if (this._sessionCache.list.length >= this.maxCachedSessions) {
+    const oldKey = this._sessionCache.list.shift();
+    delete this._sessionCache.map[oldKey];
+  }
+  this._sessionCache.list.push(key);
+  this._sessionCache.map[key] = session;
+};
+
+Agent.prototype._evictSession = function _evictSession(key) {
+  const index = this._sessionCache.list.indexOf(key);
+  if (index === -1) return;
+  this._sessionCache.list.splice(index, 1);
+  delete this._sessionCache.map[key];
+};
+
+export const globalAgent = new Agent({ keepAlive: true, scheduling: "lifo", timeout: 5000 });
+
+/* ---- request and get ---------------------------------------------------------------------------- */
+
+/** request(url[, options][, callback]) or request(options[, callback]): an http.ClientRequest
+ *  with https's agent. */
+export function request(...args) {
+  let options = {};
+  if (typeof args[0] === "string") options = urlToHttpOptions(new URL(args.shift()));
+  else if (args[0] instanceof URL) options = urlToHttpOptions(args.shift());
+  if (args[0] && typeof args[0] !== "function") Object.assign(options, args.shift());
+  options._defaultAgent = globalAgent;
+  args.unshift(options);
+  return new ClientRequest(...args);
+}
+
+export function get(input, options, cb) {
+  const req = request(input, options, cb);
+  req.end();
+  return req;
+}
+
+export default { Agent, Server, createServer, get, globalAgent, request };

package/node/prelude/inspector.js

@@ -0,0 +1,27 @@
+// node:inspector: a compiled program has no V8 inspector to connect to. It loads as in a Node
+// process no debugger is attached to: url() is undefined, close() does nothing, console is the
+// global console. What needs the inspector throws when called: open, waitForDebugger and a Session.
+// Code that loads it only to ask whether a debugger is attached (Next.js's server) runs; code that
+// profiles or debugs on request fails when asked (TypeScript's --generateCpuProfile).
+import { notSupported } from "./internal/errors.js";
+
+export function open() {
+  throw notSupported("inspector.open() (a compiled program has no V8 inspector)");
+}
+export function close() {}
+export function url() {
+  return undefined;
+}
+export function waitForDebugger() {
+  throw notSupported("inspector.waitForDebugger() (a compiled program has no V8 inspector)");
+}
+export const console = globalThis.console;
+export class Session {
+  constructor() {
+    throw notSupported("inspector.Session (a compiled program has no V8 inspector)");
+  }
+}
+export const Network = {};
+export const NetworkResources = {};
+
+export default { open, close, url, waitForDebugger, console, Session, Network, NetworkResources };

package/node/prelude/inspector_promises.js

@@ -0,0 +1,4 @@
+// node:inspector/promises: as node:inspector, a compiled program has no V8 inspector: it loads,
+// with no debugger attached, and what needs one throws when called.
+export * from "./inspector.js";
+export { default } from "./inspector.js";

package/node/prelude/internal/async_context.js

@@ -1,4 +1,4 @@
-// The async context (ADR 0020): the value the runtime carries through jobs, timers and promise
+// The async context: the value the runtime carries through jobs, timers and promise
 // reactions, which node:async_hooks' AsyncLocalStorage keeps its stores in (a frame: a Map from
 // each storage to its store, never changed once current). I/O callbacks run under none: the
 // prelude binds each to the context it was registered in, as Node runs a handle's callbacks in

package/node/prelude/internal/buffer_transcode.js

@@ -0,0 +1,44 @@
+// buffer.transcode: bytes in one encoding as bytes in another. Linked into programs that name it
+// (internal/features.js).
+import { features } from "./features.js";
+
+/* transcode's encodings, by Buffer's names for them */
+const transcodable = { ascii: "ascii", latin1: "latin1", binary: "latin1", ucs2: "utf16le", "ucs-2": "utf16le", utf16le: "utf16le", "utf-16le": "utf16le", utf8: "utf8", "utf-8": "utf8" };
+
+/** The bytes in one encoding as bytes in another: ascii, latin1, ucs2 or utf8. A character the
+ *  target can't hold becomes "?", as Node's (ICU's) transcode makes it. */
+function transcode(source, fromEncoding, toEncoding) {
+  if (!(source instanceof Uint8Array)) {
+    const e = new TypeError(`The "source" argument must be an instance of Buffer or Uint8Array.${received(source)}`);
+    e.code = "ERR_INVALID_ARG_TYPE";
+    throw e;
+  }
+  if (source.length === 0) return Buffer.alloc(0);
+  const from = transcodable[String(fromEncoding).toLowerCase()];
+  const to = transcodable[String(toEncoding).toLowerCase()];
+  if (from === undefined || to === undefined) {
+    const e = new Error("Unable to transcode Buffer [U_ILLEGAL_ARGUMENT_ERROR]");
+    e.code = "U_ILLEGAL_ARGUMENT_ERROR";
+    e.errno = 1;
+    throw e;
+  }
+  let text = Buffer.from(source.buffer, source.byteOffset, source.byteLength).toString(from);
+  const max = to === "ascii" ? 0x7f : to === "latin1" ? 0xff : -1;
+  if (max >= 0) {
+    let out = "";
+    for (const ch of text) out += ch.codePointAt(0) > max ? "?" : ch;
+    text = out;
+  }
+  return Buffer.from(text, to);
+}
+
+/* Node's "Received …" for the message */
+function received(value) {
+  if (value === null || value === undefined) return ` Received ${value}`;
+  if (typeof value === "function") return ` Received function ${value.name}`;
+  if (typeof value === "object") return ` Received an instance of ${value.constructor?.name ?? "Object"}`;
+  const shown = typeof value === "string" ? `'${value.length > 25 ? value.slice(0, 25) + "..." : value}'` : String(value);
+  return ` Received type ${typeof value} (${shown})`;
+}
+
+features.transcode = transcode;