@volter/tabnode 0.2.14-volter.88

package/src/node-lib/binding/stream_wrap.ts

@@ -0,0 +1,413 @@
+/**
+ * `internalBinding('stream_wrap')`: the libuv stream surface, and nothing above it.
+ *
+ * `internal/stream_base_commons.js` is Node's own and is vendored unmodified;
+ * it writes through `handle.writeBuffer(req, buf)` and its string cousins and
+ * reads through `handle.onread(arrayBuffer)` with the byte count in
+ * `streamBaseState[kReadBytesOrError]`. That is the whole contract, and this
+ * file implements exactly it over the engine's loopback pairing: two handles
+ * whose writes are each other's reads.
+ *
+ * Nothing here implements anything Node's files implement. There is no
+ * buffering policy, no half-open rule, no timeout: those are `net.js`'s, and
+ * `net.js` is vendored.
+ */
+import { bytesOfString } from './buffer';
+import { UV_EOF, UV_EBADF, UV_ECONNRESET } from './uv';
+
+/**
+ * The bytes this view names. Node's `Buffer.from` of a short string is a
+ * window on an 8 KB pool (`Buffer.poolSize`); taking `view.buffer` without
+ * `byteOffset` / `byteLength` carries the neighbours that sit beside it.
+ */
+function ownedBytes(view: Uint8Array): Uint8Array {
+  const copy = new Uint8Array(view.byteLength);
+  copy.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+  return copy;
+}
+import {
+  registerHandle, refHandle, unrefHandle, handleHasRef, releaseHandle, stopHandle,
+  type OwnedHandle,
+} from './handles';
+
+/** The four slots libuv's `StreamBase` reports a read or a write through. */
+export const kReadBytesOrError = 0;
+export const kArrayBufferOffset = 1;
+export const kBytesWritten = 2;
+export const kLastWriteWasAsync = 3;
+export const streamBaseState = new Int32Array(4);
+
+/** Node's `WriteWrap`: the request `writeGeneric` fills and hands to a write. */
+export class WriteWrap {
+  handle: LibuvStreamWrap | null = null;
+  oncomplete: ((status: number) => void) | null = null;
+  async = false;
+  bytes = 0;
+  buffer: unknown = null;
+  callback: unknown = null;
+  error: unknown = undefined;
+  _chunks: unknown = null;
+}
+
+/** Node's `ShutdownWrap`: the request a `_final` hands to `shutdown`. */
+export class ShutdownWrap {
+  handle: LibuvStreamWrap | null = null;
+  oncomplete: ((status: number) => void) | null = null;
+  callback: (() => void) | null = null;
+}
+
+let nextAsyncId = 1;
+
+/**
+ * The bytes one direction of a pairing is carrying, oldest first, and the
+ * handle a write of them carried. A descriptor crosses an IPC channel beside
+ * the bytes of the message it belongs to and is read out of the receiver just
+ * before those bytes reach it, which is the order `setupChannel` in Node's
+ * `internal/child_process.js` reads them in.
+ */
+interface Inbound {
+  bytes: Uint8Array;
+  handle?: unknown;
+}
+
+/**
+ * The base every `TCP` and `Pipe` extends, as `LibuvStreamWrap` is the base of
+ * libuv's `uv_stream_t` wrappers.
+ *
+ * A pairing is two of these with `peer` pointing at each other. A write copies
+ * its bytes and hands them to the peer on a microtask, because libuv never
+ * delivers a read inside the write that caused it; the peer delivers them to
+ * `onread` while it is reading and holds them while it is not, which is what
+ * `readStart` and `readStop` mean.
+ */
+export class LibuvStreamWrap implements OwnedHandle {
+  /** Set by `net.js` to `onStreamRead`; the only way bytes reach a stream. */
+  onread: ((arrayBuffer: ArrayBuffer | null) => unknown) | null = null;
+  /** `net.js` owns this flag; `readStart`/`readStop` follow it. */
+  reading = false;
+  bytesRead = 0;
+  bytesWritten = 0;
+  /** Nothing is ever queued: a write is taken whole by the peer. */
+  writeQueueSize = 0;
+  /** The engine has no descriptors for a paired handle, as libuv reports -1 for one it has no fd for. */
+  fd = -1;
+
+  /** The other end of the pairing, once there is one. */
+  peer: LibuvStreamWrap | null = null;
+  /** True once `close()` has been called; a closed handle carries nothing. */
+  closed = false;
+  /**
+   * The handle the read now being delivered carried, which `setupChannel`
+   * takes off the channel at the top of its `onread`. libuv keeps the same
+   * thing in a pipe's pending-handle queue.
+   */
+  pendingHandle: unknown = null;
+
+  protected inbound: Inbound[] = [];
+  protected inboundEof = false;
+  protected inboundError: number | null = null;
+  protected eofDelivered = false;
+  protected userBuffer: Uint8Array | null = null;
+  protected readonly asyncId = nextAsyncId++;
+
+  constructor() {
+    registerHandle(this);
+  }
+
+  getAsyncId(): number {
+    return this.asyncId;
+  }
+
+  ref(): void {
+    refHandle(this);
+  }
+
+  unref(): void {
+    unrefHandle(this);
+  }
+
+  hasRef(): boolean {
+    return handleHasRef(this);
+  }
+
+  readStart(): number {
+    if (this.closed) return UV_EBADF;
+    this.reading = true;
+    this.flushInbound();
+    return 0;
+  }
+
+  readStop(): number {
+    this.reading = false;
+    return 0;
+  }
+
+  /** Node's `onread` option: reads land in the program's own buffer. */
+  useUserBuffer(buffer: Uint8Array): void {
+    this.userBuffer = buffer;
+  }
+
+  /**
+   * libuv's `uv_shutdown`: this end says it will write no more, and the peer
+   * reads EOF. The request completes on its own turn, as libuv's does.
+   */
+  shutdown(req: ShutdownWrap): number {
+    this.sendEof();
+    queueMicrotask(() => { req.oncomplete?.(0); });
+    return 0;
+  }
+
+  writeBuffer(req: WriteWrap, buffer: Uint8Array): number {
+    return this.dispatchWrite(req, buffer);
+  }
+
+  writev(req: WriteWrap, chunks: unknown[], allBuffers: boolean): number {
+    const parts: Uint8Array[] = [];
+    if (allBuffers) {
+      for (const chunk of chunks) parts.push(chunk as Uint8Array);
+    } else {
+      for (let index = 0; index < chunks.length; index += 2) {
+        const chunk = chunks[index];
+        const encoding = chunks[index + 1] as string;
+        parts.push(typeof chunk === 'string' ? bytesOfString(chunk, encoding) : (chunk as Uint8Array));
+      }
+    }
+    let total = 0;
+    for (const part of parts) total += part.byteLength;
+    const joined = new Uint8Array(total);
+    let at = 0;
+    for (const part of parts) {
+      joined.set(new Uint8Array(part.buffer, part.byteOffset, part.byteLength), at);
+      at += part.byteLength;
+    }
+    return this.dispatchWrite(req, joined);
+  }
+
+  writeUtf8String(req: WriteWrap, text: string, handle?: unknown): number {
+    return this.dispatchWrite(req, bytesOfString(text, 'utf8'), handle);
+  }
+
+  writeAsciiString(req: WriteWrap, text: string): number {
+    return this.dispatchWrite(req, bytesOfString(text, 'ascii'));
+  }
+
+  writeLatin1String(req: WriteWrap, text: string): number {
+    return this.dispatchWrite(req, bytesOfString(text, 'latin1'));
+  }
+
+  writeUcs2String(req: WriteWrap, text: string): number {
+    return this.dispatchWrite(req, bytesOfString(text, 'ucs2'));
+  }
+
+  /**
+   * libuv's `uv_close`. The peer reads EOF, as it does when the other end of a
+   * socket goes; the callback runs on its own turn, because `net.js` emits
+   * `close` from it and Node emits that after the turn that destroyed.
+   */
+  close(callback?: () => void): void {
+    if (!this.closed) {
+      this.closed = true;
+      releaseHandle(this);
+      const peer = this.peer;
+      this.peer = null;
+      // Writes land in the peer's inbound queue at once; flushing here
+      // delivers those bytes and then EOF, in that order, on this turn. A
+      // child's setupChannel then disconnects (`connected` false) before the
+      // next `process.send`, so that send is ERR_IPC_CHANNEL_CLOSED rather
+      // than a write on a handle a later release would close (`write EBADF`).
+      if (peer) { peer.peer = null; peer.receiveEof(); peer.flushInbound(); }
+      this.onCloseHandle();
+    }
+    if (callback) queueMicrotask(callback);
+  }
+
+  /** What a `TCP` or a `Pipe` gives up beyond the stream: a port, a path. */
+  protected onCloseHandle(): void {}
+
+  /**
+   * libuv's `dup()`: a second handle on the same connection.
+   *
+   * A descriptor sent over IPC arrives in the receiver as a NEW descriptor
+   * referring to the same socket, which is what `SCM_RIGHTS` gives it, and
+   * Node's own `child_process.js` counts on exactly that: on the receiver's
+   * `NODE_HANDLE_ACK` the sender CLOSES the handle it sent. With one handle
+   * for both, that close ended the connection the child had just been given
+   * and its first write was `EBADF`.
+   *
+   * The duplicate takes over this end of the pairing and this end is left
+   * peerless, so closing it announces nothing -- the sender has already given
+   * the socket up (`handleConversion`'s `send` sets `socket._handle = null`
+   * and silences its reads before the write).
+   */
+  duplicate(): LibuvStreamWrap {
+    const copy = new LibuvStreamWrap();
+    copy.takeOverFrom(this);
+    return copy;
+  }
+
+  /** Two handles become each other's peer; what one writes the other reads. */
+  static pair(a: LibuvStreamWrap, b: LibuvStreamWrap): void {
+    a.peer = b;
+    b.peer = a;
+  }
+
+  /**
+   * Take over another handle's end of a pairing, with everything that arrived
+   * on it while nobody was holding it. This is what opening a descriptor is
+   * here: a forked child's channel is opened by the child after its parent has
+   * already written to it -- `fork(…)` and `send(…)` are one synchronous turn
+   * in every program that does it -- and the bytes waiting at that descriptor
+   * are the child's. A pairing whose bytes stayed behind left the child
+   * waiting for a message its parent had already sent.
+   */
+  takeOverFrom(other: LibuvStreamWrap): void {
+    const peer = other.peer;
+    other.peer = null;
+    if (peer) LibuvStreamWrap.pair(this, peer);
+    if (other.inbound.length > 0) {
+      this.inbound = [...this.inbound, ...other.inbound];
+      other.inbound = [];
+    }
+    if (other.inboundEof) this.inboundEof = true;
+    if (other.inboundError !== null && this.inboundError === null) this.inboundError = other.inboundError;
+    this.flushInbound();
+  }
+
+  /**
+   * A write: the bytes are copied (the caller may reuse its buffer) and put in
+   * the peer's queue at once, where anything the writer does afterwards lands
+   * behind them. Delivery is still the peer's own turn, because libuv never
+   * delivers a read inside the write that caused it. It completes
+   * synchronously — `kBytesWritten` set, `kLastWriteWasAsync` 0 — because the
+   * engine's writes are taken whole and there is no queue for a `drain` to
+   * empty.
+   *
+   * Handing the bytes over on a microtask instead put them BEHIND an end
+   * announced from the same turn: `stdin.write('hello'); stdin.end()` is one
+   * synchronous block in every program that does it, the peer read EOF first
+   * and the bytes were dropped after it, and `spawn('cat')` fed that way
+   * produced nothing.
+   */
+  protected dispatchWrite(req: WriteWrap, buffer: Uint8Array, handle?: unknown): number {
+    void req;
+    const length = buffer.byteLength;
+    streamBaseState[kBytesWritten] = length;
+    streamBaseState[kLastWriteWasAsync] = 0;
+    if (this.closed) return UV_EBADF;
+    this.bytesWritten += length;
+    const peer = this.peer;
+    if (!peer || peer.closed) return 0;
+    if (length === 0) return 0;
+    peer.receive(ownedBytes(buffer), handle);
+    return 0;
+  }
+
+  /**
+   * The peer will write no more; this end reads EOF once it has read the rest.
+   * Announced on a microtask of its own, so it lands behind the writes that
+   * were handed over before it: `stdin.write('hello'); stdin.end()` is one
+   * turn in every program, and an EOF announced from inside `end` reached the
+   * reader first and the bytes never reached it at all.
+   */
+  protected sendEof(): void {
+    const peer = this.peer;
+    if (peer) peer.receiveEof();
+  }
+
+  /**
+   * libuv's close-with-reset: the peer's next read is `ECONNRESET`, not EOF,
+   * which is how `socket.resetAndDestroy()` differs from `socket.destroy()`.
+   */
+  protected sendReset(): void {
+    const peer = this.peer;
+    if (peer) peer.receiveError(UV_ECONNRESET);
+  }
+
+  /** An error arriving on the read side, delivered as libuv delivers one. */
+  receiveError(code: number): void {
+    if (this.closed) return;
+    this.inboundError = code;
+    this.scheduleFlush();
+  }
+
+  /** Bytes arriving from the peer, and the handle their write carried. */
+  receive(bytes: Uint8Array, handle?: unknown): void {
+    if (this.closed) return;
+    this.inbound.push(handle === undefined || handle === null ? { bytes } : { bytes, handle });
+    this.scheduleFlush();
+  }
+
+  /** The peer is done writing. */
+  receiveEof(): void {
+    if (this.closed) return;
+    this.inboundEof = true;
+    this.scheduleFlush();
+  }
+
+  /**
+   * What arrived is recorded the moment it arrives and delivered on a turn of
+   * its own, once, however many arrivals that turn holds. This is the order
+   * libuv's loop reads in: everything a writer did in one turn is read in the
+   * order it did it, and never from inside the call that did it.
+   */
+  private flushScheduled = false;
+  protected scheduleFlush(): void {
+    if (this.flushScheduled) return;
+    this.flushScheduled = true;
+    queueMicrotask(() => { this.flushScheduled = false; this.flushInbound(); });
+  }
+
+  /**
+   * Hand what has arrived to `onStreamRead`, in libuv's shape: the byte count
+   * in `streamBaseState[kReadBytesOrError]`, the offset beside it, the
+   * `ArrayBuffer` as the argument. A reader that pushes back calls `readStop`
+   * from inside `onread`, so the loop re-reads `reading` every time.
+   */
+  protected flushInbound(): void {
+    while (this.reading && !this.closed && this.inbound.length > 0) {
+      const next = this.inbound.shift() as Inbound;
+      const bytes = next.bytes;
+      // The handle is on the channel before the bytes it belongs to reach the
+      // reader, which is where `setupChannel` takes it off.
+      if (next.handle !== undefined) this.pendingHandle = next.handle;
+      this.bytesRead += bytes.byteLength;
+      const target = this.userBuffer;
+      if (target) {
+        // `net.Socket({ onread })`: the bytes land in the program's buffer and
+        // `onStreamRead` hands the count to its callback.
+        const taken = Math.min(target.byteLength, bytes.byteLength);
+        target.set(bytes.subarray(0, taken));
+        if (taken < bytes.byteLength) this.inbound.unshift({ bytes: bytes.subarray(taken) });
+        streamBaseState[kReadBytesOrError] = taken;
+        streamBaseState[kArrayBufferOffset] = 0;
+        this.onread?.(null);
+        continue;
+      }
+      streamBaseState[kReadBytesOrError] = bytes.byteLength;
+      streamBaseState[kArrayBufferOffset] = bytes.byteOffset;
+      this.onread?.(bytes.buffer as ArrayBuffer);
+    }
+    if (this.reading && !this.closed && this.inbound.length === 0 && !this.eofDelivered &&
+        (this.inboundError !== null || this.inboundEof)) {
+      this.eofDelivered = true;
+      // libuv stops a stream when it reads EOF, and a stopped handle does not
+      // hold the loop: a socket whose peer has gone is not work, however much
+      // unread data is still in its buffer.
+      stopHandle(this);
+      streamBaseState[kReadBytesOrError] = this.inboundError ?? UV_EOF;
+      streamBaseState[kArrayBufferOffset] = 0;
+      this.onread?.(null);
+    }
+  }
+}
+
+export default {
+  LibuvStreamWrap,
+  WriteWrap,
+  ShutdownWrap,
+  streamBaseState,
+  kReadBytesOrError,
+  kArrayBufferOffset,
+  kBytesWritten,
+  kLastWriteWasAsync,
+};

package/src/node-lib/binding/stubs.ts

@@ -0,0 +1,19 @@
+/**
+ * The two bindings `internal/child_process.js` names only to ask an
+ * `instanceof` of.
+ *
+ * `udp_wrap`'s `UDP` tells a datagram handle from a stream one when a handle
+ * is sent over IPC, and `http_parser`'s `HTTPParser` tells a parser handle
+ * from a socket when one is released. The engine has no datagram handle and
+ * parses HTTP in JavaScript, so nothing is ever an instance of either; the
+ * classes exist so the question can be asked, and answered no.
+ */
+
+/** libuv's `uv_udp_t`, which this engine never makes one of. */
+export class UDP {}
+
+/** The HTTP parser handle a C++ Node keeps on a socket; this one has none. */
+export class HTTPParser {}
+
+export const udpWrapBinding = { UDP };
+export const httpParserBinding = { HTTPParser };

package/src/node-lib/binding/tcp_wrap.ts

@@ -0,0 +1,254 @@
+/**
+ * `internalBinding('tcp_wrap')`: the engine's loopback, in libuv's shape.
+ *
+ * One engine is one host. A `bind` reserves a port, a `listen` starts
+ * answering on it, and a `connect` to a loopback address on a port something
+ * is listening on pairs two handles whose writes are each other's reads —
+ * which is what the engine has always done for a `net` connect, moved here so
+ * that Node's own `net.js` runs on it. A connect to anything that is not this
+ * host is `ECONNREFUSED`, because there is nothing else to reach: a page's
+ * request to the outside goes through `fetch`, not through a socket.
+ *
+ * A wildcard bind holds the port for both families, as a dual-stack `::` bind
+ * does on Linux, so `connect('127.0.0.1')` reaches a server that bound `::`.
+ */
+import { LibuvStreamWrap } from './stream_wrap';
+import { __adoptHandle, ownerOf } from './handles';
+import { UV_EADDRINUSE, UV_ECONNREFUSED, UV_EINVAL, UV_ENOTSUP } from './uv';
+
+/** libuv's `uv_tcp_t` flavours, and the two flags `getFlags` builds. */
+export const constants = {
+  SOCKET: 0,
+  SERVER: 1,
+  UV_TCP_IPV6ONLY: 1,
+  UV_TCP_REUSEPORT: 4,
+};
+
+/** What `getsockname`/`getpeername` fill in. */
+export interface SockName {
+  address: string;
+  family: string;
+  port: number;
+}
+
+/** Node's `TCPConnectWrap`: the request a connect fills and is answered through. */
+export class TCPConnectWrap {
+  oncomplete: ((status: number, handle: unknown, req: unknown, readable: boolean, writable: boolean) => void) | null = null;
+  address = '';
+  port = 0;
+  localAddress: string | undefined = undefined;
+  localPort: number | undefined = undefined;
+  addressType: number | undefined = undefined;
+}
+
+/**
+ * Every port this engine holds: a handle that has bound one, listening or
+ * not, and every ephemeral port a client end was given. One space, because
+ * one engine is one host and a port is taken once.
+ */
+const boundPorts = new Map<number, TCP>();
+const ephemeralPorts = new Set<number>();
+
+/** Linux's ephemeral range, walked in order as a kernel walks it. */
+let nextEphemeral = 49152;
+function allocatePort(): number {
+  for (let tries = 0; tries < 16384; tries += 1) {
+    const port = nextEphemeral;
+    nextEphemeral = nextEphemeral >= 65535 ? 49152 : nextEphemeral + 1;
+    if (!boundPorts.has(port) && !ephemeralPorts.has(port)) return port;
+  }
+  return 0;
+}
+
+/** Loopback and the wildcards: what this engine answers for. */
+function isThisHost(address: string): boolean {
+  if (!address) return true;
+  const bare = address.startsWith('[') && address.endsWith(']') ? address.slice(1, -1) : address;
+  const name = bare.split('%')[0].toLowerCase();
+  return name === 'localhost' || name === '0.0.0.0' || name === '::' || name === '::1' ||
+    name === '0:0:0:0:0:0:0:1' || name === '0:0:0:0:0:0:0:0' || name.startsWith('127.');
+}
+
+/**
+ * What the page bridge is told when a guest starts or stops listening. The
+ * bridge used to learn this from the engine's own `http.Server`; `http` is
+ * Node's own file now and knows nothing of a page, so the news comes from
+ * where a port is actually taken.
+ */
+type ListenWatcher = (port: number, address: string) => void;
+// eslint-disable-next-line no-var, vars-on-top
+var onListenWatcher: ListenWatcher | null = null;
+// eslint-disable-next-line no-var, vars-on-top
+var onCloseWatcher: ((port: number) => void) | null = null;
+export function setPortWatchers(onListen: ListenWatcher | null, onClose: ((port: number) => void) | null): void {
+  onListenWatcher = onListen;
+  onCloseWatcher = onClose;
+}
+
+/** The listening handle a connect to this port reaches, if any. */
+export function listenerOnPort(port: number): TCP | undefined {
+  const bound = boundPorts.get(port);
+  return bound && bound.listening ? bound : undefined;
+}
+
+export class TCP extends LibuvStreamWrap {
+  /** `constants.SOCKET` or `constants.SERVER`. */
+  readonly type: number;
+  listening = false;
+  /** Set by `net.js` on a server handle; how an accepted pairing is announced. */
+  onconnection: ((status: number, clientHandle: TCP) => void) | null = null;
+
+  private local: SockName | null = null;
+  private remote: SockName | null = null;
+  private ephemeral: number | null = null;
+
+  constructor(type: number = constants.SOCKET) {
+    super();
+    this.type = type;
+  }
+
+  bind(address: string, port: number, _flags?: number): number {
+    return this.bindTo(address || '0.0.0.0', port, 'IPv4');
+  }
+
+  bind6(address: string, port: number, _flags?: number): number {
+    return this.bindTo(address || '::', port, 'IPv6');
+  }
+
+  private bindTo(address: string, port: number, family: string): number {
+    if (!isThisHost(address)) return UV_EADDRINUSE;
+    const wanted = Number(port) || 0;
+    if (wanted !== 0 && boundPorts.has(wanted)) return UV_EADDRINUSE;
+    if (wanted !== 0 && ephemeralPorts.has(wanted)) return UV_EADDRINUSE;
+    const bound = wanted === 0 ? allocatePort() : wanted;
+    if (this.local && boundPorts.get(this.local.port) === this) boundPorts.delete(this.local.port);
+    this.local = { address, family, port: bound };
+    boundPorts.set(bound, this);
+    return 0;
+  }
+
+  listen(_backlog: number): number {
+    if (!this.local) {
+      const err = this.bindTo('0.0.0.0', 0, 'IPv4');
+      if (err) return err;
+    }
+    this.listening = true;
+    if (this.local) { try { onListenWatcher?.(this.local.port, this.local.address); } catch { /* a watcher that throws is not the listen's business */ } }
+    return 0;
+  }
+
+  connect(req: TCPConnectWrap, address: string, port: number): number {
+    return this.connectTo(req, address, port, 'IPv4');
+  }
+
+  connect6(req: TCPConnectWrap, address: string, port: number): number {
+    return this.connectTo(req, address, port, 'IPv6');
+  }
+
+  private connectTo(req: TCPConnectWrap, address: string, port: number, family: string): number {
+    const target = Number(port);
+    const reachable = isThisHost(address);
+    if (!this.local) {
+      const mine = allocatePort();
+      ephemeralPorts.add(mine);
+      this.ephemeral = mine;
+      this.local = { address: family === 'IPv6' ? '::1' : '127.0.0.1', family, port: mine };
+    }
+    this.remote = { address, family, port: target };
+    // libuv answers a connect through the request, never from the call: a
+    // refused connection is `oncomplete(UV_ECONNREFUSED)`, which is what
+    // `afterConnect` turns into the socket's `ECONNREFUSED` error.
+    queueMicrotask(() => {
+      if (this.closed) return;
+      const server = reachable ? listenerOnPort(target) : undefined;
+      if (!server) {
+        req.oncomplete?.(UV_ECONNREFUSED, this, req, true, true);
+        return;
+      }
+      const accepted = new TCP(constants.SOCKET);
+      accepted.local = { ...(server.local as SockName), port: target };
+      accepted.remote = { ...(this.local as SockName) };
+      // An accepted connection is a handle of the loop that is serving, not of
+      // the one that connected: the pairing is made inside the connector's own
+      // turn, so without this the server's end of every connection would hold
+      // the connecting run alive until the server closed it.
+      __adoptHandle(accepted, ownerOf(server));
+      LibuvStreamWrap.pair(this, accepted);
+      server.onconnection?.(0, accepted);
+      req.oncomplete?.(0, this, req, true, true);
+    });
+    return 0;
+  }
+
+  /**
+   * Name both ends of a pairing the engine made without a connect. The page
+   * bridge's end of an upgraded connection is one: there was no `connect`, and
+   * the socket an `upgrade` listener is handed still has to answer
+   * `remoteAddress` and `localPort` as a connection's socket does.
+   */
+  adoptNames(local: SockName, remote: SockName): void {
+    this.local = { ...local };
+    this.remote = { ...remote };
+  }
+
+  /** libuv's `dup()`: the same connection, under both its names. */
+  override duplicate(): TCP {
+    const copy = new TCP(constants.SOCKET);
+    if (this.local && this.remote) copy.adoptNames(this.local, this.remote);
+    copy.takeOverFrom(this);
+    return copy;
+  }
+
+  getsockname(out: Partial<SockName>): number {
+    if (!this.local) return UV_EINVAL;
+    out.address = this.local.address;
+    out.family = this.local.family;
+    out.port = this.local.port;
+    return 0;
+  }
+
+  getpeername(out: Partial<SockName>): number {
+    if (!this.remote) return UV_EINVAL;
+    out.address = this.remote.address;
+    out.family = this.remote.family;
+    out.port = this.remote.port;
+    return 0;
+  }
+
+  /** Nothing is buffered between two handles in one realm, so there is nothing to delay. */
+  setNoDelay(_enable: boolean): number {
+    return 0;
+  }
+
+  /** There is no idle connection to probe: a pairing is alive while both ends are. */
+  setKeepAlive(_enable: boolean, _delay: number): number {
+    return 0;
+  }
+
+  setSimultaneousAccepts(_enable: boolean): number {
+    return 0;
+  }
+
+  /** An engine handle carries no descriptor a program can hand it. */
+  open(_fd: number): number {
+    return UV_ENOTSUP;
+  }
+
+  /** libuv's `uv_tcp_close_reset`: the peer reads ECONNRESET rather than EOF. */
+  reset(callback?: () => void): number {
+    this.sendReset();
+    this.close(callback);
+    return 0;
+  }
+
+  protected override onCloseHandle(): void {
+    const wasListening = this.listening;
+    this.listening = false;
+    this.onconnection = null;
+    if (wasListening && this.local) { try { onCloseWatcher?.(this.local.port); } catch { /* as above */ } }
+    if (this.local && boundPorts.get(this.local.port) === this) boundPorts.delete(this.local.port);
+    if (this.ephemeral !== null) { ephemeralPorts.delete(this.ephemeral); this.ephemeral = null; }
+  }
+}
+
+export default { TCP, TCPConnectWrap, constants };