@gurezo/web-serial-rxjs 2.3.6 → 3.0.0

package/dist/index.mjs

@@ -1,190 +1,679 @@
+// src/internal/assert-never.ts
+function assertNever(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
+}
+
 // src/session/create-serial-session.ts
 import {
-  BehaviorSubject as BehaviorSubject2,
+  BehaviorSubject as BehaviorSubject3,
   distinctUntilChanged,
   map as map2,
-  Observable as Observable3,
-  ReplaySubject,
-  share,
-  Subject,
-  switchMap
+  Observable as Observable5,
+  Subject as Subject3
 } from "rxjs";
 
 // src/errors/serial-error-code.ts
-var SerialErrorCode = /* @__PURE__ */ ((SerialErrorCode2) => {
-  SerialErrorCode2["BROWSER_NOT_SUPPORTED"] = "BROWSER_NOT_SUPPORTED";
-  SerialErrorCode2["PORT_NOT_AVAILABLE"] = "PORT_NOT_AVAILABLE";
-  SerialErrorCode2["PORT_OPEN_FAILED"] = "PORT_OPEN_FAILED";
-  SerialErrorCode2["PORT_ALREADY_OPEN"] = "PORT_ALREADY_OPEN";
-  SerialErrorCode2["PORT_NOT_OPEN"] = "PORT_NOT_OPEN";
-  SerialErrorCode2["READ_FAILED"] = "READ_FAILED";
-  SerialErrorCode2["WRITE_FAILED"] = "WRITE_FAILED";
-  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 || {});
-
-// src/errors/serial-error.ts
-var SerialError = class _SerialError extends Error {
+var SerialErrorCode = {
   /**
-   * Creates a new SerialError instance.
+   * Browser does not support the Web Serial API.
    *
-   * @param code - The error code identifying the type of error
-   * @param message - A human-readable error message
-   * @param originalError - The original error that caused this SerialError, if any
+   * This error occurs when attempting to use serial port functionality in a browser
+   * that doesn't support the Web Serial API. Supported desktop browsers are Chrome,
+   * Edge, Opera, and Firefox 151+. Safari and mobile browsers are not supported.
+   *
+   * **Suggested action**: Inform the user to use a supported browser.
    */
-  constructor(code, message, originalError) {
-    super(message);
-    this.name = "SerialError";
-    this.code = code;
-    this.originalError = originalError;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _SerialError);
-    }
-  }
+  BROWSER_NOT_SUPPORTED: "BROWSER_NOT_SUPPORTED",
   /**
-   * Check if the error matches a specific error code.
+   * Serial port is not available.
    *
-   * This is a convenience method for checking the error code without directly
-   * comparing the code property.
+   * This error occurs when a requested port cannot be accessed, such as when
+   * getting previously granted ports fails or when the port is already in use
+   * by another application.
    *
-   * @param code - The error code to check against
-   * @returns `true` if this error's code matches the provided code, `false` otherwise
+   * **Suggested action**: Check if the port is available or being used by another application.
+   */
+  PORT_NOT_AVAILABLE: "PORT_NOT_AVAILABLE",
+  /**
+   * Failed to open the serial port.
    *
-   * @example
-   * ```typescript
-   * if (error.is(SerialErrorCode.PORT_NOT_OPEN)) {
-   *   // Handle port not open error
-   * }
-   * ```
+   * This error occurs when the port cannot be opened, typically due to incorrect
+   * connection parameters, hardware issues, or permission problems.
+   *
+   * **Suggested action**: Verify connection parameters and check hardware connections.
    */
-  is(code) {
-    return this.code === code;
-  }
+  PORT_OPEN_FAILED: "PORT_OPEN_FAILED",
+  /**
+   * Serial port is already open.
+   *
+   * This error occurs when attempting to open a port that is already connected.
+   * Only one connection can be active at a time per SerialClient instance.
+   *
+   * **Suggested action**: Disconnect the current port before connecting a new one.
+   */
+  PORT_ALREADY_OPEN: "PORT_ALREADY_OPEN",
+  /**
+   * Serial port is not open.
+   *
+   * This error occurs when attempting to read from or write to a port that hasn't
+   * been opened yet. The port must be connected before performing I/O operations.
+   *
+   * **Suggested action**: Call {@link SerialClient.connect} before reading or writing.
+   */
+  PORT_NOT_OPEN: "PORT_NOT_OPEN",
+  /**
+   * Failed to read from the serial port.
+   *
+   * This error occurs when reading data from the port fails, typically due to
+   * connection loss, hardware issues, or stream errors.
+   *
+   * **Suggested action**: Check the connection and hardware, then retry the read operation.
+   */
+  READ_FAILED: "READ_FAILED",
+  /**
+   * Failed to write to the serial port.
+   *
+   * This error occurs when writing data to the port fails, typically due to
+   * connection loss, hardware issues, or stream errors.
+   *
+   * **Suggested action**: Check the connection and hardware, then retry the write operation.
+   */
+  WRITE_FAILED: "WRITE_FAILED",
+  /**
+   * Serial port connection was lost.
+   *
+   * This error occurs when the connection to the serial port is unexpectedly
+   * terminated, such as when the device is disconnected or the port is closed
+   * by another process.
+   *
+   * **Suggested action**: Check the physical connection and reconnect if needed.
+   */
+  CONNECTION_LOST: "CONNECTION_LOST",
+  /**
+   * Invalid filter options provided.
+   *
+   * This error occurs when port filter options are invalid, such as when
+   * filter values are out of range or missing required fields.
+   *
+   * **Suggested action**: Verify filter options match the expected format and value ranges.
+   */
+  INVALID_FILTER_OPTIONS: "INVALID_FILTER_OPTIONS",
+  /**
+   * Operation was cancelled by the user.
+   *
+   * This error occurs when the user cancels a port selection dialog or aborts
+   * an operation before it completes.
+   *
+   * **Suggested action**: This is a normal condition - no action required, but you may want
+   * to inform the user that the operation was cancelled.
+   */
+  OPERATION_CANCELLED: "OPERATION_CANCELLED",
+  /**
+   * Operation timed out before completion.
+   *
+   * This error occurs when an operation waits for a condition (for example, prompt
+   * detection) and the timeout period elapses first.
+   */
+  OPERATION_TIMEOUT: "OPERATION_TIMEOUT",
+  /**
+   * Internal line buffer exceeded its configured size limit.
+   *
+   * This error occurs when the incomplete line tail held by the {@link SerialSession.lines$}
+   * framing buffer grows beyond {@link SerialSessionOptions.lineBuffer} `maxChars`.
+   * Leading characters are discarded to bound memory; the session remains connected.
+   *
+   * **Suggested action**: Increase `lineBuffer.maxChars`, handle framing on `receive$`,
+   * or ensure the device sends line terminators.
+   */
+  LINE_BUFFER_OVERFLOW: "LINE_BUFFER_OVERFLOW",
+  /**
+   * Invalid receive replay options provided.
+   *
+   * This error occurs when {@link SerialSessionOptions.receiveReplay} values are
+   * out of range, such as a non-integer `bufferSize` or `maxChars`.
+   *
+   * **Suggested action**: Verify `receiveReplay` options match the documented
+   * ranges and value types.
+   */
+  INVALID_RECEIVE_REPLAY_OPTIONS: "INVALID_RECEIVE_REPLAY_OPTIONS",
+  /**
+   * Invalid terminal buffer options provided.
+   *
+   * This error occurs when {@link SerialSessionOptions.terminalBuffer} values are
+   * out of range, such as a negative or non-integer `maxLines` or `maxChars`.
+   *
+   * **Suggested action**: Verify `terminalBuffer` options match the documented
+   * ranges and value types.
+   */
+  INVALID_TERMINAL_BUFFER_OPTIONS: "INVALID_TERMINAL_BUFFER_OPTIONS",
+  /**
+   * Invalid line buffer options provided.
+   *
+   * This error occurs when {@link SerialSessionOptions.lineBuffer} values are
+   * out of range, such as a negative or non-integer `maxChars`.
+   *
+   * **Suggested action**: Verify `lineBuffer` options match the documented
+   * ranges and value types.
+   */
+  INVALID_LINE_BUFFER_OPTIONS: "INVALID_LINE_BUFFER_OPTIONS",
+  /**
+   * Invalid connection options provided.
+   *
+   * This error occurs when connection fields such as `baudRate` are out of
+   * range at session creation time.
+   *
+   * **Suggested action**: Verify connection options match the documented
+   * ranges and value types.
+   */
+  INVALID_CONNECTION_OPTIONS: "INVALID_CONNECTION_OPTIONS",
+  /**
+   * Receive replay buffer exceeded its configured character limit.
+   *
+   * This error occurs when buffered chunks on {@link SerialSession.receiveReplay$}
+   * exceed {@link SerialSessionOptions.receiveReplay} `maxChars`. Oldest chunks
+   * are discarded to bound memory; the session remains connected.
+   *
+   * **Suggested action**: Increase `receiveReplay.maxChars`, reduce chunk size at
+   * the source, or subscribe earlier to avoid relying on a large replay buffer.
+   */
+  RECEIVE_REPLAY_BUFFER_OVERFLOW: "RECEIVE_REPLAY_BUFFER_OVERFLOW",
+  /**
+   * Session has been disposed and can no longer be used.
+   *
+   * This error occurs when calling {@link SerialSession.connect$} or
+   * {@link SerialSession.send$} after {@link SerialSession.dispose$} has
+   * completed. Create a new session instead of reusing a disposed instance.
+   *
+   * **Suggested action**: Call {@link SerialSession.dispose$} only when
+   * permanently tearing down a session, then create a new one if needed.
+   */
+  SESSION_DISPOSED: "SESSION_DISPOSED",
+  /**
+   * Unknown error occurred.
+   *
+   * This error code is used for errors that don't fit into any other category.
+   * The original error details may be available in the error's message or originalError property.
+   *
+   * **Suggested action**: Check the error message and originalError for more details.
+   */
+  UNKNOWN: "UNKNOWN"
 };
 
 // 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/branded-numbers.ts
+function brandBaudRate(value) {
+  return value;
+}
+function brandSerialPortBufferSize(value) {
+  return value;
+}
+function brandReceiveReplayBufferSize(value) {
+  return value;
+}
+function brandMaxChars(value) {
+  return value;
+}
+function brandMaxLines(value) {
+  return value;
+}
+
+// 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) {
+  const maxLines = options?.maxLines ?? DEFAULT_TERMINAL_BUFFER_OPTIONS.maxLines;
+  const maxChars = options?.maxChars ?? DEFAULT_TERMINAL_BUFFER_OPTIONS.maxChars;
+  return {
+    maxLines: brandMaxLines(maxLines),
+    maxChars: brandMaxChars(maxChars)
+  };
+}
 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 })
   );
   return { text$ };
 }
 
-// src/session/internal/build-request-options.ts
-function buildRequestOptions(options) {
-  if (!options || !options.filters || options.filters.length === 0) {
-    return void 0;
-  }
-  for (const filter of options.filters) {
-    if (!filter.usbVendorId && !filter.usbProductId) {
-      throw new SerialError(
-        "INVALID_FILTER_OPTIONS" /* INVALID_FILTER_OPTIONS */,
-        "Filter must have at least usbVendorId or usbProductId"
-      );
-    }
-    if (filter.usbVendorId !== void 0) {
-      if (!Number.isInteger(filter.usbVendorId) || filter.usbVendorId < 0 || filter.usbVendorId > 65535) {
-        throw new SerialError(
-          "INVALID_FILTER_OPTIONS" /* INVALID_FILTER_OPTIONS */,
-          `Invalid usbVendorId: ${filter.usbVendorId}. Must be an integer between 0 and 65535.`
-        );
-      }
-    }
-    if (filter.usbProductId !== void 0) {
-      if (!Number.isInteger(filter.usbProductId) || filter.usbProductId < 0 || filter.usbProductId > 65535) {
-        throw new SerialError(
-          "INVALID_FILTER_OPTIONS" /* INVALID_FILTER_OPTIONS */,
-          `Invalid usbProductId: ${filter.usbProductId}. Must be an integer between 0 and 65535.`
-        );
-      }
-    }
-  }
-  return {
-    filters: options.filters
-  };
-}
-
 // src/session/internal/has-web-serial-support.ts
 function hasWebSerialSupport() {
   return typeof navigator !== "undefined" && "serial" in navigator && navigator.serial !== void 0 && navigator.serial !== null;
 }
 
+// src/session/internal/receive-pipeline.ts
+import {
+  BehaviorSubject,
+  share,
+  Subject as Subject2,
+  switchMap
+} from "rxjs";
+
+// src/errors/serial-error-context.ts
+var CAUSE_CONTEXT_CODES = /* @__PURE__ */ new Set([
+  SerialErrorCode.PORT_NOT_AVAILABLE,
+  SerialErrorCode.PORT_OPEN_FAILED,
+  SerialErrorCode.READ_FAILED,
+  SerialErrorCode.WRITE_FAILED,
+  SerialErrorCode.CONNECTION_LOST,
+  SerialErrorCode.OPERATION_CANCELLED,
+  SerialErrorCode.UNKNOWN
+]);
+function isCauseContextCode(code) {
+  return CAUSE_CONTEXT_CODES.has(code);
+}
+
+// src/errors/serial-error.ts
+var ErrorWithCaptureStackTrace = Error;
+var SerialError = class _SerialError extends Error {
+  /**
+   * Creates a new SerialError instance.
+   *
+   * @param code - The error code identifying the type of error
+   * @param message - A human-readable error message
+   * @param originalError - The original error that caused this SerialError, if any
+   * @param context - Structured metadata for the error code. When omitted, cause-bearing
+   *   codes derive `{ cause }` from `originalError`.
+   */
+  constructor(code, message, originalError, context) {
+    super(message);
+    this.name = "SerialError";
+    this.code = code;
+    if (originalError !== void 0) {
+      this.originalError = originalError;
+    }
+    if (context !== void 0) {
+      this.context = context;
+    } else if (originalError !== void 0 && isCauseContextCode(code)) {
+      this.context = { cause: originalError };
+    } else {
+      this.context = void 0;
+    }
+    if (ErrorWithCaptureStackTrace.captureStackTrace) {
+      ErrorWithCaptureStackTrace.captureStackTrace(this, _SerialError);
+    }
+  }
+  /**
+   * Check if the error matches a specific error code.
+   *
+   * This is a convenience method for checking the error code without directly
+   * comparing the code property. When this method returns `true`, TypeScript
+   * narrows `this.code` and `this.context` to the shapes defined for the
+   * provided `code` argument.
+   *
+   * @param code - The error code to check against
+   * @returns Type predicate: `true` if this error's code matches the provided
+   *   code (and `this.code` / `this.context` are narrowed), `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * if (error.is(SerialErrorCode.LINE_BUFFER_OVERFLOW)) {
+   *   // error.code and error.context.maxChars are narrowed
+   * }
+   * ```
+   */
+  is(code) {
+    return this.code === code;
+  }
+};
+
 // src/session/internal/line-buffer.ts
-function createLineBuffer() {
-  let buffer = "";
+var DEFAULT_LINE_BUFFER_OPTIONS = {
+  maxChars: 1048576
+};
+function createLineBuffer(options) {
+  const limits = {
+    maxChars: brandMaxChars(
+      options?.maxChars ?? DEFAULT_LINE_BUFFER_OPTIONS.maxChars
+    )
+  };
+  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 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;
       }
-      const nl = buffer.indexOf("\n");
-      if (nl >= 0) {
-        out.push(buffer.slice(0, nl));
-        buffer = buffer.slice(nl + 1);
-        continue;
+    }
+    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/internal/receive-pipeline.ts
+function createReceivePipeline(deps) {
+  const { resolvedOptions, reportError } = deps;
+  const receiveSubject = new Subject2();
+  const linesSubject = new Subject2();
+  const lineBuffer = createLineBuffer(resolvedOptions.lineBuffer);
+  const receive$ = receiveSubject.asObservable();
+  const lines$ = linesSubject.asObservable();
+  const receiveReplayStream$ = resolvedOptions.receiveReplay.enabled ? new BehaviorSubject(receive$) : null;
+  let activeReceiveReplay = null;
+  const clearReplay = () => {
+    if (receiveReplayStream$) {
+      if (activeReceiveReplay) {
+        activeReceiveReplay.complete();
+        activeReceiveReplay = null;
       }
-      if (cr >= 0 && cr + 1 === buffer.length) {
-        break;
+      receiveReplayStream$.next(receive$);
+    }
+  };
+  const startLiveReceiveReplay = () => {
+    if (!receiveReplayStream$) {
+      return;
+    }
+    if (activeReceiveReplay) {
+      activeReceiveReplay.complete();
+      activeReceiveReplay = null;
+    }
+    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$;
+  const clearLineBuffer = () => {
+    lineBuffer.clear();
+  };
+  const handleChunk = (text) => {
+    receiveSubject.next(text);
+    if (activeReceiveReplay) {
+      const { overflowed: overflowed2 } = activeReceiveReplay.next(text);
+      if (overflowed2) {
+        reportError(
+          new SerialError(
+            SerialErrorCode.RECEIVE_REPLAY_BUFFER_OVERFLOW,
+            "Receive replay buffer exceeded configured limits; oldest chunks were discarded",
+            void 0,
+            {
+              maxChars: resolvedOptions.receiveReplay.maxChars,
+              bufferSize: resolvedOptions.receiveReplay.bufferSize
+            }
+          ),
+          {
+            fallbackCode: SerialErrorCode.RECEIVE_REPLAY_BUFFER_OVERFLOW
+          }
+        );
       }
-      break;
     }
-    return out;
+    const { lines, overflowed } = lineBuffer.feed(text);
+    if (overflowed) {
+      reportError(
+        new SerialError(
+          SerialErrorCode.LINE_BUFFER_OVERFLOW,
+          "Line buffer exceeded maxChars; leading data was discarded",
+          void 0,
+          { maxChars: resolvedOptions.lineBuffer.maxChars }
+        ),
+        { fallbackCode: SerialErrorCode.LINE_BUFFER_OVERFLOW }
+      );
+    }
+    for (const line of lines) {
+      linesSubject.next(line);
+    }
+  };
+  const complete = () => {
+    receiveSubject.complete();
+    linesSubject.complete();
+    receiveReplayStream$?.complete();
+  };
+  return {
+    receive$,
+    lines$,
+    receiveReplay$,
+    clearReplay,
+    startLiveReceiveReplay,
+    clearLineBuffer,
+    handleChunk,
+    complete
   };
-  return { feed, clear };
+}
+
+// src/session/internal/error-severity.ts
+var ERROR_SEVERITY = {
+  [SerialErrorCode.READ_FAILED]: "fatal",
+  [SerialErrorCode.CONNECTION_LOST]: "fatal",
+  [SerialErrorCode.PORT_OPEN_FAILED]: "fatal",
+  [SerialErrorCode.OPERATION_CANCELLED]: "fatal",
+  [SerialErrorCode.UNKNOWN]: "fatal",
+  [SerialErrorCode.LINE_BUFFER_OVERFLOW]: "non-fatal",
+  [SerialErrorCode.RECEIVE_REPLAY_BUFFER_OVERFLOW]: "non-fatal",
+  [SerialErrorCode.BROWSER_NOT_SUPPORTED]: "non-fatal",
+  [SerialErrorCode.PORT_ALREADY_OPEN]: "non-fatal",
+  [SerialErrorCode.PORT_NOT_OPEN]: "non-fatal",
+  [SerialErrorCode.WRITE_FAILED]: "non-fatal"
+};
+function resolveErrorSeverity(code) {
+  if (code in ERROR_SEVERITY) {
+    return ERROR_SEVERITY[code];
+  }
+  return "fatal";
 }
 
 // src/session/normalize-serial-error.ts
@@ -197,7 +686,7 @@ function normalizeSerialError(error, options) {
   const prefix = options.messagePrefix ?? DEFAULT_MESSAGE_PREFIX;
   if (isDomExceptionWithName(error, "NotFoundError")) {
     return new SerialError(
-      "OPERATION_CANCELLED" /* OPERATION_CANCELLED */,
+      SerialErrorCode.OPERATION_CANCELLED,
       "Port selection was cancelled by the user",
       error
     );
@@ -210,8 +699,195 @@ function normalizeSerialError(error, options) {
   );
 }
 
+// src/session/session-runtime.ts
+import { BehaviorSubject as BehaviorSubject2 } from "rxjs";
+
+// src/session/serial-session-state.ts
+var SerialSessionStatus = {
+  Idle: "idle",
+  Connecting: "connecting",
+  Connected: "connected",
+  Disconnecting: "disconnecting",
+  Unsupported: "unsupported",
+  Error: "error",
+  Disposed: "disposed"
+};
+
+// src/session/session-runtime.ts
+var S = SerialSessionStatus;
+var ALLOWED_TRANSITIONS = {
+  [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]: []
+};
+function runtimeToSessionStatus(runtime) {
+  return runtime.status;
+}
+function runtimeToPublicState(runtime) {
+  switch (runtime.status) {
+    case S.Idle:
+      return { status: S.Idle };
+    case S.Connecting:
+      return { status: S.Connecting };
+    case S.Connected:
+      return { status: S.Connected, portInfo: runtime.port.getInfo() };
+    case S.Disconnecting:
+      return { status: S.Disconnecting };
+    case S.Unsupported:
+      return { status: S.Unsupported };
+    case S.Error:
+      return { status: S.Error, error: runtime.error };
+    case S.Disposed:
+      return { status: S.Disposed };
+    default:
+      return assertNeverRuntime(runtime);
+  }
+}
+function isValidTransition(from, to) {
+  if (from === to) {
+    return false;
+  }
+  return ALLOWED_TRANSITIONS[from].includes(
+    to
+  );
+}
+function createIdleRuntime() {
+  return { status: S.Idle };
+}
+function createConnectingRuntime(cancel) {
+  return { status: S.Connecting, cancel };
+}
+function createConnectedRuntime(port, pump) {
+  return { status: S.Connected, port, pump };
+}
+function createDisconnectingRuntime(port) {
+  return { status: S.Disconnecting, port };
+}
+function createErrorRuntime(error) {
+  return { status: S.Error, error };
+}
+function createUnsupportedRuntime() {
+  return { status: S.Unsupported };
+}
+function createDisposedRuntime() {
+  return { status: S.Disposed };
+}
+function createInitialRuntime(supported) {
+  return supported ? createIdleRuntime() : createUnsupportedRuntime();
+}
+function getRuntimePort(runtime) {
+  switch (runtime.status) {
+    case S.Connected:
+      return runtime.port;
+    case S.Disconnecting:
+      return runtime.port;
+    default:
+      return null;
+  }
+}
+function getRuntimePump(runtime) {
+  if (runtime.status === S.Connected) {
+    return runtime.pump;
+  }
+  return null;
+}
+function createSessionRuntimeController(initial) {
+  let runtime = initial;
+  const subject = new BehaviorSubject2(
+    runtimeToPublicState(initial)
+  );
+  const transition = (next) => {
+    const from = runtimeToSessionStatus(runtime);
+    const to = runtimeToSessionStatus(next);
+    if (from === to) {
+      return false;
+    }
+    if (!isValidTransition(from, to)) {
+      if (typeof console !== "undefined" && console.warn) {
+        console.warn(
+          `[web-serial-rxjs] Ignoring invalid SerialSession transition ${from} -> ${to}`
+        );
+      }
+      return false;
+    }
+    runtime = next;
+    subject.next(runtimeToPublicState(next));
+    return true;
+  };
+  return {
+    get runtime() {
+      return runtime;
+    },
+    get status() {
+      return runtimeToSessionStatus(runtime);
+    },
+    get state$() {
+      return subject.asObservable();
+    },
+    transition,
+    complete() {
+      subject.complete();
+    }
+  };
+}
+function assertNeverRuntime(value) {
+  return assertNever(value);
+}
+
+// src/session/internal/session-error-reporter.ts
+function createSessionErrorReporter(deps) {
+  const {
+    controller,
+    errorsSubject,
+    sendQueue,
+    isDisposed,
+    updatePortInfo,
+    teardownPump,
+    closePortSafely
+  } = deps;
+  const createDisposedError = () => new SerialError(
+    SerialErrorCode.SESSION_DISPOSED,
+    "SerialSession has been disposed"
+  );
+  const reportError = (error, options) => {
+    const serialError = normalizeSerialError(error, options);
+    if (isDisposed()) {
+      return serialError;
+    }
+    errorsSubject.next(serialError);
+    if (resolveErrorSeverity(serialError.code) === "fatal") {
+      const runtime = controller.runtime;
+      const portToClose = getRuntimePort(runtime);
+      const pump = getRuntimePump(runtime);
+      controller.transition(createErrorRuntime(serialError));
+      sendQueue.clear();
+      updatePortInfo(null);
+      void teardownPump(pump).then(() => closePortSafely(portToClose));
+    }
+    return serialError;
+  };
+  return { reportError, createDisposedError };
+}
+
+// src/session/internal/session-lifecycle.ts
+import { Observable as Observable3 } from "rxjs";
+
+// src/session/internal/build-request-options.ts
+function buildRequestOptions(options) {
+  if (!options?.filters || options.filters.length === 0) {
+    return void 0;
+  }
+  return {
+    filters: options.filters
+  };
+}
+
 // 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 +909,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) {
@@ -252,63 +931,342 @@ function createReadPump(port, { onChunk, onError }) {
       if (!stopped) {
         onError(
           normalizeSerialError(error, {
-            fallbackCode: "READ_FAILED" /* READ_FAILED */,
+            fallbackCode: SerialErrorCode.READ_FAILED,
             messagePrefix: "Read pump failed"
           })
         );
       }
     } finally {
-      running = false;
-      releaseReader();
+      running = false;
+      releaseReader();
+    }
+  };
+  return {
+    start() {
+      if (running || stopped) {
+        return;
+      }
+      const stream = port.readable;
+      if (!stream) {
+        stopped = true;
+        onError(
+          new SerialError(
+            SerialErrorCode.CONNECTION_LOST,
+            "Read pump failed: port.readable is not available"
+          )
+        );
+        return;
+      }
+      void pump(stream);
+    },
+    async stop() {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      if (!reader) {
+        return;
+      }
+      try {
+        await reader.cancel();
+      } catch {
+      } finally {
+        releaseReader();
+      }
+    },
+    get isRunning() {
+      return running;
+    }
+  };
+}
+
+// src/session/internal/session-lifecycle.ts
+function createSessionLifecycle(deps) {
+  const {
+    controller,
+    resolvedOptions,
+    sendQueue,
+    receivePipeline,
+    portInfoSubject,
+    errorsSubject,
+    isDisposed,
+    reportError,
+    createDisposedError
+  } = deps;
+  const updatePortInfo = (port) => {
+    portInfoSubject.next(port ? port.getInfo() : null);
+  };
+  const teardownPump = async (pump) => {
+    receivePipeline.clearReplay();
+    receivePipeline.clearLineBuffer();
+    if (pump) {
+      await pump.stop();
+    }
+  };
+  const closePortSafely = async (port) => {
+    if (!port) {
+      return;
+    }
+    try {
+      await port.close();
+    } catch {
+    }
+  };
+  const teardownFromSnapshot = async (snapshot) => {
+    if (snapshot.status === SerialSessionStatus.Connecting) {
+      snapshot.cancel();
+    }
+    sendQueue.clear();
+    if (snapshot.status === SerialSessionStatus.Connected || snapshot.status === SerialSessionStatus.Disconnecting || snapshot.status === SerialSessionStatus.Error) {
+      const portToClose = getRuntimePort(snapshot);
+      const pump = getRuntimePump(snapshot);
+      await teardownPump(pump);
+      await closePortSafely(portToClose);
+      updatePortInfo(null);
+    }
+    receivePipeline.clearLineBuffer();
+  };
+  const completeSubjects = () => {
+    controller.complete();
+    errorsSubject.complete();
+    receivePipeline.complete();
+    portInfoSubject.complete();
+  };
+  const dispose$ = () => new Observable3((subscriber) => {
+    if (isDisposed()) {
+      subscriber.next();
+      subscriber.complete();
+      return;
+    }
+    const snapshot = controller.runtime;
+    controller.transition(createDisposedRuntime());
+    const run = async () => {
+      try {
+        await teardownFromSnapshot(snapshot);
+        completeSubjects();
+        subscriber.next();
+        subscriber.complete();
+      } catch (error) {
+        const serialError = normalizeSerialError(error, {
+          fallbackCode: SerialErrorCode.UNKNOWN,
+          messagePrefix: "Unexpected dispose failure"
+        });
+        subscriber.error(serialError);
+      }
+    };
+    void run();
+  });
+  const writeToPort = async (payload) => {
+    const runtime = controller.runtime;
+    if (runtime.status !== SerialSessionStatus.Connected || !runtime.port.writable) {
+      throw new SerialError(
+        SerialErrorCode.PORT_NOT_OPEN,
+        "Cannot send data while session is not connected"
+      );
+    }
+    const writer = runtime.port.writable.getWriter();
+    try {
+      await writer.write(payload);
+    } finally {
+      try {
+        writer.releaseLock();
+      } catch {
+      }
     }
   };
-  return {
-    start() {
-      if (running || stopped) {
-        return;
+  const connect$ = () => new Observable3((subscriber) => {
+    if (isDisposed()) {
+      subscriber.error(createDisposedError());
+      return;
+    }
+    if (!hasWebSerialSupport()) {
+      const error = reportError(
+        new SerialError(
+          SerialErrorCode.BROWSER_NOT_SUPPORTED,
+          "Web Serial API is not supported in this environment"
+        ),
+        { fallbackCode: SerialErrorCode.BROWSER_NOT_SUPPORTED }
+      );
+      subscriber.error(error);
+      return;
+    }
+    const current = controller.status;
+    if (current !== SerialSessionStatus.Idle && current !== SerialSessionStatus.Error) {
+      const error = reportError(
+        new SerialError(
+          SerialErrorCode.PORT_ALREADY_OPEN,
+          `Cannot connect while session state is '${current}'`
+        ),
+        { fallbackCode: SerialErrorCode.PORT_ALREADY_OPEN }
+      );
+      subscriber.error(error);
+      return;
+    }
+    let cancelled = false;
+    const cancelInFlightConnect = () => {
+      cancelled = true;
+      if (controller.status === SerialSessionStatus.Connecting) {
+        controller.transition(createIdleRuntime());
       }
-      const stream = port.readable;
-      if (!stream) {
-        stopped = true;
-        onError(
-          new SerialError(
-            "CONNECTION_LOST" /* CONNECTION_LOST */,
-            "Read pump failed: port.readable is not available"
-          )
+    };
+    controller.transition(createConnectingRuntime(cancelInFlightConnect));
+    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);
+        }
+        const serialError = reportError(error, {
+          fallbackCode: SerialErrorCode.PORT_OPEN_FAILED,
+          messagePrefix: "Failed to open port"
+        });
+        if (!cancelled) {
+          subscriber.error(serialError);
+        }
         return;
       }
-      void pump(stream);
-    },
-    async stop() {
-      if (stopped) {
+      if (cancelled || isDisposed()) {
+        await closePortSafely(selectedPort);
         return;
       }
-      stopped = true;
-      if (!reader) {
+      receivePipeline.clearLineBuffer();
+      if (resolvedOptions.receiveReplay.enabled) {
+        receivePipeline.startLiveReceiveReplay();
+      }
+      const pump = createReadPump(selectedPort, {
+        onChunk: receivePipeline.handleChunk,
+        onError: (pumpError) => reportError(pumpError, {
+          fallbackCode: SerialErrorCode.READ_FAILED,
+          messagePrefix: "Read pump failed"
+        }),
+        onDone: () => {
+          if (controller.status !== SerialSessionStatus.Connected) {
+            return;
+          }
+          reportError(
+            new SerialError(
+              SerialErrorCode.CONNECTION_LOST,
+              "Read pump ended unexpectedly: stream closed while connected"
+            ),
+            {
+              fallbackCode: SerialErrorCode.CONNECTION_LOST
+            }
+          );
+        }
+      });
+      pump.start();
+      sendQueue.clear();
+      if (isDisposed()) {
+        await teardownPump(pump);
+        await closePortSafely(selectedPort);
         return;
       }
+      controller.transition(createConnectedRuntime(selectedPort, pump));
+      updatePortInfo(selectedPort);
+      subscriber.next();
+      subscriber.complete();
+    };
+    void run();
+    return () => {
+      cancelInFlightConnect();
+    };
+  });
+  const disconnect$ = () => new Observable3((subscriber) => {
+    if (isDisposed()) {
+      subscriber.next();
+      subscriber.complete();
+      return;
+    }
+    const runtime = controller.runtime;
+    if (runtime.status === SerialSessionStatus.Idle || runtime.status === SerialSessionStatus.Unsupported || runtime.status === SerialSessionStatus.Disconnecting) {
+      subscriber.next();
+      subscriber.complete();
+      return;
+    }
+    if (runtime.status === SerialSessionStatus.Connecting) {
+      runtime.cancel();
+      subscriber.next();
+      subscriber.complete();
+      return;
+    }
+    if (runtime.status !== SerialSessionStatus.Connected && runtime.status !== SerialSessionStatus.Error) {
+      const error = reportError(
+        new SerialError(
+          SerialErrorCode.PORT_NOT_OPEN,
+          `Cannot disconnect while session state is '${runtime.status}'`
+        ),
+        { fallbackCode: SerialErrorCode.PORT_NOT_OPEN }
+      );
+      subscriber.error(error);
+      return;
+    }
+    const portToClose = getRuntimePort(runtime);
+    controller.transition(createDisconnectingRuntime(portToClose));
+    sendQueue.clear();
+    const run = async () => {
       try {
-        await reader.cancel();
-      } catch {
-      } finally {
-        releaseReader();
+        const pump = getRuntimePump(controller.runtime);
+        await teardownPump(pump);
+        if (portToClose) {
+          try {
+            await portToClose.close();
+          } catch (error) {
+            updatePortInfo(null);
+            const serialError = reportError(error, {
+              fallbackCode: SerialErrorCode.CONNECTION_LOST,
+              messagePrefix: "Failed to close port"
+            });
+            subscriber.error(serialError);
+            return;
+          }
+        }
+        updatePortInfo(null);
+        if (!isDisposed()) {
+          controller.transition(createIdleRuntime());
+        }
+        subscriber.next();
+        subscriber.complete();
+      } catch (error) {
+        const serialError = reportError(error, {
+          fallbackCode: SerialErrorCode.UNKNOWN,
+          messagePrefix: "Unexpected disconnect failure"
+        });
+        subscriber.error(serialError);
       }
-    },
-    get isRunning() {
-      return running;
-    }
+    };
+    void run();
+  });
+  return {
+    connect$,
+    disconnect$,
+    dispose$,
+    writeToPort,
+    teardownPump,
+    closePortSafely,
+    updatePortInfo
   };
 }
 
 // src/session/send-queue.ts
-import { Observable, defer } from "rxjs";
+import { Observable as Observable4, defer } from "rxjs";
 function createSendQueue() {
   let chain = Promise.resolve();
   return {
     enqueue(operation) {
       return defer(
-        () => new Observable((subscriber) => {
+        () => new Observable4((subscriber) => {
           let cancelled = false;
           const run = async () => {
             try {
@@ -340,373 +1298,243 @@ function createSendQueue() {
   };
 }
 
+// src/session/internal/validate-serial-port-filters.ts
+function validateSerialPortFilters(filters) {
+  if (!filters || filters.length === 0) {
+    return filters;
+  }
+  for (const filter of filters) {
+    if (!filter.usbVendorId && !filter.usbProductId) {
+      throw new SerialError(
+        SerialErrorCode.INVALID_FILTER_OPTIONS,
+        "Filter must have at least usbVendorId or usbProductId"
+      );
+    }
+    if (filter.usbVendorId !== void 0) {
+      if (!Number.isInteger(filter.usbVendorId) || filter.usbVendorId < 0 || filter.usbVendorId > 65535) {
+        throw new SerialError(
+          SerialErrorCode.INVALID_FILTER_OPTIONS,
+          `Invalid usbVendorId: ${filter.usbVendorId}. Must be an integer between 0 and 65535.`
+        );
+      }
+    }
+    if (filter.usbProductId !== void 0) {
+      if (!Number.isInteger(filter.usbProductId) || filter.usbProductId < 0 || filter.usbProductId > 65535) {
+        throw new SerialError(
+          SerialErrorCode.INVALID_FILTER_OPTIONS,
+          `Invalid usbProductId: ${filter.usbProductId}. Must be an integer between 0 and 65535.`
+        );
+      }
+    }
+  }
+  return filters;
+}
+
 // 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(
+      SerialErrorCode.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(
+      SerialErrorCode.INVALID_RECEIVE_REPLAY_OPTIONS,
+      `Invalid receiveReplay.maxChars: ${maxChars}. Must be a safe integer between 0 and ${MAX_RECEIVE_REPLAY_MAX_CHARS}.`
+    );
+  }
+  return {
+    enabled: merged.enabled,
+    bufferSize: brandReceiveReplayBufferSize(bufferSize),
+    maxChars: brandMaxChars(maxChars)
+  };
+}
+function resolveTerminalBufferOptions(options) {
+  const merged = {
+    ...DEFAULT_TERMINAL_BUFFER_OPTIONS,
+    ...options
+  };
+  const { maxLines, maxChars } = merged;
+  if (!Number.isSafeInteger(maxLines) || maxLines < 0) {
+    throw new SerialError(
+      SerialErrorCode.INVALID_TERMINAL_BUFFER_OPTIONS,
+      `Invalid terminalBuffer.maxLines: ${maxLines}. Must be a safe integer >= 0.`
+    );
+  }
+  if (!Number.isSafeInteger(maxChars) || maxChars < 0) {
+    throw new SerialError(
+      SerialErrorCode.INVALID_TERMINAL_BUFFER_OPTIONS,
+      `Invalid terminalBuffer.maxChars: ${maxChars}. Must be a safe integer >= 0.`
+    );
+  }
+  return {
+    maxLines: brandMaxLines(maxLines),
+    maxChars: brandMaxChars(maxChars)
+  };
+}
+function resolveLineBufferOptions(options) {
+  const merged = {
+    ...DEFAULT_LINE_BUFFER_OPTIONS,
+    ...options
+  };
+  const { maxChars } = merged;
+  if (!Number.isSafeInteger(maxChars) || maxChars < 0) {
+    throw new SerialError(
+      SerialErrorCode.INVALID_LINE_BUFFER_OPTIONS,
+      `Invalid lineBuffer.maxChars: ${maxChars}. Must be a safe integer >= 0.`
+    );
+  }
+  return {
+    maxChars: brandMaxChars(maxChars)
+  };
+}
 var DEFAULT_SERIAL_SESSION_OPTIONS = {
-  baudRate: 9600,
+  baudRate: brandBaudRate(9600),
   dataBits: 8,
   stopBits: 1,
   parity: "none",
-  bufferSize: 255,
+  bufferSize: brandSerialPortBufferSize(255),
   flowControl: "none",
-  filters: void 0,
-  receiveReplay: { ...DEFAULT_RECEIVE_REPLAY }
-};
-
-// src/session/serial-session-state.ts
-var SerialSessionState = {
-  Idle: "idle",
-  Connecting: "connecting",
-  Connected: "connected",
-  Disconnecting: "disconnecting",
-  Unsupported: "unsupported",
-  Error: "error"
-};
-
-// 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]: []
+  receiveReplay: resolveReceiveReplayOptions(),
+  terminalBuffer: resolveTerminalBufferOptions(),
+  lineBuffer: resolveLineBufferOptions()
 };
-var SessionStateMachine = class {
-  constructor(initial = SerialSessionState.Idle) {
-    this.subject = new BehaviorSubject(initial);
-  }
-  get current() {
-    return this.subject.getValue();
-  }
-  get state$() {
-    return this.subject.asObservable();
-  }
-  toConnecting() {
-    return this.transition(S.Connecting);
-  }
-  toConnected() {
-    return this.transition(S.Connected);
-  }
-  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;
-    }
-    this.subject.next(next);
-    return true;
+function resolveConnectionOptions(options) {
+  const merged = {
+    baudRate: DEFAULT_SERIAL_SESSION_OPTIONS.baudRate,
+    dataBits: DEFAULT_SERIAL_SESSION_OPTIONS.dataBits,
+    stopBits: DEFAULT_SERIAL_SESSION_OPTIONS.stopBits,
+    parity: DEFAULT_SERIAL_SESSION_OPTIONS.parity,
+    bufferSize: DEFAULT_SERIAL_SESSION_OPTIONS.bufferSize,
+    flowControl: DEFAULT_SERIAL_SESSION_OPTIONS.flowControl,
+    ...options
+  };
+  const { baudRate, bufferSize } = merged;
+  if (!Number.isSafeInteger(baudRate) || baudRate <= 0) {
+    throw new SerialError(
+      SerialErrorCode.INVALID_CONNECTION_OPTIONS,
+      `Invalid baudRate: ${baudRate}. Must be a safe integer > 0.`
+    );
   }
-};
+  return {
+    dataBits: merged.dataBits ?? DEFAULT_SERIAL_SESSION_OPTIONS.dataBits,
+    stopBits: merged.stopBits ?? DEFAULT_SERIAL_SESSION_OPTIONS.stopBits,
+    parity: merged.parity ?? DEFAULT_SERIAL_SESSION_OPTIONS.parity,
+    flowControl: merged.flowControl ?? DEFAULT_SERIAL_SESSION_OPTIONS.flowControl,
+    baudRate: brandBaudRate(baudRate),
+    bufferSize: brandSerialPortBufferSize(
+      bufferSize ?? DEFAULT_SERIAL_SESSION_OPTIONS.bufferSize
+    )
+  };
+}
+function resolveSerialSessionOptions(options) {
+  const connection = resolveConnectionOptions(options);
+  const filters = validateSerialPortFilters(options?.filters);
+  return {
+    ...connection,
+    ...filters !== void 0 ? { filters } : {},
+    receiveReplay: resolveReceiveReplayOptions(options?.receiveReplay),
+    terminalBuffer: resolveTerminalBufferOptions(options?.terminalBuffer),
+    lineBuffer: resolveLineBufferOptions(options?.lineBuffer)
+  };
+}
 
 // src/session/create-serial-session.ts
 function createSerialSession(options) {
-  const resolvedOptions = {
-    ...DEFAULT_SERIAL_SESSION_OPTIONS,
-    ...options,
-    filters: options?.filters,
-    receiveReplay: {
-      ...DEFAULT_SERIAL_SESSION_OPTIONS.receiveReplay,
-      ...options?.receiveReplay
-    }
-  };
-  const supported = hasWebSerialSupport();
-  const machine = new SessionStateMachine(
-    supported ? SerialSessionState.Idle : SerialSessionState.Unsupported
+  const resolvedOptions = resolveSerialSessionOptions(options);
+  const controller = createSessionRuntimeController(
+    createInitialRuntime(hasWebSerialSupport())
   );
-  const errorsSubject = new Subject();
-  const receiveSubject = new Subject();
-  const linesSubject = new Subject();
+  const errorsSubject = new Subject3();
   const sendQueue = createSendQueue();
   const textEncoder = new TextEncoder();
-  const lineBuffer = createLineBuffer();
+  const portInfoSubject = new BehaviorSubject3(null);
+  const isDisposed = () => controller.status === SerialSessionStatus.Disposed;
+  const errorReporterRef = {};
+  const receivePipeline = createReceivePipeline({
+    resolvedOptions,
+    reportError: (error, options2) => errorReporterRef.reportError(error, options2)
+  });
+  const lifecycle = createSessionLifecycle({
+    controller,
+    resolvedOptions,
+    sendQueue,
+    receivePipeline,
+    portInfoSubject,
+    errorsSubject,
+    isDisposed,
+    reportError: (error, options2) => errorReporterRef.reportError(error, options2),
+    createDisposedError: () => errorReporterRef.createDisposedError()
+  });
+  const { reportError, createDisposedError } = createSessionErrorReporter({
+    controller,
+    errorsSubject,
+    sendQueue,
+    isDisposed,
+    updatePortInfo: lifecycle.updatePortInfo,
+    teardownPump: lifecycle.teardownPump,
+    closePortSafely: lifecycle.closePortSafely
+  });
+  errorReporterRef.reportError = reportError;
+  errorReporterRef.createDisposedError = createDisposedError;
+  const { receive$, lines$, receiveReplay$ } = receivePipeline;
   const errors$ = errorsSubject.asObservable();
-  const receive$ = receiveSubject.asObservable();
-  const lines$ = linesSubject.asObservable();
-  const terminalText$ = createTerminalBuffer(receive$).text$;
-  const isConnected$ = machine.state$.pipe(
-    map2((state) => state === SerialSessionState.Connected),
+  const terminalText$ = createTerminalBuffer(
+    receive$,
+    resolvedOptions.terminalBuffer
+  ).text$;
+  const isConnected$ = controller.state$.pipe(
+    map2((state) => state.status === SerialSessionStatus.Connected),
     distinctUntilChanged()
   );
-  const portInfoSubject = new BehaviorSubject2(null);
   const portInfo$ = portInfoSubject.asObservable();
-  const receiveReplayStream$ = resolvedOptions.receiveReplay.enabled ? new BehaviorSubject2(receive$) : null;
-  let activeReceiveReplay = null;
-  const clearLiveReceiveReplay = () => {
-    if (receiveReplayStream$) {
-      if (activeReceiveReplay) {
-        activeReceiveReplay.complete();
-        activeReceiveReplay = null;
-      }
-      receiveReplayStream$.next(receive$);
-    }
-  };
-  const startLiveReceiveReplay = () => {
-    if (!receiveReplayStream$) {
-      return;
-    }
-    if (activeReceiveReplay) {
-      activeReceiveReplay.complete();
-      activeReceiveReplay = null;
-    }
-    const rs = new ReplaySubject(resolvedOptions.receiveReplay.bufferSize);
-    activeReceiveReplay = rs;
-    receiveReplayStream$.next(rs.asObservable());
-  };
-  const receiveReplay$ = receiveReplayStream$ ? receiveReplayStream$.pipe(switchMap((inner) => inner), share()) : receive$;
-  let activePort = null;
-  let activePump = null;
-  const setActivePort = (port) => {
-    activePort = port;
-    portInfoSubject.next(port ? port.getInfo() : null);
-  };
-  const teardownPump = async () => {
-    clearLiveReceiveReplay();
-    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;
-      setActivePort(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 */,
-        "Cannot send data while session is not connected"
-      );
-    }
-    const writer = port.writable.getWriter();
-    try {
-      await writer.write(payload);
-    } finally {
-      try {
-        writer.releaseLock();
-      } catch {
-      }
-    }
-  };
   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;
-        }
-        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);
-            }
-            const serialError = reportError(error, "fatal", {
-              fallbackCode: "PORT_OPEN_FAILED" /* PORT_OPEN_FAILED */,
-              messagePrefix: "Failed to open port"
-            });
-            if (!cancelled) {
-              subscriber.error(serialError);
-            }
-            return;
-          }
-          if (cancelled) {
-            await closePortSafely(selectedPort);
-            return;
-          }
-          setActivePort(selectedPort);
-          lineBuffer.clear();
-          if (resolvedOptions.receiveReplay.enabled) {
-            startLiveReceiveReplay();
-          }
-          activePump = createReadPump(selectedPort, {
-            onChunk: (text) => {
-              receiveSubject.next(text);
-              if (activeReceiveReplay) {
-                activeReceiveReplay.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) {
-                setActivePort(null);
-                const serialError = reportError(error, "fatal", {
-                  fallbackCode: "CONNECTION_LOST" /* CONNECTION_LOST */,
-                  messagePrefix: "Failed to close port"
-                });
-                subscriber.error(serialError);
-                return;
-              }
-            }
-            setActivePort(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();
-      });
-    },
+    connect$: lifecycle.connect$,
+    disconnect$: lifecycle.disconnect$,
+    dispose$: lifecycle.dispose$,
+    destroy$: lifecycle.dispose$,
     send$(data) {
+      if (isDisposed()) {
+        return new Observable5((subscriber) => {
+          subscriber.error(createDisposedError());
+        });
+      }
       return sendQueue.enqueue(async () => {
         const payload = typeof data === "string" ? textEncoder.encode(data) : data;
         try {
-          await writeToPort(payload);
+          await lifecycle.writeToPort(payload);
         } catch (error) {
-          throw reportError(error, "non-fatal", {
-            fallbackCode: "WRITE_FAILED" /* WRITE_FAILED */,
+          throw reportError(error, {
+            fallbackCode: SerialErrorCode.WRITE_FAILED,
             messagePrefix: "Failed to write data"
           });
         }
       });
     },
-    state$: machine.state$,
+    state$: controller.state$,
     isConnected$,
     portInfo$,
     getPortInfo() {
       return portInfoSubject.getValue();
     },
     getCurrentPort() {
-      return activePort;
+      return getRuntimePort(controller.runtime);
     },
     errors$,
     receive$,
@@ -716,10 +1544,16 @@ function createSerialSession(options) {
   };
 }
 export {
+  DEFAULT_LINE_BUFFER_OPTIONS,
+  DEFAULT_TERMINAL_BUFFER_OPTIONS,
+  MAX_RECEIVE_REPLAY_BUFFER_SIZE,
+  MAX_RECEIVE_REPLAY_MAX_CHARS,
   SerialError,
   SerialErrorCode,
-  SerialSessionState,
+  SerialSessionStatus,
+  assertNever,
   createSerialSession,
-  createTerminalBuffer
+  createTerminalBuffer,
+  resolveSerialSessionOptions
 };
 //# sourceMappingURL=index.mjs.map