@gurezo/web-serial-rxjs 0.1.21 → 2.0.0

package/dist/index.js

@@ -1,5 +1,5 @@
-// packages/web-serial-rxjs/src/client/serial-client.ts
-import { Observable as Observable2, defer, switchMap } from "rxjs";
+// packages/web-serial-rxjs/src/session/create-serial-session.ts
+import { distinctUntilChanged, map, Observable as Observable3, Subject } from "rxjs";
 
 // packages/web-serial-rxjs/src/errors/serial-error-code.ts
 var SerialErrorCode = /* @__PURE__ */ ((SerialErrorCode2) => {
@@ -13,6 +13,7 @@ var SerialErrorCode = /* @__PURE__ */ ((SerialErrorCode2) => {
   SerialErrorCode2["CONNECTION_LOST"] = "CONNECTION_LOST";
   SerialErrorCode2["INVALID_FILTER_OPTIONS"] = "INVALID_FILTER_OPTIONS";
   SerialErrorCode2["OPERATION_CANCELLED"] = "OPERATION_CANCELLED";
+  SerialErrorCode2["OPERATION_TIMEOUT"] = "OPERATION_TIMEOUT";
   SerialErrorCode2["UNKNOWN"] = "UNKNOWN";
   return SerialErrorCode2;
 })(SerialErrorCode || {});
@@ -56,54 +57,7 @@ var SerialError = class _SerialError extends Error {
   }
 };
 
-// packages/web-serial-rxjs/src/browser/browser-detection.ts
-var BrowserType = /* @__PURE__ */ ((BrowserType2) => {
-  BrowserType2["CHROME"] = "chrome";
-  BrowserType2["EDGE"] = "edge";
-  BrowserType2["OPERA"] = "opera";
-  BrowserType2["UNKNOWN"] = "unknown";
-  return BrowserType2;
-})(BrowserType || {});
-function hasWebSerialSupport() {
-  return typeof navigator !== "undefined" && "serial" in navigator && navigator.serial !== void 0 && navigator.serial !== null;
-}
-function detectBrowserType() {
-  if (typeof navigator === "undefined" || !navigator.userAgent) {
-    return "unknown" /* UNKNOWN */;
-  }
-  const ua = navigator.userAgent.toLowerCase();
-  if (ua.includes("edg/")) {
-    return "edge" /* EDGE */;
-  }
-  if (ua.includes("opr/") || ua.includes("opera/")) {
-    return "opera" /* OPERA */;
-  }
-  if (ua.includes("chrome/")) {
-    return "chrome" /* CHROME */;
-  }
-  return "unknown" /* UNKNOWN */;
-}
-function isChromiumBased() {
-  const browserType = detectBrowserType();
-  return browserType === "chrome" /* CHROME */ || browserType === "edge" /* EDGE */ || browserType === "opera" /* OPERA */;
-}
-
-// packages/web-serial-rxjs/src/browser/browser-support.ts
-function checkBrowserSupport() {
-  if (!hasWebSerialSupport()) {
-    const browserType = detectBrowserType();
-    const browserName = browserType === "unknown" /* UNKNOWN */ ? "your browser" : browserType.toUpperCase();
-    throw new SerialError(
-      "BROWSER_NOT_SUPPORTED" /* BROWSER_NOT_SUPPORTED */,
-      `Web Serial API is not supported in ${browserName}. Please use a Chromium-based browser (Chrome, Edge, or Opera).`
-    );
-  }
-}
-function isBrowserSupported() {
-  return hasWebSerialSupport();
-}
-
-// packages/web-serial-rxjs/src/filters/build-request-options.ts
+// packages/web-serial-rxjs/src/session/internal/build-request-options.ts
 function buildRequestOptions(options) {
   if (!options || !options.filters || options.filters.length === 0) {
     return void 0;
@@ -137,165 +91,204 @@ function buildRequestOptions(options) {
   };
 }
 
-// packages/web-serial-rxjs/src/io/observable-to-writable.ts
-function observableToWritable(observable) {
-  let writer = null;
-  let subscription = null;
-  let stream = null;
-  stream = new WritableStream({
-    async start() {
-      if (!stream) {
-        return;
+// packages/web-serial-rxjs/src/session/internal/has-web-serial-support.ts
+function hasWebSerialSupport() {
+  return typeof navigator !== "undefined" && "serial" in navigator && navigator.serial !== void 0 && navigator.serial !== null;
+}
+
+// packages/web-serial-rxjs/src/session/internal/line-buffer.ts
+function createLineBuffer() {
+  let buffer = "";
+  const clear = () => {
+    buffer = "";
+  };
+  const feed = (chunk) => {
+    buffer += chunk;
+    const out = [];
+    for (; ; ) {
+      const crlf = buffer.indexOf("\r\n");
+      if (crlf >= 0) {
+        out.push(buffer.slice(0, crlf));
+        buffer = buffer.slice(crlf + 2);
+        continue;
       }
-      writer = stream.getWriter();
-      subscription = observable.subscribe({
-        next: async (chunk) => {
-          if (writer) {
-            try {
-              await writer.write(chunk);
-            } catch (error) {
-              subscription?.unsubscribe();
-              if (writer) {
-                writer.releaseLock();
-              }
-              throw error;
-            }
-          }
-        },
-        error: async (error) => {
-          if (writer) {
-            try {
-              await writer.abort(error);
-            } catch {
-            } finally {
-              writer.releaseLock();
-              writer = null;
-            }
-          }
-        },
-        complete: async () => {
-          if (writer) {
-            try {
-              await writer.close();
-            } catch {
-            } finally {
-              writer.releaseLock();
-              writer = null;
-            }
-          }
-        }
-      });
-    },
-    abort(reason) {
-      if (subscription) {
-        subscription.unsubscribe();
-        subscription = null;
+      const cr = buffer.indexOf("\r");
+      if (cr >= 0 && cr + 1 < buffer.length && buffer[cr + 1] !== "\n") {
+        out.push(buffer.slice(0, cr));
+        buffer = buffer.slice(cr + 1);
+        continue;
       }
-      if (writer) {
-        writer.abort(reason).catch(() => {
-        });
-        writer.releaseLock();
-        writer = null;
+      const nl = buffer.indexOf("\n");
+      if (nl >= 0) {
+        out.push(buffer.slice(0, nl));
+        buffer = buffer.slice(nl + 1);
+        continue;
+      }
+      if (cr >= 0 && cr + 1 === buffer.length) {
+        break;
       }
+      break;
     }
-  });
-  return stream;
+    return out;
+  };
+  return { feed, clear };
 }
-function subscribeToWritable(observable, stream) {
-  const writer = stream.getWriter();
-  const errorHandler = async (error) => {
+
+// packages/web-serial-rxjs/src/session/normalize-serial-error.ts
+var DEFAULT_MESSAGE_PREFIX = "Serial operation failed";
+var isDomExceptionWithName = (error, name) => typeof DOMException !== "undefined" && error instanceof DOMException && error.name === name;
+function normalizeSerialError(error, options) {
+  if (error instanceof SerialError) {
+    return error;
+  }
+  const prefix = options.messagePrefix ?? DEFAULT_MESSAGE_PREFIX;
+  if (isDomExceptionWithName(error, "NotFoundError")) {
+    return new SerialError(
+      "OPERATION_CANCELLED" /* OPERATION_CANCELLED */,
+      "Port selection was cancelled by the user",
+      error
+    );
+  }
+  const cause = error instanceof Error ? error : new Error(String(error));
+  return new SerialError(
+    options.fallbackCode,
+    `${prefix}: ${cause.message}`,
+    cause
+  );
+}
+
+// packages/web-serial-rxjs/src/session/read-pump.ts
+function createReadPump(port, { onChunk, onError }) {
+  let reader = null;
+  let running = false;
+  let stopped = false;
+  const decoder = new TextDecoder(void 0, { fatal: false });
+  const releaseReader = () => {
+    if (!reader) {
+      return;
+    }
     try {
-      await writer.abort(error);
+      reader.releaseLock();
     } catch {
+    }
+    reader = null;
+  };
+  const pump = async (stream) => {
+    reader = stream.getReader();
+    running = true;
+    try {
+      while (!stopped) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (value && value.byteLength > 0) {
+          const text = decoder.decode(value, { stream: true });
+          if (text.length > 0) {
+            onChunk(text);
+          }
+        }
+      }
+      if (!stopped) {
+        const tail = decoder.decode();
+        if (tail.length > 0) {
+          onChunk(tail);
+        }
+      }
+    } catch (error) {
+      if (!stopped) {
+        onError(
+          normalizeSerialError(error, {
+            fallbackCode: "READ_FAILED" /* READ_FAILED */,
+            messagePrefix: "Read pump failed"
+          })
+        );
+      }
     } finally {
-      writer.releaseLock();
+      running = false;
+      releaseReader();
     }
   };
-  const subscription = observable.subscribe({
-    next: async (chunk) => {
-      try {
-        await writer.write(chunk);
-      } catch (error) {
-        subscription.unsubscribe();
-        writer.releaseLock();
-        const serialError = new SerialError(
-          "WRITE_FAILED" /* WRITE_FAILED */,
-          `Failed to write to stream: ${error instanceof Error ? error.message : String(error)}`,
-          error instanceof Error ? error : new Error(String(error))
+  return {
+    start() {
+      if (running || stopped) {
+        return;
+      }
+      const stream = port.readable;
+      if (!stream) {
+        stopped = true;
+        onError(
+          new SerialError(
+            "CONNECTION_LOST" /* CONNECTION_LOST */,
+            "Read pump failed: port.readable is not available"
+          )
         );
-        await errorHandler(serialError);
+        return;
       }
+      void pump(stream);
     },
-    error: errorHandler,
-    complete: async () => {
+    async stop() {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      if (!reader) {
+        return;
+      }
       try {
-        await writer.close();
+        await reader.cancel();
       } catch {
       } finally {
-        writer.releaseLock();
+        releaseReader();
       }
-    }
-  });
-  return {
-    unsubscribe: () => {
-      subscription.unsubscribe();
-      writer.releaseLock();
+    },
+    get isRunning() {
+      return running;
     }
   };
 }
 
-// packages/web-serial-rxjs/src/io/readable-to-observable.ts
-import { Observable } from "rxjs";
-function readableToObservable(stream) {
-  return new Observable((subscriber) => {
-    const reader = stream.getReader();
-    const pump = async () => {
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            subscriber.complete();
-            break;
-          }
-          if (value) {
-            subscriber.next(value);
-          }
-        }
-      } catch (error) {
-        if (error instanceof Error) {
-          subscriber.error(
-            new SerialError(
-              "READ_FAILED" /* READ_FAILED */,
-              `Failed to read from stream: ${error.message}`,
-              error
-            )
-          );
-        } else {
-          subscriber.error(
-            new SerialError(
-              "READ_FAILED" /* READ_FAILED */,
-              "Failed to read from stream: Unknown error",
-              error
-            )
+// packages/web-serial-rxjs/src/session/send-queue.ts
+import { Observable, defer } from "rxjs";
+function createSendQueue() {
+  let chain = Promise.resolve();
+  return {
+    enqueue(operation) {
+      return defer(
+        () => new Observable((subscriber) => {
+          let cancelled = false;
+          const run = async () => {
+            try {
+              const value = await operation();
+              if (!cancelled) {
+                subscriber.next(value);
+                subscriber.complete();
+              }
+            } catch (error) {
+              if (!cancelled) {
+                subscriber.error(error);
+              }
+            }
+          };
+          const scheduled = chain.then(run, run);
+          chain = scheduled.then(
+            () => void 0,
+            () => void 0
           );
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    };
-    pump().catch((error) => {
-      if (!subscriber.closed) {
-        subscriber.error(error);
-      }
-    });
-    return () => {
-      reader.releaseLock();
-    };
-  });
+          return () => {
+            cancelled = true;
+          };
+        })
+      );
+    },
+    clear() {
+      chain = Promise.resolve();
+    }
+  };
 }
 
-// packages/web-serial-rxjs/src/types/options.ts
-var DEFAULT_SERIAL_CLIENT_OPTIONS = {
+// packages/web-serial-rxjs/src/session/serial-session-options.ts
+var DEFAULT_SERIAL_SESSION_OPTIONS = {
   baudRate: 9600,
   dataBits: 8,
   stopBits: 1,
@@ -305,291 +298,318 @@ var DEFAULT_SERIAL_CLIENT_OPTIONS = {
   filters: void 0
 };
 
-// packages/web-serial-rxjs/src/client/serial-client.ts
-var SerialClientImpl = class {
-  /**
-   * Creates a new SerialClientImpl instance.
-   *
-   * @param options - Optional configuration options for the serial port connection
-   * @throws {@link SerialError} with code {@link SerialErrorCode.BROWSER_NOT_SUPPORTED} if the browser doesn't support Web Serial API
-   * @internal
-   */
-  constructor(options) {
-    /** @internal */
-    this.port = null;
-    /** @internal */
-    this.isOpen = false;
-    /** @internal */
-    this.readSubscription = null;
-    /** @internal */
-    this.writeSubscription = null;
-    checkBrowserSupport();
-    this.options = {
-      ...DEFAULT_SERIAL_CLIENT_OPTIONS,
-      ...options,
-      filters: options?.filters
-    };
+// packages/web-serial-rxjs/src/session/serial-session-state.ts
+var SerialSessionState = {
+  Idle: "idle",
+  Connecting: "connecting",
+  Connected: "connected",
+  Disconnecting: "disconnecting",
+  Unsupported: "unsupported",
+  Error: "error"
+};
+
+// packages/web-serial-rxjs/src/session/session-state-machine.ts
+import { BehaviorSubject } from "rxjs";
+var S = SerialSessionState;
+var ALLOWED_TRANSITIONS = {
+  [S.Idle]: [S.Connecting, S.Error],
+  [S.Connecting]: [S.Connected, S.Error, S.Idle],
+  [S.Connected]: [S.Disconnecting, S.Error],
+  [S.Disconnecting]: [S.Idle, S.Error],
+  [S.Error]: [S.Idle, S.Connecting],
+  [S.Unsupported]: []
+};
+var SessionStateMachine = class {
+  constructor(initial = SerialSessionState.Idle) {
+    this.subject = new BehaviorSubject(initial);
   }
-  /**
-   * Request a serial port from the user.
-   *
-   * @returns Observable that emits the selected SerialPort
-   * @internal
-   */
-  requestPort() {
-    return defer(() => {
-      checkBrowserSupport();
-      return navigator.serial.requestPort(buildRequestOptions(this.options)).catch((error) => {
-        if (error instanceof DOMException && error.name === "NotFoundError") {
-          throw new SerialError(
-            "OPERATION_CANCELLED" /* OPERATION_CANCELLED */,
-            "Port selection was cancelled by the user",
-            error
-          );
-        }
-        throw new SerialError(
-          "PORT_NOT_AVAILABLE" /* PORT_NOT_AVAILABLE */,
-          `Failed to request port: ${error instanceof Error ? error.message : String(error)}`,
-          error instanceof Error ? error : new Error(String(error))
-        );
-      });
-    });
+  get current() {
+    return this.subject.getValue();
   }
-  /**
-   * Get available serial ports.
-   *
-   * @returns Observable that emits an array of available SerialPorts
-   * @internal
-   */
-  getPorts() {
-    return defer(() => {
-      checkBrowserSupport();
-      return navigator.serial.getPorts().catch((error) => {
-        throw new SerialError(
-          "PORT_NOT_AVAILABLE" /* PORT_NOT_AVAILABLE */,
-          `Failed to get ports: ${error instanceof Error ? error.message : String(error)}`,
-          error instanceof Error ? error : new Error(String(error))
-        );
-      });
-    });
+  get state$() {
+    return this.subject.asObservable();
   }
-  /**
-   * Connect to a serial port.
-   *
-   * @param port - Optional SerialPort to connect to. If not provided, will request one.
-   * @returns Observable that completes when the port is opened
-   * @internal
-   */
-  connect(port) {
-    checkBrowserSupport();
-    if (this.isOpen) {
-      return new Observable2((subscriber) => {
-        subscriber.error(
-          new SerialError(
-            "PORT_ALREADY_OPEN" /* PORT_ALREADY_OPEN */,
-            "Port is already open"
-          )
-        );
-      });
-    }
-    const port$ = port ? new Observable2((subscriber) => {
-      subscriber.next(port);
-      subscriber.complete();
-    }) : this.requestPort();
-    return port$.pipe(
-      switchMap((selectedPort) => {
-        return defer(() => {
-          this.port = selectedPort;
-          return this.port.open({
-            baudRate: this.options.baudRate,
-            dataBits: this.options.dataBits,
-            stopBits: this.options.stopBits,
-            parity: this.options.parity,
-            bufferSize: this.options.bufferSize,
-            flowControl: this.options.flowControl
-          }).then(() => {
-            this.isOpen = true;
-          }).catch((error) => {
-            this.port = null;
-            this.isOpen = false;
-            if (error instanceof SerialError) {
-              throw error;
-            }
-            throw new SerialError(
-              "PORT_OPEN_FAILED" /* PORT_OPEN_FAILED */,
-              `Failed to open port: ${error instanceof Error ? error.message : String(error)}`,
-              error instanceof Error ? error : new Error(String(error))
-            );
-          });
-        });
-      })
-    );
+  toConnecting() {
+    return this.transition(S.Connecting);
   }
-  /**
-   * Disconnect from the serial port.
-   *
-   * @returns Observable that completes when the port is closed
-   * @internal
-   */
-  disconnect() {
-    return defer(() => {
-      if (!this.isOpen || !this.port) {
-        return Promise.resolve();
-      }
-      if (this.readSubscription) {
-        this.readSubscription.unsubscribe();
-        this.readSubscription = null;
-      }
-      if (this.writeSubscription) {
-        this.writeSubscription.unsubscribe();
-        this.writeSubscription = null;
-      }
-      return this.port.close().then(() => {
-        this.port = null;
-        this.isOpen = false;
-      }).catch((error) => {
-        this.port = null;
-        this.isOpen = false;
-        throw new SerialError(
-          "CONNECTION_LOST" /* CONNECTION_LOST */,
-          `Failed to close port: ${error instanceof Error ? error.message : String(error)}`,
-          error instanceof Error ? error : new Error(String(error))
-        );
-      });
-    });
+  toConnected() {
+    return this.transition(S.Connected);
   }
-  /**
-   * Get an Observable that emits data read from the serial port.
-   *
-   * @returns Observable that emits Uint8Array chunks
-   * @internal
-   */
-  getReadStream() {
-    if (!this.isOpen || !this.port || !this.port.readable) {
-      throw new SerialError(
-        "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
-        "Port is not open or readable stream is not available"
-      );
+  toDisconnecting() {
+    return this.transition(S.Disconnecting);
+  }
+  toIdle() {
+    return this.transition(S.Idle);
+  }
+  toError() {
+    return this.transition(S.Error);
+  }
+  toUnsupported() {
+    return this.transition(S.Unsupported);
+  }
+  complete() {
+    this.subject.complete();
+  }
+  transition(next) {
+    const current = this.subject.getValue();
+    if (current === next) {
+      return false;
+    }
+    const allowed = ALLOWED_TRANSITIONS[current];
+    if (!allowed.includes(next)) {
+      if (typeof console !== "undefined" && console.warn) {
+        console.warn(
+          `[web-serial-rxjs] Ignoring invalid SerialSession transition ${current} -> ${next}`
+        );
+      }
+      return false;
     }
-    return readableToObservable(this.port.readable);
+    this.subject.next(next);
+    return true;
   }
-  /**
-   * Write data to the serial port from an Observable.
-   *
-   * @param data$ - Observable that emits Uint8Array chunks to write
-   * @returns Observable that completes when writing is finished
-   * @internal
-   */
-  writeStream(data$) {
-    if (!this.isOpen || !this.port || !this.port.writable) {
+};
+
+// packages/web-serial-rxjs/src/session/create-serial-session.ts
+function createSerialSession(options) {
+  const resolvedOptions = {
+    ...DEFAULT_SERIAL_SESSION_OPTIONS,
+    ...options,
+    filters: options?.filters
+  };
+  const supported = hasWebSerialSupport();
+  const machine = new SessionStateMachine(
+    supported ? SerialSessionState.Idle : SerialSessionState.Unsupported
+  );
+  const errorsSubject = new Subject();
+  const receiveSubject = new Subject();
+  const linesSubject = new Subject();
+  const sendQueue = createSendQueue();
+  const textEncoder = new TextEncoder();
+  const lineBuffer = createLineBuffer();
+  const errors$ = errorsSubject.asObservable();
+  const receive$ = receiveSubject.asObservable();
+  const lines$ = linesSubject.asObservable();
+  const isConnected$ = machine.state$.pipe(
+    map((state) => state === SerialSessionState.Connected),
+    distinctUntilChanged()
+  );
+  let activePort = null;
+  let activePump = null;
+  const teardownPump = async () => {
+    const pump = activePump;
+    activePump = null;
+    lineBuffer.clear();
+    if (pump) {
+      await pump.stop();
+    }
+  };
+  const closePortSafely = async (port) => {
+    if (!port) {
+      return;
+    }
+    try {
+      await port.close();
+    } catch {
+    }
+  };
+  const reportError = (error, severity, options2) => {
+    const serialError = normalizeSerialError(error, options2);
+    errorsSubject.next(serialError);
+    if (severity === "fatal") {
+      machine.toError();
+      sendQueue.clear();
+      const portToClose = activePort;
+      activePort = null;
+      void teardownPump().then(() => closePortSafely(portToClose));
+    }
+    return serialError;
+  };
+  const writeToPort = async (payload) => {
+    const port = activePort;
+    if (machine.current !== SerialSessionState.Connected || !port || !port.writable) {
       throw new SerialError(
         "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
-        "Port is not open or writable stream is not available"
+        "Cannot send data while session is not connected"
       );
     }
-    if (this.writeSubscription) {
-      this.writeSubscription.unsubscribe();
-    }
-    this.writeSubscription = subscribeToWritable(data$, this.port.writable);
-    return new Observable2((subscriber) => {
-      if (!this.writeSubscription) {
-        subscriber.error(
-          new SerialError(
-            "WRITE_FAILED" /* WRITE_FAILED */,
-            "Write subscription is not available"
-          )
-        );
-        return;
+    const writer = port.writable.getWriter();
+    try {
+      await writer.write(payload);
+    } finally {
+      try {
+        writer.releaseLock();
+      } catch {
       }
-      const originalUnsubscribe = this.writeSubscription.unsubscribe;
-      this.writeSubscription = {
-        unsubscribe: () => {
-          originalUnsubscribe();
-          subscriber.complete();
+    }
+  };
+  return {
+    isBrowserSupported() {
+      return hasWebSerialSupport();
+    },
+    connect$() {
+      return new Observable3((subscriber) => {
+        if (!hasWebSerialSupport()) {
+          const error = reportError(
+            new SerialError(
+              "BROWSER_NOT_SUPPORTED" /* BROWSER_NOT_SUPPORTED */,
+              "Web Serial API is not supported in this environment"
+            ),
+            "non-fatal",
+            { fallbackCode: "BROWSER_NOT_SUPPORTED" /* BROWSER_NOT_SUPPORTED */ }
+          );
+          subscriber.error(error);
+          return;
         }
-      };
-      data$.subscribe({
-        complete: () => {
-          if (this.writeSubscription) {
-            this.writeSubscription.unsubscribe();
-            this.writeSubscription = null;
+        const current = machine.current;
+        if (current !== SerialSessionState.Idle && current !== SerialSessionState.Error) {
+          const error = reportError(
+            new SerialError(
+              "PORT_ALREADY_OPEN" /* PORT_ALREADY_OPEN */,
+              `Cannot connect while session state is '${current}'`
+            ),
+            "non-fatal",
+            { fallbackCode: "PORT_ALREADY_OPEN" /* PORT_ALREADY_OPEN */ }
+          );
+          subscriber.error(error);
+          return;
+        }
+        let cancelled = false;
+        machine.toConnecting();
+        const run = async () => {
+          let selectedPort = null;
+          try {
+            selectedPort = await navigator.serial.requestPort(
+              buildRequestOptions(resolvedOptions)
+            );
+            await selectedPort.open({
+              baudRate: resolvedOptions.baudRate,
+              dataBits: resolvedOptions.dataBits,
+              stopBits: resolvedOptions.stopBits,
+              parity: resolvedOptions.parity,
+              bufferSize: resolvedOptions.bufferSize,
+              flowControl: resolvedOptions.flowControl
+            });
+          } catch (error) {
+            if (selectedPort) {
+              await closePortSafely(selectedPort);
+            }
+            activePort = null;
+            const serialError = reportError(error, "fatal", {
+              fallbackCode: "PORT_OPEN_FAILED" /* PORT_OPEN_FAILED */,
+              messagePrefix: "Failed to open port"
+            });
+            if (!cancelled) {
+              subscriber.error(serialError);
+            }
+            return;
           }
-          subscriber.complete();
-        },
-        error: (error) => {
-          if (this.writeSubscription) {
-            this.writeSubscription.unsubscribe();
-            this.writeSubscription = null;
+          if (cancelled) {
+            await closePortSafely(selectedPort);
+            return;
           }
+          activePort = selectedPort;
+          lineBuffer.clear();
+          activePump = createReadPump(selectedPort, {
+            onChunk: (text) => {
+              receiveSubject.next(text);
+              for (const line of lineBuffer.feed(text)) {
+                linesSubject.next(line);
+              }
+            },
+            onError: (pumpError) => reportError(pumpError, "fatal", {
+              fallbackCode: "READ_FAILED" /* READ_FAILED */,
+              messagePrefix: "Read pump failed"
+            })
+          });
+          activePump.start();
+          sendQueue.clear();
+          machine.toConnected();
+          subscriber.next();
+          subscriber.complete();
+        };
+        void run();
+        return () => {
+          cancelled = true;
+        };
+      });
+    },
+    disconnect$() {
+      return new Observable3((subscriber) => {
+        const current = machine.current;
+        if (current === SerialSessionState.Idle || current === SerialSessionState.Unsupported) {
+          subscriber.next();
+          subscriber.complete();
+          return;
+        }
+        if (current !== SerialSessionState.Connected && current !== SerialSessionState.Error) {
+          const error = reportError(
+            new SerialError(
+              "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
+              `Cannot disconnect while session state is '${current}'`
+            ),
+            "non-fatal",
+            { fallbackCode: "PORT_NOT_OPEN" /* PORT_NOT_OPEN */ }
+          );
           subscriber.error(error);
+          return;
         }
+        machine.toDisconnecting();
+        sendQueue.clear();
+        const portToClose = activePort;
+        const run = async () => {
+          try {
+            await teardownPump();
+            if (portToClose) {
+              try {
+                await portToClose.close();
+              } catch (error) {
+                activePort = null;
+                const serialError = reportError(error, "fatal", {
+                  fallbackCode: "CONNECTION_LOST" /* CONNECTION_LOST */,
+                  messagePrefix: "Failed to close port"
+                });
+                subscriber.error(serialError);
+                return;
+              }
+            }
+            activePort = null;
+            machine.toIdle();
+            subscriber.next();
+            subscriber.complete();
+          } catch (error) {
+            const serialError = reportError(error, "fatal", {
+              fallbackCode: "UNKNOWN" /* UNKNOWN */,
+              messagePrefix: "Unexpected disconnect failure"
+            });
+            subscriber.error(serialError);
+          }
+        };
+        void run();
       });
-    });
-  }
-  /**
-   * Write a single chunk of data to the serial port.
-   *
-   * @param data - Data to write
-   * @returns Observable that completes when the data is written
-   * @internal
-   */
-  write(data) {
-    return defer(() => {
-      if (!this.isOpen || !this.port || !this.port.writable) {
-        throw new SerialError(
-          "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
-          "Port is not open or writable stream is not available"
-        );
-      }
-      const writer = this.port.writable.getWriter();
-      return writer.write(data).then(() => {
-        writer.releaseLock();
-      }).catch((error) => {
-        writer.releaseLock();
-        throw new SerialError(
-          "WRITE_FAILED" /* WRITE_FAILED */,
-          `Failed to write data: ${error instanceof Error ? error.message : String(error)}`,
-          error instanceof Error ? error : new Error(String(error))
-        );
+    },
+    send$(data) {
+      return sendQueue.enqueue(async () => {
+        const payload = typeof data === "string" ? textEncoder.encode(data) : data;
+        try {
+          await writeToPort(payload);
+        } catch (error) {
+          throw reportError(error, "non-fatal", {
+            fallbackCode: "WRITE_FAILED" /* WRITE_FAILED */,
+            messagePrefix: "Failed to write data"
+          });
+        }
       });
-    });
-  }
-  /**
-   * Check if the port is currently open.
-   *
-   * @returns `true` if a port is currently open, `false` otherwise
-   * @internal
-   */
-  get connected() {
-    return this.isOpen;
-  }
-  /**
-   * Get the current SerialPort instance.
-   *
-   * @returns The current SerialPort instance, or `null` if no port is open
-   * @internal
-   */
-  get currentPort() {
-    return this.port;
-  }
-};
-
-// packages/web-serial-rxjs/src/client/index.ts
-function createSerialClient(options) {
-  return new SerialClientImpl(options);
+    },
+    state$: machine.state$,
+    isConnected$,
+    errors$,
+    receive$,
+    lines$
+  };
 }
 export {
-  BrowserType,
   SerialError,
   SerialErrorCode,
-  buildRequestOptions,
-  checkBrowserSupport,
-  createSerialClient,
-  detectBrowserType,
-  hasWebSerialSupport,
-  isBrowserSupported,
-  isChromiumBased,
-  observableToWritable,
-  readableToObservable,
-  subscribeToWritable
+  SerialSessionState,
+  createSerialSession
 };