@gurezo/web-serial-rxjs 3.1.0 → 4.0.0

package/dist/index.mjs

@@ -4,13 +4,7 @@ function assertNever(value) {
 }
 
 // src/session/create-serial-session.ts
-import {
-  BehaviorSubject as BehaviorSubject3,
-  distinctUntilChanged,
-  map as map2,
-  Observable as Observable5,
-  Subject as Subject3
-} from "rxjs";
+import { Observable as Observable4, Subject as Subject2 } from "rxjs";
 
 // src/errors/serial-error-code.ts
 var SerialErrorCode = {
@@ -134,16 +128,6 @@ var SerialErrorCode = {
    * 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.
    *
@@ -174,17 +158,6 @@ var SerialErrorCode = {
    * 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.
    *
@@ -211,6 +184,83 @@ var SerialErrorCode = {
 // src/terminal/create-terminal-buffer.ts
 import { map, scan, shareReplay } 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.
+   *   @deprecated Prefer passing `{ cause }` via {@link context}. When omitted,
+   *   cause-bearing codes derive `{ cause }` from this argument for backward
+   *   compatibility.
+   * @param context - Structured metadata for the error code. For cause-bearing
+   *   codes, pass `{ cause }` here. When omitted, cause-bearing codes derive
+   *   `{ cause }` from the legacy {@link originalError} argument.
+   */
+  constructor(code, message, originalError, context) {
+    super(message);
+    this.name = "SerialError";
+    this.code = code;
+    if (context !== void 0) {
+      this.context = context;
+    } else if (originalError !== void 0 && isCauseContextCode(code)) {
+      this.context = { cause: originalError };
+    } else {
+      this.context = void 0;
+    }
+    if (originalError !== void 0) {
+      this.originalError = originalError;
+    } else if (isCauseContextCode(code) && this.context !== void 0) {
+      const causeContext = this.context;
+      if (causeContext.cause instanceof Error) {
+        this.originalError = causeContext.cause;
+      }
+    }
+    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/internal/branded-numbers.ts
 function brandBaudRate(value) {
   return value;
@@ -218,9 +268,6 @@ function brandBaudRate(value) {
 function brandSerialPortBufferSize(value) {
   return value;
 }
-function brandReceiveReplayBufferSize(value) {
-  return value;
-}
 function brandMaxChars(value) {
   return value;
 }
@@ -468,12 +515,40 @@ var DEFAULT_TERMINAL_BUFFER_OPTIONS = {
   maxChars: 1048576,
   stripAnsi: true
 };
-function resolveTerminalBufferLimits(options) {
-  const maxLines = options?.maxLines ?? DEFAULT_TERMINAL_BUFFER_OPTIONS.maxLines;
-  const maxChars = options?.maxChars ?? DEFAULT_TERMINAL_BUFFER_OPTIONS.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.`,
+      void 0,
+      {
+        field: "terminalBuffer.maxLines",
+        value: maxLines,
+        constraint: "non-negative-safe-integer"
+      }
+    );
+  }
+  if (!Number.isSafeInteger(maxChars) || maxChars < 0) {
+    throw new SerialError(
+      SerialErrorCode.INVALID_TERMINAL_BUFFER_OPTIONS,
+      `Invalid terminalBuffer.maxChars: ${maxChars}. Must be a safe integer >= 0.`,
+      void 0,
+      {
+        field: "terminalBuffer.maxChars",
+        value: maxChars,
+        constraint: "non-negative-safe-integer"
+      }
+    );
+  }
   return {
     maxLines: brandMaxLines(maxLines),
-    maxChars: brandMaxChars(maxChars)
+    maxChars: brandMaxChars(maxChars),
+    stripAnsi: merged.stripAnsi
   };
 }
 var initialTerminalState = {
@@ -481,9 +556,12 @@ var initialTerminalState = {
   currentLine: ""
 };
 function createTerminalBuffer(receive$, options) {
-  const limits = resolveTerminalBufferLimits(options);
-  const stripAnsi = options?.stripAnsi ?? DEFAULT_TERMINAL_BUFFER_OPTIONS.stripAnsi;
-  const ansiStripper = stripAnsi ? createAnsiStripper() : null;
+  const resolved = resolveTerminalBufferOptions(options);
+  const limits = {
+    maxLines: resolved.maxLines,
+    maxChars: resolved.maxChars
+  };
+  const ansiStripper = resolved.stripAnsi ? createAnsiStripper() : null;
   const text$ = receive$.pipe(
     scan((state, chunk) => {
       const normalized = ansiStripper !== null ? ansiStripper.feed(chunk) : chunk;
@@ -497,105 +575,62 @@ function createTerminalBuffer(receive$, options) {
 }
 
 // src/session/internal/has-web-serial-support.ts
-function hasWebSerialSupport() {
+function isWebSerialSupported() {
   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.
-   *   @deprecated Prefer passing `{ cause }` via {@link context}. When omitted,
-   *   cause-bearing codes derive `{ cause }` from this argument for backward
-   *   compatibility.
-   * @param context - Structured metadata for the error code. For cause-bearing
-   *   codes, pass `{ cause }` here. When omitted, cause-bearing codes derive
-   *   `{ cause }` from the legacy {@link originalError} argument.
-   */
-  constructor(code, message, originalError, context) {
-    super(message);
-    this.name = "SerialError";
-    this.code = code;
-    if (context !== void 0) {
-      this.context = context;
-    } else if (originalError !== void 0 && isCauseContextCode(code)) {
-      this.context = { cause: originalError };
-    } else {
-      this.context = void 0;
+// src/session/internal/port-teardown.ts
+function createPortTeardown(deps) {
+  const { receivePipeline } = deps;
+  const teardownPump = async (pump) => {
+    receivePipeline.clearLineBuffer();
+    if (pump) {
+      await pump.stop();
     }
-    if (originalError !== void 0) {
-      this.originalError = originalError;
-    } else if (isCauseContextCode(code) && this.context !== void 0) {
-      const causeContext = this.context;
-      if (causeContext.cause instanceof Error) {
-        this.originalError = causeContext.cause;
-      }
+  };
+  const closePortSafely = async (port) => {
+    if (!port) {
+      return;
     }
-    if (ErrorWithCaptureStackTrace.captureStackTrace) {
-      ErrorWithCaptureStackTrace.captureStackTrace(this, _SerialError);
+    try {
+      await port.close();
+    } catch {
     }
-  }
-  /**
-   * 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;
-  }
-};
+  };
+  return { teardownPump, closePortSafely };
+}
+
+// src/session/internal/receive-pipeline.ts
+import { Subject } from "rxjs";
 
 // src/session/internal/line-buffer.ts
 var DEFAULT_LINE_BUFFER_OPTIONS = {
   maxChars: 1048576
 };
-function createLineBuffer(options) {
-  const limits = {
-    maxChars: brandMaxChars(
-      options?.maxChars ?? DEFAULT_LINE_BUFFER_OPTIONS.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.`,
+      void 0,
+      {
+        field: "lineBuffer.maxChars",
+        value: maxChars,
+        constraint: "non-negative-safe-integer"
+      }
+    );
+  }
+  return {
+    maxChars: brandMaxChars(maxChars)
+  };
+}
+function createLineBuffer(options) {
+  const limits = resolveLineBufferOptions(options);
   const tokenizer = createNewlineTokenizer("line");
   const clear = () => {
     tokenizer.clear();
@@ -614,129 +649,30 @@ function createLineBuffer(options) {
   return { feed, clear };
 }
 
-// src/session/internal/receive-replay-buffer.ts
-import { Observable, Subject } from "rxjs";
-function totalChars(chunks) {
-  return chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-}
-function createReceiveReplayBuffer(options) {
-  const chunks = [];
-  const live$ = new Subject();
-  let completed = false;
-  const trim = () => {
-    let overflowed = false;
-    while (chunks.length > options.bufferSize) {
-      chunks.shift();
-      overflowed = true;
-    }
-    if (options.maxChars > 0) {
-      let chars = totalChars(chunks);
-      while (chars > options.maxChars && chunks.length > 1) {
-        chars -= chunks.shift().length;
-        overflowed = true;
-      }
-    }
-    return overflowed;
-  };
-  const next = (chunk) => {
-    if (completed) {
-      return { overflowed: false };
-    }
-    chunks.push(chunk);
-    const overflowed = trim();
-    live$.next(chunk);
-    return { overflowed };
-  };
-  const asObservable = () => new Observable((subscriber) => {
-    for (const chunk of chunks) {
-      subscriber.next(chunk);
-    }
-    if (completed) {
-      subscriber.complete();
-      return;
-    }
-    return live$.subscribe(subscriber);
-  });
-  const complete = () => {
-    if (completed) {
-      return;
-    }
-    completed = true;
-    chunks.length = 0;
-    live$.complete();
-  };
-  return { next, asObservable, complete };
-}
-
 // src/session/internal/receive-pipeline.ts
 function createReceivePipeline(deps) {
-  const { resolvedOptions, reportError } = deps;
-  const receiveSubject = new Subject2();
-  const linesSubject = new Subject2();
+  const { resolvedOptions } = deps;
+  const receiveSubject = new Subject();
+  const linesSubject = new Subject();
+  const bufferErrorsSubject = new Subject();
   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 bufferErrors$ = bufferErrorsSubject.asObservable();
   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(
+      bufferErrorsSubject.next(
         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) {
@@ -746,14 +682,12 @@ function createReceivePipeline(deps) {
   const complete = () => {
     receiveSubject.complete();
     linesSubject.complete();
-    receiveReplayStream$?.complete();
+    bufferErrorsSubject.complete();
   };
   return {
     receive$,
     lines$,
-    receiveReplay$,
-    clearReplay,
-    startLiveReceiveReplay,
+    bufferErrors$,
     clearLineBuffer,
     handleChunk,
     complete
@@ -768,7 +702,6 @@ var ERROR_SEVERITY = {
   [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",
@@ -807,7 +740,7 @@ function normalizeSerialError(error, options) {
 }
 
 // src/session/session-runtime.ts
-import { BehaviorSubject as BehaviorSubject2 } from "rxjs";
+import { BehaviorSubject } from "rxjs";
 
 // src/session/serial-session-state.ts
 var SerialSessionStatus = {
@@ -904,7 +837,7 @@ function getRuntimePump(runtime) {
 }
 function createSessionRuntimeController(initial) {
   let runtime = initial;
-  const subject = new BehaviorSubject2(
+  const subject = new BehaviorSubject(
     runtimeToPublicState(initial)
   );
   const transition = (next) => {
@@ -921,8 +854,9 @@ function createSessionRuntimeController(initial) {
       }
       return false;
     }
+    const publicState = runtimeToPublicState(next);
     runtime = next;
-    subject.next(runtimeToPublicState(next));
+    subject.next(publicState);
     return true;
   };
   return {
@@ -952,7 +886,6 @@ function createSessionErrorReporter(deps) {
     errorsSubject,
     sendQueue,
     isDisposed,
-    updatePortInfo,
     teardownPump,
     closePortSafely
   } = deps;
@@ -972,7 +905,6 @@ function createSessionErrorReporter(deps) {
       const pump = getRuntimePump(runtime);
       controller.transition(createErrorRuntime(serialError));
       sendQueue.clear();
-      updatePortInfo(null);
       void teardownPump(pump).then(() => closePortSafely(portToClose));
     }
     return serialError;
@@ -981,7 +913,7 @@ function createSessionErrorReporter(deps) {
 }
 
 // src/session/internal/session-lifecycle.ts
-import { Observable as Observable3 } from "rxjs";
+import { Observable as Observable2 } from "rxjs";
 
 // src/session/internal/build-request-options.ts
 function buildRequestOptions(options) {
@@ -1094,31 +1026,13 @@ function createSessionLifecycle(deps) {
     resolvedOptions,
     sendQueue,
     receivePipeline,
-    portInfoSubject,
     errorsSubject,
     isDisposed,
+    teardownPump,
+    closePortSafely,
     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();
@@ -1129,7 +1043,6 @@ function createSessionLifecycle(deps) {
       const pump = getRuntimePump(snapshot);
       await teardownPump(pump);
       await closePortSafely(portToClose);
-      updatePortInfo(null);
     }
     receivePipeline.clearLineBuffer();
   };
@@ -1137,9 +1050,8 @@ function createSessionLifecycle(deps) {
     controller.complete();
     errorsSubject.complete();
     receivePipeline.complete();
-    portInfoSubject.complete();
   };
-  const dispose$ = () => new Observable3((subscriber) => {
+  const dispose$ = () => new Observable2((subscriber) => {
     if (isDisposed()) {
       subscriber.next();
       subscriber.complete();
@@ -1181,12 +1093,12 @@ function createSessionLifecycle(deps) {
       }
     }
   };
-  const connect$ = () => new Observable3((subscriber) => {
+  const connect$ = () => new Observable2((subscriber) => {
     if (isDisposed()) {
       subscriber.error(createDisposedError());
       return;
     }
-    if (!hasWebSerialSupport()) {
+    if (!isWebSerialSupported()) {
       const error = reportError(
         new SerialError(
           SerialErrorCode.BROWSER_NOT_SUPPORTED,
@@ -1249,9 +1161,6 @@ function createSessionLifecycle(deps) {
         return;
       }
       receivePipeline.clearLineBuffer();
-      if (resolvedOptions.receiveReplay.enabled) {
-        receivePipeline.startLiveReceiveReplay();
-      }
       const pump = createReadPump(selectedPort, {
         onChunk: receivePipeline.handleChunk,
         onError: (pumpError) => reportError(pumpError, {
@@ -1281,7 +1190,6 @@ function createSessionLifecycle(deps) {
         return;
       }
       controller.transition(createConnectedRuntime(selectedPort, pump));
-      updatePortInfo(selectedPort);
       subscriber.next();
       subscriber.complete();
     };
@@ -1290,7 +1198,7 @@ function createSessionLifecycle(deps) {
       cancelInFlightConnect();
     };
   });
-  const disconnect$ = () => new Observable3((subscriber) => {
+  const disconnect$ = () => new Observable2((subscriber) => {
     if (isDisposed()) {
       subscriber.next();
       subscriber.complete();
@@ -1330,7 +1238,6 @@ function createSessionLifecycle(deps) {
           try {
             await portToClose.close();
           } catch (error) {
-            updatePortInfo(null);
             const serialError = reportError(error, {
               fallbackCode: SerialErrorCode.CONNECTION_LOST,
               messagePrefix: "Failed to close port"
@@ -1339,7 +1246,6 @@ function createSessionLifecycle(deps) {
             return;
           }
         }
-        updatePortInfo(null);
         if (!isDisposed()) {
           controller.transition(createIdleRuntime());
         }
@@ -1359,21 +1265,18 @@ function createSessionLifecycle(deps) {
     connect$,
     disconnect$,
     dispose$,
-    writeToPort,
-    teardownPump,
-    closePortSafely,
-    updatePortInfo
+    writeToPort
   };
 }
 
 // src/session/send-queue.ts
-import { Observable as Observable4, defer } from "rxjs";
+import { Observable as Observable3, defer } from "rxjs";
 function createSendQueue() {
   let chain = Promise.resolve();
   return {
     enqueue(operation) {
       return defer(
-        () => new Observable4((subscriber) => {
+        () => new Observable3((subscriber) => {
           let cancelled = false;
           const run = async () => {
             try {
@@ -1463,107 +1366,6 @@ function validateSerialPortFilters(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,
-  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}.`,
-      void 0,
-      {
-        field: "receiveReplay.bufferSize",
-        value: bufferSize,
-        constraint: "receive-replay-buffer-size-range"
-      }
-    );
-  }
-  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}.`,
-      void 0,
-      {
-        field: "receiveReplay.maxChars",
-        value: maxChars,
-        constraint: "receive-replay-max-chars-range"
-      }
-    );
-  }
-  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.`,
-      void 0,
-      {
-        field: "terminalBuffer.maxLines",
-        value: maxLines,
-        constraint: "non-negative-safe-integer"
-      }
-    );
-  }
-  if (!Number.isSafeInteger(maxChars) || maxChars < 0) {
-    throw new SerialError(
-      SerialErrorCode.INVALID_TERMINAL_BUFFER_OPTIONS,
-      `Invalid terminalBuffer.maxChars: ${maxChars}. Must be a safe integer >= 0.`,
-      void 0,
-      {
-        field: "terminalBuffer.maxChars",
-        value: maxChars,
-        constraint: "non-negative-safe-integer"
-      }
-    );
-  }
-  return {
-    maxLines: brandMaxLines(maxLines),
-    maxChars: brandMaxChars(maxChars),
-    stripAnsi: merged.stripAnsi
-  };
-}
-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.`,
-      void 0,
-      {
-        field: "lineBuffer.maxChars",
-        value: maxChars,
-        constraint: "non-negative-safe-integer"
-      }
-    );
-  }
-  return {
-    maxChars: brandMaxChars(maxChars)
-  };
-}
 var DEFAULT_SERIAL_SESSION_OPTIONS = {
   baudRate: brandBaudRate(9600),
   dataBits: 8,
@@ -1571,7 +1373,6 @@ var DEFAULT_SERIAL_SESSION_OPTIONS = {
   parity: "none",
   bufferSize: brandSerialPortBufferSize(255),
   flowControl: "none",
-  receiveReplay: resolveReceiveReplayOptions(),
   terminalBuffer: resolveTerminalBufferOptions(),
   lineBuffer: resolveLineBufferOptions()
 };
@@ -1585,7 +1386,8 @@ function resolveConnectionOptions(options) {
     flowControl: DEFAULT_SERIAL_SESSION_OPTIONS.flowControl,
     ...options
   };
-  const { baudRate, bufferSize } = merged;
+  const baudRate = merged.baudRate ?? DEFAULT_SERIAL_SESSION_OPTIONS.baudRate;
+  const bufferSize = merged.bufferSize ?? DEFAULT_SERIAL_SESSION_OPTIONS.bufferSize;
   if (!Number.isSafeInteger(baudRate) || baudRate <= 0) {
     throw new SerialError(
       SerialErrorCode.INVALID_CONNECTION_OPTIONS,
@@ -1598,15 +1400,25 @@ function resolveConnectionOptions(options) {
       }
     );
   }
+  if (!Number.isSafeInteger(bufferSize) || bufferSize <= 0) {
+    throw new SerialError(
+      SerialErrorCode.INVALID_CONNECTION_OPTIONS,
+      `Invalid bufferSize: ${bufferSize}. Must be a safe integer > 0.`,
+      void 0,
+      {
+        field: "bufferSize",
+        value: bufferSize,
+        constraint: "positive-safe-integer"
+      }
+    );
+  }
   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
-    )
+    bufferSize: brandSerialPortBufferSize(bufferSize)
   };
 }
 function resolveSerialSessionOptions(options) {
@@ -1615,7 +1427,6 @@ function resolveSerialSessionOptions(options) {
   return {
     ...connection,
     ...filters !== void 0 ? { filters } : {},
-    receiveReplay: resolveReceiveReplayOptions(options?.receiveReplay),
     terminalBuffer: resolveTerminalBufferOptions(options?.terminalBuffer),
     lineBuffer: resolveLineBufferOptions(options?.lineBuffer)
   };
@@ -1625,62 +1436,52 @@ function resolveSerialSessionOptions(options) {
 function createSerialSession(options) {
   const resolvedOptions = resolveSerialSessionOptions(options);
   const controller = createSessionRuntimeController(
-    createInitialRuntime(hasWebSerialSupport())
+    createInitialRuntime(isWebSerialSupported())
   );
-  const errorsSubject = new Subject3();
+  const errorsSubject = new Subject2();
   const sendQueue = createSendQueue();
   const textEncoder = new TextEncoder();
-  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 receivePipeline = createReceivePipeline({ resolvedOptions });
+  const { teardownPump, closePortSafely } = createPortTeardown({
+    receivePipeline
   });
-  const lifecycle = createSessionLifecycle({
+  const { reportError, createDisposedError } = createSessionErrorReporter({
     controller,
-    resolvedOptions,
-    sendQueue,
-    receivePipeline,
-    portInfoSubject,
     errorsSubject,
+    sendQueue,
     isDisposed,
-    reportError: (error, options2) => errorReporterRef.reportError(error, options2),
-    createDisposedError: () => errorReporterRef.createDisposedError()
+    teardownPump,
+    closePortSafely
   });
-  const { reportError, createDisposedError } = createSessionErrorReporter({
+  receivePipeline.bufferErrors$.subscribe(
+    (error) => reportError(error, { fallbackCode: error.code })
+  );
+  const lifecycle = createSessionLifecycle({
     controller,
-    errorsSubject,
+    resolvedOptions,
     sendQueue,
+    receivePipeline,
+    errorsSubject,
     isDisposed,
-    updatePortInfo: lifecycle.updatePortInfo,
-    teardownPump: lifecycle.teardownPump,
-    closePortSafely: lifecycle.closePortSafely
+    teardownPump,
+    closePortSafely,
+    reportError,
+    createDisposedError
   });
-  errorReporterRef.reportError = reportError;
-  errorReporterRef.createDisposedError = createDisposedError;
-  const { receive$, lines$, receiveReplay$ } = receivePipeline;
+  const { receive$, lines$ } = receivePipeline;
   const errors$ = errorsSubject.asObservable();
   const terminalText$ = createTerminalBuffer(
     receive$,
     resolvedOptions.terminalBuffer
   ).text$;
-  const isConnected$ = controller.state$.pipe(
-    map2((state) => state.status === SerialSessionStatus.Connected),
-    distinctUntilChanged()
-  );
-  const portInfo$ = portInfoSubject.asObservable();
   return {
-    isBrowserSupported() {
-      return hasWebSerialSupport();
-    },
     connect$: lifecycle.connect$,
     disconnect$: lifecycle.disconnect$,
     dispose$: lifecycle.dispose$,
-    destroy$: lifecycle.dispose$,
     send$(data) {
       if (isDisposed()) {
-        return new Observable5((subscriber) => {
+        return new Observable4((subscriber) => {
           subscriber.error(createDisposedError());
         });
       }
@@ -1697,15 +1498,9 @@ function createSerialSession(options) {
       });
     },
     state$: controller.state$,
-    isConnected$,
-    portInfo$,
-    getPortInfo() {
-      return portInfoSubject.getValue();
-    },
     errors$,
     receive$,
     terminalText$,
-    receiveReplay$,
     lines$
   };
 }
@@ -1717,8 +1512,6 @@ function isConnectedSessionState(state) {
 export {
   DEFAULT_LINE_BUFFER_OPTIONS,
   DEFAULT_TERMINAL_BUFFER_OPTIONS,
-  MAX_RECEIVE_REPLAY_BUFFER_SIZE,
-  MAX_RECEIVE_REPLAY_MAX_CHARS,
   SerialError,
   SerialErrorCode,
   SerialSessionStatus,
@@ -1726,6 +1519,7 @@ export {
   createSerialSession,
   createTerminalBuffer,
   isConnectedSessionState,
+  isWebSerialSupported,
   resolveSerialSessionOptions
 };
 //# sourceMappingURL=index.mjs.map