Method writeAsync

src/push.ts:237–280

* Write chunks asynchronously. * - 'strict': Queues if buffer full but rejects if too many pending writes (>= highWaterMark) * - 'block': Waits for buffer space (unbounded pending writes) * - 'drop-*': Always succeeds (handled by writeSync) * * If signal is provided, a write blocked o

(chunks: Uint8Array[], signal?: AbortSignal)

   * is per-operation cancellation, not terminal failure.
   */
  async writeAsync(chunks: Uint8Array[], signal?: AbortSignal): Promise<void> {
    // Check for pre-aborted signal
    if (signal?.aborted) {
      throw signal.reason ?? new DOMException('Aborted', 'AbortError');
    }

    // Check if write is possible
    if (this.writerState !== 'open') {
      throw new TypeError('Writer is closed');
    }
    if (this.consumerState !== 'active') {
      throw this.consumerState === 'thrown' && this.error
        ? this.error
        : new TypeError('Stream closed by consumer');
    }

    // Try sync first
    if (this.writeSync(chunks)) {
      return;
    }

    // Buffer is full - handle based on policy
    switch (this.backpressure) {
      case 'strict':
        // In strict mode, highWaterMark limits pendingWrites (the "hose")
        // If too many writes are already pending, caller is ignoring backpressure
        if (this.pendingWrites.length >= this.highWaterMark) {
          throw new RangeError(
            'Backpressure violation: too many pending writes. ' +
            'Await each write() call to respect backpressure.'
          );
        }
        // Otherwise, queue this write and wait for space
        return this.createPendingWrite(chunks, signal);

      case 'block':
        // Wait for space (unbounded pending writes)
        return this.createPendingWrite(chunks, signal);

      default:
        // This shouldn't happen - writeSync handles drop-* policies
        throw new Error('Unexpected: writeSync should have handled non-strict policy');
    }
  }

  /**
   * Create a pending write promise, optionally racing against a signal.