Method writer

lib/internal/quic/quic.js:2116–2367

* Returns a Writer for pushing data to this stream incrementally. * Only available when no body source was provided at creation time * or via setBody(). Non-writable streams return an already-closed Writer. * @type {object}

()

   * @type {object}
   */
  get writer() {
    assertIsQuicStream(this);
    const inner = this.#inner;
    if (inner.writer !== undefined) return inner.writer;
    if (inner.outboundSet) {
      throw new ERR_INVALID_STATE(
        'Stream outbound already configured with a body source');
    }

    const handle = this.#handle;
    const stream = this;
    let closed = false;
    let errored = false;
    let error = null;
    let totalBytesWritten = 0;
    let drainWakeup = null;

    // Drain callback - C++ fires this when send buffer has space
    stream[kDrain] = () => {
      if (drainWakeup) {
        drainWakeup.resolve(true);
        drainWakeup = null;
      }
    };

    // A note on backpressure handling: per the stream/iter spec, the default
    // backpressure policy for writers is strict, meaning that if the stream
    // signals backpressure additional writes are rejected until the buffer has
    // capacity again.

    function writeSync(chunk) {
      // If the stream is closed, errored, or write-ended, we cannot accept
      // more data. Refuse the sync write.
      // If a drain is already pending, another operation is waiting
      // for capacity. Refuse the sync write.
      if (closed || errored || stream.#inner.state.writeEnded || drainWakeup != null) {
        return false;
      }
      chunk = toUint8Array(chunk);
      const len = TypedArrayPrototypeGetByteLength(chunk);
      if (len === 0) return true;
      // Refuse the write only when there is no available capacity at
      // all. When writeDesiredSize > 0 we allow the write even if the
      // chunk is larger than the remaining capacity -- the C++ side
      // will accept the data into the DataQueue and
      // UpdateWriteDesiredSize() will drop writeDesiredSize toward 0,
      // at which point the standard drain mechanism takes over.
      // This follows the Web Streams model where writes beyond the HWM
      // succeed and backpressure applies to *subsequent* writes.
      if (stream.#inner.state.writeDesiredSize === 0) return false;
      const result = handle.write([chunk]);
      if (result === undefined) return false;
      totalBytesWritten += len;
      return true;
    }

    async function write(chunk, options = kEmptyObject) {
      validateObject(options, 'options');