@durable-streams/client 0.1.5 → 0.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@durable-streams/client",
   "description": "TypeScript client for the Durable Streams protocol",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "author": "Durable Stream contributors",
   "license": "Apache-2.0",
   "repository": {
@@ -47,7 +47,7 @@
   "devDependencies": {
     "fast-check": "^4.4.0",
     "tsdown": "^0.9.0",
-    "@durable-streams/server": "0.1.6"
+    "@durable-streams/server": "0.1.7"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/idempotent-producer.ts

@@ -76,12 +76,9 @@ function normalizeContentType(contentType: string | undefined): string {
 
 /**
  * Internal type for pending batch entries.
- * Stores original data for proper JSON batching.
  */
 interface PendingEntry {
-  /** Original data - parsed for JSON mode batching */
-  data: unknown
-  /** Encoded bytes for byte-stream mode */
+  /** Encoded bytes */
   body: Uint8Array
 }
 
@@ -173,18 +170,37 @@ export class IdempotentProducer {
     producerId: string,
     opts?: IdempotentProducerOptions
   ) {
+    // Validate inputs
+    const epoch = opts?.epoch ?? 0
+    const maxBatchBytes = opts?.maxBatchBytes ?? 1024 * 1024 // 1MB
+    const maxInFlight = opts?.maxInFlight ?? 5
+    const lingerMs = opts?.lingerMs ?? 5
+
+    if (epoch < 0) {
+      throw new Error(`epoch must be >= 0`)
+    }
+    if (maxBatchBytes <= 0) {
+      throw new Error(`maxBatchBytes must be > 0`)
+    }
+    if (maxInFlight <= 0) {
+      throw new Error(`maxInFlight must be > 0`)
+    }
+    if (lingerMs < 0) {
+      throw new Error(`lingerMs must be >= 0`)
+    }
+
     this.#stream = stream
     this.#producerId = producerId
-    this.#epoch = opts?.epoch ?? 0
+    this.#epoch = epoch
     this.#autoClaim = opts?.autoClaim ?? false
-    this.#maxBatchBytes = opts?.maxBatchBytes ?? 1024 * 1024 // 1MB
-    this.#lingerMs = opts?.lingerMs ?? 5
+    this.#maxBatchBytes = maxBatchBytes
+    this.#lingerMs = lingerMs
     this.#signal = opts?.signal
     this.#onError = opts?.onError
     this.#fetchClient =
       opts?.fetch ?? ((...args: Parameters<typeof fetch>) => fetch(...args))
 
-    this.#maxInFlight = opts?.maxInFlight ?? 5
+    this.#maxInFlight = maxInFlight
 
     // When autoClaim is true, epoch is not yet known until first batch completes
     // We block pipelining until then to avoid racing with the claim
@@ -224,12 +240,22 @@ export class IdempotentProducer {
    * Errors are reported via onError callback if configured. Use flush() to
    * wait for all pending messages to be sent.
    *
-   * For JSON streams, pass native objects (which will be serialized internally).
+   * For JSON streams, pass pre-serialized JSON strings.
    * For byte streams, pass string or Uint8Array.
    *
-   * @param body - Data to append (object for JSON streams, string or Uint8Array for byte streams)
+   * @param body - Data to append (string or Uint8Array)
+   *
+   * @example
+   * ```typescript
+   * // JSON stream
+   * producer.append(JSON.stringify({ message: "hello" }));
+   *
+   * // Byte stream
+   * producer.append("raw text data");
+   * producer.append(new Uint8Array([1, 2, 3]));
+   * ```
    */
-  append(body: Uint8Array | string | unknown): void {
+  append(body: Uint8Array | string): void {
     if (this.#closed) {
       throw new DurableStreamError(
         `Producer is closed`,
@@ -239,35 +265,21 @@ export class IdempotentProducer {
       )
     }
 
-    const isJson =
-      normalizeContentType(this.#stream.contentType) === `application/json`
-
     let bytes: Uint8Array
-    let data: unknown
-
-    if (isJson) {
-      // For JSON streams: accept native objects, serialize internally
-      const json = JSON.stringify(body)
-      bytes = new TextEncoder().encode(json)
-      data = body
+    if (typeof body === `string`) {
+      bytes = new TextEncoder().encode(body)
+    } else if (body instanceof Uint8Array) {
+      bytes = body
     } else {
-      // For byte streams, require string or Uint8Array
-      if (typeof body === `string`) {
-        bytes = new TextEncoder().encode(body)
-      } else if (body instanceof Uint8Array) {
-        bytes = body
-      } else {
-        throw new DurableStreamError(
-          `Non-JSON streams require string or Uint8Array`,
-          `BAD_REQUEST`,
-          400,
-          undefined
-        )
-      }
-      data = bytes
+      throw new DurableStreamError(
+        `append() requires string or Uint8Array. For objects, use JSON.stringify().`,
+        `BAD_REQUEST`,
+        400,
+        undefined
+      )
     }
 
-    this.#pendingBatch.push({ data, body: bytes })
+    this.#pendingBatch.push({ body: bytes })
     this.#batchBytes += bytes.length
 
     // Check if batch should be sent immediately
@@ -523,8 +535,9 @@ export class IdempotentProducer {
       // For JSON mode: always send as array (server flattens one level)
       // Single append: [value] → server stores value
       // Multiple appends: [val1, val2] → server stores val1, val2
-      const values = batch.map((e) => e.data)
-      batchedBody = JSON.stringify(values)
+      // Input is pre-serialized JSON strings, join them into an array
+      const jsonStrings = batch.map((e) => new TextDecoder().decode(e.body))
+      batchedBody = `[${jsonStrings.join(`,`)}]`
     } else {
       // For byte mode: concatenate all chunks
       const totalSize = batch.reduce((sum, e) => sum + e.body.length, 0)

package/src/response.ts

@@ -96,9 +96,9 @@ export class StreamResponseImpl<
   #isLoading: boolean
 
   // --- Evolving state ---
-  offset: Offset
-  cursor?: string
-  upToDate: boolean
+  #offset: Offset
+  #cursor?: string
+  #upToDate: boolean
 
   // --- Internal state ---
   #isJsonMode: boolean
@@ -133,9 +133,9 @@ export class StreamResponseImpl<
     this.contentType = config.contentType
     this.live = config.live
     this.startOffset = config.startOffset
-    this.offset = config.initialOffset
-    this.cursor = config.initialCursor
-    this.upToDate = config.initialUpToDate
+    this.#offset = config.initialOffset
+    this.#cursor = config.initialCursor
+    this.#upToDate = config.initialUpToDate
 
     // Initialize response metadata from first response
     this.#headers = config.firstResponse.headers
@@ -284,6 +284,20 @@ export class StreamResponseImpl<
     return this.#isLoading
   }
 
+  // --- Evolving state getters ---
+
+  get offset(): Offset {
+    return this.#offset
+  }
+
+  get cursor(): string | undefined {
+    return this.#cursor
+  }
+
+  get upToDate(): boolean {
+    return this.#upToDate
+  }
+
   // =================================
   // Internal helpers
   // =================================
@@ -340,10 +354,10 @@ export class StreamResponseImpl<
   #updateStateFromResponse(response: Response): void {
     // Update stream-specific state
     const offset = response.headers.get(STREAM_OFFSET_HEADER)
-    if (offset) this.offset = offset
+    if (offset) this.#offset = offset
     const cursor = response.headers.get(STREAM_CURSOR_HEADER)
-    if (cursor) this.cursor = cursor
-    this.upToDate = response.headers.has(STREAM_UP_TO_DATE_HEADER)
+    if (cursor) this.#cursor = cursor
+    this.#upToDate = response.headers.has(STREAM_UP_TO_DATE_HEADER)
 
     // Update response metadata to reflect latest server response
     this.#headers = response.headers
@@ -400,12 +414,12 @@ export class StreamResponseImpl<
    * Update instance state from an SSE control event.
    */
   #updateStateFromSSEControl(controlEvent: SSEControlEvent): void {
-    this.offset = controlEvent.streamNextOffset
+    this.#offset = controlEvent.streamNextOffset
     if (controlEvent.streamCursor) {
-      this.cursor = controlEvent.streamCursor
+      this.#cursor = controlEvent.streamCursor
     }
     if (controlEvent.upToDate !== undefined) {
-      this.upToDate = controlEvent.upToDate
+      this.#upToDate = controlEvent.upToDate
     }
   }
 
@@ -887,7 +901,17 @@ export class StreamResponseImpl<
         // Get response text first (handles empty responses gracefully)
         const text = await result.value.text()
         const content = text.trim() || `[]` // Default to empty array if no content or whitespace
-        const parsed = JSON.parse(content) as T | Array<T>
+        let parsed: T | Array<T>
+        try {
+          parsed = JSON.parse(content) as T | Array<T>
+        } catch (err) {
+          const preview =
+            content.length > 100 ? content.slice(0, 100) + `...` : content
+          throw new DurableStreamError(
+            `Failed to parse JSON response: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`,
+            `PARSE_ERROR`
+          )
+        }
         if (Array.isArray(parsed)) {
           items.push(...parsed)
         } else {
@@ -1021,7 +1045,17 @@ export class StreamResponseImpl<
         // Parse JSON and flatten arrays (handle empty responses gracefully)
         const text = await response.text()
         const content = text.trim() || `[]` // Default to empty array if no content or whitespace
-        const parsed = JSON.parse(content) as TJson | Array<TJson>
+        let parsed: TJson | Array<TJson>
+        try {
+          parsed = JSON.parse(content) as TJson | Array<TJson>
+        } catch (err) {
+          const preview =
+            content.length > 100 ? content.slice(0, 100) + `...` : content
+          throw new DurableStreamError(
+            `Failed to parse JSON response: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`,
+            `PARSE_ERROR`
+          )
+        }
         pendingItems = Array.isArray(parsed) ? parsed : [parsed]
 
         // Enqueue first item
@@ -1065,7 +1099,7 @@ export class StreamResponseImpl<
   // =====================
 
   subscribeJson<T = TJson>(
-    subscriber: (batch: JsonBatch<T>) => Promise<void>
+    subscriber: (batch: JsonBatch<T>) => void | Promise<void>
   ): () => void {
     this.#ensureNoConsumption(`subscribeJson`)
     this.#ensureJsonMode()
@@ -1086,9 +1120,20 @@ export class StreamResponseImpl<
           // Get response text first (handles empty responses gracefully)
           const text = await response.text()
           const content = text.trim() || `[]` // Default to empty array if no content or whitespace
-          const parsed = JSON.parse(content) as T | Array<T>
+          let parsed: T | Array<T>
+          try {
+            parsed = JSON.parse(content) as T | Array<T>
+          } catch (err) {
+            const preview =
+              content.length > 100 ? content.slice(0, 100) + `...` : content
+            throw new DurableStreamError(
+              `Failed to parse JSON response: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`,
+              `PARSE_ERROR`
+            )
+          }
           const items = Array.isArray(parsed) ? parsed : [parsed]
 
+          // Await callback (handles both sync and async)
           await subscriber({
             items,
             offset,
@@ -1121,7 +1166,9 @@ export class StreamResponseImpl<
     }
   }
 
-  subscribeBytes(subscriber: (chunk: ByteChunk) => Promise<void>): () => void {
+  subscribeBytes(
+    subscriber: (chunk: ByteChunk) => void | Promise<void>
+  ): () => void {
     this.#ensureNoConsumption(`subscribeBytes`)
     const abortController = new AbortController()
     const reader = this.#getResponseReader()
@@ -1139,6 +1186,7 @@ export class StreamResponseImpl<
 
           const buffer = await response.arrayBuffer()
 
+          // Await callback (handles both sync and async)
           await subscriber({
             data: new Uint8Array(buffer),
             offset,
@@ -1171,7 +1219,9 @@ export class StreamResponseImpl<
     }
   }
 
-  subscribeText(subscriber: (chunk: TextChunk) => Promise<void>): () => void {
+  subscribeText(
+    subscriber: (chunk: TextChunk) => void | Promise<void>
+  ): () => void {
     this.#ensureNoConsumption(`subscribeText`)
     const abortController = new AbortController()
     const reader = this.#getResponseReader()
@@ -1189,6 +1239,7 @@ export class StreamResponseImpl<
 
           const text = await response.text()
 
+          // Await callback (handles both sync and async)
           await subscriber({
             text,
             offset,

package/src/sse.ts

@@ -6,6 +6,7 @@
  * - `event: control` events contain `streamNextOffset` and optional `streamCursor` and `upToDate`
  */
 
+import { DurableStreamError } from "./error"
 import type { Offset } from "./types"
 
 /**
@@ -79,10 +80,17 @@ export async function* parseSSEStream(
                   streamCursor: control.streamCursor,
                   upToDate: control.upToDate,
                 }
-              } catch {
-                // Invalid control event, skip
+              } catch (err) {
+                // Control events contain critical offset data - don't silently ignore
+                const preview =
+                  dataStr.length > 100 ? dataStr.slice(0, 100) + `...` : dataStr
+                throw new DurableStreamError(
+                  `Failed to parse SSE control event: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`,
+                  `PARSE_ERROR`
+                )
               }
             }
+            // Unknown event types are silently skipped per protocol
           }
           currentEvent = { data: [] }
         } else if (line.startsWith(`event:`)) {
@@ -122,8 +130,13 @@ export async function* parseSSEStream(
             streamCursor: control.streamCursor,
             upToDate: control.upToDate,
           }
-        } catch {
-          // Invalid control event, skip
+        } catch (err) {
+          const preview =
+            dataStr.length > 100 ? dataStr.slice(0, 100) + `...` : dataStr
+          throw new DurableStreamError(
+            `Failed to parse SSE control event: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`,
+            `PARSE_ERROR`
+          )
         }
       }
     }

package/src/stream-api.ts

@@ -14,7 +14,12 @@ import {
 import { DurableStreamError, FetchBackoffAbortError } from "./error"
 import { BackoffDefaults, createFetchWithBackoff } from "./fetch"
 import { StreamResponseImpl } from "./response"
-import { handleErrorResponse, resolveHeaders, resolveParams } from "./utils"
+import {
+  handleErrorResponse,
+  resolveHeaders,
+  resolveParams,
+  warnIfUsingHttpInBrowser,
+} from "./utils"
 import type { LiveMode, Offset, StreamOptions, StreamResponse } from "./types"
 
 /**
@@ -41,7 +46,7 @@ import type { LiveMode, Offset, StreamOptions, StreamResponse } from "./types"
  *   url,
  *   auth,
  *   offset: savedOffset,
- *   live: "auto",
+ *   live: true,
  * })
  * live.subscribeJson(async (batch) => {
  *   for (const item of batch.items) {
@@ -119,6 +124,9 @@ async function streamInternal<TJson = unknown>(
   // Normalize URL
   const url = options.url instanceof URL ? options.url.toString() : options.url
 
+  // Warn if using HTTP in browser (can cause connection limit issues)
+  warnIfUsingHttpInBrowser(url, options.warnOnHttp)
+
   // Build the first request
   const fetchUrl = new URL(url)
 
@@ -127,7 +135,8 @@ async function streamInternal<TJson = unknown>(
   fetchUrl.searchParams.set(OFFSET_QUERY_PARAM, startOffset)
 
   // Set live query param for explicit modes
-  const live: LiveMode = options.live ?? `auto`
+  // true means auto-select (no query param, handled by consumption method)
+  const live: LiveMode = options.live ?? true
   if (live === `long-poll` || live === `sse`) {
     fetchUrl.searchParams.set(LIVE_QUERY_PARAM, live)
   }
@@ -197,15 +206,13 @@ async function streamInternal<TJson = unknown>(
     const nextUrl = new URL(url)
     nextUrl.searchParams.set(OFFSET_QUERY_PARAM, offset)
 
-    // For subsequent requests in auto mode, use long-poll
-    // BUT: if we're resuming from a paused state, don't set live mode
-    // to avoid a long-poll that holds for 20sec - we want an immediate response
-    // so the UI can show "connected" status quickly
+    // For subsequent requests, set live mode unless resuming from pause
+    // (resuming from pause needs immediate response for UI status)
     if (!resumingFromPause) {
-      if (live === `auto` || live === `long-poll`) {
-        nextUrl.searchParams.set(LIVE_QUERY_PARAM, `long-poll`)
-      } else if (live === `sse`) {
+      if (live === `sse`) {
         nextUrl.searchParams.set(LIVE_QUERY_PARAM, `sse`)
+      } else if (live === true || live === `long-poll`) {
+        nextUrl.searchParams.set(LIVE_QUERY_PARAM, `long-poll`)
       }
     }
 

package/src/stream.ts

@@ -11,6 +11,7 @@ import {
   InvalidSignalError,
   MissingStreamUrlError,
 } from "./error"
+import { IdempotentProducer } from "./idempotent-producer"
 import {
   SSE_COMPATIBLE_CONTENT_TYPES,
   STREAM_EXPIRES_AT_HEADER,
@@ -37,6 +38,7 @@ import type {
   CreateOptions,
   HeadResult,
   HeadersRecord,
+  IdempotentProducerOptions,
   MaybePromise,
   ParamsRecord,
   StreamErrorHandler,
@@ -49,7 +51,7 @@ import type {
  * Queued message for batching.
  */
 interface QueuedMessage {
-  data: unknown
+  data: Uint8Array | string
   seq?: string
   contentType?: string
   signal?: AbortSignal
@@ -71,10 +73,7 @@ function normalizeContentType(contentType: string | undefined): string {
  */
 function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
   return (
-    value !== null &&
-    typeof value === `object` &&
-    `then` in value &&
-    typeof (value as PromiseLike<unknown>).then === `function`
+    value != null && typeof (value as PromiseLike<unknown>).then === `function`
   )
 }
 
@@ -121,7 +120,7 @@ export interface DurableStreamOptions extends StreamHandleOptions {
  * });
  *
  * // Write data
- * await stream.append({ message: "hello" });
+ * await stream.append(JSON.stringify({ message: "hello" }));
  *
  * // Read with the new API
  * const res = await stream.stream<{ message: string }>();
@@ -350,23 +349,27 @@ export class DurableStream {
    * a POST is in-flight will be batched together into a single request.
    * This significantly improves throughput for high-frequency writes.
    *
-   * - `body` may be Uint8Array, string, or any JSON-serializable value (for JSON streams).
-   * - `body` may also be a Promise that resolves to any of the above types.
+   * - `body` must be string or Uint8Array.
+   * - For JSON streams, pass pre-serialized JSON strings.
+   * - `body` may also be a Promise that resolves to string or Uint8Array.
    * - Strings are encoded as UTF-8.
    * - `seq` (if provided) is sent as stream-seq (writer coordination).
    *
    * @example
    * ```typescript
-   * // Direct value
-   * await stream.append({ message: "hello" });
+   * // JSON stream - pass pre-serialized JSON
+   * await stream.append(JSON.stringify({ message: "hello" }));
+   *
+   * // Byte stream
+   * await stream.append("raw text data");
+   * await stream.append(new Uint8Array([1, 2, 3]));
    *
    * // Promise value - awaited before buffering
    * await stream.append(fetchData());
-   * await stream.append(Promise.all([a, b, c]));
    * ```
    */
   async append(
-    body: BodyInit | Uint8Array | string | unknown,
+    body: Uint8Array | string | Promise<Uint8Array | string>,
     opts?: AppendOptions
   ): Promise<void> {
     // Await promises before buffering
@@ -382,7 +385,7 @@ export class DurableStream {
    * Direct append without batching (used when batching is disabled).
    */
   async #appendDirect(
-    body: BodyInit | Uint8Array | string | unknown,
+    body: Uint8Array | string,
     opts?: AppendOptions
   ): Promise<void> {
     const { requestHeaders, fetchUrl } = await this.#buildRequest()
@@ -398,9 +401,11 @@ export class DurableStream {
     }
 
     // For JSON mode, wrap body in array to match protocol (server flattens one level)
+    // Input is pre-serialized JSON string
     const isJson = normalizeContentType(contentType) === `application/json`
-    const bodyToEncode = isJson ? [body] : body
-    const encodedBody = encodeBody(bodyToEncode)
+    const bodyStr =
+      typeof body === `string` ? body : new TextDecoder().decode(body)
+    const encodedBody: BodyInit = isJson ? `[${bodyStr}]` : bodyStr
 
     const response = await this.#fetchClient(fetchUrl.toString(), {
       method: `POST`,
@@ -418,7 +423,7 @@ export class DurableStream {
    * Append with batching - buffers messages and sends them in batches.
    */
   async #appendWithBatching(
-    body: unknown,
+    body: Uint8Array | string,
     opts?: AppendOptions
   ): Promise<void> {
     return new Promise<void>((resolve, reject) => {
@@ -511,29 +516,17 @@ export class DurableStream {
       // For JSON mode: always send as array (server flattens one level)
       // Single append: [value] → server stores value
       // Multiple appends: [val1, val2] → server stores val1, val2
-      const values = batch.map((m) => m.data)
-      batchedBody = JSON.stringify(values)
+      // Input is pre-serialized JSON strings, join them into an array
+      const jsonStrings = batch.map((m) =>
+        typeof m.data === `string` ? m.data : new TextDecoder().decode(m.data)
+      )
+      batchedBody = `[${jsonStrings.join(`,`)}]`
     } else {
-      // For byte mode: concatenate all chunks
-      const totalSize = batch.reduce((sum, m) => {
-        const size =
-          typeof m.data === `string`
-            ? new TextEncoder().encode(m.data).length
-            : (m.data as Uint8Array).length
-        return sum + size
-      }, 0)
-
-      const concatenated = new Uint8Array(totalSize)
-      let offset = 0
-      for (const msg of batch) {
-        const bytes =
-          typeof msg.data === `string`
-            ? new TextEncoder().encode(msg.data)
-            : (msg.data as Uint8Array)
-        concatenated.set(bytes, offset)
-        offset += bytes.length
-      }
-      batchedBody = concatenated
+      // For byte mode: concatenate all chunks as a string
+      const strings = batch.map((m) =>
+        typeof m.data === `string` ? m.data : new TextDecoder().decode(m.data)
+      )
+      batchedBody = strings.join(``)
     }
 
     // Combine signals: stream-level signal + any per-message signals
@@ -634,6 +627,11 @@ export class DurableStream {
    * Returns a WritableStream that can be used with `pipeTo()` or
    * `pipeThrough()` from any ReadableStream source.
    *
+   * Uses IdempotentProducer internally for:
+   * - Automatic batching (controlled by lingerMs, maxBatchBytes)
+   * - Exactly-once delivery semantics
+   * - Streaming writes (doesn't buffer entire content in memory)
+   *
    * @example
    * ```typescript
    * // Pipe from fetch response
@@ -643,32 +641,55 @@ export class DurableStream {
    * // Pipe through a transform
    * const readable = someStream.pipeThrough(new TextEncoderStream());
    * await readable.pipeTo(stream.writable());
+   *
+   * // With custom producer options
+   * await source.pipeTo(stream.writable({
+   *   producerId: "my-producer",
+   *   lingerMs: 10,
+   *   maxBatchBytes: 64 * 1024,
+   * }));
    * ```
    */
-  writable(opts?: AppendOptions): WritableStream<Uint8Array | string> {
-    const chunks: Array<Uint8Array | string> = []
-    const stream = this
+  writable(
+    opts?: Pick<
+      IdempotentProducerOptions,
+      `lingerMs` | `maxBatchBytes` | `onError`
+    > & {
+      producerId?: string
+      signal?: AbortSignal
+    }
+  ): WritableStream<Uint8Array | string> {
+    // Generate a random producer ID if not provided
+    const producerId =
+      opts?.producerId ?? `writable-${crypto.randomUUID().slice(0, 8)}`
+
+    // Track async errors to surface in close() so pipeTo() rejects on failure
+    let writeError: Error | null = null
+
+    const producer = new IdempotentProducer(this, producerId, {
+      autoClaim: true, // Ephemeral producer, auto-claim epoch
+      lingerMs: opts?.lingerMs,
+      maxBatchBytes: opts?.maxBatchBytes,
+      onError: (error) => {
+        if (!writeError) writeError = error // Capture first error
+        opts?.onError?.(error) // Still call user's handler
+      },
+      signal: opts?.signal ?? this.#options.signal,
+    })
 
     return new WritableStream<Uint8Array | string>({
       write(chunk) {
-        chunks.push(chunk)
+        producer.append(chunk)
       },
       async close() {
-        if (chunks.length > 0) {
-          // Create a ReadableStream from collected chunks
-          const readable = new ReadableStream<Uint8Array | string>({
-            start(controller) {
-              for (const chunk of chunks) {
-                controller.enqueue(chunk)
-              }
-              controller.close()
-            },
-          })
-          await stream.appendStream(readable, opts)
-        }
+        await producer.flush()
+        await producer.close()
+        if (writeError) throw writeError // Causes pipeTo() to reject
       },
-      abort(reason) {
-        console.error(`WritableStream aborted:`, reason)
+      abort(_reason) {
+        producer.close().catch((err) => {
+          opts?.onError?.(err) // Report instead of swallowing
+        })
       },
     })
   }