visaljs 0.0.8 → 0.0.10

package/node/prelude/https.js

@@ -7,10 +7,11 @@ import { Agent as HttpAgent, ClientRequest, Server as HttpServer } from "./http.
 import { invalidArgType } from "./internal/errors.js";
 import { Server as TlsServer, connect as tlsConnect } from "./tls.js";
 import { urlToHttpOptions } from "./url.js";
+import { callableClass } from "./internal/features.js";
 
 /* ---- Server ------------------------------------------------------------------------------------- */
 
-export class Server extends TlsServer {
+class ServerClass extends TlsServer {
   constructor(options, requestListener) {
     if (typeof options === "function") {
       requestListener = options;
@@ -28,6 +29,7 @@ export class Server extends TlsServer {
     });
   }
 }
+export const Server = callableClass(ServerClass, "Server");  /* Server(…) without new, as Node's */
 
 /* http.Server's methods: its requests, timeouts and connections */
 for (const key of Object.getOwnPropertyNames(HttpServer.prototype)) {
@@ -123,7 +125,7 @@ Agent.prototype._evictSession = function _evictSession(key) {
   delete this._sessionCache.map[key];
 };
 
-export const globalAgent = new Agent({ keepAlive: true, scheduling: "lifo", timeout: 5000 });
+export let globalAgent = new Agent({ keepAlive: true, scheduling: "lifo", timeout: 5000 });
 
 /* ---- request and get ---------------------------------------------------------------------------- */
 
@@ -145,4 +147,13 @@ export function get(input, options, cb) {
   return req;
 }
 
-export default { Agent, Server, createServer, get, globalAgent, request };
+export default {
+  Agent, Server, createServer, get, request,
+  /* an accessor, as Node's: a program may replace the agent requests use by default */
+  get globalAgent() {
+    return globalAgent;
+  },
+  set globalAgent(value) {
+    globalAgent = value;
+  },
+};

package/node/prelude/internal/events_extras.js

@@ -1,6 +1,7 @@
 // node:events' functions on emitters and EventTargets (getEventListeners, the max-listener
 // counts, addAbortListener) and EventEmitterAsyncResource. Linked into programs that name them
 // (internal/features.js).
+import { eventTargetListeners } from "visaljs:host";
 import { AsyncResource } from "../async_hooks.js";
 import { EventEmitter, EventEmitterAsyncResource as EventEmitterAsyncResourceWrapper } from "../events.js";
 import { invalidArgType } from "./errors.js";
@@ -18,11 +19,7 @@ function validateSignal(signal, name) {
 /** An emitter's listeners for the event, or an EventTarget's (as its listeners() would). */
 function getEventListeners(emitterOrTarget, type) {
   if (typeof emitterOrTarget?.listeners === "function") return emitterOrTarget.listeners(type);
-  if (isEventTarget(emitterOrTarget)) {
-    const e = new Error("getEventListeners of an EventTarget is not supported by visaljs yet");
-    e.code = "ERR_VISALJS_UNSUPPORTED";
-    throw e;
-  }
+  if (isEventTarget(emitterOrTarget)) return eventTargetListeners(emitterOrTarget, type) ?? [];
   throw invalidArgType("emitter", "an instance of EventEmitter or EventTarget", emitterOrTarget);
 }
 

package/node/prelude/internal/features.js

@@ -53,3 +53,20 @@ export function provideClass(Wrapper, Class) {
   Object.defineProperty(Class.prototype, "constructor", { value: Wrapper, writable: true, configurable: true });
   Object.setPrototypeOf(Wrapper, Object.getPrototypeOf(Class));
 }
+
+/** A class as Node's constructor functions are: callable without new (`http.Server(…)`, as
+ *  `new http.Server(…)`), and subclassed and tested with instanceof as the class. */
+export function callableClass(Class, name = Class.name) {
+  const Callable = function (...args) {
+    return Reflect.construct(Class, args, new.target ?? Callable);
+  };
+  Object.defineProperty(Callable, "name", { value: name });
+  Object.defineProperty(Callable, "length", { value: Class.length });
+  Object.setPrototypeOf(Callable, Object.getPrototypeOf(Class));
+  for (const key of Reflect.ownKeys(Class)) {
+    if (key !== "length" && key !== "name" && key !== "prototype") Object.defineProperty(Callable, key, Object.getOwnPropertyDescriptor(Class, key));
+  }
+  Callable.prototype = Class.prototype;
+  Object.defineProperty(Class.prototype, "constructor", { value: Callable, writable: true, configurable: true });
+  return Callable;
+}

package/node/prelude/internal/http_agent.js

@@ -3,6 +3,7 @@
 // response is done goes to freeSockets (unref'd, so it doesn't keep the program running) for
 // the next request to the same origin, until the agent's timeout or the server's Keep-Alive hint.
 // Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { httpGuard } from "visaljs:host";
 import { EventEmitter } from "../events.js";
 import { createConnection } from "../net.js";
 import { invalidArgType, invalidArgValue, outOfRange } from "./errors.js";
@@ -13,6 +14,73 @@ function freeSocketErrorListener() {
   this.emit("agentRemove");
 }
 
+/* Node's free socket data guard: bytes a socket reads while it waits in the pool (no request on it)
+ * would be taken for the next request's response; the socket is destroyed instead. The bytes are
+ * caught in C (httpGuard), before they reach the socket's stream; attaching the next request's
+ * parser takes the guard off. */
+const guardedSockets = new Map();  /* the guarded sockets, by their handle's id */
+
+function onGuardedData(id) {
+  const socket = guardedSockets.get(id);
+  guardedSockets.delete(id);
+  socket?.destroy();
+}
+
+/* Node's maybeEnableKeylog: the sockets' keylog events become the agent's */
+function maybeEnableKeylog(eventName) {
+  if (eventName !== "keylog") return;
+  this.removeListener("newListener", maybeEnableKeylog);
+  const emit = this.emit.bind(this);
+  this._onKeylog = function onkeylog(keylog) {
+    emit("keylog", keylog, this);  /* this: the socket */
+  };
+  for (const set of [this.freeSockets, this.sockets]) {
+    for (const sockets of Object.values(set)) for (const socket of sockets) socket.on("keylog", this._onKeylog);
+  }
+}
+
+function installFreeSocketDataGuard(socket) {
+  /* a TLS socket's reads are records (session tickets, alerts) before they're data: its own */
+  if (socket.encrypted) return;
+  if (socket.readableLength > 0) {
+    socket.destroy();
+    return;
+  }
+  if (socket.connecting) {
+    if (!socket._freeGuardConnect) {  /* once: a socket may come back to the pool before it connects */
+      socket._freeGuardConnect = () => {
+        socket._freeGuardConnect = undefined;
+        installFreeSocketDataGuard(socket);
+      };
+      socket.once("connect", socket._freeGuardConnect);
+    }
+    return;
+  }
+  const id = socket._handle;
+  if (typeof id === "number" && httpGuard(id, onGuardedData)) {
+    guardedSockets.set(id, socket);
+    socket._freeGuardId = id;
+    /* one listener while it's guarded, taken off when it's reused (a kept-alive socket comes back
+     * to the pool after each request) */
+    socket._freeGuardClose = () => removeFreeSocketDataGuard(socket);
+    socket.once("close", socket._freeGuardClose);
+  }
+}
+
+function removeFreeSocketDataGuard(socket) {
+  if (socket._freeGuardConnect) {
+    socket.removeListener("connect", socket._freeGuardConnect);
+    socket._freeGuardConnect = undefined;
+  }
+  if (socket._freeGuardClose) {
+    socket.removeListener("close", socket._freeGuardClose);
+    socket._freeGuardClose = undefined;
+  }
+  const id = socket._freeGuardId;
+  if (id !== undefined && guardedSockets.get(id) === socket) guardedSockets.delete(id);
+  socket._freeGuardId = undefined;
+}
+
 export function Agent(options) {
   if (!(this instanceof Agent)) return new Agent(options);
   EventEmitter.call(this);
@@ -29,6 +97,9 @@ export function Agent(options) {
   this.maxSockets = this.options.maxSockets || Agent.defaultMaxSockets;
   this.maxFreeSockets = this.options.maxFreeSockets || 256;
   this.scheduling = this.options.scheduling || "lifo";
+  /* what the server's Keep-Alive timeout is cut by, so the socket isn't reused as the server closes it */
+  const buffer = this.options.agentKeepAliveTimeoutBuffer;
+  this.agentKeepAliveTimeoutBuffer = typeof buffer === "number" && buffer >= 0 && Number.isFinite(buffer) ? buffer : 1000;
   this.maxTotalSockets = this.options.maxTotalSockets;
   this.totalSocketCount = 0;
   if (this.scheduling !== "fifo" && this.scheduling !== "lifo") throw invalidArgValue("scheduling", "must be one of: 'fifo', 'lifo'", this.scheduling);
@@ -39,6 +110,9 @@ export function Agent(options) {
     this.maxTotalSockets = Infinity;
   }
 
+  /* keylog events only once someone listens: then every socket's, the existing ones' too */
+  this.on("newListener", maybeEnableKeylog);
+
   /* a socket whose request is done: the next queued request's, kept alive, or destroyed */
   this.on("free", (socket, options) => {
     const name = this.getName(options);
@@ -70,6 +144,7 @@ export function Agent(options) {
     socket._httpMessage = null;
     this.removeSocket(socket, options);
     socket.once("error", freeSocketErrorListener);
+    installFreeSocketDataGuard(socket);
     freeSockets.push(socket);
   });
 }
@@ -131,7 +206,12 @@ Agent.prototype.addRequest = function addRequest(req, options, port, localAddres
   }
   const freeLen = freeSockets ? freeSockets.length : 0;
   const sockLen = freeLen + this.sockets[name].length;
+  /* a reused socket takes the request's highWaterMark, as Node's */
+  if (socket && options.highWaterMark != null && socket.writableHighWaterMark !== options.highWaterMark) {
+    socket._writableState.highWaterMark = options.highWaterMark;
+  }
   if (socket) {
+    removeFreeSocketDataGuard(socket);
     this.reuseSocket(socket, req);
     setRequestSocket(this, req, socket);
     this.sockets[name].push(socket);
@@ -163,6 +243,7 @@ Agent.prototype.createSocket = function createSocket(req, options, cb) {
     this.sockets[name].push(s);
     this.totalSocketCount++;
     installListeners(this, s, options);
+    if (this._onKeylog) s.on("keylog", this._onKeylog);
     cb(null, s);
   };
   if (this.keepAlive) {
@@ -244,7 +325,7 @@ Agent.prototype.keepSocketAlive = function keepSocketAlive(socket) {
   const hint = socket._httpMessage?.res?.headers["keep-alive"];
   const seconds = hint ? /^timeout=(\d+)/.exec(hint)?.[1] : undefined;
   if (seconds) {
-    let serverHintTimeout = parseInt(seconds, 10) * 1000 - 1000;
+    let serverHintTimeout = parseInt(seconds, 10) * 1000 - this.agentKeepAliveTimeoutBuffer;
     serverHintTimeout = serverHintTimeout > 0 ? serverHintTimeout : 0;
     if (serverHintTimeout === 0) canKeepSocketAlive = false;
     else if (serverHintTimeout < agentTimeout) agentTimeout = serverHintTimeout;
@@ -272,4 +353,9 @@ function setRequestSocket(agent, req, socket) {
   socket.setTimeout(req.timeout);
 }
 
-export const globalAgent = new Agent({ keepAlive: true, scheduling: "lifo", timeout: 5000 });
+export let globalAgent = new Agent({ keepAlive: true, scheduling: "lifo", timeout: 5000 });
+
+/* http.globalAgent's setter: the agent requests use by default from then on, as Node's */
+export function setGlobalAgent(agent) {
+  globalAgent = agent;
+}

package/node/prelude/internal/http_chars.ts

@@ -0,0 +1,22 @@
+"use static";
+// The characters HTTP allows in header names (a token, RFC 9110 §5.6.2) and values: Node's
+// tokenRegExp and headerCharRegex as loops, typed (setHeader checks both on every call).
+
+export function isHttpToken(s: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    const alnum = (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
+    /* ! # $ % & ' * + - . ^ _ ` | ~ */
+    if (!alnum && c !== 33 && !(c >= 35 && c <= 39) && c !== 42 && c !== 43 && c !== 45 && c !== 46 && c !== 94 && c !== 95 && c !== 96 && c !== 124 && c !== 126) return false;
+  }
+  return s.length > 0;
+}
+
+/** A character outside tab, 0x20-0x7e and 0x80-0xff. */
+export function hasInvalidHeaderChar(s: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if ((c < 32 && c !== 9) || c === 127 || c > 255) return true;
+  }
+  return false;
+}

package/node/prelude/internal/http_symbols.js

@@ -0,0 +1,3 @@
+// node:http's internal symbols that Node's node:_http_server exports: the server's
+// connections-checking timer.
+export const kConnectionsCheckingInterval = Symbol("http.server.connectionsCheckingInterval");

package/node/prelude/internal/net_bound.js

@@ -0,0 +1,123 @@
+// net.BoundSocket, as Node's: a TCP or pipe handle bound at once (its errors thrown by the
+// constructor), neither listening nor connecting until one Server (server.listen(bound)) or Socket
+// (new net.Socket({ handle: bound })) adopts it, which then owns it. No DNS: a host is an IP.
+// Linked into programs that name BoundSocket (internal/features.js); net.js adopts the handle
+// through features.adoptBoundSocket.
+import { netAddress, netBind, netClose, netFd, netOpen } from "visaljs:host";
+import { BoundSocket as Wrapper } from "../net.js";
+import { codeError, invalidArgType, invalidArgValue, validateString } from "./errors.js";
+import { features, provideClass } from "./features.js";
+import { isIP } from "./net.js";
+
+const kConsume = Symbol("kBoundSocketConsume");
+
+const adopted = () => codeError(Error, "ERR_SOCKET_HANDLE_ADOPTED", "The bound socket has already been adopted by a server or socket");
+
+function validateBoolean(value, name) {
+  if (typeof value !== "boolean") throw invalidArgType(name, "of type boolean", value);
+}
+
+class BoundSocket {
+  #handle = null;  /* the host handle's id, until adopted or closed */
+  #address = {};
+  #path;
+
+  constructor(options = {}) {
+    if (options === null || typeof options !== "object" || Array.isArray(options)) throw invalidArgType("options", "of type object", options);
+    if (options.path !== undefined) {
+      this.#bindPipe(options);
+      return;
+    }
+    const { exceptionWithHostPort, validatePort } = features.net;
+    const port = validatePort(options.port ?? 0, "options.port");
+    const ipv6Only = options.ipv6Only ?? false;
+    validateBoolean(ipv6Only, "options.ipv6Only");
+    const reusePort = options.reusePort ?? false;
+    validateBoolean(reusePort, "options.reusePort");
+    let { host } = options;
+    if (host === undefined || host === null) {
+      host = ipv6Only ? "::" : "0.0.0.0";
+    } else {
+      validateString(host, "options.host");
+      if (isIP(host) === 0) {
+        throw invalidArgValue("options.host", "must be a numeric IP address; net.BoundSocket does not perform DNS resolution", host);
+      }
+    }
+    const id = netOpen(false);
+    let err = netBind(id, host, port, (ipv6Only ? 1 : 0) | (reusePort ? 2 : 0));
+    /* libuv keeps a bind's EADDRINUSE for the next getsockname, listen or connect: asked now, so it
+     * throws here, as Node's */
+    if (err === 0) {
+      const a = netAddress(id, false);
+      if (typeof a === "number") err = a;
+      else this.#address = { address: a[0], family: a[1], port: a[2] };
+    }
+    if (err) {
+      netClose(id);
+      throw exceptionWithHostPort(err, "bind", host, port);
+    }
+    this.#handle = id;
+  }
+
+  /* a Unix domain socket's path (or a Windows named pipe's); one starting with "\0" is in Linux's
+   * abstract namespace */
+  #bindPipe(options) {
+    const { path, host, port, ipv6Only, reusePort } = options;
+    if (host !== undefined || port !== undefined || ipv6Only !== undefined || reusePort !== undefined) {
+      throw invalidArgValue("options", "path is mutually exclusive with host, port, ipv6Only, and reusePort", options);
+    }
+    validateString(path, "options.path");
+    if (path[0] === "\0" && process.platform !== "linux") {
+      throw invalidArgValue("options.path", "abstract socket paths are only supported on Linux", path);
+    }
+    const id = netOpen(true);
+    const err = netBind(id, path);
+    if (err) {
+      netClose(id);
+      throw features.net.errnoException(err, "bind");
+    }
+    this.#handle = id;
+    this.#path = path;
+  }
+
+  /* { address, family, port }, or a pipe's path */
+  address() {
+    if (this.#handle === null) throw adopted();
+    return this.#path ?? this.#address;
+  }
+
+  /* the descriptor, or -1 where sockets have none (Windows) */
+  fd() {
+    if (this.#handle === null) throw adopted();
+    const fd = netFd(this.#handle);
+    return fd < 0 ? -1 : fd;
+  }
+
+  close() {
+    if (this.#handle === null) throw adopted();
+    netClose(this.#handle);
+    this.#handle = null;
+  }
+
+  [Symbol.dispose]() {
+    if (this.#handle !== null) {
+      netClose(this.#handle);
+      this.#handle = null;
+    }
+  }
+
+  get isPipe() {
+    return this.#path !== undefined;
+  }
+
+  [kConsume]() {
+    if (this.#handle === null) throw adopted();
+    const id = this.#handle;
+    this.#handle = null;
+    return { id, path: this.#path };
+  }
+}
+
+/* the handle of a BoundSocket being adopted ({ id, path }), or null for anything else */
+features.adoptBoundSocket = (value) => (value instanceof BoundSocket ? value[kConsume]() : null);
+provideClass(Wrapper, BoundSocket);

package/node/prelude/internal/net_onread.js

@@ -0,0 +1,73 @@
+// net.Socket's onread option, as Node's: the bytes read go into the user's buffer, a buffer's worth
+// at a time, and to its callback instead of 'data'. The callback returning false, or pausing,
+// stops reading, as a read into that buffer would: the bytes not yet given wait for resume().
+// Linked into programs that name onread (internal/features.js).
+import { netReadStart, netReadStop } from "visaljs:host";
+import { features } from "./features.js";
+
+function deliver(socket, bytes) {
+  for (let at = 0; at < bytes.length;) {
+    const { buffer, callback } = socket._onread;
+    const buf = typeof buffer === "function" ? buffer() : buffer;
+    const n = Math.min(buf.length, bytes.length - at);
+    buf.set(bytes.subarray(at, at + n));
+    at += n;
+    const more = callback.call(socket, n, buf) !== false && socket._reading;
+    if (!more) {
+      if (at < bytes.length) socket._onreadRest = bytes.subarray(at);
+      return false;
+    }
+  }
+  return true;
+}
+
+features.onread = {
+  /* bytes read: false stops reading */
+  deliver,
+
+  /* a TLS socket's decrypted bytes: all of them, false when a callback asks to stop (its reads
+   * resume through its own stream, not the bytes kept here) */
+  deliverAll(socket, bytes) {
+    let more = true;
+    for (let at = 0; at < bytes.length;) {
+      const { buffer, callback } = socket._onread;
+      const buf = typeof buffer === "function" ? buffer() : buffer;
+      const n = Math.min(buf.length, bytes.length - at);
+      buf.set(bytes.subarray(at, at + n));
+      at += n;
+      if (callback.call(socket, n, buf) === false) more = false;
+    }
+    return more;
+  },
+
+  /* libuv takes a buffer for the read that finds EOF too: a buffer function is asked for one */
+  eof(socket) {
+    if (typeof socket._onread.buffer === "function") socket._onread.buffer();
+  },
+
+  /* Node's: pausing stops reading from the handle, resuming starts it (a TLS socket reads through
+   * its own stream) */
+  pause(socket) {
+    if (socket.encrypted || socket.connecting || socket._handle === null || !socket._reading) return;
+    socket._reading = false;
+    if (!socket.destroyed) {
+      const err = netReadStop(socket._handle);
+      if (err) socket.destroy(features.net.errnoException(err, "read"));
+    }
+  },
+
+  resume(socket) {
+    if (!socket.encrypted && !socket.connecting && socket._handle !== null && !socket._reading) socket._startReading();
+  },
+
+  /* reading again: the bytes left from the last read first, as the next read */
+  rest(socket) {
+    const rest = socket._onreadRest;
+    socket._onreadRest = null;
+    process.nextTick(() => {
+      if (socket.destroyed || socket._handle === null) return;
+      if (deliver(socket, rest)) netReadStart(socket._handle);
+      else socket._reading = false;
+    });
+  },
+};

package/node/prelude/internal/net_tos.js

@@ -0,0 +1,54 @@
+// net.Socket's type of service, as Node's: setTypeOfService, getTypeOfService and the
+// typeOfService option (IP_TOS, or IPV6_TCLASS on an IPv6 socket; on Windows, best effort). Linked
+// into programs that name it (internal/features.js).
+import { errnoName, netTypeOfService } from "visaljs:host";
+import { invalidArgType } from "./errors.js";
+import { features } from "./features.js";
+import { validateInt32 } from "./streams/validators.js";
+
+const isWindows = process.platform === "win32";
+const UV_EBADF = -9;
+
+/* Node's handle exists from connect() on, its descriptor only once connect(2) is under way:
+ * between the two, the option can't be set or read */
+const noDescriptor = (socket) => socket._handle === null && socket.connecting;
+
+features.validateTypeOfService = (tos) => validateInt32(tos, "options.typeOfService", 0, 255);
+
+/* kept until there's a handle */
+features.setTypeOfService = function (tos) {
+  if (Number.isNaN(tos)) throw invalidArgType("tos", "of type number", tos);
+  validateInt32(tos, "tos", 0, 255);
+  if (noDescriptor(this) && !this._isPipe && tos !== this._tos) {
+    this._tos = tos;
+    if (!isWindows) throw features.net.errnoException(UV_EBADF, "setTypeOfService");
+    return this;
+  }
+  if (this._handle === null || this._isPipe) {
+    this._tos = tos;
+    return this;
+  }
+  if (tos !== this._tos) {
+    this._tos = tos;
+    const err = netTypeOfService(this._handle, tos);
+    if (err && !isWindows) throw features.net.errnoException(err, "setTypeOfService");
+  }
+  return this;
+};
+
+features.getTypeOfService = function () {
+  if (noDescriptor(this) && !this._isPipe && !isWindows) throw features.net.errnoException(UV_EBADF, "getTypeOfService");
+  if (this._handle === null || this._isPipe) return this._tos !== undefined ? this._tos : 0;
+  const res = netTypeOfService(this._handle, -1);
+  if (res < 0) {
+    if (isWindows) return this._tos !== undefined ? this._tos : 0;
+    throw features.net.errnoException(res, "getTypeOfService");
+  }
+  return res;
+};
+
+/* the type of service given before the connection, set once it's made */
+features.applyTypeOfService = (socket) => {
+  const err = netTypeOfService(socket._handle, socket._tos);
+  if (err && errnoName(err) !== "EBADF" && !isWindows) socket.emit("error", features.net.errnoException(err, "setTypeOfService"));
+};

package/node/prelude/internal/perf_observe.js

@@ -109,7 +109,13 @@ class PerformanceResourceTiming extends PerformanceEntry {
   }
 }
 
-/* perf_hooks.js calls this with each mark and measure */
+/* 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);
 };

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

@@ -12,6 +12,7 @@ import {
   tlsRootCertificates, tlsRun, tlsSession, tlsSetNoRenegotiation, tlsShutdown, tlsVerifyError,
 } from "visaljs:host";
 import { codeError, invalidArgType, outOfRange, validateFunction, validateString } from "../errors.js";
+import { features } from "../features.js";
 import { isIP } from "../net.js";
 import { Server as NetServer, Socket } from "../../net.js";
 import { createSecureContext, SecureContext, sslError, tlsFailure, VERSION_NAMES, verifyError } from "./common.js";
@@ -343,7 +344,7 @@ export class TLSSocket extends Socket {
   _pushPlain(bytes) {
     this._unrefTimer();
     let more;
-    if (this._onread) more = this._deliver(bytes);
+    if (this._onread) more = features.onread.deliverAll(this, bytes);
     else more = this.push(bytes);
     if (!more && this._secureEstablished) this._stopReading();
   }