@orkestrel/sse 0.0.1

package/dist/src/core/index.d.cts

@@ -0,0 +1,250 @@
+/**
+ * The byte-order mark (`U+FEFF`), stripped from the very first chunk of an SSE
+ * stream (a leading BOM on later chunks is ordinary content). Spelled as a
+ * codepoint so the wire content is unambiguous in source.
+ */
+export declare const BOM: string;
+
+/**
+ * Create a Server-Sent-Events (SSE) stream parser - a stateful handle that turns
+ * string chunks into the complete events dispatched so far.
+ *
+ * @param options - See {@link SSEParserOptions}.
+ * @remarks
+ * `options.limit` caps the total buffered characters (un-consumed line buffer plus
+ * the in-progress event's field lengths); unset → unbounded, the default. Feed
+ * chunks to `parse(chunk)` as they arrive; each blank line DISPATCHES an event whose
+ * `data` is its `data:` fields joined by `\n` (plus the last `event:` / `id:` /
+ * `retry:`), and an in-progress event split across chunk boundaries is buffered until
+ * its blank line arrives (or `flush()` forces it out at end-of-stream). The `id` /
+ * `retry` getters expose the persisted last-event-id / reconnection time, which
+ * survive dispatch and only clear on `reset()`. Generic and event-free - no
+ * server / agent coupling; never throws on malformed input, only on a configured
+ * `limit` being exceeded (an {@link import('./errors.js').SSEError} with code
+ * `'OVERFLOW'`). Pair it with a `TextDecoder({ stream: true })` to also handle
+ * multi-byte UTF-8 characters split across byte reads.
+ *
+ * @returns A working {@link SSEParserInterface}
+ *
+ * @example
+ * ```ts
+ * import { createSSEParser, isSSEError } from '@src/core'
+ *
+ * const parser = createSSEParser({ limit: 1_000_000 })
+ * parser.parse('data: a\ndata: b\n\n') // [{ data: 'a\nb' }] - the two data lines joined
+ * parser.parse('event: ping\ndata: 1') // [] - buffered until its blank line
+ * parser.parse('\n\n')                  // [{ data: '1', event: 'ping' }]
+ * try {
+ * 	parser.parse('x'.repeat(2_000_000))
+ * } catch (error) {
+ * 	if (isSSEError(error) && error.code === 'OVERFLOW') parser.reset()
+ * }
+ * ```
+ */
+export declare function createSSEParser(options?: SSEParserOptions): SSEParserInterface;
+
+/**
+ * Narrow an unknown caught value to an {@link SSEError}.
+ *
+ * @param value - The value to test (typically a `catch` binding)
+ * @returns `true` when `value` is an {@link SSEError}
+ *
+ * @example
+ * ```ts
+ * import { isSSEError } from '@src/core'
+ *
+ * try {
+ * 	parser.parse(chunk)
+ * } catch (error) {
+ * 	if (isSSEError(error) && error.code === 'OVERFLOW') parser.reset()
+ * }
+ * ```
+ */
+export declare function isSSEError(value: unknown): value is SSEError;
+
+/**
+ * The NUL byte (`U+0000`). The SSE spec voids an `id:` field whose value contains
+ * it, so an `id` carrying a NUL is never surfaced. Spelled as a codepoint so the
+ * wire content is unambiguous in source.
+ */
+export declare const NUL: string;
+
+/**
+ * An error thrown by the SSE parser.
+ *
+ * @remarks
+ * Thrown for: a `parse(chunk)` call whose resulting buffered total (un-consumed
+ * line buffer + accumulated per-event field lengths + the incoming chunk) would
+ * exceed a configured {@link import('./types.js').SSEParserOptions.limit}
+ * (`OVERFLOW`). The parser's state is left UNCHANGED by the throwing call - the
+ * chunk is not appended - so a consumer may `reset()` and continue. `context`
+ * carries at least `{ limit, size }`: the configured limit and the size the
+ * buffer would have reached.
+ */
+export declare class SSEError extends Error {
+    readonly code: SSEErrorCode;
+    readonly context?: Readonly<Record<string, unknown>>;
+    constructor(code: SSEErrorCode, message: string, context?: Readonly<Record<string, unknown>>);
+}
+
+/**
+ * Machine-readable codes carried by an {@link import('./errors.js').SSEError}.
+ *
+ * @remarks
+ * `'OVERFLOW'` - a `parse(chunk)` call would push the buffered total over a
+ * configured {@link SSEParserOptions.limit}.
+ */
+export declare type SSEErrorCode = 'OVERFLOW';
+
+/**
+ * One dispatched Server-Sent Event - the value a blank line flushes from an
+ * {@link SSEParserInterface}.
+ *
+ * @remarks
+ * - `data` is the concatenation of every `data:` field in the event, joined by a
+ *   single `\n` (the SSE rule: `data: a` + `data: b` → `"a\nb"`), with NO trailing
+ *   newline. An event is dispatched only when its data buffer is non-empty, so `data`
+ *   is always a string (possibly empty when an explicit empty `data:` line was sent).
+ * - `event` is the last `event:` field seen before the blank line (the event type);
+ *   absent when no `event:` field appeared.
+ * - `id` is the last `id:` field seen (the last-event-id); absent when none appeared.
+ *   A spec NUL inside an `id` voids it, so it is never surfaced.
+ * - `retry` is the `retry:` reconnection time in milliseconds - present only when the
+ *   field's value was an integer (a non-integer `retry:` is ignored).
+ */
+export declare interface SSEEvent {
+    /** The event's concatenated data - each `data:` field joined by `\n`, no trailing newline. */
+    readonly data: string;
+    /** The event type - the last `event:` field's value, if any. */
+    readonly event?: string;
+    /** The last-event-id - the last `id:` field's value, if any. */
+    readonly id?: string;
+    /** The reconnection time in ms - the `retry:` field, present only when it was an integer. */
+    readonly retry?: number;
+}
+
+/**
+ * A stateful Server-Sent-Events (SSE) stream parser - feed it string chunks, get
+ * back the complete events dispatched so far.
+ *
+ * @remarks
+ * - **The wire format.** SSE is a UTF-8 text stream of events separated by a blank
+ *   line. Within an event each line is a `field: value` (one optional space after the
+ *   colon is stripped; a line with no colon is a field with an empty value; a line
+ *   STARTING with a colon is a comment and is ignored). The fields: `data` is appended
+ *   to the event's data buffer - MULTIPLE `data:` lines concatenate with `\n` between
+ *   them (`data: a` + `data: b` → `"a\nb"`), with no trailing newline; `event` sets the
+ *   event type (last wins); `id` sets the last-event-id (last wins; an `id` containing a
+ *   NUL is ignored per spec); `retry` sets the reconnection time in ms (integer only -
+ *   a non-integer is ignored). Unknown fields are ignored.
+ * - **Blank-line dispatch.** A blank line flushes the accumulated event: an
+ *   {@link SSEEvent} is emitted ONLY when the data buffer is non-empty (a dispatch with
+ *   an empty data buffer emits nothing - a comment-only or field-only "event" produces
+ *   no event), and the data buffer + event type reset for the next event afterwards.
+ *   `id` / `retry` ride on the emitted event for the consumer to track per-event - the
+ *   emitted event's shape is unchanged - AND are separately persisted as connection
+ *   state, exposed via the sticky `id` / `retry` getters (see below).
+ * - **Sticky connection state.** Each valid `id:` field updates a persisted
+ *   last-event-id, exposed via the `id` getter; each valid `retry:` field updates a
+ *   persisted reconnection time, exposed via the `retry` getter. Neither is cleared
+ *   when an event dispatches - only `reset()` clears them - matching WHATWG
+ *   last-event-id semantics. A NUL-voided `id` field does not alter the persisted
+ *   value.
+ * - **Cross-chunk reassembly.** `parse(chunk)` appends `chunk` to an internal buffer,
+ *   splits on the line terminator, processes every COMPLETE line, and retains the
+ *   trailing partial line (and any in-progress event) for the next call - so an event
+ *   split across chunk boundaries is reassembled once its blank line arrives. An
+ *   un-terminated final event stays buffered and is never emitted until its blank
+ *   line arrives - call `flush()` to force it out at end-of-stream instead.
+ * - **Line endings + BOM.** `\r\n`, `\r`, and `\n` are all valid terminators and are
+ *   normalized; a CRLF split across two chunks is held safely (a trailing `\r` is
+ *   retained, not flushed as a line, until its `\n` is known). A leading byte-order
+ *   mark on the first NON-EMPTY chunk is stripped (an empty `parse('')` call before
+ *   any content does not arm the BOM check).
+ * - **Bounded buffering.** Pass {@link SSEParserOptions.limit} to cap the total
+ *   buffered characters (un-consumed line buffer + in-progress event field lengths);
+ *   a `parse(chunk)` call that would exceed it throws an {@link SSEError} with code
+ *   `'OVERFLOW'` and leaves parser state unchanged - the chunk is not appended.
+ * - **Total + event-free.** A pure functional primitive - no Emitter, no events, no
+ *   server / HTTP / agent coupling. It never throws on malformed input (a bad `retry`
+ *   is ignored, not thrown) - it throws only an {@link SSEError} when a configured
+ *   `limit` is exceeded. Testable with plain strings. Pair it with a
+ *   `TextDecoder({ stream: true })` when reading a byte stream so multi-byte UTF-8
+ *   characters split across reads are handled (the decoder handles partial CHARS, this
+ *   parser handles partial LINES + events).
+ *
+ * @example
+ * ```ts
+ * const parser = new SSEParser({ limit: 1_000_000 })
+ * parser.parse('data: a\ndata: b\n\n') // [{ data: 'a\nb' }] - the two data lines joined
+ * parser.parse('event: ping\ndata: 1') // [] - the event is buffered until its blank line
+ * parser.parse('\n\n')                  // [{ data: '1', event: 'ping' }]
+ * parser.id                             // undefined - no `id:` field has been seen
+ * ```
+ */
+export declare class SSEParser implements SSEParserInterface {
+    #private;
+    constructor(options?: SSEParserOptions);
+    get id(): string | undefined;
+    get retry(): number | undefined;
+    parse(chunk: string): readonly SSEEvent[];
+    flush(): SSEEvent[];
+    reset(): void;
+}
+
+/**
+ * A stateful Server-Sent-Events (SSE) stream parser: feed it string chunks, get
+ * back the complete events dispatched so far. A trailing partial line / in-progress
+ * event is buffered until the rest arrives.
+ */
+export declare interface SSEParserInterface {
+    /**
+     * Append `chunk`, then return every event a blank line has DISPATCHED (its `data:`
+     * fields concatenated with `\n`, plus the last `event:` / `id:` / `retry:`); an
+     * in-progress event and a trailing partial line are retained for the next call.
+     *
+     * @throws {@link import('./errors.js').SSEError} with code `'OVERFLOW'` when a
+         * configured `limit` would be exceeded - the parser's state is left unchanged.
+         */
+     parse(chunk: string): readonly SSEEvent[];
+     /**
+      * Treat any remaining buffered partial line as if it had been terminated, then
+      * dispatch the in-progress event if its data buffer is non-empty. A convenience
+      * beyond the WHATWG algorithm, which discards an unterminated final event at EOF
+      * - without calling `flush()`, that spec-faithful discard is this parser's
+      * default behavior.
+      *
+      * @returns The dispatched event as a single-element array, or `[]` when there was
+      * nothing to dispatch.
+      */
+     flush(): SSEEvent[];
+     /** The persisted last-event-id (WHATWG last-event-id): set by each valid `id:`
+      * field and NOT cleared when an event dispatches; `undefined` until the first
+      * valid `id:` field arrives, or after `reset()`. */
+     readonly id: string | undefined;
+     /** The last valid `retry:` reconnection time seen, in ms; `undefined` until the
+      * first valid `retry:` field arrives, or after `reset()`. */
+     readonly retry: number | undefined;
+     /** Drop any buffered partial line, in-progress event, and persisted id/retry -
+      * reset for a fresh stream. */
+     reset(): void;
+    }
+
+    /**
+     * Options for {@link import('./factories.js').createSSEParser} / the
+     * {@link import('./SSEParser.js').SSEParser} constructor.
+     *
+     * @remarks
+     * `limit` - the maximum total buffered characters the parser will hold at once (the
+     * un-consumed line buffer plus the in-progress event's accumulated field lengths -
+     * data segments + event type + pending id). Unset → unbounded, the default and
+     * existing behavior: the parser then never throws. When set, a `parse(chunk)` call
+     * that would push the buffered total over `limit` throws an
+     * {@link import('./errors.js').SSEError} with code `'OVERFLOW'` instead of appending
+     * the chunk.
+     */
+    export declare interface SSEParserOptions {
+        readonly limit?: number;
+    }
+
+    export { }

package/dist/src/core/index.d.ts

@@ -0,0 +1,250 @@
+/**
+ * The byte-order mark (`U+FEFF`), stripped from the very first chunk of an SSE
+ * stream (a leading BOM on later chunks is ordinary content). Spelled as a
+ * codepoint so the wire content is unambiguous in source.
+ */
+export declare const BOM: string;
+
+/**
+ * Create a Server-Sent-Events (SSE) stream parser - a stateful handle that turns
+ * string chunks into the complete events dispatched so far.
+ *
+ * @param options - See {@link SSEParserOptions}.
+ * @remarks
+ * `options.limit` caps the total buffered characters (un-consumed line buffer plus
+ * the in-progress event's field lengths); unset → unbounded, the default. Feed
+ * chunks to `parse(chunk)` as they arrive; each blank line DISPATCHES an event whose
+ * `data` is its `data:` fields joined by `\n` (plus the last `event:` / `id:` /
+ * `retry:`), and an in-progress event split across chunk boundaries is buffered until
+ * its blank line arrives (or `flush()` forces it out at end-of-stream). The `id` /
+ * `retry` getters expose the persisted last-event-id / reconnection time, which
+ * survive dispatch and only clear on `reset()`. Generic and event-free - no
+ * server / agent coupling; never throws on malformed input, only on a configured
+ * `limit` being exceeded (an {@link import('./errors.js').SSEError} with code
+ * `'OVERFLOW'`). Pair it with a `TextDecoder({ stream: true })` to also handle
+ * multi-byte UTF-8 characters split across byte reads.
+ *
+ * @returns A working {@link SSEParserInterface}
+ *
+ * @example
+ * ```ts
+ * import { createSSEParser, isSSEError } from '@src/core'
+ *
+ * const parser = createSSEParser({ limit: 1_000_000 })
+ * parser.parse('data: a\ndata: b\n\n') // [{ data: 'a\nb' }] - the two data lines joined
+ * parser.parse('event: ping\ndata: 1') // [] - buffered until its blank line
+ * parser.parse('\n\n')                  // [{ data: '1', event: 'ping' }]
+ * try {
+ * 	parser.parse('x'.repeat(2_000_000))
+ * } catch (error) {
+ * 	if (isSSEError(error) && error.code === 'OVERFLOW') parser.reset()
+ * }
+ * ```
+ */
+export declare function createSSEParser(options?: SSEParserOptions): SSEParserInterface;
+
+/**
+ * Narrow an unknown caught value to an {@link SSEError}.
+ *
+ * @param value - The value to test (typically a `catch` binding)
+ * @returns `true` when `value` is an {@link SSEError}
+ *
+ * @example
+ * ```ts
+ * import { isSSEError } from '@src/core'
+ *
+ * try {
+ * 	parser.parse(chunk)
+ * } catch (error) {
+ * 	if (isSSEError(error) && error.code === 'OVERFLOW') parser.reset()
+ * }
+ * ```
+ */
+export declare function isSSEError(value: unknown): value is SSEError;
+
+/**
+ * The NUL byte (`U+0000`). The SSE spec voids an `id:` field whose value contains
+ * it, so an `id` carrying a NUL is never surfaced. Spelled as a codepoint so the
+ * wire content is unambiguous in source.
+ */
+export declare const NUL: string;
+
+/**
+ * An error thrown by the SSE parser.
+ *
+ * @remarks
+ * Thrown for: a `parse(chunk)` call whose resulting buffered total (un-consumed
+ * line buffer + accumulated per-event field lengths + the incoming chunk) would
+ * exceed a configured {@link import('./types.js').SSEParserOptions.limit}
+ * (`OVERFLOW`). The parser's state is left UNCHANGED by the throwing call - the
+ * chunk is not appended - so a consumer may `reset()` and continue. `context`
+ * carries at least `{ limit, size }`: the configured limit and the size the
+ * buffer would have reached.
+ */
+export declare class SSEError extends Error {
+    readonly code: SSEErrorCode;
+    readonly context?: Readonly<Record<string, unknown>>;
+    constructor(code: SSEErrorCode, message: string, context?: Readonly<Record<string, unknown>>);
+}
+
+/**
+ * Machine-readable codes carried by an {@link import('./errors.js').SSEError}.
+ *
+ * @remarks
+ * `'OVERFLOW'` - a `parse(chunk)` call would push the buffered total over a
+ * configured {@link SSEParserOptions.limit}.
+ */
+export declare type SSEErrorCode = 'OVERFLOW';
+
+/**
+ * One dispatched Server-Sent Event - the value a blank line flushes from an
+ * {@link SSEParserInterface}.
+ *
+ * @remarks
+ * - `data` is the concatenation of every `data:` field in the event, joined by a
+ *   single `\n` (the SSE rule: `data: a` + `data: b` → `"a\nb"`), with NO trailing
+ *   newline. An event is dispatched only when its data buffer is non-empty, so `data`
+ *   is always a string (possibly empty when an explicit empty `data:` line was sent).
+ * - `event` is the last `event:` field seen before the blank line (the event type);
+ *   absent when no `event:` field appeared.
+ * - `id` is the last `id:` field seen (the last-event-id); absent when none appeared.
+ *   A spec NUL inside an `id` voids it, so it is never surfaced.
+ * - `retry` is the `retry:` reconnection time in milliseconds - present only when the
+ *   field's value was an integer (a non-integer `retry:` is ignored).
+ */
+export declare interface SSEEvent {
+    /** The event's concatenated data - each `data:` field joined by `\n`, no trailing newline. */
+    readonly data: string;
+    /** The event type - the last `event:` field's value, if any. */
+    readonly event?: string;
+    /** The last-event-id - the last `id:` field's value, if any. */
+    readonly id?: string;
+    /** The reconnection time in ms - the `retry:` field, present only when it was an integer. */
+    readonly retry?: number;
+}
+
+/**
+ * A stateful Server-Sent-Events (SSE) stream parser - feed it string chunks, get
+ * back the complete events dispatched so far.
+ *
+ * @remarks
+ * - **The wire format.** SSE is a UTF-8 text stream of events separated by a blank
+ *   line. Within an event each line is a `field: value` (one optional space after the
+ *   colon is stripped; a line with no colon is a field with an empty value; a line
+ *   STARTING with a colon is a comment and is ignored). The fields: `data` is appended
+ *   to the event's data buffer - MULTIPLE `data:` lines concatenate with `\n` between
+ *   them (`data: a` + `data: b` → `"a\nb"`), with no trailing newline; `event` sets the
+ *   event type (last wins); `id` sets the last-event-id (last wins; an `id` containing a
+ *   NUL is ignored per spec); `retry` sets the reconnection time in ms (integer only -
+ *   a non-integer is ignored). Unknown fields are ignored.
+ * - **Blank-line dispatch.** A blank line flushes the accumulated event: an
+ *   {@link SSEEvent} is emitted ONLY when the data buffer is non-empty (a dispatch with
+ *   an empty data buffer emits nothing - a comment-only or field-only "event" produces
+ *   no event), and the data buffer + event type reset for the next event afterwards.
+ *   `id` / `retry` ride on the emitted event for the consumer to track per-event - the
+ *   emitted event's shape is unchanged - AND are separately persisted as connection
+ *   state, exposed via the sticky `id` / `retry` getters (see below).
+ * - **Sticky connection state.** Each valid `id:` field updates a persisted
+ *   last-event-id, exposed via the `id` getter; each valid `retry:` field updates a
+ *   persisted reconnection time, exposed via the `retry` getter. Neither is cleared
+ *   when an event dispatches - only `reset()` clears them - matching WHATWG
+ *   last-event-id semantics. A NUL-voided `id` field does not alter the persisted
+ *   value.
+ * - **Cross-chunk reassembly.** `parse(chunk)` appends `chunk` to an internal buffer,
+ *   splits on the line terminator, processes every COMPLETE line, and retains the
+ *   trailing partial line (and any in-progress event) for the next call - so an event
+ *   split across chunk boundaries is reassembled once its blank line arrives. An
+ *   un-terminated final event stays buffered and is never emitted until its blank
+ *   line arrives - call `flush()` to force it out at end-of-stream instead.
+ * - **Line endings + BOM.** `\r\n`, `\r`, and `\n` are all valid terminators and are
+ *   normalized; a CRLF split across two chunks is held safely (a trailing `\r` is
+ *   retained, not flushed as a line, until its `\n` is known). A leading byte-order
+ *   mark on the first NON-EMPTY chunk is stripped (an empty `parse('')` call before
+ *   any content does not arm the BOM check).
+ * - **Bounded buffering.** Pass {@link SSEParserOptions.limit} to cap the total
+ *   buffered characters (un-consumed line buffer + in-progress event field lengths);
+ *   a `parse(chunk)` call that would exceed it throws an {@link SSEError} with code
+ *   `'OVERFLOW'` and leaves parser state unchanged - the chunk is not appended.
+ * - **Total + event-free.** A pure functional primitive - no Emitter, no events, no
+ *   server / HTTP / agent coupling. It never throws on malformed input (a bad `retry`
+ *   is ignored, not thrown) - it throws only an {@link SSEError} when a configured
+ *   `limit` is exceeded. Testable with plain strings. Pair it with a
+ *   `TextDecoder({ stream: true })` when reading a byte stream so multi-byte UTF-8
+ *   characters split across reads are handled (the decoder handles partial CHARS, this
+ *   parser handles partial LINES + events).
+ *
+ * @example
+ * ```ts
+ * const parser = new SSEParser({ limit: 1_000_000 })
+ * parser.parse('data: a\ndata: b\n\n') // [{ data: 'a\nb' }] - the two data lines joined
+ * parser.parse('event: ping\ndata: 1') // [] - the event is buffered until its blank line
+ * parser.parse('\n\n')                  // [{ data: '1', event: 'ping' }]
+ * parser.id                             // undefined - no `id:` field has been seen
+ * ```
+ */
+export declare class SSEParser implements SSEParserInterface {
+    #private;
+    constructor(options?: SSEParserOptions);
+    get id(): string | undefined;
+    get retry(): number | undefined;
+    parse(chunk: string): readonly SSEEvent[];
+    flush(): SSEEvent[];
+    reset(): void;
+}
+
+/**
+ * A stateful Server-Sent-Events (SSE) stream parser: feed it string chunks, get
+ * back the complete events dispatched so far. A trailing partial line / in-progress
+ * event is buffered until the rest arrives.
+ */
+export declare interface SSEParserInterface {
+    /**
+     * Append `chunk`, then return every event a blank line has DISPATCHED (its `data:`
+     * fields concatenated with `\n`, plus the last `event:` / `id:` / `retry:`); an
+     * in-progress event and a trailing partial line are retained for the next call.
+     *
+     * @throws {@link import('./errors.js').SSEError} with code `'OVERFLOW'` when a
+         * configured `limit` would be exceeded - the parser's state is left unchanged.
+         */
+     parse(chunk: string): readonly SSEEvent[];
+     /**
+      * Treat any remaining buffered partial line as if it had been terminated, then
+      * dispatch the in-progress event if its data buffer is non-empty. A convenience
+      * beyond the WHATWG algorithm, which discards an unterminated final event at EOF
+      * - without calling `flush()`, that spec-faithful discard is this parser's
+      * default behavior.
+      *
+      * @returns The dispatched event as a single-element array, or `[]` when there was
+      * nothing to dispatch.
+      */
+     flush(): SSEEvent[];
+     /** The persisted last-event-id (WHATWG last-event-id): set by each valid `id:`
+      * field and NOT cleared when an event dispatches; `undefined` until the first
+      * valid `id:` field arrives, or after `reset()`. */
+     readonly id: string | undefined;
+     /** The last valid `retry:` reconnection time seen, in ms; `undefined` until the
+      * first valid `retry:` field arrives, or after `reset()`. */
+     readonly retry: number | undefined;
+     /** Drop any buffered partial line, in-progress event, and persisted id/retry -
+      * reset for a fresh stream. */
+     reset(): void;
+    }
+
+    /**
+     * Options for {@link import('./factories.js').createSSEParser} / the
+     * {@link import('./SSEParser.js').SSEParser} constructor.
+     *
+     * @remarks
+     * `limit` - the maximum total buffered characters the parser will hold at once (the
+     * un-consumed line buffer plus the in-progress event's accumulated field lengths -
+     * data segments + event type + pending id). Unset → unbounded, the default and
+     * existing behavior: the parser then never throws. When set, a `parse(chunk)` call
+     * that would push the buffered total over `limit` throws an
+     * {@link import('./errors.js').SSEError} with code `'OVERFLOW'` instead of appending
+     * the chunk.
+     */
+    export declare interface SSEParserOptions {
+        readonly limit?: number;
+    }
+
+    export { }