@gurezo/web-serial-rxjs 2.4.0 → 3.0.0

package/dist/index.mjs

@@ -1,77 +1,224 @@
+// 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 Observable4,
-  share,
-  Subject as Subject2,
-  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["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 || {});
-
-// 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";
 
+// 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 = "";
@@ -229,9 +376,11 @@ var DEFAULT_TERMINAL_BUFFER_OPTIONS = {
   maxChars: 1048576
 };
 function resolveTerminalBufferLimits(options) {
+  const maxLines = options?.maxLines ?? DEFAULT_TERMINAL_BUFFER_OPTIONS.maxLines;
+  const maxChars = options?.maxChars ?? DEFAULT_TERMINAL_BUFFER_OPTIONS.maxChars;
   return {
-    ...DEFAULT_TERMINAL_BUFFER_OPTIONS,
-    ...options
+    maxLines: brandMaxLines(maxLines),
+    maxChars: brandMaxChars(maxChars)
   };
 }
 var initialTerminalState = {
@@ -251,53 +400,96 @@ function createTerminalBuffer(receive$, options) {
   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
 var DEFAULT_LINE_BUFFER_OPTIONS = {
   maxChars: 1048576
 };
 function createLineBuffer(options) {
   const limits = {
-    ...DEFAULT_LINE_BUFFER_OPTIONS,
-    ...options
+    maxChars: brandMaxChars(
+      options?.maxChars ?? DEFAULT_LINE_BUFFER_OPTIONS.maxChars
+    )
   };
   const tokenizer = createNewlineTokenizer("line");
   const clear = () => {
@@ -371,6 +563,119 @@ function createReceiveReplayBuffer(options) {
   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;
+      }
+      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
+          }
+        );
+      }
+    }
+    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
+  };
+}
+
+// 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
 var DEFAULT_MESSAGE_PREFIX = "Serial operation failed";
 var isDomExceptionWithName = (error, name) => typeof DOMException !== "undefined" && error instanceof DOMException && error.name === name;
@@ -381,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
     );
@@ -394,29 +699,216 @@ function normalizeSerialError(error, options) {
   );
 }
 
-// src/session/read-pump.ts
-function createReadPump(port, { onChunk, onError, onDone }) {
-  let reader = null;
-  let running = false;
-  let stopped = false;
-  const decoder = new TextDecoder(void 0, { fatal: false });
-  const releaseReader = () => {
-    if (!reader) {
-      return;
-    }
-    try {
-      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) {
+// 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, onDone }) {
+  let reader = null;
+  let running = false;
+  let stopped = false;
+  const decoder = new TextDecoder(void 0, { fatal: false });
+  const releaseReader = () => {
+    if (!reader) {
+      return;
+    }
+    try {
+      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) {
           if (!stopped) {
             onDone?.();
           }
@@ -439,7 +931,7 @@ function createReadPump(port, { onChunk, onError, onDone }) {
       if (!stopped) {
         onError(
           normalizeSerialError(error, {
-            fallbackCode: "READ_FAILED" /* READ_FAILED */,
+            fallbackCode: SerialErrorCode.READ_FAILED,
             messagePrefix: "Read pump failed"
           })
         );
@@ -459,7 +951,7 @@ function createReadPump(port, { onChunk, onError, onDone }) {
         stopped = true;
         onError(
           new SerialError(
-            "CONNECTION_LOST" /* CONNECTION_LOST */,
+            SerialErrorCode.CONNECTION_LOST,
             "Read pump failed: port.readable is not available"
           )
         );
@@ -488,14 +980,293 @@ function createReadPump(port, { onChunk, onError, onDone }) {
   };
 }
 
+// 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 {
+      }
+    }
+  };
+  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());
+      }
+    };
+    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;
+      }
+      if (cancelled || isDisposed()) {
+        await closePortSafely(selectedPort);
+        return;
+      }
+      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 {
+        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);
+      }
+    };
+    void run();
+  });
+  return {
+    connect$,
+    disconnect$,
+    dispose$,
+    writeToPort,
+    teardownPump,
+    closePortSafely,
+    updatePortInfo
+  };
+}
+
 // src/session/send-queue.ts
-import { Observable as Observable2, defer } from "rxjs";
+import { Observable as Observable4, defer } from "rxjs";
 function createSendQueue() {
   let chain = Promise.resolve();
   return {
     enqueue(operation) {
       return defer(
-        () => new Observable2((subscriber) => {
+        () => new Observable4((subscriber) => {
           let cancelled = false;
           const run = async () => {
             try {
@@ -527,6 +1298,38 @@ 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;
@@ -543,531 +1346,195 @@ function resolveReceiveReplayOptions(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 */,
+      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(
-      "INVALID_RECEIVE_REPLAY_OPTIONS" /* INVALID_RECEIVE_REPLAY_OPTIONS */,
+      SerialErrorCode.INVALID_RECEIVE_REPLAY_OPTIONS,
       `Invalid receiveReplay.maxChars: ${maxChars}. Must be a safe integer between 0 and ${MAX_RECEIVE_REPLAY_MAX_CHARS}.`
     );
   }
-  return merged;
+  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 },
-  terminalBuffer: { ...DEFAULT_TERMINAL_BUFFER_OPTIONS },
-  lineBuffer: { ...DEFAULT_LINE_BUFFER_OPTIONS }
-};
-
-// src/session/serial-session-state.ts
-var SerialSessionState = {
-  Idle: "idle",
-  Connecting: "connecting",
-  Connected: "connected",
-  Disconnecting: "disconnecting",
-  Unsupported: "unsupported",
-  Error: "error",
-  Disposed: "disposed"
+  receiveReplay: resolveReceiveReplayOptions(),
+  terminalBuffer: resolveTerminalBufferOptions(),
+  lineBuffer: resolveLineBufferOptions()
 };
-
-// src/session/session-state-machine.ts
-import { BehaviorSubject } from "rxjs";
-var S = SerialSessionState;
-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]: []
-};
-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);
-  }
-  toDisposed() {
-    return this.transition(S.Disposed);
-  }
-  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: 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 resolvedOptions = resolveSerialSessionOptions(options);
+  const controller = createSessionRuntimeController(
+    createInitialRuntime(hasWebSerialSupport())
   );
-  const errorsSubject = new Subject2();
-  const receiveSubject = new Subject2();
-  const linesSubject = new Subject2();
+  const errorsSubject = new Subject3();
   const sendQueue = createSendQueue();
   const textEncoder = new TextEncoder();
-  const lineBuffer = createLineBuffer(resolvedOptions.lineBuffer);
+  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$,
     resolvedOptions.terminalBuffer
   ).text$;
-  const isConnected$ = machine.state$.pipe(
-    map2((state) => state === SerialSessionState.Connected),
+  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 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);
-  };
-  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);
-    if (disposed) {
-      return serialError;
-    }
-    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 Observable4((subscriber) => {
-        if (disposed) {
-          subscriber.error(createDisposedError());
-          return;
-        }
-        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;
-        const cancelInFlightConnect = () => {
-          cancelled = true;
-          if (machine.current === SerialSessionState.Connecting) {
-            machine.toIdle();
-          }
-        };
-        activeConnectCancel = cancelInFlightConnect;
-        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 || disposed) {
-            await closePortSafely(selectedPort);
-            return;
-          }
-          setActivePort(selectedPort);
-          lineBuffer.clear();
-          if (resolvedOptions.receiveReplay.enabled) {
-            startLiveReceiveReplay();
-          }
-          activePump = createReadPump(selectedPort, {
-            onChunk: (text) => {
-              receiveSubject.next(text);
-              if (activeReceiveReplay) {
-                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 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 () => {
-          clearActiveConnectCancel(cancelInFlightConnect);
-          cancelInFlightConnect();
-        };
-      });
-    },
-    disconnect$() {
-      return new Observable4((subscriber) => {
-        if (disposed) {
-          subscriber.next();
-          subscriber.complete();
-          return;
-        }
-        const current = machine.current;
-        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;
-        }
-        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);
-            if (!disposed) {
-              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();
-      });
-    },
-    dispose$,
-    destroy$: dispose$,
+    connect$: lifecycle.connect$,
+    disconnect$: lifecycle.disconnect$,
+    dispose$: lifecycle.dispose$,
+    destroy$: lifecycle.dispose$,
     send$(data) {
-      if (disposed) {
-        return new Observable4((subscriber) => {
+      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$,
@@ -1079,10 +1546,14 @@ 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