react-native-web-serial-api 0.0.3 → 0.2.0

package/lib/commonjs/WebSerial.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.serial = exports.SerialPort = exports.Serial = void 0;
-var _webStreamsPolyfill = require("web-streams-polyfill");
 var _domException = require("./lib/dom-exception");
 var _eventTarget = require("./lib/event-target");
 var _promise = require("./lib/promise");
+var _webStreams = require("./lib/web-streams");
 var _UsbSerial = require("./UsbSerial");
 /**
  * @see https://wicg.github.io/serial/#dom-paritytype
@@ -65,6 +65,7 @@ const kDefaultFlowControl = 'none';
 const kAcceptableDataBits = [7, 8];
 const kAcceptableStopBits = [1, 2];
 const kAcceptableParity = ['none', 'even', 'odd'];
+const kAcceptableFlowControl = ['none', 'hardware'];
 function parityToNative(parity) {
   switch (parity) {
     case 'odd':
@@ -75,8 +76,29 @@ function parityToNative(parity) {
       return 0;
   }
 }
+const FLOW_CONTROL_NATIVE = {
+  none: 'NONE',
+  hardware: 'RTS_CTS'
+};
 function flowControlToNative(flowControl) {
-  return flowControl === 'hardware' ? 'RTS_CTS' : 'NONE';
+  return FLOW_CONTROL_NATIVE[flowControl];
+}
+
+/**
+ * Normalise a writable chunk to a plain byte array. The Web Serial writable
+ * accepts any BufferSource — a bare `ArrayBuffer` or any `ArrayBufferView`
+ * (`DataView`, typed arrays, including views with a non-zero `byteOffset`). A
+ * naive `Array.from(chunk)` only works for the iterable typed arrays and
+ * silently yields `[]` for an `ArrayBuffer`/`DataView`, so handle each shape.
+ */
+function bufferSourceToBytes(chunk) {
+  if (chunk instanceof Uint8Array) {
+    return Array.from(chunk);
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    return Array.from(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+  }
+  return Array.from(new Uint8Array(chunk));
 }
 
 /**
@@ -113,15 +135,48 @@ class SerialPort extends _eventTarget.EventTarget {
   #portNumber;
   #usbVendorId;
   #usbProductId;
-
-  // Tracks the current state of output signals for partial updates
-  #outputSignals = {
-    dataTerminalReady: false,
-    requestToSend: false,
-    break: false
-  };
+  // Baud rate of the current open(), used to size the native write timeout.
+  #baudRate = 0;
   #dataSubscription = null;
   #errorSubscription = null;
+
+  // The live stream controllers, captured in the readable/writable getters, so
+  // a device loss can error the in-flight read/write with a "NetworkError".
+  #readableController = null;
+  #writableController = null;
+  #forgetRequested = false;
+  #resetToClosedState(state = 'closed') {
+    this.#dataSubscription?.remove();
+    this.#errorSubscription?.remove();
+    this.#dataSubscription = null;
+    this.#errorSubscription = null;
+    this.#readableController = null;
+    this.#writableController = null;
+    this.#readable = null;
+    this.#writable = null;
+    this.#readFatal = false;
+    this.#writeFatal = false;
+    this.#pendingClosePromise = null;
+    this.#bufferSize = undefined;
+    this.#baudRate = 0;
+    this.#state = state;
+    this.#connected = false;
+    this.#forgetRequested = state === 'forgotten';
+  }
+
+  /**
+   * Compute a native write timeout (ms) large enough to actually drain `length`
+   * bytes at the negotiated baud rate. A fixed 2 s timeout spuriously fails
+   * large writes on slow links; this scales with the payload while keeping a 2 s
+   * floor. ~10 bits per byte (start + 8 data + stop) with a 2× safety margin.
+   */
+  #writeTimeoutFor(length) {
+    const kMinTimeoutMs = 2000;
+    /* istanbul ignore next — baudRate is always > 0 when the port is open */
+    const baud = this.#baudRate > 0 ? this.#baudRate : 9600;
+    const estimatedMs = Math.ceil(length * 10 * 1000 / baud) * 2;
+    return Math.max(kMinTimeoutMs, estimatedMs);
+  }
   constructor(usb, deviceId, portNumber, usbVendorId, usbProductId) {
     super();
     this.#usb = usb;
@@ -136,12 +191,13 @@ class SerialPort extends _eventTarget.EventTarget {
       getVid: () => this.#usbVendorId,
       getPid: () => this.#usbProductId,
       getPortNumber: () => this.#portNumber,
-      getDeviceId: () => this.#deviceId,
+      isForgotten: () => this.#state === 'forgotten',
       setDeviceId: id => {
         this.#deviceId = id;
         serialPortDeviceIds.set(this, id);
       },
-      handleDeviceLost: () => this.#handleDeviceLost()
+      handleDeviceLost: () => this.#handleDeviceLost(),
+      handleDeviceDetached: () => this.#handleDeviceDetached()
     });
   }
 
@@ -152,33 +208,70 @@ class SerialPort extends _eventTarget.EventTarget {
    * After this, a later open() (e.g. when the device is re-attached) succeeds.
    */
   #handleDeviceLost() {
-    // Tear down read/write streams without invoking the OS on the dead device.
+    const wasForgotten = this.#state === 'forgotten';
+
+    // Reject any in-flight read/write with a "NetworkError" (per spec), erroring
+    // the stream controllers directly. We must NOT cancel()/abort() the streams:
+    // cancel() rejects on a reader-locked stream (leaving the read orphaned) and
+    // both would try to invoke the OS on the now-gone device.
+    const lost = new _domException.DOMException('The device has been lost.', 'NetworkError');
     if (this.#readable) {
       this.#readFatal = true;
       try {
-        // No active reader is required for cancel(); errors are non-fatal here.
-        this.#readable.cancel().catch(() => {});
+        this.#readableController?.error(lost);
       } catch {}
     }
     if (this.#writable) {
       this.#writeFatal = true;
       try {
-        this.#writable.abort().catch(() => {});
+        this.#writableController?.error(lost);
       } catch {}
     }
-    this.#dataSubscription?.remove();
-    this.#errorSubscription?.remove();
-    this.#dataSubscription = null;
-    this.#errorSubscription = null;
+    this.#resetToClosedState(wasForgotten ? 'forgotten' : 'closed');
+    this.dispatchEvent(new _eventTarget.Event('disconnect'));
+  }
+
+  /**
+   * Reset this port to a closed, re-openable state after a clean physical
+   * detach. Unlike device loss, buffered readable bytes should still be
+   * observable before the stream ends.
+   */
+  #handleDeviceDetached() {
+    const wasForgotten = this.#state === 'forgotten';
+    const readable = this.#readable;
+    const writable = this.#writable;
+
+    // Keep the public event and state transition synchronous so existing
+    // callers observe the detach immediately, but defer the stream teardown by
+    // one microtask to let already-queued data drain first.
+    this.#state = wasForgotten ? 'forgotten' : 'closed';
+    this.#connected = false;
     this.#readable = null;
     this.#writable = null;
-    this.#readFatal = false;
-    this.#writeFatal = false;
-    this.#pendingClosePromise = null;
-    this.#bufferSize = undefined;
-    this.#state = 'closed';
-    this.#connected = false;
     this.dispatchEvent(new _eventTarget.Event('disconnect'));
+    queueMicrotask(() => {
+      // Close the readable stream so any bytes already queued can still be
+      // drained by the consumer before EOF.
+      try {
+        if (readable) this.#readableController?.close();
+      } catch {}
+
+      // A detached device can no longer accept writes, so reject any writable
+      // traffic and clear local state.
+      const lost = new _domException.DOMException('The device has been lost.', 'NetworkError');
+      if (writable) {
+        this.#writeFatal = true;
+        try {
+          this.#writableController?.error(lost);
+        } catch {}
+      }
+
+      // Mirror the stream-closing bookkeeping without treating this as a hard
+      // read fatal error.
+      this.#handleClosingReadableStream();
+      this.#handleClosingWritableStream();
+      this.#resetToClosedState(wasForgotten ? 'forgotten' : 'closed');
+    });
   }
 
   /**
@@ -247,17 +340,29 @@ class SerialPort extends _eventTarget.EventTarget {
     const deviceId = this.#deviceId;
     const portNumber = this.#portNumber;
     const bufferSize = this.#bufferSize;
-    const stream = new _webStreamsPolyfill.ReadableStream({
+    const stream = new _webStreams.ReadableStreamImpl({
       start(controller) {
+        self.#readableController = controller;
         self.#dataSubscription = self.#usb.onData(event => {
           if (event.deviceId === deviceId && event.portNumber === portNumber) {
-            controller.enqueue(new Uint8Array(event.data));
+            try {
+              controller.enqueue(new Uint8Array(event.data));
+            } catch {
+              // The stream may already be closing/closed — e.g. a data event
+              // racing cancel()/close(), where the stream is closed but this
+              // subscription is not yet torn down. Dropping the chunk is
+              // correct (the consumer has stopped reading) and avoids throwing
+              // out of the transport's event-dispatch loop.
+            }
           }
         });
         self.#errorSubscription = self.#usb.onError(event => {
           if (event.deviceId === deviceId && event.portNumber === portNumber) {
             self.#readFatal = true; // Set this.[[readFatal]] to true.
-            controller.error(new _domException.DOMException(event.error, 'NetworkError'));
+            // Surface the spec error type (BreakError, BufferOverrunError,
+            // FramingError, ParityError, …) when the transport reports one;
+            // fall back to NetworkError otherwise.
+            controller.error(new _domException.DOMException(event.error, event.errorName ?? 'NetworkError'));
             self.#handleClosingReadableStream();
           }
         });
@@ -268,7 +373,7 @@ class SerialPort extends _eventTarget.EventTarget {
         await self.#usb.purgeHwBuffers(deviceId, portNumber, false, true).catch(() => {});
         self.#handleClosingReadableStream();
       }
-    }, new _webStreamsPolyfill.ByteLengthQueuingStrategy({
+    }, new _webStreams.ByteLengthQueuingStrategyImpl({
       highWaterMark: bufferSize
     }));
 
@@ -299,10 +404,14 @@ class SerialPort extends _eventTarget.EventTarget {
     const deviceId = this.#deviceId;
     const portNumber = this.#portNumber;
     const bufferSize = this.#bufferSize;
-    const stream = new _webStreamsPolyfill.WritableStream({
+    const stream = new _webStreams.WritableStreamImpl({
+      start(controller) {
+        self.#writableController = controller;
+      },
       async write(chunk) {
+        const bytes = bufferSourceToBytes(chunk);
         try {
-          await self.#usb.write(deviceId, portNumber, Array.from(chunk));
+          await self.#usb.write(deviceId, portNumber, bytes, self.#writeTimeoutFor(bytes.length));
         } catch (e) {
           // If the port was disconnected, set this.[[writeFatal]] to true.
           self.#writeFatal = true;
@@ -321,7 +430,7 @@ class SerialPort extends _eventTarget.EventTarget {
         // of all software and hardware transmit buffers for the port.
         self.#handleClosingWritableStream();
       }
-    }, new _webStreamsPolyfill.ByteLengthQueuingStrategy({
+    }, new _webStreams.ByteLengthQueuingStrategyImpl({
       highWaterMark: bufferSize
     }));
 
@@ -380,7 +489,7 @@ class SerialPort extends _eventTarget.EventTarget {
 
     // 3. If options["baudRate"] is 0, reject promise with a TypeError and
     // return promise.
-    if (options.baudRate === 0) {
+    if (!Number.isFinite(options.baudRate) || options.baudRate <= 0) {
       throw new TypeError('baudRate must be a positive, non-zero value.');
     }
 
@@ -401,7 +510,7 @@ class SerialPort extends _eventTarget.EventTarget {
     // 6. If options["bufferSize"] is 0, reject promise with a TypeError and
     // return promise.
     const bufferSize = options.bufferSize ?? kDefaultBufferSize;
-    if (bufferSize === 0) {
+    if (!Number.isFinite(bufferSize) || bufferSize <= 0) {
       throw new TypeError('bufferSize must be a positive, non-zero value.');
     }
     const parity = options.parity ?? kDefaultParity;
@@ -409,6 +518,9 @@ class SerialPort extends _eventTarget.EventTarget {
       throw new TypeError(`parity must be one of: ${kAcceptableParity.join(', ')}.`);
     }
     const flowControl = options.flowControl ?? kDefaultFlowControl;
+    if (!kAcceptableFlowControl.includes(flowControl)) {
+      throw new TypeError(`flowControl must be one of: ${kAcceptableFlowControl.join(', ')}.`);
+    }
 
     // 8. Set this.[[state]] to "opening".
     this.#state = 'opening';
@@ -429,13 +541,41 @@ class SerialPort extends _eventTarget.EventTarget {
       this.#state = 'closed';
       throw new _domException.DOMException(`Failed to open serial port: ${e.message}`, 'NetworkError');
     }
-    if (flowControl !== 'none') {
-      await this.#usb.setFlowControl(this.#deviceId, this.#portNumber, flowControlToNative(flowControl));
+    try {
+      if (flowControl !== 'none') {
+        await this.#usb.setFlowControl(this.#deviceId, this.#portNumber, flowControlToNative(flowControl));
+      }
+      await this.#usb.startReading(this.#deviceId, this.#portNumber);
+    } catch (e) {
+      // If post-open setup fails (flow-control/read pump), best-effort close
+      // and reset local state so a subsequent open() can succeed cleanly.
+      try {
+        await this.#usb.close(this.#deviceId, this.#portNumber);
+      } catch {
+        // ignore
+      }
+      this.#resetToClosedState(this.#forgetRequested ? 'forgotten' : 'closed');
+      throw new _domException.DOMException(`Failed to open serial port: ${e.message}`, 'NetworkError');
+    }
+
+    // Guard against lifecycle races (e.g. forget() called while open() is
+    // still awaiting native setup). Do not revive a forgotten/changed state.
+    if (this.#state !== 'opening') {
+      try {
+        await this.#usb.close(this.#deviceId, this.#portNumber);
+      } catch {
+        // ignore
+      }
+      if (this.#state === 'forgotten' || this.#state === 'forgetting') {
+        this.#resetToClosedState('forgotten');
+        throw new _domException.DOMException('The port has been forgotten while opening.', 'InvalidStateError');
+      }
+      this.#resetToClosedState();
+      throw new _domException.DOMException('Failed to open serial port: state changed while opening.', 'NetworkError');
     }
     this.#state = 'opened'; // 9.3. Set this.[[state]] to "opened".
     this.#bufferSize = bufferSize; // 9.4. Set this.[[bufferSize]] to options["bufferSize"].
-
-    await this.#usb.startReading(this.#deviceId, this.#portNumber);
+    this.#baudRate = options.baudRate;
 
     // When the port becomes logically connected:
     this.#connected = true; // 2. Set port.[[connected]] to true.
@@ -443,6 +583,13 @@ class SerialPort extends _eventTarget.EventTarget {
     // device presence (attach/detach), dispatched by Serial from the native
     // USB state events — not logical open()/close(). So we do not dispatch them
     // here; that also avoids re-entrancy with auto-reconnect listeners.
+
+    // Materialise the readable eagerly so its data subscription is live the
+    // instant the native read pump (startReading, above) begins emitting. The
+    // device may transmit immediately on open; without an active subscription
+    // those first bytes would be delivered to no listener and silently lost in
+    // the window between open() resolving and the first port.readable access.
+    void this.readable;
   }
 
   /**
@@ -492,17 +639,11 @@ class SerialPort extends _eventTarget.EventTarget {
     } catch {
       // ignore
     }
-    this.#dataSubscription?.remove();
-    this.#errorSubscription?.remove();
-    this.#dataSubscription = null;
-    this.#errorSubscription = null;
-    this.#state = 'closed'; // 10.1.2. Set this.[[state]] to "closed".
-    this.#readFatal = false; // 10.1.3. Set this.[[readFatal]] and this.[[writeFatal]] to false.
-    this.#writeFatal = false; // 10.1.3. (continued)
-    this.#pendingClosePromise = null; // 10.1.4. Set this.[[pendingClosePromise]] to null.
 
-    // When the port is no longer logically connected:
-    this.#connected = false; // 2. Set port.[[connected]] to false.
+    // 10.1.2-10.1.4 and logical disconnect bookkeeping.
+    // If forget() was requested while close() was in flight, preserve
+    // forgotten semantics instead of reviving the port to "closed".
+    this.#resetToClosedState(this.#forgetRequested ? 'forgotten' : 'closed');
     // (No port-level "disconnect" dispatch here — that event signals physical
     // detach, fired by Serial from the native USB state events. See open().)
   }
@@ -513,6 +654,14 @@ class SerialPort extends _eventTarget.EventTarget {
   async forget() {
     // The forget() method steps are:
 
+    this.#forgetRequested = true;
+
+    // Forgetting an open port must not leave active streams/native resources
+    // behind. Close first so the instance becomes cleanly unusable afterwards.
+    if (this.#state === 'opened') {
+      await this.close();
+    }
+
     // 2.1. Set this.[[state]] to "forgetting".
     this.#state = 'forgetting';
     // 2.2. Remove this from the sequence of serial ports on the system which
@@ -539,12 +688,6 @@ class SerialPort extends _eventTarget.EventTarget {
     if (signals.dataTerminalReady === undefined && signals.requestToSend === undefined && signals.break === undefined) {
       throw new TypeError('At least one signal must be specified.');
     }
-
-    // Merge with current output signal state for partial updates
-    this.#outputSignals = {
-      ...this.#outputSignals,
-      ...signals
-    };
     const promises = [];
 
     // 4.1. If signals["dataTerminalReady"] is present, invoke the operating
@@ -618,6 +761,17 @@ class SerialPort extends _eventTarget.EventTarget {
   #handleClosingReadableStream() {
     // To handle closing the readable stream perform the following steps:
 
+    // Drop the native data/error subscription tied to this readable. Without
+    // this a later readable (after cancel() + re-acquire) would coexist with the
+    // old subscription, which then enqueues into the cancelled controller and
+    // throws. close()/handleDeviceLost() also clear these; doing it here covers
+    // a standalone readable.cancel().
+    this.#dataSubscription?.remove();
+    this.#errorSubscription?.remove();
+    this.#dataSubscription = null;
+    this.#errorSubscription = null;
+    this.#readableController = null;
+
     // 1. Set this.[[readable]] to null.
     this.#readable = null;
 
@@ -634,6 +788,8 @@ class SerialPort extends _eventTarget.EventTarget {
   #handleClosingWritableStream() {
     // To handle closing the writable stream perform the following steps:
 
+    this.#writableController = null;
+
     // 1. Set this.[[writable]] to null.
     this.#writable = null;
 
@@ -657,6 +813,20 @@ class Serial extends _eventTarget.EventTarget {
   #usb = null;
   #knownPorts = new Map();
   #initialized = false;
+  #injected;
+
+  /**
+   * @param transport Optional transport override. When provided, this `Serial`
+   * talks to it instead of the global native module — the transport override used by tests
+   * and the virtual serial device harness (`new Serial(new InMemorySerialTransport())`).
+   * Omit it for the normal native-backed instance; the singleton `serial`
+   * export is created this way and can still be redirected globally via
+   * `setUsbSerial()`.
+   */
+  constructor(transport) {
+    super();
+    this.#injected = transport ?? null;
+  }
 
   /**
    * Subscribing to "connect"/"disconnect" must wire up the native USB state
@@ -678,32 +848,39 @@ class Serial extends _eventTarget.EventTarget {
     if (this.#initialized) return this.#usb;
     this.#initialized = true;
     try {
-      this.#usb = (0, _UsbSerial.getUsbSerial)();
+      this.#usb = this.#injected ?? (0, _UsbSerial.getUsbSerial)();
 
       // A USB device was attached. Android assigns a NEW deviceId on every
       // attach, so match previously-known ports of the same physical device by
       // VID/PID, update their deviceId, re-key them, and fire "connect" on the
       // same SerialPort instance (W3C spec model: the port is reused).
       this.#usb.onConnect(event => {
-        let matched = false;
-        for (const [key, port] of [...this.#knownPorts.entries()]) {
+        // Native connect events expose VID/PID but not a stable unique
+        // identifier. To avoid mis-associating identical devices, remap only
+        // when there is exactly one disconnected candidate.
+        const candidates = Array.from(this.#knownPorts.entries()).filter(([, port]) => {
           const internals = portInternals.get(port);
-          if (!internals) continue;
-          if (internals.getVid() === event.usbVendorId && internals.getPid() === event.usbProductId) {
-            internals.setDeviceId(event.deviceId);
-            const newKey = this.#portKey(event.deviceId, internals.getPortNumber());
-            if (newKey !== key) {
-              this.#knownPorts.delete(key);
-              this.#knownPorts.set(newKey, port);
-            }
-            port.dispatchEvent(new _eventTarget.Event('connect'));
-            matched = true;
-          }
+          if (internals.getVid() !== event.usbVendorId) return false;
+          if (internals.getPid() !== event.usbProductId) return false;
+          if (internals.isForgotten()) return false;
+          return !port.connected;
+        });
+        if (candidates.length === 1) {
+          const [key, port] = candidates[0];
+          const internals = portInternals.get(port);
+          internals.setDeviceId(event.deviceId);
+          const newKey = this.#portKey(event.deviceId, internals.getPortNumber());
+          this.#knownPorts.delete(key);
+          this.#knownPorts.set(newKey, port);
+          // Dispatched on the port; it bubbles to this Serial (event.target
+          // stays the port, per spec — see setEventParent below).
+          port.dispatchEvent(new _eventTarget.Event('connect'));
+          return;
         }
+
+        // No known port matched (or matching is ambiguous): fire a Serial-level
+        // "connect" so listeners refresh; getPorts() surfaces the new port.
         this.dispatchEvent(new _eventTarget.Event('connect'));
-        // If we matched no known port this is a brand-new device; getPorts()
-        // will surface it on the next refresh.
-        void matched;
       });
 
       // A USB device was detached. Reset the matching port(s) to a closed,
@@ -711,13 +888,21 @@ class Serial extends _eventTarget.EventTarget {
       // SerialPort instance so a re-attach can reuse it. handleDeviceLost()
       // dispatches "disconnect" on the port.
       this.#usb.onDisconnect(event => {
+        const wasLost = event.lost ?? true;
         const prefix = `${event.deviceId}:`;
+        let matched = false;
         for (const [key, port] of [...this.#knownPorts.entries()]) {
           if (key.startsWith(prefix)) {
-            portInternals.get(port)?.handleDeviceLost();
+            // Physical loss tears down the stream immediately; a clean detach
+            // lets any already-buffered bytes drain before EOF.
+            const internals = portInternals.get(port);
+            if (wasLost) internals?.handleDeviceLost();else internals?.handleDeviceDetached();
+            matched = true;
           }
         }
-        this.dispatchEvent(new _eventTarget.Event('disconnect'));
+        // No known port matched (e.g. a device never opened): fire a
+        // Serial-level "disconnect" so listeners can still refresh.
+        if (!matched) this.dispatchEvent(new _eventTarget.Event('disconnect'));
       });
     } catch {
       this.#usb = null;
@@ -792,8 +977,12 @@ class Serial extends _eventTarget.EventTarget {
     } of portIds) {
       if (!hasPermission) continue;
       const key = this.#portKey(deviceId, portNumber);
-      if (!this.#knownPorts.has(key)) {
-        this.#knownPorts.set(key, new SerialPort(usb, deviceId, portNumber, usbVendorId, usbProductId));
+      const known = this.#knownPorts.get(key);
+      if (!known || portInternals.get(known)?.isForgotten()) {
+        const port = new SerialPort(usb, deviceId, portNumber, usbVendorId, usbProductId);
+        // The port's connect/disconnect events bubble to this Serial.
+        (0, _eventTarget.setEventParent)(port, this);
+        this.#knownPorts.set(key, port);
       }
       ports.push(this.#knownPorts.get(key));
     }
@@ -812,6 +1001,9 @@ class Serial extends _eventTarget.EventTarget {
     if (!usb) {
       throw new _domException.DOMException('NativeUsbSerial is not available.', 'NotFoundError');
     }
+    if ((options.allowedBluetoothServiceClassIds?.length ?? 0) > 0) {
+      throw new TypeError('allowedBluetoothServiceClassIds is not supported in Android USB mode.');
+    }
 
     // 4. If options["filters"] is present, then for each filter in
     // options["filters"] run the following steps:
@@ -854,8 +1046,12 @@ class Serial extends _eventTarget.EventTarget {
 
     // 5.6. Let port be a SerialPort representing the port chosen by the user.
     const key = `${portId.deviceId}:${portId.portNumber}`;
-    if (!this.#knownPorts.has(key)) {
-      this.#knownPorts.set(key, new SerialPort(usb, portId.deviceId, portId.portNumber, portId.usbVendorId, portId.usbProductId));
+    const known = this.#knownPorts.get(key);
+    if (!known || portInternals.get(known)?.isForgotten()) {
+      const port = new SerialPort(usb, portId.deviceId, portId.portNumber, portId.usbVendorId, portId.usbProductId);
+      // The port's connect/disconnect events bubble to this Serial.
+      (0, _eventTarget.setEventParent)(port, this);
+      this.#knownPorts.set(key, port);
     }
 
     // 5.7. Resolve promise with port.