feat: replace ?offset= seek with HTTP Range streaming across API, proxy, and client

- API: enableRangeProcessing true on no-offset FileStream path
- Proxy: transparent Range relay, forwards 206/416/Content-Range verbatim
- TrackMediaClient: Range: bytes=X- replaces ?offset=X; response disposed via TrackMediaResponse
- StreamDecoder: reinitializeForRangeContinuation retains wavHeader, counts raw PCM against 206 Content-Length
- AudioPlayer: seekBeyondBuffer adds headerSize for file-absolute offset; duration guard prevents continuation overwriting full-track duration
- StreamingAudioPlayerService: seek guard corrected to >= 0 (file-absolute offset contract)

DeepDrftPublic/Interop/audio/StreamDecoder.ts

@@ -60,6 +60,14 @@ export class StreamDecoder {
     private streamComplete: boolean = false;
     private headerError: string | null = null;
 
+    // Range-continuation state. After a seek-beyond-buffer the server responds 206
+    // with raw PCM from a file-absolute offset (no WAV header). We retain the header
+    // parsed from the initial stream and treat the whole body as audio data. The
+    // stream-complete check then counts raw bytes against the 206 Content-Length
+    // (remainingByteLength) rather than the full-file totalStreamLength + headerSize.
+    private isContinuation: boolean = false;
+    private remainingByteLength: number = 0;
+
     // Pre-header accumulator. WAV headers can span multiple network chunks
     // (small first segment, extended LIST/INFO/JUNK chunks before 'data', etc.),
     // so we buffer raw bytes here until parseHeader succeeds rather than assuming
@@ -84,6 +92,8 @@ export class StreamDecoder {
         this.headerBytesReceived = 0;
         this.headerSearchChunks = [];
         this.headerError = null;
+        this.isContinuation = false;
+        this.remainingByteLength = 0;
     }
 
     /**
@@ -183,6 +193,16 @@ export class StreamDecoder {
      * otherwise pre-header bytes count toward the total.
      */
     private updateStreamCompleteFlag(): void {
+        // Range-continuation: the 206 body is pure audio (no header), so compare raw
+        // audio bytes directly against the 206 Content-Length. Do NOT add headerSize —
+        // there is no header in this response.
+        if (this.isContinuation) {
+            if (this.remainingByteLength > 0 && this.totalRawBytes >= this.remainingByteLength) {
+                this.streamComplete = true;
+            }
+            return;
+        }
+
         if (this.totalStreamLength <= 0) return;
         const totalReceived = this.wavHeader
             ? this.totalRawBytes + this.wavHeader.headerSize
@@ -445,23 +465,34 @@ export class StreamDecoder {
         this.headerBytesReceived = 0;
         this.headerSearchChunks = [];
         this.headerError = null;
+        this.isContinuation = false;
+        this.remainingByteLength = 0;
     }
 
     /**
-     * Reinitialize for offset streaming - preserves header format knowledge
-     * Called when seeking beyond buffer to prepare for new stream from server
+     * Reinitialize for a Range-continuation stream after seek-beyond-buffer.
+     *
+     * The server responds to a Range request with 206 Partial Content carrying raw
+     * PCM from a file-absolute offset — there is NO WAV header in this body. We retain
+     * the header parsed from the initial stream (its format describes every segment we
+     * synthesise via createWavFile) and feed the entire 206 body straight into the
+     * decode pipeline. The `if (!this.wavHeader)` branch in processChunk therefore goes
+     * directly to addRawData and tryParseHeader is never re-entered.
+     *
+     * @param remainingByteLength the Content-Length of the 206 response — the number of
+     *   bytes from the range start to EOF, NOT the full file size. Stream-complete is
+     *   reached when totalRawBytes >= this value.
      */
-    reinitializeForOffset(totalStreamLength: number): void {
-        // Reset data state but we'll get a fresh header from the offset stream
+    reinitializeForRangeContinuation(remainingByteLength: number): void {
+        // Retain this.wavHeader — the 206 body carries no header to reparse.
         this.rawChunks = [];
         this.totalRawBytes = 0;
         this.processedBytes = 0;
-        this.totalStreamLength = totalStreamLength;
         this.streamComplete = false;
         this.headerBytesReceived = 0;
         this.headerSearchChunks = [];
         this.headerError = null;
-        // wavHeader will be reparsed from the new stream (server sends fresh header)
-        this.wavHeader = null;
+        this.isContinuation = true;
+        this.remainingByteLength = remainingByteLength;
     }
 }