SSE parser byte-level optimization, chunked decoding, auto-reconnect

[Copilot]

Implements the four iOS-specific optimizations discussed in the issue: reducing ARC/CPU overhead in the SSE parser, handling proxied chunked streams, seamless reconnection on network switches, and thread-safety documentation.

SSEParser: byte-level accumulation

• lineBuffer changed from String to Data; line-ending scan uses raw bytes (0x0A/0x0D)
• Field names compared as [UInt8] arrays — no String allocation per line
• String(data:encoding:.utf8) deferred to event dispatch boundary (\n\n)

ChunkedDecoder (new)

• Incremental state-machine that strips Transfer-Encoding: chunked framing before SSE parsing
• Handles partial chunks split across TCP segments, chunk extensions, hex size variants
• Integrated via enableChunkedDecoding() on NWAsyncSocket

SSE auto-reconnect with Last-Event-ID

• enableSSEAutoReconnect(retryInterval:) — on error disconnect, schedules reconnect preserving lastEventId
• Honors server-sent retry: field for backoff interval
• Delegate callback socket(_:willAutoReconnectWithLastEventId:afterDelay:) lets the app re-send the HTTP request with Last-Event-ID header
• Explicit disconnect() cancels auto-reconnect

Thread safety docs

• Documented socketQueue / delegateQueue separation in class-level and method-level doc comments (behavior was already correct)

let socket = NWAsyncSocket(delegate: self, delegateQueue: .main)
socket.enableSSEParsing()
socket.enableChunkedDecoding()        // behind Nginx/CDN
socket.enableSSEAutoReconnect()       // auto-retry with Last-Event-ID
try socket.connect(toHost: "api.example.com", onPort: 443)

87 tests pass (71 existing + 16 new ChunkedDecoder tests). All existing SSEParser/StreamBuffer/ReadRequest tests unchanged.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[Copilot]

Pull request overview

Adds iOS-focused streaming improvements to NWAsyncSocket: more efficient SSE parsing, support for HTTP Transfer-Encoding: chunked streams (common behind proxies/CDNs), and an SSE auto-reconnect mechanism that preserves Last-Event-ID, along with updated thread-safety documentation.

Changes:

• Refactors SSEParser to accumulate and scan at the byte level, deferring String conversion to event dispatch.
• Introduces ChunkedDecoder (and tests) and integrates it into the socket read path via enableChunkedDecoding().
• Adds SSE auto-reconnect state + delegate callback socket(_:willAutoReconnectWithLastEventId:afterDelay:) and documents queueing/threading behavior.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 6 comments.

Show a summary per file

File	Description
Sources/NWAsyncSocket/SSEParser.swift	Switches SSE parsing to byte-level buffering and field matching to reduce allocations.
Sources/NWAsyncSocket/ChunkedDecoder.swift	New incremental decoder to strip HTTP chunked framing before higher-level parsing.
Sources/NWAsyncSocket/NWAsyncSocket.swift	Wires chunked decoding into the read loop; adds auto-reconnect state machine and thread-safety docs.
Sources/NWAsyncSocket/NWAsyncSocketDelegate.swift	Adds an optional delegate callback for auto-reconnect with last event ID and delay.
Tests/NWAsyncSocketTests/ChunkedDecoderTests.swift	Adds unit tests covering chunk parsing across segment boundaries, extensions, and SSE payloads.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

decode(_:) always appends incoming bytes to buffer, even after the decoder reaches .complete. Since the .complete state breaks the loop without consuming or clearing buffer, any subsequent data (e.g., trailers after the 0-sized chunk, or accidental extra bytes) will be retained indefinitely and can grow memory unbounded. Consider short-circuiting when state == .complete (don’t append / immediately return empty) and/or clearing buffer when transitioning to .complete after the final chunk/trailers are consumed.

[Copilot]

In .readingTrailer, if the next two bytes are not \r\n, the code still transitions back to .waitingForSize without consuming anything. This can cause the next size-line parse to include invalid trailer bytes and desynchronize the state machine. Consider strictly requiring \r\n (wait for more data if partial, otherwise treat as malformed input by resetting/marking complete/adding an error path) before moving back to .waitingForSize.

Suggested change

	// Skip the trailing CRLF.
	if buffer[buffer.startIndex] == 0x0D
	&& buffer[buffer.index(after: buffer.startIndex)] == 0x0A {
	buffer = Data(buffer.suffix(from: buffer.startIndex + 2))
	}
	let first = buffer[buffer.startIndex]
	let second = buffer[buffer.index(after: buffer.startIndex)]
	// Require a proper CRLF trailer; otherwise treat as malformed input.
	guard first == 0x0D, second == 0x0A else {
	state = .complete
	break loop
	}
	// Skip the trailing CRLF.
	buffer = Data(buffer.suffix(from: buffer.startIndex + 2))

[Copilot]

disconnectInternal resets buffer and (in the non-auto-reconnect path) resets the sseParser, but it never resets chunkedDecoder. If a disconnect happens mid-chunk, the decoder may carry buffered partial state into the next connection on the same NWAsyncSocket instance, corrupting subsequent reads/SSE parsing. Consider resetting (or recreating) chunkedDecoder during disconnect when chunked decoding is enabled.

[Copilot]

Auto-reconnect is gated on error != nil (shouldAutoReconnect = ... && error != nil). However, readNextChunk() calls disconnectInternal(error: nil) when isComplete == true (EOF), which is also an unexpected disconnect scenario for SSE streams. If the goal is to recover from network switches / remote closes, consider triggering auto-reconnect on EOF/cancelled states as well (e.g., treat isComplete as an auto-reconnect-eligible disconnect, unless the user explicitly called disconnect()).

Suggested change

	let shouldAutoReconnect = sseAutoReconnectEnabled && sseParser != nil && error != nil
	let shouldAutoReconnect = sseAutoReconnectEnabled && sseParser != nil

[Copilot]

The byte-level parser still copies data for every extracted line (let lineData = Data(lineBuffer[start..<...])) and also copies the remaining buffer when trimming consumed bytes (lineBuffer = Data(lineBuffer.suffix(...))). For high-throughput SSE, this can add significant allocation/copy overhead and partially undermines the intended optimization. Consider operating on Data.SubSequence/indices (or a ring buffer) to avoid per-line copies, and only materialize Data/String at dispatch time.

[Copilot]

Test name testByteByteFeed looks like a typo and reads ambiguously. Renaming to something like testByteByByteFeed (or similar) would improve clarity when scanning test output and failure reports.

Suggested change

	func testByteByteFeed() {
	func testByteByByteFeed() {