@gurezo/web-serial-rxjs 2.3.6 → 2.4.0

package/dist/index.mjs

@@ -3,10 +3,9 @@ import {
   BehaviorSubject as BehaviorSubject2,
   distinctUntilChanged,
   map as map2,
-  Observable as Observable3,
-  ReplaySubject,
+  Observable as Observable4,
   share,
-  Subject,
+  Subject as Subject2,
   switchMap
 } from "rxjs";
 
@@ -23,6 +22,10 @@ var SerialErrorCode = /* @__PURE__ */ ((SerialErrorCode2) => {
   SerialErrorCode2["INVALID_FILTER_OPTIONS"] = "INVALID_FILTER_OPTIONS";
   SerialErrorCode2["OPERATION_CANCELLED"] = "OPERATION_CANCELLED";
   SerialErrorCode2["OPERATION_TIMEOUT"] = "OPERATION_TIMEOUT";
+  SerialErrorCode2["LINE_BUFFER_OVERFLOW"] = "LINE_BUFFER_OVERFLOW";
+  SerialErrorCode2["INVALID_RECEIVE_REPLAY_OPTIONS"] = "INVALID_RECEIVE_REPLAY_OPTIONS";
+  SerialErrorCode2["RECEIVE_REPLAY_BUFFER_OVERFLOW"] = "RECEIVE_REPLAY_BUFFER_OVERFLOW";
+  SerialErrorCode2["SESSION_DISPOSED"] = "SESSION_DISPOSED";
   SerialErrorCode2["UNKNOWN"] = "UNKNOWN";
   return SerialErrorCode2;
 })(SerialErrorCode || {});
@@ -68,42 +71,180 @@ var SerialError = class _SerialError extends Error {
 
 // src/terminal/create-terminal-buffer.ts
 import { map, scan, shareReplay } from "rxjs";
-function applyTerminalChunk(state, chunk) {
-  let { completed, currentLine } = state;
-  const len = chunk.length;
-  for (let i = 0; i < len; i++) {
-    const c = chunk.charAt(i);
-    if (c === "\r") {
-      const next = i + 1 < len ? chunk.charAt(i + 1) : "";
-      if (next === "\n") {
-        completed += currentLine + "\n";
-        currentLine = "";
-        i++;
+
+// src/internal/newline-tokenizer.ts
+function createNewlineTokenizer(mode) {
+  let pending = "";
+  let deferredTrailingCr = false;
+  const clear = () => {
+    pending = "";
+    deferredTrailingCr = false;
+  };
+  const restorePending = (text) => {
+    pending = text;
+    deferredTrailingCr = false;
+  };
+  const feed = (chunk) => {
+    const events = [];
+    let i = 0;
+    if (mode === "line" && deferredTrailingCr) {
+      deferredTrailingCr = false;
+      if (chunk.length > 0 && chunk.charAt(0) === "\n") {
+        events.push({ type: "line", content: pending });
+        pending = "";
+        i = 1;
       } else {
-        currentLine = "";
+        events.push({ type: "line", content: pending });
+        pending = "";
       }
-    } else if (c === "\n") {
-      completed += currentLine + "\n";
-      currentLine = "";
+    }
+    const len = chunk.length;
+    for (; i < len; i++) {
+      const c = chunk.charAt(i);
+      if (c === "\r") {
+        const next = i + 1 < len ? chunk.charAt(i + 1) : "";
+        if (next === "\n") {
+          events.push({ type: "line", content: pending });
+          pending = "";
+          i++;
+          continue;
+        }
+        if (mode === "line") {
+          if (next !== "") {
+            events.push({ type: "line", content: pending });
+            pending = "";
+            continue;
+          }
+          deferredTrailingCr = true;
+          break;
+        }
+        events.push({ type: "carriage-return" });
+        pending = "";
+        continue;
+      }
+      if (c === "\n") {
+        events.push({ type: "line", content: pending });
+        pending = "";
+        continue;
+      }
+      pending += c;
+    }
+    return events;
+  };
+  const trimPending = (maxChars) => {
+    if (maxChars <= 0) {
+      return false;
+    }
+    const text = deferredTrailingCr ? `${pending}\r` : pending;
+    if (text.length <= maxChars) {
+      return false;
+    }
+    const trimmed = text.slice(text.length - maxChars);
+    if (trimmed.endsWith("\r")) {
+      pending = trimmed.slice(0, -1);
+      deferredTrailingCr = true;
     } else {
-      currentLine += c;
+      pending = trimmed;
+      deferredTrailingCr = false;
+    }
+    return true;
+  };
+  return {
+    feed,
+    clear,
+    restorePending,
+    getPendingText: () => deferredTrailingCr ? `${pending}\r` : pending,
+    trimPending
+  };
+}
+
+// src/terminal/create-terminal-buffer.ts
+function applyTerminalChunk(state, chunk) {
+  const tokenizer = createNewlineTokenizer("terminal");
+  tokenizer.restorePending(state.currentLine);
+  const events = tokenizer.feed(chunk);
+  let { completed } = state;
+  for (const event of events) {
+    if (event.type === "line") {
+      completed += event.content + "\n";
     }
   }
-  return { completed, currentLine };
+  return {
+    completed,
+    currentLine: tokenizer.getPendingText()
+  };
 }
 function terminalDisplayText(state) {
   return state.completed + state.currentLine;
 }
+function countCompletedLines(completed) {
+  if (completed.length === 0) {
+    return 0;
+  }
+  let count = 0;
+  for (let i = 0; i < completed.length; i++) {
+    if (completed.charAt(i) === "\n") {
+      count++;
+    }
+  }
+  return count;
+}
+function trimCompletedByMaxLines(completed, maxLines) {
+  if (maxLines <= 0) {
+    return completed;
+  }
+  let trimmed = completed;
+  while (countCompletedLines(trimmed) > maxLines) {
+    const firstNewline = trimmed.indexOf("\n");
+    if (firstNewline < 0) {
+      break;
+    }
+    trimmed = trimmed.slice(firstNewline + 1);
+  }
+  return trimmed;
+}
+function trimTerminalState(state, limits) {
+  let { completed, currentLine } = state;
+  if (limits.maxLines > 0) {
+    completed = trimCompletedByMaxLines(completed, limits.maxLines);
+  }
+  if (limits.maxChars > 0) {
+    let total = completed.length + currentLine.length;
+    while (total > limits.maxChars) {
+      const excess = total - limits.maxChars;
+      if (completed.length >= excess) {
+        completed = completed.slice(excess);
+        break;
+      }
+      const removeFromCurrent = excess - completed.length;
+      completed = "";
+      currentLine = currentLine.slice(removeFromCurrent);
+      total = completed.length + currentLine.length;
+    }
+  }
+  return { completed, currentLine };
+}
+var DEFAULT_TERMINAL_BUFFER_OPTIONS = {
+  maxLines: 1e4,
+  maxChars: 1048576
+};
+function resolveTerminalBufferLimits(options) {
+  return {
+    ...DEFAULT_TERMINAL_BUFFER_OPTIONS,
+    ...options
+  };
+}
 var initialTerminalState = {
   completed: "",
   currentLine: ""
 };
-function createTerminalBuffer(receive$) {
+function createTerminalBuffer(receive$, options) {
+  const limits = resolveTerminalBufferLimits(options);
   const text$ = receive$.pipe(
-    scan(
-      (state, chunk) => applyTerminalChunk(state, chunk),
-      initialTerminalState
-    ),
+    scan((state, chunk) => {
+      const next = applyTerminalChunk(state, chunk);
+      return trimTerminalState(next, limits);
+    }, initialTerminalState),
     map(terminalDisplayText),
     shareReplay({ bufferSize: 1, refCount: true })
   );
@@ -150,43 +291,86 @@ function hasWebSerialSupport() {
 }
 
 // src/session/internal/line-buffer.ts
-function createLineBuffer() {
-  let buffer = "";
+var DEFAULT_LINE_BUFFER_OPTIONS = {
+  maxChars: 1048576
+};
+function createLineBuffer(options) {
+  const limits = {
+    ...DEFAULT_LINE_BUFFER_OPTIONS,
+    ...options
+  };
+  const tokenizer = createNewlineTokenizer("line");
   const clear = () => {
-    buffer = "";
+    tokenizer.clear();
   };
   const feed = (chunk) => {
-    buffer += chunk;
+    const events = tokenizer.feed(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;
+    for (const event of events) {
+      if (event.type === "line") {
+        out.push(event.content);
       }
-      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;
-      }
-      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 out;
+    const overflowed = tokenizer.trimPending(limits.maxChars);
+    return { lines: out, overflowed };
   };
   return { feed, clear };
 }
 
+// src/session/internal/receive-replay-buffer.ts
+import { Observable, Subject } from "rxjs";
+function totalChars(chunks) {
+  return chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+}
+function createReceiveReplayBuffer(options) {
+  const chunks = [];
+  const live$ = new Subject();
+  let completed = false;
+  const trim = () => {
+    let overflowed = false;
+    while (chunks.length > options.bufferSize) {
+      chunks.shift();
+      overflowed = true;
+    }
+    if (options.maxChars > 0) {
+      let chars = totalChars(chunks);
+      while (chars > options.maxChars && chunks.length > 1) {
+        chars -= chunks.shift().length;
+        overflowed = true;
+      }
+    }
+    return overflowed;
+  };
+  const next = (chunk) => {
+    if (completed) {
+      return { overflowed: false };
+    }
+    chunks.push(chunk);
+    const overflowed = trim();
+    live$.next(chunk);
+    return { overflowed };
+  };
+  const asObservable = () => new Observable((subscriber) => {
+    for (const chunk of chunks) {
+      subscriber.next(chunk);
+    }
+    if (completed) {
+      subscriber.complete();
+      return;
+    }
+    return live$.subscribe(subscriber);
+  });
+  const complete = () => {
+    if (completed) {
+      return;
+    }
+    completed = true;
+    chunks.length = 0;
+    live$.complete();
+  };
+  return { next, asObservable, complete };
+}
+
 // 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;
@@ -211,7 +395,7 @@ function normalizeSerialError(error, options) {
 }
 
 // src/session/read-pump.ts
-function createReadPump(port, { onChunk, onError }) {
+function createReadPump(port, { onChunk, onError, onDone }) {
   let reader = null;
   let running = false;
   let stopped = false;
@@ -233,6 +417,9 @@ function createReadPump(port, { onChunk, onError }) {
       while (!stopped) {
         const { done, value } = await reader.read();
         if (done) {
+          if (!stopped) {
+            onDone?.();
+          }
           break;
         }
         if (value && value.byteLength > 0) {
@@ -302,13 +489,13 @@ function createReadPump(port, { onChunk, onError }) {
 }
 
 // src/session/send-queue.ts
-import { Observable, defer } from "rxjs";
+import { Observable as Observable2, defer } from "rxjs";
 function createSendQueue() {
   let chain = Promise.resolve();
   return {
     enqueue(operation) {
       return defer(
-        () => new Observable((subscriber) => {
+        () => new Observable2((subscriber) => {
           let cancelled = false;
           const run = async () => {
             try {
@@ -341,10 +528,33 @@ function createSendQueue() {
 }
 
 // src/session/serial-session-options.ts
+var MAX_RECEIVE_REPLAY_BUFFER_SIZE = 65536;
+var MAX_RECEIVE_REPLAY_MAX_CHARS = 1048576;
 var DEFAULT_RECEIVE_REPLAY = {
   enabled: false,
-  bufferSize: 512
+  bufferSize: 512,
+  maxChars: 0
 };
+function resolveReceiveReplayOptions(options) {
+  const merged = {
+    ...DEFAULT_RECEIVE_REPLAY,
+    ...options
+  };
+  const { bufferSize, maxChars } = merged;
+  if (!Number.isSafeInteger(bufferSize) || bufferSize < 1 || bufferSize > MAX_RECEIVE_REPLAY_BUFFER_SIZE) {
+    throw new SerialError(
+      "INVALID_RECEIVE_REPLAY_OPTIONS" /* INVALID_RECEIVE_REPLAY_OPTIONS */,
+      `Invalid receiveReplay.bufferSize: ${bufferSize}. Must be a safe integer between 1 and ${MAX_RECEIVE_REPLAY_BUFFER_SIZE}.`
+    );
+  }
+  if (!Number.isSafeInteger(maxChars) || maxChars < 0 || maxChars > MAX_RECEIVE_REPLAY_MAX_CHARS) {
+    throw new SerialError(
+      "INVALID_RECEIVE_REPLAY_OPTIONS" /* INVALID_RECEIVE_REPLAY_OPTIONS */,
+      `Invalid receiveReplay.maxChars: ${maxChars}. Must be a safe integer between 0 and ${MAX_RECEIVE_REPLAY_MAX_CHARS}.`
+    );
+  }
+  return merged;
+}
 var DEFAULT_SERIAL_SESSION_OPTIONS = {
   baudRate: 9600,
   dataBits: 8,
@@ -353,7 +563,9 @@ var DEFAULT_SERIAL_SESSION_OPTIONS = {
   bufferSize: 255,
   flowControl: "none",
   filters: void 0,
-  receiveReplay: { ...DEFAULT_RECEIVE_REPLAY }
+  receiveReplay: { ...DEFAULT_RECEIVE_REPLAY },
+  terminalBuffer: { ...DEFAULT_TERMINAL_BUFFER_OPTIONS },
+  lineBuffer: { ...DEFAULT_LINE_BUFFER_OPTIONS }
 };
 
 // src/session/serial-session-state.ts
@@ -363,19 +575,21 @@ var SerialSessionState = {
   Connected: "connected",
   Disconnecting: "disconnecting",
   Unsupported: "unsupported",
-  Error: "error"
+  Error: "error",
+  Disposed: "disposed"
 };
 
 // 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]: []
+  [S.Idle]: [S.Connecting, S.Error, S.Disposed],
+  [S.Connecting]: [S.Connected, S.Error, S.Idle, S.Disposed],
+  [S.Connected]: [S.Disconnecting, S.Error, S.Disposed],
+  [S.Disconnecting]: [S.Idle, S.Error, S.Disposed],
+  [S.Error]: [S.Idle, S.Connecting, S.Disposed],
+  [S.Unsupported]: [S.Disposed],
+  [S.Disposed]: []
 };
 var SessionStateMachine = class {
   constructor(initial = SerialSessionState.Idle) {
@@ -405,6 +619,9 @@ var SessionStateMachine = class {
   toUnsupported() {
     return this.transition(S.Unsupported);
   }
+  toDisposed() {
+    return this.transition(S.Disposed);
+  }
   complete() {
     this.subject.complete();
   }
@@ -433,25 +650,33 @@ function createSerialSession(options) {
     ...DEFAULT_SERIAL_SESSION_OPTIONS,
     ...options,
     filters: options?.filters,
-    receiveReplay: {
-      ...DEFAULT_SERIAL_SESSION_OPTIONS.receiveReplay,
-      ...options?.receiveReplay
+    receiveReplay: resolveReceiveReplayOptions(options?.receiveReplay),
+    terminalBuffer: {
+      ...DEFAULT_SERIAL_SESSION_OPTIONS.terminalBuffer,
+      ...options?.terminalBuffer
+    },
+    lineBuffer: {
+      ...DEFAULT_SERIAL_SESSION_OPTIONS.lineBuffer,
+      ...options?.lineBuffer
     }
   };
   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 errorsSubject = new Subject2();
+  const receiveSubject = new Subject2();
+  const linesSubject = new Subject2();
   const sendQueue = createSendQueue();
   const textEncoder = new TextEncoder();
-  const lineBuffer = createLineBuffer();
+  const lineBuffer = createLineBuffer(resolvedOptions.lineBuffer);
   const errors$ = errorsSubject.asObservable();
   const receive$ = receiveSubject.asObservable();
   const lines$ = linesSubject.asObservable();
-  const terminalText$ = createTerminalBuffer(receive$).text$;
+  const terminalText$ = createTerminalBuffer(
+    receive$,
+    resolvedOptions.terminalBuffer
+  ).text$;
   const isConnected$ = machine.state$.pipe(
     map2((state) => state === SerialSessionState.Connected),
     distinctUntilChanged()
@@ -477,13 +702,70 @@ function createSerialSession(options) {
       activeReceiveReplay.complete();
       activeReceiveReplay = null;
     }
-    const rs = new ReplaySubject(resolvedOptions.receiveReplay.bufferSize);
-    activeReceiveReplay = rs;
-    receiveReplayStream$.next(rs.asObservable());
+    const buffer = createReceiveReplayBuffer({
+      bufferSize: resolvedOptions.receiveReplay.bufferSize,
+      maxChars: resolvedOptions.receiveReplay.maxChars
+    });
+    activeReceiveReplay = buffer;
+    receiveReplayStream$.next(buffer.asObservable());
   };
   const receiveReplay$ = receiveReplayStream$ ? receiveReplayStream$.pipe(switchMap((inner) => inner), share()) : receive$;
   let activePort = null;
   let activePump = null;
+  let activeConnectCancel = null;
+  let disposed = false;
+  const createDisposedError = () => new SerialError(
+    "SESSION_DISPOSED" /* SESSION_DISPOSED */,
+    "SerialSession has been disposed"
+  );
+  const completeSession = async () => {
+    const current = machine.current;
+    if (current === SerialSessionState.Connecting) {
+      activeConnectCancel?.();
+    }
+    sendQueue.clear();
+    if (current === SerialSessionState.Connected || current === SerialSessionState.Error || current === SerialSessionState.Disconnecting) {
+      const portToClose = activePort;
+      await teardownPump();
+      await closePortSafely(portToClose);
+      setActivePort(null);
+    }
+    lineBuffer.clear();
+    machine.toDisposed();
+    machine.complete();
+    errorsSubject.complete();
+    receiveSubject.complete();
+    linesSubject.complete();
+    portInfoSubject.complete();
+    receiveReplayStream$?.complete();
+  };
+  const dispose$ = () => new Observable4((subscriber) => {
+    if (disposed) {
+      subscriber.next();
+      subscriber.complete();
+      return;
+    }
+    disposed = true;
+    const run = async () => {
+      try {
+        await completeSession();
+        subscriber.next();
+        subscriber.complete();
+      } catch (error) {
+        const serialError = normalizeSerialError(error, {
+          fallbackCode: "UNKNOWN" /* UNKNOWN */,
+          messagePrefix: "Unexpected dispose failure"
+        });
+        subscriber.error(serialError);
+      }
+    };
+    void run();
+  });
+  const clearActiveConnectCancel = (cancel) => {
+    if (activeConnectCancel === cancel) {
+      activeConnectCancel = null;
+    }
+  };
   const setActivePort = (port) => {
     activePort = port;
     portInfoSubject.next(port ? port.getInfo() : null);
@@ -508,6 +790,9 @@ function createSerialSession(options) {
   };
   const reportError = (error, severity, options2) => {
     const serialError = normalizeSerialError(error, options2);
+    if (disposed) {
+      return serialError;
+    }
     errorsSubject.next(serialError);
     if (severity === "fatal") {
       machine.toError();
@@ -541,7 +826,11 @@ function createSerialSession(options) {
       return hasWebSerialSupport();
     },
     connect$() {
-      return new Observable3((subscriber) => {
+      return new Observable4((subscriber) => {
+        if (disposed) {
+          subscriber.error(createDisposedError());
+          return;
+        }
         if (!hasWebSerialSupport()) {
           const error = reportError(
             new SerialError(
@@ -568,6 +857,13 @@ function createSerialSession(options) {
           return;
         }
         let cancelled = false;
+        const cancelInFlightConnect = () => {
+          cancelled = true;
+          if (machine.current === SerialSessionState.Connecting) {
+            machine.toIdle();
+          }
+        };
+        activeConnectCancel = cancelInFlightConnect;
         machine.toConnecting();
         const run = async () => {
           let selectedPort = null;
@@ -596,7 +892,7 @@ function createSerialSession(options) {
             }
             return;
           }
-          if (cancelled) {
+          if (cancelled || disposed) {
             await closePortSafely(selectedPort);
             return;
           }
@@ -609,33 +905,89 @@ function createSerialSession(options) {
             onChunk: (text) => {
               receiveSubject.next(text);
               if (activeReceiveReplay) {
-                activeReceiveReplay.next(text);
+                const { overflowed: overflowed2 } = activeReceiveReplay.next(text);
+                if (overflowed2) {
+                  reportError(
+                    new SerialError(
+                      "RECEIVE_REPLAY_BUFFER_OVERFLOW" /* RECEIVE_REPLAY_BUFFER_OVERFLOW */,
+                      `Receive replay buffer exceeded configured limits; oldest chunks were discarded`
+                    ),
+                    "non-fatal",
+                    {
+                      fallbackCode: "RECEIVE_REPLAY_BUFFER_OVERFLOW" /* RECEIVE_REPLAY_BUFFER_OVERFLOW */
+                    }
+                  );
+                }
+              }
+              const { lines, overflowed } = lineBuffer.feed(text);
+              if (overflowed) {
+                reportError(
+                  new SerialError(
+                    "LINE_BUFFER_OVERFLOW" /* LINE_BUFFER_OVERFLOW */,
+                    `Line buffer exceeded maxChars (${resolvedOptions.lineBuffer.maxChars}); leading data was discarded`
+                  ),
+                  "non-fatal",
+                  { fallbackCode: "LINE_BUFFER_OVERFLOW" /* LINE_BUFFER_OVERFLOW */ }
+                );
               }
-              for (const line of lineBuffer.feed(text)) {
+              for (const line of lines) {
                 linesSubject.next(line);
               }
             },
             onError: (pumpError) => reportError(pumpError, "fatal", {
               fallbackCode: "READ_FAILED" /* READ_FAILED */,
               messagePrefix: "Read pump failed"
-            })
+            }),
+            onDone: () => {
+              if (machine.current !== SerialSessionState.Connected) {
+                return;
+              }
+              reportError(
+                new SerialError(
+                  "CONNECTION_LOST" /* CONNECTION_LOST */,
+                  "Read pump ended unexpectedly: stream closed while connected"
+                ),
+                "fatal",
+                {
+                  fallbackCode: "CONNECTION_LOST" /* CONNECTION_LOST */
+                }
+              );
+            }
           });
           activePump.start();
           sendQueue.clear();
+          if (disposed) {
+            await teardownPump();
+            await closePortSafely(selectedPort);
+            setActivePort(null);
+            return;
+          }
           machine.toConnected();
           subscriber.next();
           subscriber.complete();
         };
         void run();
         return () => {
-          cancelled = true;
+          clearActiveConnectCancel(cancelInFlightConnect);
+          cancelInFlightConnect();
         };
       });
     },
     disconnect$() {
-      return new Observable3((subscriber) => {
+      return new Observable4((subscriber) => {
+        if (disposed) {
+          subscriber.next();
+          subscriber.complete();
+          return;
+        }
         const current = machine.current;
-        if (current === SerialSessionState.Idle || current === SerialSessionState.Unsupported) {
+        if (current === SerialSessionState.Idle || current === SerialSessionState.Unsupported || current === SerialSessionState.Disconnecting) {
+          subscriber.next();
+          subscriber.complete();
+          return;
+        }
+        if (current === SerialSessionState.Connecting) {
+          activeConnectCancel?.();
           subscriber.next();
           subscriber.complete();
           return;
@@ -672,7 +1024,9 @@ function createSerialSession(options) {
               }
             }
             setActivePort(null);
-            machine.toIdle();
+            if (!disposed) {
+              machine.toIdle();
+            }
             subscriber.next();
             subscriber.complete();
           } catch (error) {
@@ -686,7 +1040,14 @@ function createSerialSession(options) {
         void run();
       });
     },
+    dispose$,
+    destroy$: dispose$,
     send$(data) {
+      if (disposed) {
+        return new Observable4((subscriber) => {
+          subscriber.error(createDisposedError());
+        });
+      }
       return sendQueue.enqueue(async () => {
         const payload = typeof data === "string" ? textEncoder.encode(data) : data;
         try {
@@ -716,6 +1077,8 @@ function createSerialSession(options) {
   };
 }
 export {
+  DEFAULT_LINE_BUFFER_OPTIONS,
+  DEFAULT_TERMINAL_BUFFER_OPTIONS,
   SerialError,
   SerialErrorCode,
   SerialSessionState,