@gurezo/web-serial-rxjs 2.3.6 → 3.0.0

package/README.ja.md

@@ -27,7 +27,7 @@ Web Serial API は**デスクトップ**ブラウザでのみサポートされ
 
 ## 受信の replay（`receive$` と `receiveReplay$`）
 
-`receive$` は **non-replay** のままです。購読後に届くチャンクだけが見えます。接続ごとに直近 *N* 件のデコード済みテキスト**チャンク**（read pump の 1 回の `onChunk` あたり 1 件。文字数ではありません）を遅延購読者にも渡したい場合は、`createSerialSession` に `receiveReplay: { enabled: true, bufferSize: 512 }` を指定し、`receiveReplay$` を購読します。`bufferSize` を大きくするとメモリ負荷が増えます。receive replay が **無効**（既定）のとき、`receiveReplay$` は `receive$` と同じ hot ストリームです。`lines$` の行分割に replay は付きません。生チャンクの `receiveReplay$` のみが対象です。
+`receive$` は **non-replay** のままです。購読後に届くチャンクだけが見えます。接続ごとに直近 *N* 件のデコード済みテキスト**チャンク**（read pump の 1 回の `onChunk` あたり 1 件。文字数ではありません）を遅延購読者にも渡したい場合は、`createSerialSession` に `receiveReplay: { enabled: true, bufferSize: 512 }` を指定し、`receiveReplay$` を購読します。`bufferSize` は 1〜65536 の正の safe integer である必要があります。任意の `maxChars` で保持チャンク全体の文字数上限を指定でき、超過時は古いチャンクから破棄し non-fatal の `RECEIVE_REPLAY_BUFFER_OVERFLOW` を `errors$` に emit します。`bufferSize` やチャンクサイズを大きくするとメモリ負荷が増えます。receive replay が **無効**（既定）のとき、`receiveReplay$` は `receive$` と同じ hot ストリームです。`lines$` の行分割に replay は付きません。生チャンクの `receiveReplay$` のみが対象です。
 
 ## `receive$` と `lines$`
 

package/README.md

@@ -27,7 +27,7 @@ After a successful `connect$`, use `getPortInfo()` or subscribe to `portInfo$` f
 
 ## Receive replay (`receive$` vs `receiveReplay$`)
 
-`receive$` is **non-replay**: late subscribers only see chunks emitted after they subscribe. To retain the last *N* decoded text **chunks** per open connection (same bytes as `receive$`, e.g. for boot logs), pass `receiveReplay: { enabled: true, bufferSize: 512 }` to `createSerialSession` and subscribe to `receiveReplay$`. Larger `bufferSize` uses more memory. When receive replay is **off** (default), `receiveReplay$` is the same hot stream as `receive$`. This option does not add replay to `lines$`—only raw decoder chunks on `receiveReplay$`.
+`receive$` is **non-replay**: late subscribers only see chunks emitted after they subscribe. To retain the last *N* decoded text **chunks** per open connection (same bytes as `receive$`, e.g. for boot logs), pass `receiveReplay: { enabled: true, bufferSize: 512 }` to `createSerialSession` and subscribe to `receiveReplay$`. `bufferSize` must be a positive safe integer up to 65536. Optional `maxChars` bounds total buffered characters by discarding oldest chunks (non-fatal `RECEIVE_REPLAY_BUFFER_OVERFLOW` on `errors$`). Larger `bufferSize` or chunk sizes use more memory. When receive replay is **off** (default), `receiveReplay$` is the same hot stream as `receive$`. This option does not add replay to `lines$`—only raw decoder chunks on `receiveReplay$`.
 
 ## `receive$` vs `lines$`
 

package/dist/errors/serial-error-code.d.ts

@@ -24,7 +24,7 @@
  * }
  * ```
  */
-export declare enum SerialErrorCode {
+export declare const SerialErrorCode: {
     /**
      * Browser does not support the Web Serial API.
      *
@@ -34,7 +34,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Inform the user to use a supported browser.
      */
-    BROWSER_NOT_SUPPORTED = "BROWSER_NOT_SUPPORTED",
+    readonly BROWSER_NOT_SUPPORTED: "BROWSER_NOT_SUPPORTED";
     /**
      * Serial port is not available.
      *
@@ -44,7 +44,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Check if the port is available or being used by another application.
      */
-    PORT_NOT_AVAILABLE = "PORT_NOT_AVAILABLE",
+    readonly PORT_NOT_AVAILABLE: "PORT_NOT_AVAILABLE";
     /**
      * Failed to open the serial port.
      *
@@ -53,7 +53,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Verify connection parameters and check hardware connections.
      */
-    PORT_OPEN_FAILED = "PORT_OPEN_FAILED",
+    readonly PORT_OPEN_FAILED: "PORT_OPEN_FAILED";
     /**
      * Serial port is already open.
      *
@@ -62,7 +62,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Disconnect the current port before connecting a new one.
      */
-    PORT_ALREADY_OPEN = "PORT_ALREADY_OPEN",
+    readonly PORT_ALREADY_OPEN: "PORT_ALREADY_OPEN";
     /**
      * Serial port is not open.
      *
@@ -71,7 +71,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Call {@link SerialClient.connect} before reading or writing.
      */
-    PORT_NOT_OPEN = "PORT_NOT_OPEN",
+    readonly PORT_NOT_OPEN: "PORT_NOT_OPEN";
     /**
      * Failed to read from the serial port.
      *
@@ -80,7 +80,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Check the connection and hardware, then retry the read operation.
      */
-    READ_FAILED = "READ_FAILED",
+    readonly READ_FAILED: "READ_FAILED";
     /**
      * Failed to write to the serial port.
      *
@@ -89,7 +89,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Check the connection and hardware, then retry the write operation.
      */
-    WRITE_FAILED = "WRITE_FAILED",
+    readonly WRITE_FAILED: "WRITE_FAILED";
     /**
      * Serial port connection was lost.
      *
@@ -99,7 +99,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Check the physical connection and reconnect if needed.
      */
-    CONNECTION_LOST = "CONNECTION_LOST",
+    readonly CONNECTION_LOST: "CONNECTION_LOST";
     /**
      * Invalid filter options provided.
      *
@@ -108,7 +108,7 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Verify filter options match the expected format and value ranges.
      */
-    INVALID_FILTER_OPTIONS = "INVALID_FILTER_OPTIONS",
+    readonly INVALID_FILTER_OPTIONS: "INVALID_FILTER_OPTIONS";
     /**
      * Operation was cancelled by the user.
      *
@@ -118,14 +118,87 @@ export declare enum SerialErrorCode {
      * **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",
+    readonly 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",
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly 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.
+     */
+    readonly SESSION_DISPOSED: "SESSION_DISPOSED";
     /**
      * Unknown error occurred.
      *
@@ -134,6 +207,11 @@ export declare enum SerialErrorCode {
      *
      * **Suggested action**: Check the error message and originalError for more details.
      */
-    UNKNOWN = "UNKNOWN"
-}
+    readonly UNKNOWN: "UNKNOWN";
+};
+/**
+ * String union of allowed {@link SerialErrorCode} runtime values
+ * (same set as the values on the {@link SerialErrorCode} object).
+ */
+export type SerialErrorCode = (typeof SerialErrorCode)[keyof typeof SerialErrorCode];
 //# sourceMappingURL=serial-error-code.d.ts.map

package/dist/errors/serial-error-code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serial-error-code.d.ts","sourceRoot":"","sources":["../../src/errors/serial-error-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,oBAAY,eAAe;IACzB;;;;;;;;OAQG;IACH,qBAAqB,0BAA0B;IAE/C;;;;;;;;OAQG;IACH,kBAAkB,uBAAuB;IAEzC;;;;;;;OAOG;IACH,gBAAgB,qBAAqB;IAErC;;;;;;;OAOG;IACH,iBAAiB,sBAAsB;IAEvC;;;;;;;OAOG;IACH,aAAa,kBAAkB;IAE/B;;;;;;;OAOG;IACH,WAAW,gBAAgB;IAE3B;;;;;;;OAOG;IACH,YAAY,iBAAiB;IAE7B;;;;;;;;OAQG;IACH,eAAe,oBAAoB;IAEnC;;;;;;;OAOG;IACH,sBAAsB,2BAA2B;IAEjD;;;;;;;;OAQG;IACH,mBAAmB,wBAAwB;IAE3C;;;;;OAKG;IACH,iBAAiB,sBAAsB;IAEvC;;;;;;;OAOG;IACH,OAAO,YAAY;CACpB"}
+{"version":3,"file":"serial-error-code.d.ts","sourceRoot":"","sources":["../../src/errors/serial-error-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;OAQG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;OAOG;;CAEK,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,eAAe,GACzB,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC"}

package/dist/errors/serial-error-context.d.ts

@@ -0,0 +1,47 @@
+import { SerialErrorCode } from './serial-error-code';
+/**
+ * Context payload for errors that wrap an underlying failure.
+ */
+export type SerialErrorCauseContext = {
+    readonly cause: unknown;
+};
+/**
+ * Maps each {@link SerialErrorCode} to its structured context shape.
+ *
+ * Codes mapped to `undefined` have no machine-readable metadata beyond
+ * {@link SerialError.message}. Overflow codes expose configured limits so
+ * callers do not need to parse error messages.
+ */
+export interface SerialErrorContextMap {
+    [SerialErrorCode.BROWSER_NOT_SUPPORTED]: undefined;
+    [SerialErrorCode.PORT_NOT_AVAILABLE]: SerialErrorCauseContext;
+    [SerialErrorCode.PORT_OPEN_FAILED]: SerialErrorCauseContext;
+    [SerialErrorCode.PORT_ALREADY_OPEN]: undefined;
+    [SerialErrorCode.PORT_NOT_OPEN]: undefined;
+    [SerialErrorCode.READ_FAILED]: SerialErrorCauseContext;
+    [SerialErrorCode.WRITE_FAILED]: SerialErrorCauseContext;
+    [SerialErrorCode.CONNECTION_LOST]: SerialErrorCauseContext;
+    [SerialErrorCode.INVALID_FILTER_OPTIONS]: undefined;
+    [SerialErrorCode.OPERATION_CANCELLED]: SerialErrorCauseContext;
+    [SerialErrorCode.OPERATION_TIMEOUT]: undefined;
+    [SerialErrorCode.LINE_BUFFER_OVERFLOW]: {
+        readonly maxChars: number;
+    };
+    [SerialErrorCode.INVALID_RECEIVE_REPLAY_OPTIONS]: undefined;
+    [SerialErrorCode.INVALID_TERMINAL_BUFFER_OPTIONS]: undefined;
+    [SerialErrorCode.INVALID_LINE_BUFFER_OPTIONS]: undefined;
+    [SerialErrorCode.INVALID_CONNECTION_OPTIONS]: undefined;
+    [SerialErrorCode.RECEIVE_REPLAY_BUFFER_OVERFLOW]: {
+        readonly maxChars: number;
+        readonly bufferSize: number;
+    };
+    [SerialErrorCode.SESSION_DISPOSED]: undefined;
+    [SerialErrorCode.UNKNOWN]: SerialErrorCauseContext;
+}
+/**
+ * @internal
+ */
+export declare function isCauseContextCode(code: SerialErrorCode): code is keyof {
+    [K in keyof SerialErrorContextMap as SerialErrorContextMap[K] extends SerialErrorCauseContext ? K : never]: SerialErrorContextMap[K];
+};
+//# sourceMappingURL=serial-error-context.d.ts.map

package/dist/errors/serial-error-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serial-error-context.d.ts","sourceRoot":"","sources":["../../src/errors/serial-error-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,CAAC,eAAe,CAAC,qBAAqB,CAAC,EAAE,SAAS,CAAC;IACnD,CAAC,eAAe,CAAC,kBAAkB,CAAC,EAAE,uBAAuB,CAAC;IAC9D,CAAC,eAAe,CAAC,gBAAgB,CAAC,EAAE,uBAAuB,CAAC;IAC5D,CAAC,eAAe,CAAC,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC/C,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC;IAC3C,CAAC,eAAe,CAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC;IACvD,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,uBAAuB,CAAC;IACxD,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE,uBAAuB,CAAC;IAC3D,CAAC,eAAe,CAAC,sBAAsB,CAAC,EAAE,SAAS,CAAC;IACpD,CAAC,eAAe,CAAC,mBAAmB,CAAC,EAAE,uBAAuB,CAAC;IAC/D,CAAC,eAAe,CAAC,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC/C,CAAC,eAAe,CAAC,oBAAoB,CAAC,EAAE;QACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,CAAC,eAAe,CAAC,8BAA8B,CAAC,EAAE,SAAS,CAAC;IAC5D,CAAC,eAAe,CAAC,+BAA+B,CAAC,EAAE,SAAS,CAAC;IAC7D,CAAC,eAAe,CAAC,2BAA2B,CAAC,EAAE,SAAS,CAAC;IACzD,CAAC,eAAe,CAAC,0BAA0B,CAAC,EAAE,SAAS,CAAC;IACxD,CAAC,eAAe,CAAC,8BAA8B,CAAC,EAAE;QAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;KAC7B,CAAC;IACF,CAAC,eAAe,CAAC,gBAAgB,CAAC,EAAE,SAAS,CAAC;IAC9C,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAC;CACpD;AAYD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,eAAe,GACpB,IAAI,IAAI,MAAM;KACd,CAAC,IAAI,MAAM,qBAAqB,IAAI,qBAAqB,CAAC,CAAC,CAAC,SAAS,uBAAuB,GACzF,CAAC,GACD,KAAK,GAAG,qBAAqB,CAAC,CAAC,CAAC;CACrC,CAEA"}

package/dist/errors/serial-error.d.ts

@@ -1,5 +1,7 @@
 import { SerialErrorCode } from './serial-error-code';
+import { type SerialErrorCauseContext, type SerialErrorContextMap } from './serial-error-context';
 export { SerialErrorCode };
+export type { SerialErrorCauseContext, SerialErrorContextMap };
 /**
  * Custom error class for serial port operations.
  *
@@ -19,6 +21,10 @@ export { SerialErrorCode };
  *       console.error(`Original error:`, error.originalError);
  *     }
  *
+ *     if (error.is(SerialErrorCode.LINE_BUFFER_OVERFLOW)) {
+ *       console.error(`maxChars: ${error.context.maxChars}`);
+ *     }
+ *
  *     // Check specific error code
  *     if (error.is(SerialErrorCode.BROWSER_NOT_SUPPORTED)) {
  *       // Handle browser not supported
@@ -27,7 +33,7 @@ export { SerialErrorCode };
  * }
  * ```
  */
-export declare class SerialError extends Error {
+export declare class SerialError<TCode extends SerialErrorCode = SerialErrorCode> extends Error {
     /**
      * The error code identifying the type of error that occurred.
      *
@@ -35,12 +41,23 @@ export declare class SerialError extends Error {
      *
      * @see {@link SerialErrorCode} for all available error codes
      */
-    readonly code: SerialErrorCode;
+    readonly code: TCode;
+    /**
+     * Structured metadata associated with {@link code}.
+     *
+     * When {@link is} returns `true`, TypeScript narrows this property to the
+     * context shape defined in {@link SerialErrorContextMap} for that code.
+     */
+    readonly context: SerialErrorContextMap[TCode];
     /**
      * The original error that caused this SerialError, if available.
      *
      * This property contains the underlying error (e.g., DOMException, TypeError)
      * that was wrapped in this SerialError. It may be undefined if no original error exists.
+     *
+     * @deprecated Prefer {@link context} for cause-bearing codes. This property is
+     *   retained for backward compatibility and is kept in sync when a cause is
+     *   provided.
      */
     readonly originalError?: Error;
     /**
@@ -49,24 +66,29 @@ export declare class SerialError extends Error {
      * @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: SerialErrorCode, message: string, originalError?: Error);
+    constructor(code: TCode, message: string, originalError?: Error, context?: SerialErrorContextMap[TCode]);
     /**
      * 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.
+     * 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 `true` if this error's code matches the provided code, `false` otherwise
+     * @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.PORT_NOT_OPEN)) {
-     *   // Handle port not open error
+     * if (error.is(SerialErrorCode.LINE_BUFFER_OVERFLOW)) {
+     *   // error.code and error.context.maxChars are narrowed
      * }
      * ```
      */
-    is(code: SerialErrorCode): boolean;
+    is<C extends SerialErrorCode>(code: C): this is SerialError<C>;
 }
 //# sourceMappingURL=serial-error.d.ts.map

package/dist/errors/serial-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serial-error.d.ts","sourceRoot":"","sources":["../../src/errors/serial-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC;;;;;;OAMG;IACH,SAAgB,IAAI,EAAE,eAAe,CAAC;IAEtC;;;;;OAKG;IACH,SAAgB,aAAa,CAAC,EAAE,KAAK,CAAC;IAEtC;;;;;;OAMG;gBACS,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,KAAK;IAczE;;;;;;;;;;;;;;;OAeG;IACI,EAAE,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO;CAG1C"}
+{"version":3,"file":"serial-error.d.ts","sourceRoot":"","sources":["../../src/errors/serial-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC3B,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,eAAe,EAAE,CAAC;AAC3B,YAAY,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,CAAC;AAY/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,WAAW,CACtB,KAAK,SAAS,eAAe,GAAG,eAAe,CAC/C,SAAQ,KAAK;IACb;;;;;;OAMG;IACH,SAAgB,IAAI,EAAE,KAAK,CAAC;IAE5B;;;;;OAKG;IACH,SAAgB,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAEtD;;;;;;;;;OASG;IACH,SAAgB,aAAa,CAAC,EAAE,KAAK,CAAC;IAEtC;;;;;;;;OAQG;gBAED,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,KAAK,EACrB,OAAO,CAAC,EAAE,qBAAqB,CAAC,KAAK,CAAC;IA0BxC;;;;;;;;;;;;;;;;;;OAkBG;IACI,EAAE,CAAC,CAAC,SAAS,eAAe,EACjC,IAAI,EAAE,CAAC,GACN,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC;CAG1B"}

package/dist/index.d.ts

@@ -15,10 +15,16 @@
  *
  * - {@link createSerialSession} - factory for a {@link SerialSession}
  * - {@link createTerminalBuffer} - terminal-style display text from {@link SerialSession.receive$}
+ * - {@link TerminalBufferOptions} - memory limits for terminal display text
+ * - {@link LineBufferOptions} - memory limits for lines$ incomplete line tail
  * - {@link SerialSession} - the runtime interface
  * - {@link SerialSessionOptions} - connection options
- * - {@link SerialSessionState} - `state$` payload values (const + type)
+ * - {@link SerialPayload} - payload accepted by {@link SerialSession.send$}
+ * - {@link SerialConnectionOptions} - `port.open` connection parameters (excluding filters)
+ * - {@link SerialSessionStatus} - lifecycle status literals for `state$.status`
+ * - {@link SerialSessionState} - discriminated union emitted by `state$`
  * - {@link SerialError} / {@link SerialErrorCode} - unified error surface
+ * - {@link SerialErrorContextMap} - structured metadata per error code
  *
  * ## Browser Support
  *
@@ -55,10 +61,12 @@
  * }
  * ```
  */
-export { createSerialSession, SerialSessionState } from './session';
-export type { SerialSession, SerialSessionOptions, SerialSessionReceiveReplayOptions, } from './session';
+export { assertNever } from './internal/assert-never';
+export { createSerialSession, SerialSessionStatus, DEFAULT_LINE_BUFFER_OPTIONS, resolveSerialSessionOptions, MAX_RECEIVE_REPLAY_BUFFER_SIZE, MAX_RECEIVE_REPLAY_MAX_CHARS } from './session';
+export type { SerialSession, SerialSessionState, IdleSessionState, ConnectingSessionState, ConnectedSessionState, DisconnectingSessionState, UnsupportedSessionState, ErrorSessionState, DisposedSessionState, SerialSessionOptions, SerialSessionReceiveReplayOptions, ResolvedSerialSessionOptions, SerialPayload, SerialConnectionOptions, LineBufferOptions, } from './session';
 export { SerialError } from './errors/serial-error';
+export type { SerialErrorCauseContext, SerialErrorContextMap } from './errors/serial-error';
 export { SerialErrorCode } from './errors/serial-error-code';
-export { createTerminalBuffer } from './terminal/create-terminal-buffer';
-export type { TerminalBuffer } from './terminal/create-terminal-buffer';
+export { createTerminalBuffer, DEFAULT_TERMINAL_BUFFER_OPTIONS } from './terminal/create-terminal-buffer';
+export type { TerminalBuffer, TerminalBufferOptions } from './terminal/create-terminal-buffer';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpE,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,iCAAiC,GAClC,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,YAAY,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,8BAA8B,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAC;AAC7L,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,iCAAiC,EACjC,4BAA4B,EAC5B,aAAa,EACb,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,YAAY,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC5F,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,oBAAoB,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AAC1G,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC"}