@volter/tabnode 0.4.1 → 0.5.1

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

@@ -13,7 +13,10 @@
  * `net.js` is vendored.
  */
 import { bytesOfString } from './buffer';
-import { UV_EOF, UV_EBADF, UV_ECONNRESET } from './uv';
+import { UV_EOF, UV_EBADF, UV_ECONNRESET, UV_EPIPE } from './uv';
+import { attachNativeStream, nativeStreamFor } from '../../native-stream-binding';
+import type { TCP } from './tcp_wrap';
+import type { Pipe } from './pipe_wrap';
 
 /**
  * The bytes this view names. Node's `Buffer.from` of a short string is a
@@ -70,15 +73,33 @@ interface Inbound {
   handle?: unknown;
 }
 
+/** The connection end shared by duplicated native descriptors, not a JS socket. */
+class StreamEndpoint {
+  readonly handles = new Set<LibuvStreamWrap>();
+  peer: StreamEndpoint | null = null;
+  inbound: Inbound[] = [];
+  eof = false;
+  error: number | null = null;
+  writeEnded = false;
+  flushScheduled = false;
+  readonly finalizers: Array<() => void> = [];
+  readonly capacityListeners = new Set<() => void>();
+
+  capacityChanged(): void {
+    for (const listener of [...this.capacityListeners]) listener();
+  }
+
+  constructor(handle: LibuvStreamWrap) { this.handles.add(handle); }
+}
+
 /**
  * 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.
+ * A pairing joins two connection endpoints. Duplicated wrappers reference the
+ * same endpoint and consume its bytes once. A write queues a copy at the peer;
+ * reads are delivered on its own turn while a wrapper is reading, 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. */
@@ -92,8 +113,13 @@ export class LibuvStreamWrap implements OwnedHandle {
   /** 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;
+  private streamEndpoint = new StreamEndpoint(this);
+  /** A live wrapper on the other end, including after the original was closed. */
+  get peer(): LibuvStreamWrap | null {
+    const native = nativeStreamFor(this);
+    if (native) return native.peer;
+    return this.streamEndpoint.peer?.handles.values().next().value ?? null;
+  }
   /** True once `close()` has been called; a closed handle carries nothing. */
   closed = false;
   /**
@@ -103,9 +129,9 @@ export class LibuvStreamWrap implements OwnedHandle {
    */
   pendingHandle: unknown = null;
 
-  protected inbound: Inbound[] = [];
-  protected inboundEof = false;
-  protected inboundError: number | null = null;
+  protected get inbound(): Inbound[] { return this.streamEndpoint.inbound; }
+  protected get inboundEof(): boolean { return this.streamEndpoint.eof; }
+  protected get inboundError(): number | null { return this.streamEndpoint.error; }
   protected eofDelivered = false;
   protected userBuffer: Uint8Array | null = null;
   protected readonly asyncId = nextAsyncId++;
@@ -114,15 +140,22 @@ export class LibuvStreamWrap implements OwnedHandle {
     registerHandle(this);
   }
 
+  protected attachNative(kind: 'tcp' | 'pipe', type: number): void {
+    attachNativeStream(this as unknown as TCP | Pipe, kind, type,
+      callback => this.closeLocal(callback), () => this.flushInbound());
+  }
+
   getAsyncId(): number {
     return this.asyncId;
   }
 
   ref(): void {
+    nativeStreamFor(this)?.operation('ref');
     refHandle(this);
   }
 
   unref(): void {
+    nativeStreamFor(this)?.operation('unref');
     unrefHandle(this);
   }
 
@@ -132,12 +165,16 @@ export class LibuvStreamWrap implements OwnedHandle {
 
   readStart(): number {
     if (this.closed) return UV_EBADF;
+    const status = nativeStreamFor(this)?.beginRead() ?? 0;
+    if (status !== 0) return status;
     this.reading = true;
     this.flushInbound();
     return 0;
   }
 
   readStop(): number {
+    // The remote owner may already have posted its one permitted read. Keep
+    // that credit until arrival; pause guest delivery without granting another.
     this.reading = false;
     return 0;
   }
@@ -152,13 +189,16 @@ export class LibuvStreamWrap implements OwnedHandle {
    * reads EOF. The request completes on its own turn, as libuv's does.
    */
   shutdown(req: ShutdownWrap): number {
+    if (this.closed) return UV_EBADF;
+    const native = nativeStreamFor(this);
+    if (native) return native.shutdown(status => req.oncomplete?.(status));
     this.sendEof();
     queueMicrotask(() => { req.oncomplete?.(0); });
     return 0;
   }
 
-  writeBuffer(req: WriteWrap, buffer: Uint8Array): number {
-    return this.dispatchWrite(req, buffer);
+  writeBuffer(req: WriteWrap, buffer: Uint8Array, handle?: unknown): number {
+    return this.dispatchWrite(req, buffer, handle);
   }
 
   writev(req: WriteWrap, chunks: unknown[], allBuffers: boolean): number {
@@ -172,6 +212,8 @@ export class LibuvStreamWrap implements OwnedHandle {
         parts.push(typeof chunk === 'string' ? bytesOfString(chunk, encoding) : (chunk as Uint8Array));
       }
     }
+    const native = nativeStreamFor(this);
+    if (native) return native.write(req, parts);
     let total = 0;
     for (const part of parts) total += part.byteLength;
     const joined = new Uint8Array(total);
@@ -200,25 +242,58 @@ export class LibuvStreamWrap implements OwnedHandle {
   }
 
   /**
-   * 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
+   * libuv's `uv_close`. The peer reads EOF when the last descriptor closes;
+   * 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 {
+    const native = nativeStreamFor(this);
+    if (native) { native.close(callback); return; }
+    this.closeLocal(callback);
+  }
+
+  private closeLocal(callback?: () => void): void {
+    const failures: unknown[] = [];
+    const release = (action: () => void): void => { try { action(); } catch (cause) { failures.push(cause); } };
     if (!this.closed) {
       this.closed = true;
       releaseHandle(this);
-      const peer = this.peer;
-      this.peer = null;
+      const endpoint = this.streamEndpoint;
+      endpoint.handles.delete(this);
       // 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();
+      // Closing one descriptor must not end a connection another process
+      // still holds (`send(socket, { keepOpen: true })` is one such case).
+      if (endpoint.handles.size === 0) {
+        const peer = endpoint.peer;
+        endpoint.peer = null;
+        if (peer) {
+          peer.peer = null;
+          peer.eof = true;
+          for (const handle of peer.handles) release(() => handle.flushInbound());
+        }
+        for (const finalize of endpoint.finalizers.splice(0)) release(finalize);
+        // SCM_RIGHTS copies queued on an unread IPC channel have no receiving
+        // process yet. Closing that channel must release them too.
+        for (const pending of endpoint.inbound) {
+          if (pending.handle instanceof LibuvStreamWrap) release(() => (pending.handle as LibuvStreamWrap).close());
+        }
+        endpoint.inbound.length = 0;
+        release(() => endpoint.capacityChanged());
+        endpoint.capacityListeners.clear();
+      }
+      release(() => this.onCloseHandle());
     }
-    if (callback) queueMicrotask(callback);
+    // Node schedules a destroy(error)'s error on nextTick after close() returns.
+    // The native close completion comes afterward. One microtask here ran the
+    // close listener first, so ClientRequest replaced the actual policy denial
+    // with ECONNRESET ("socket hang up"). Leave that tick ahead of completion.
+    if (callback) queueMicrotask(() => queueMicrotask(callback));
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) throw new AggregateError(failures, 'Native stream cleanup failed.');
   }
 
   /** What a `TCP` or a `Pipe` gives up beyond the stream: a port, a path. */
@@ -234,21 +309,61 @@ export class LibuvStreamWrap implements OwnedHandle {
    * 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).
+   * Both descriptors share the connection and its unread bytes. Node may
+   * close the sender on acknowledgement or keep it open; the binding must
+   * support either, without knowing the child_process option that chose it.
    */
   duplicate(): LibuvStreamWrap {
     const copy = new LibuvStreamWrap();
-    copy.takeOverFrom(this);
+    copy.shareConnectionFrom(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;
+    const left = nativeStreamFor(a), right = nativeStreamFor(b);
+    if (left || right) {
+      if (!left || !right) throw new Error('Cannot pair native and realm-local stream handles.');
+      left.pair(right);
+      return;
+    }
+    a.streamEndpoint.peer = b.streamEndpoint;
+    b.streamEndpoint.peer = a.streamEndpoint;
+  }
+
+  /** A fresh wrapper acquires a descriptor reference on this connection. */
+  protected shareConnectionFrom(other: LibuvStreamWrap): void {
+    this.streamEndpoint.handles.delete(this);
+    this.streamEndpoint = other.streamEndpoint;
+    this.streamEndpoint.handles.add(this);
+  }
+
+  /** Native connection resources outlive individual duplicated wrappers. */
+  protected onLastReferenceClose(callback: () => void): void {
+    this.streamEndpoint.finalizers.push(callback);
+  }
+
+  /** Host transports bound copies waiting in the native receiving queue. */
+  get peerQueuedBytes(): number {
+    let bytes = 0;
+    for (const chunk of this.streamEndpoint.peer?.inbound ?? []) bytes += chunk.bytes.byteLength;
+    return bytes;
+  }
+
+  get peerQueuedHandles(): number {
+    let count = 0;
+    for (const chunk of this.streamEndpoint.peer?.inbound ?? []) {
+      if (chunk.handle !== undefined && chunk.handle !== null) count++;
+    }
+    return count;
+  }
+
+  /** Changes to the same connection end, even after its wrapper is replaced. */
+  onPeerReadCapacity(listener: () => void): () => void {
+    const endpoint = this.streamEndpoint.peer;
+    if (!endpoint) return () => {};
+    endpoint.capacityListeners.add(listener);
+    return () => { endpoint.capacityListeners.delete(listener); };
   }
 
   /**
@@ -261,15 +376,11 @@ export class LibuvStreamWrap implements OwnedHandle {
    * 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;
+    if (other === this) return;
+    if (nativeStreamFor(this) || nativeStreamFor(other)) throw new Error('Remote descriptors must be inherited and opened through their owner.');
+    this.shareConnectionFrom(other);
+    this.streamEndpoint.handles.delete(other);
+    other.streamEndpoint = new StreamEndpoint(other);
     this.flushInbound();
   }
 
@@ -289,11 +400,14 @@ export class LibuvStreamWrap implements OwnedHandle {
    * produced nothing.
    */
   protected dispatchWrite(req: WriteWrap, buffer: Uint8Array, handle?: unknown): number {
+    const native = nativeStreamFor(this);
+    if (native) return native.write(req, [buffer], handle);
     void req;
     const length = buffer.byteLength;
     streamBaseState[kBytesWritten] = length;
     streamBaseState[kLastWriteWasAsync] = 0;
     if (this.closed) return UV_EBADF;
+    if (this.streamEndpoint.writeEnded) return UV_EPIPE;
     this.bytesWritten += length;
     const peer = this.peer;
     if (!peer || peer.closed) return 0;
@@ -310,6 +424,7 @@ export class LibuvStreamWrap implements OwnedHandle {
    * reader first and the bytes never reached it at all.
    */
   protected sendEof(): void {
+    this.streamEndpoint.writeEnded = true;
     const peer = this.peer;
     if (peer) peer.receiveEof();
   }
@@ -319,6 +434,7 @@ export class LibuvStreamWrap implements OwnedHandle {
    * which is how `socket.resetAndDestroy()` differs from `socket.destroy()`.
    */
   protected sendReset(): void {
+    this.streamEndpoint.writeEnded = true;
     const peer = this.peer;
     if (peer) peer.receiveError(UV_ECONNRESET);
   }
@@ -326,7 +442,7 @@ export class LibuvStreamWrap implements OwnedHandle {
   /** An error arriving on the read side, delivered as libuv delivers one. */
   receiveError(code: number): void {
     if (this.closed) return;
-    this.inboundError = code;
+    this.streamEndpoint.error = code;
     this.scheduleFlush();
   }
 
@@ -340,7 +456,7 @@ export class LibuvStreamWrap implements OwnedHandle {
   /** The peer is done writing. */
   receiveEof(): void {
     if (this.closed) return;
-    this.inboundEof = true;
+    this.streamEndpoint.eof = true;
     this.scheduleFlush();
   }
 
@@ -350,11 +466,14 @@ export class LibuvStreamWrap implements OwnedHandle {
    * 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(); });
+    const endpoint = this.streamEndpoint;
+    if (endpoint.flushScheduled) return;
+    endpoint.flushScheduled = true;
+    queueMicrotask(() => {
+      endpoint.flushScheduled = false;
+      for (const handle of endpoint.handles) handle.flushInbound();
+    });
   }
 
   /**
@@ -364,39 +483,44 @@ export class LibuvStreamWrap implements OwnedHandle {
    * 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;
+    try {
+      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;
+        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);
+          this.bytesRead += taken;
+          target.set(bytes.subarray(0, taken));
+          if (taken < bytes.byteLength) this.inbound.unshift({ bytes: bytes.subarray(taken) });
+          streamBaseState[kReadBytesOrError] = taken;
+          streamBaseState[kArrayBufferOffset] = 0;
+          try { this.onread?.(null); } finally { this.streamEndpoint.capacityChanged(); }
+          continue;
+        }
+        streamBaseState[kReadBytesOrError] = bytes.byteLength;
+        this.bytesRead += bytes.byteLength;
+        streamBaseState[kArrayBufferOffset] = bytes.byteOffset;
+        try { this.onread?.(bytes.buffer as ArrayBuffer); } finally { this.streamEndpoint.capacityChanged(); }
+      }
+      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);
-        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);
+    } finally {
+      nativeStreamFor(this)?.readFlushed(this.inbound.length === 0, this.eofDelivered);
     }
   }
 }

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

@@ -14,7 +14,8 @@
  */
 import { LibuvStreamWrap } from './stream_wrap';
 import { __adoptHandle, ownerOf } from './handles';
-import { UV_EADDRINUSE, UV_ECONNREFUSED, UV_EINVAL, UV_ENOTSUP } from './uv';
+import { nativeStreamFor, registerNativeStreamConstructor } from '../../native-stream-binding';
+import { UV_EADDRINUSE, UV_ECONNREFUSED, UV_EINVAL, UV_ENOTSUP, UV_EBADF } from './uv';
 
 /** libuv's `uv_tcp_t` flavours, and the two flags `getFlags` builds. */
 export const constants = {
@@ -100,18 +101,22 @@ export class TCP extends LibuvStreamWrap {
 
   private local: SockName | null = null;
   private remote: SockName | null = null;
-  private ephemeral: number | null = null;
 
   constructor(type: number = constants.SOCKET) {
     super();
     this.type = type;
+    this.attachNative('tcp', type);
   }
 
   bind(address: string, port: number, _flags?: number): number {
+    const native = nativeStreamFor(this);
+    if (native) return native.call({ operation: 'bind', id: native.descriptor.id, address, port, flags: _flags }).status;
     return this.bindTo(address || '0.0.0.0', port, 'IPv4');
   }
 
   bind6(address: string, port: number, _flags?: number): number {
+    const native = nativeStreamFor(this);
+    if (native) return native.call({ operation: 'bind', id: native.descriptor.id, address, port, flags: _flags, ipv6: true }).status;
     return this.bindTo(address || '::', port, 'IPv6');
   }
 
@@ -124,10 +129,17 @@ export class TCP extends LibuvStreamWrap {
     if (this.local && boundPorts.get(this.local.port) === this) boundPorts.delete(this.local.port);
     this.local = { address, family, port: bound };
     boundPorts.set(bound, this);
+    this.onLastReferenceClose(() => { if (boundPorts.get(bound) === this) boundPorts.delete(bound); });
     return 0;
   }
 
   listen(_backlog: number): number {
+    const native = nativeStreamFor(this);
+    if (native) {
+      const status = native.call({ operation: 'listen', id: native.descriptor.id, backlog: _backlog }).status;
+      if (status === 0) this.listening = true;
+      return status;
+    }
     if (!this.local) {
       const err = this.bindTo('0.0.0.0', 0, 'IPv4');
       if (err) return err;
@@ -146,12 +158,14 @@ export class TCP extends LibuvStreamWrap {
   }
 
   private connectTo(req: TCPConnectWrap, address: string, port: number, family: string): number {
+    const native = nativeStreamFor(this);
+    if (native) return native.connect(address, port, family === 'IPv6', status => req.oncomplete?.(status, this, req, true, true));
     const target = Number(port);
     const reachable = isThisHost(address);
     if (!this.local) {
       const mine = allocatePort();
       ephemeralPorts.add(mine);
-      this.ephemeral = mine;
+      this.onLastReferenceClose(() => { ephemeralPorts.delete(mine); });
       this.local = { address: family === 'IPv6' ? '::1' : '127.0.0.1', family, port: mine };
     }
     this.remote = { address, family, port: target };
@@ -165,7 +179,7 @@ export class TCP extends LibuvStreamWrap {
         req.oncomplete?.(UV_ECONNREFUSED, this, req, true, true);
         return;
       }
-      const accepted = new TCP(constants.SOCKET);
+      const accepted = new (server.constructor as typeof 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
@@ -193,13 +207,20 @@ export class TCP extends LibuvStreamWrap {
 
   /** libuv's `dup()`: the same connection, under both its names. */
   override duplicate(): TCP {
-    const copy = new TCP(constants.SOCKET);
+    const native = nativeStreamFor(this);
+    const copy = native ? native.duplicate() as TCP : new (this.constructor as typeof TCP)(constants.SOCKET);
     if (this.local && this.remote) copy.adoptNames(this.local, this.remote);
-    copy.takeOverFrom(this);
+    if (!native) copy.shareConnectionFrom(this);
     return copy;
   }
 
   getsockname(out: Partial<SockName>): number {
+    const native = nativeStreamFor(this);
+    if (native) {
+      const result = native.call({ operation: 'getsockname', id: native.descriptor.id });
+      if (result.address) Object.assign(out, result.address);
+      return result.status;
+    }
     if (!this.local) return UV_EINVAL;
     out.address = this.local.address;
     out.family = this.local.family;
@@ -208,6 +229,12 @@ export class TCP extends LibuvStreamWrap {
   }
 
   getpeername(out: Partial<SockName>): number {
+    const native = nativeStreamFor(this);
+    if (native) {
+      const result = native.call({ operation: 'getpeername', id: native.descriptor.id });
+      if (result.address) Object.assign(out, result.address);
+      return result.status;
+    }
     if (!this.remote) return UV_EINVAL;
     out.address = this.remote.address;
     out.family = this.remote.family;
@@ -231,11 +258,20 @@ export class TCP extends LibuvStreamWrap {
 
   /** An engine handle carries no descriptor a program can hand it. */
   open(_fd: number): number {
+    const native = nativeStreamFor(this);
+    if (native) {
+      const status = native.call({ operation: 'open', id: native.descriptor.id, fd: _fd }).status;
+      if (status === 0) this.fd = _fd;
+      return status;
+    }
     return UV_ENOTSUP;
   }
 
   /** libuv's `uv_tcp_close_reset`: the peer reads ECONNRESET rather than EOF. */
   reset(callback?: () => void): number {
+    if (this.closed) return UV_EBADF;
+    const native = nativeStreamFor(this);
+    if (native) return native.close(callback, true);
     this.sendReset();
     this.close(callback);
     return 0;
@@ -246,9 +282,8 @@ export class TCP extends LibuvStreamWrap {
     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; }
   }
 }
 
+registerNativeStreamConstructor('tcp', TCP);
 export default { TCP, TCPConnectWrap, constants };