Function configureOutbound

lib/internal/quic/quic.js:1328–1403

(handle, stream, body)

const kDefaultMaxPendingDatagrams = 128;

function configureOutbound(handle, stream, body) {
  // body: null - close writable side immediately (FIN)
  if (body === null) {
    handle.initStreamingSource();
    handle.endWrite();
    return;
  }

  // Handle Promise - await and recurse. Native promises auto-flatten,
  // so the resolved value will never itself be a promise.
  if (isPromise(body)) {
    PromisePrototypeThen(
      body,
      (resolved) => configureOutbound(handle, stream, resolved),
      (err) => {
        if (!stream.destroyed) {
          stream.destroy(err);
        }
      },
    );
    return;
  }

  // Tier: One-shot - string (checked before sync iterable since
  // strings are iterable but we want the one-shot path).
  // Buffer.from may return a pooled buffer whose ArrayBuffer cannot
  // be transferred, so run it through validateBody which copies when
  // the buffer is a partial view of a larger ArrayBuffer.
  if (typeof body === 'string') {
    handle.attachSource(validateBody(Buffer.from(body, 'utf8')));
    return;
  }

  // Tier: One-shot - FileHandle. The C++ layer creates an fd-backed
  // DataQueue entry from the file path. The FileHandle is locked to
  // prevent concurrent use and closed automatically when the stream
  // finishes.
  if (FileHandle.isFileHandle(body)) {
    if (body[kFileLocked]) {
      throw new ERR_INVALID_STATE('FileHandle is locked');
    }
    body[kFileLocked] = true;
    handle.attachSource(body[kFileHandle]);
    return;
  }

  // Tier: One-shot - ArrayBuffer, SharedArrayBuffer, TypedArray,
  // DataView, Blob. validateBody handles transfer-vs-copy logic,
  // SharedArrayBuffer copying, and partial view safety.
  if (isArrayBuffer(body) || isSharedArrayBuffer(body) ||
      isArrayBufferView(body) || isBlob(body)) {
    handle.attachSource(validateBody(body));
    return;
  }

  // Tier: Streaming - AsyncIterable (ReadableStream, stream.Readable,
  // async generators, etc.). Checked before sync iterable because some
  // objects implement both protocols and we prefer async.