Retain the established getter name for API compatibility.

Retain the established getter name for API compatibility.

Encodes ordered name/value fields and returns an owned byte slice.

Fields are emitted in the supplied order and duplicate names are preserved. Callers must place every pseudo-header before regular fields. Use the HTTP::Headers overload when the encoder should perform that reordering.

Encodes ordered fields with optional per-field overrides.

Encodes headers and returns an owned byte slice.

Pseudo-headers are emitted before regular headers regardless of their insertion order. The returned bytes remain valid after later calls.

The _writer argument is retained for compatibility. New code that owns its output buffer should use #encode_into. When _writer is given, the returned slice is always a fresh copy: it never aliases _writer's own buffer, so mutating one afterward cannot affect the other.

Encodes ordered tuple fields using a per-field policy block.

Fields remain in supplied order. The block receives normalized names and may return FieldOptions overrides.

Encodes ordered fields with explicit options and a policy block.

Each HeaderField option takes precedence over the corresponding callback option, which takes precedence over the per-call value.

Encodes headers using a policy evaluated once per field in wire order.

The block receives the normalized name and value and may return FieldOptions overrides. A nil return retains the per-call values.

The block must not call back into #encode/#encode_into on this same encoder (that raises Error), and must not mutate headers itself: pseudo-headers and regular headers are each walked in a separate pass over the same HTTP::Headers, so a mutation made from the block during the first pass would be observed by the second.

encoder.encode(headers, huffman: HPack::HuffmanMode::SMALLER) do |name, _|
  if name == "authorization"
    HPack::FieldOptions.new(indexing: HPack::Indexing::NEVER)
  end
end

Encodes decoded fields while preserving each field's indexing marker.

Only Huffman behavior may be overridden; in particular, Indexing::NEVER cannot be downgraded while forwarding.

Appends one encoded block for ordered name/value fields to output.

Existing output is not cleared, duplicate names are preserved, and fields are emitted in the supplied order. Callers must place every pseudo-header before regular fields.

The block is encoded into an internal buffer first, so a failure during encoding leaves output untouched. The completed block is then copied to output in a single write call; whether that call itself can partially deliver bytes before raising depends on output's own semantics, not on the encoder.

Appends ordered fields with optional per-field overrides to output.

The block is encoded into an internal buffer first, so a failure during encoding leaves output untouched. The completed block is then copied to output in a single write call; whether that call itself can partially deliver bytes before raising depends on output's own semantics, not on the encoder.

Appends one encoded block for headers to output.

Existing output is not cleared. Pseudo-headers are emitted before regular headers regardless of insertion order.

The block is encoded into an internal buffer first, so a failure during encoding leaves output untouched. The completed block is then copied to output in a single write call; whether that call itself can partially deliver bytes before raising depends on output's own semantics, not on the encoder.

Appends policy-driven ordered tuple fields to output.

The block is encoded into an internal buffer first, so a failure during encoding leaves output untouched. The completed block is then copied to output in a single write call; whether that call itself can partially deliver bytes before raising depends on output's own semantics, not on the encoder.

Appends ordered fields using explicit options and a policy block.

The block is encoded into an internal buffer first, so a failure during encoding leaves output untouched. The completed block is then copied to output in a single write call; whether that call itself can partially deliver bytes before raising depends on output's own semantics, not on the encoder.

Appends a policy-driven encoded block for headers to output.

Existing output is not cleared. The policy is evaluated once per field after name normalization and pseudo-header ordering.

As with the policy-block #encode(headers) overload, the block must not call back into this same encoder and must not mutate headers (pseudo-headers and regular headers are walked in two separate passes over it).

The block is encoded into an internal buffer first, so a failure during encoding leaves output untouched. The completed block is then copied to output in a single write call; whether that call itself can partially deliver bytes before raising depends on output's own semantics, not on the encoder.

Appends decoded fields while preserving every indexing marker.

The block is encoded into an internal buffer first, so a failure during encoding leaves output untouched. The completed block is then copied to output in a single write call; whether that call itself can partially deliver bytes before raising depends on output's own semantics, not on the encoder.

Changes the dynamic-table capacity and queues the corresponding HPACK size update for the beginning of the next encoded field block.

The local table is resized immediately. Multiple changes before a block are coalesced to the smallest requested size followed by the final size. Pending updates are consumed only after a field block is encoded successfully.

Use this operation for negotiated capacity changes. Calling #table.resize directly does not signal the peer decoder.