Commit 9f8486170c5a5dda56381098cf10ecf8c6364d9b | zig

author	Andrew Kelley <andrew@ziglang.org> 2025-06-26 13:09:08-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:30-07:00
log	9f8486170c5a5dda56381098cf10ecf8c6364d9b
tree	0e53d8f0eac7314e56733eb24162debf9a89547c
parent	d4545f216a6ea86caec208cabc724004b7ef320a

std.http compiling again

13 files changed, 290 insertions(+), 237 deletions(-)

lib
- std
  - Build.zig
  - Build
    Cache.zig
    Step
    Run.zig
  - Uri.zig
  - compress
    flate
    Decompress.zig
    zstd
    Decompress.zig
  - debug
    Dwarf.zig
  - http.zig
  - http
    Client.zig
    Server.zig
    test.zig
  - io
    Reader.zig
    Writer.zig

lib/std/Build.zig+1-1

...	@@ -2061,7 +2061,7 @@ pub fn runAllowFail(	...	@@ -2061,7 +2061,7 @@ pub fn runAllowFail(
2061	try child.spawn();	2061	try child.spawn();
2062		2062
2063	var file_reader = child.stdout.?.readerStreaming();	2063	var file_reader = child.stdout.?.readerStreaming();
2064	const stdout = try file_reader.interface().readRemainingAlloc(b.allocator, .limited(max_output_size));	2064	const stdout = try file_reader.interface().allocRemaining(b.allocator, .limited(max_output_size));
2065	errdefer b.allocator.free(stdout);	2065	errdefer b.allocator.free(stdout);
2066		2066
2067	const term = try child.wait();	2067	const term = try child.wait();

lib/std/Build/Cache.zig+1-1

...	@@ -663,7 +663,7 @@ pub const Manifest = struct {	...	@@ -663,7 +663,7 @@ pub const Manifest = struct {
663	const input_file_count = self.files.entries.len;	663	const input_file_count = self.files.entries.len;
664	var manifest_reader = self.manifest_file.?.reader(); // Reads positionally from zero.	664	var manifest_reader = self.manifest_file.?.reader(); // Reads positionally from zero.
665	const limit: std.io.Limit = .limited(manifest_file_size_max);	665	const limit: std.io.Limit = .limited(manifest_file_size_max);
666	const file_contents = manifest_reader.interface().readRemainingAlloc(gpa, limit) catch \|err\| switch (err) {	666	const file_contents = manifest_reader.interface().allocRemaining(gpa, limit) catch \|err\| switch (err) {
667	error.OutOfMemory => return error.OutOfMemory,	667	error.OutOfMemory => return error.OutOfMemory,
668	error.StreamTooLong => return error.OutOfMemory,	668	error.StreamTooLong => return error.OutOfMemory,
669	error.ReadFailed => {	669	error.ReadFailed => {

lib/std/Build/Step/Run.zig+2-2

lib/std/Uri.zig+2-2

...	@@ -465,11 +465,11 @@ fn merge_paths(base: Component, new: []u8, aux_buf: *[]u8) error{NoSpaceLeft}!Co	...	@@ -465,11 +465,11 @@ fn merge_paths(base: Component, new: []u8, aux_buf: *[]u8) error{NoSpaceLeft}!Co
465	var aux: Writer = .fixed(aux_buf.*);	465	var aux: Writer = .fixed(aux_buf.*);
466	if (!base.isEmpty()) {	466	if (!base.isEmpty()) {
467	aux.print("{fpath}", .{base}) catch return error.NoSpaceLeft;	467	aux.print("{fpath}", .{base}) catch return error.NoSpaceLeft;
468	aux.end = std.mem.lastIndexOfScalar(u8, aux.getWritten(), '/') orelse	468	aux.end = std.mem.lastIndexOfScalar(u8, aux.buffered(), '/') orelse
469	return remove_dot_segments(new);	469	return remove_dot_segments(new);
470	}	470	}
471	aux.print("/{s}", .{new}) catch return error.NoSpaceLeft;	471	aux.print("/{s}", .{new}) catch return error.NoSpaceLeft;
472	const merged_path = remove_dot_segments(aux.getWritten());	472	const merged_path = remove_dot_segments(aux.buffered());
473	aux_buf.* = aux_buf.*[merged_path.percent_encoded.len..];	473	aux_buf.* = aux_buf.*[merged_path.percent_encoded.len..];
474	return merged_path;	474	return merged_path;
475	}	475	}

lib/std/compress/flate/Decompress.zig+6-6

lib/std/compress/zstd/Decompress.zig+3-3

...	@@ -7,7 +7,7 @@ const zstd = @import("../zstd.zig");	...	@@ -7,7 +7,7 @@ const zstd = @import("../zstd.zig");
7	const Writer = std.io.Writer;	7	const Writer = std.io.Writer;
8		8
9	input: *Reader,	9	input: *Reader,
10	interface: Reader,	10	reader: Reader,
11	state: State,	11	state: State,
12	verify_checksum: bool,	12	verify_checksum: bool,
13	err: ?Error = null,	13	err: ?Error = null,
...	@@ -68,7 +68,7 @@ pub fn init(input: *Reader, buffer: []u8, options: Options) Decompress {	...	@@ -68,7 +68,7 @@ pub fn init(input: *Reader, buffer: []u8, options: Options) Decompress {
68	.input = input,	68	.input = input,
69	.state = .new_frame,	69	.state = .new_frame,
70	.verify_checksum = options.verify_checksum,	70	.verify_checksum = options.verify_checksum,
71	.interface = .{	71	.reader = .{
72	.vtable = &.{ .stream = stream },	72	.vtable = &.{ .stream = stream },
73	.buffer = buffer,	73	.buffer = buffer,
74	.seek = 0,	74	.seek = 0,
...	@@ -78,7 +78,7 @@ pub fn init(input: *Reader, buffer: []u8, options: Options) Decompress {	...	@@ -78,7 +78,7 @@ pub fn init(input: *Reader, buffer: []u8, options: Options) Decompress {
78	}	78	}
79		79
80	fn stream(r: Reader, w: Writer, limit: Limit) Reader.StreamError!usize {	80	fn stream(r: Reader, w: Writer, limit: Limit) Reader.StreamError!usize {
81	const d: *Decompress = @alignCast(@fieldParentPtr("interface", r));	81	const d: *Decompress = @alignCast(@fieldParentPtr("reader", r));
82	const in = d.input;	82	const in = d.input;
83		83
84	switch (d.state) {	84	switch (d.state) {

lib/std/debug/Dwarf.zig+1-1

...	@@ -2242,7 +2242,7 @@ pub const ElfModule = struct {	...	@@ -2242,7 +2242,7 @@ pub const ElfModule = struct {
2242		2242
2243	var zlib_stream: std.compress.flate.Decompress = .init(&section_reader, .zlib, &.{});	2243	var zlib_stream: std.compress.flate.Decompress = .init(&section_reader, .zlib, &.{});
2244		2244
2245	const decompressed_section = zlib_stream.interface.allocRemaining(gpa, .limited(ch_size)) catch	2245	const decompressed_section = zlib_stream.reader.allocRemaining(gpa, .limited(ch_size)) catch
2246	continue;	2246	continue;
2247	if (decompressed_section.len != ch_size) {	2247	if (decompressed_section.len != ch_size) {
2248	gpa.free(decompressed_section);	2248	gpa.free(decompressed_section);

lib/std/http.zig+49-55

...	@@ -328,6 +328,9 @@ pub const Header = struct {	...	@@ -328,6 +328,9 @@ pub const Header = struct {
328		328
329	pub const Reader = struct {	329	pub const Reader = struct {
330	in: *std.io.Reader,	330	in: *std.io.Reader,
		331	/// This is preallocated memory that might be used by `bodyReader`. That
		332	/// function might return a pointer to this field, or a different
		333	/// `*std.io.Reader`. Advisable to not access this field directly.
331	interface: std.io.Reader,	334	interface: std.io.Reader,
332	/// Keeps track of whether the stream is ready to accept a new request,	335	/// Keeps track of whether the stream is ready to accept a new request,
333	/// making invalid API usage cause assertion failures rather than HTTP	336	/// making invalid API usage cause assertion failures rather than HTTP
...	@@ -489,31 +492,31 @@ pub const Reader = struct {	...	@@ -489,31 +492,31 @@ pub const Reader = struct {
489	content_encoding: ContentEncoding,	492	content_encoding: ContentEncoding,
490	decompressor: *Decompressor,	493	decompressor: *Decompressor,
491	decompression_buffer: []u8,	494	decompression_buffer: []u8,
492	) std.io.Reader {	495	) *std.io.Reader {
493	if (transfer_encoding == .none and content_length == null) {	496	if (transfer_encoding == .none and content_length == null) {
494	assert(reader.state == .received_head);	497	assert(reader.state == .received_head);
495	reader.state = .body_none;	498	reader.state = .body_none;
496	switch (content_encoding) {	499	switch (content_encoding) {
497	.identity => {	500	.identity => {
498	return reader.in.reader();	501	return reader.in;
499	},	502	},
500	.deflate => {	503	.deflate => {
501	decompressor.compression = .{ .deflate = .init(reader.in) };	504	decompressor.* = .{ .flate = .init(reader.in, .raw, decompression_buffer) };
502	return decompressor.compression.deflate.reader();	505	return &decompressor.flate.reader;
503	},	506	},
504	.gzip => {	507	.gzip => {
505	decompressor.compression = .{ .gzip = .init(reader.in) };	508	decompressor.* = .{ .flate = .init(reader.in, .gzip, decompression_buffer) };
506	return decompressor.compression.gzip.reader();	509	return &decompressor.flate.reader;
507	},	510	},
508	.zstd => {	511	.zstd => {
509	decompressor.compression = .{ .zstd = .init(reader.in, .{ .verify_checksum = false }) };	512	decompressor.* = .{ .zstd = .init(reader.in, decompression_buffer, .{ .verify_checksum = false }) };
510	return decompressor.compression.zstd.reader();	513	return &decompressor.zstd.reader;
511	},	514	},
512	.compress => unreachable,	515	.compress => unreachable,
513	}	516	}
514	}	517	}
515	const transfer_reader = bodyReader(reader, transfer_encoding, content_length);	518	const transfer_reader = bodyReader(reader, &.{}, transfer_encoding, content_length);
516	return decompressor.reader(transfer_reader, decompression_buffer, content_encoding);	519	return decompressor.init(transfer_reader, decompression_buffer, content_encoding);
517	}	520	}
518		521
519	fn contentLengthStream(	522	fn contentLengthStream(
...	@@ -711,42 +714,33 @@ pub const Reader = struct {	...	@@ -711,42 +714,33 @@ pub const Reader = struct {
711	}	714	}
712	};	715	};
713		716
714	pub const Decompressor = struct {	717	pub const Decompressor = union(enum) {
715	compression: Compression,	718	flate: std.compress.flate.Decompress,
716	buffered_reader: std.io.Reader,	719	zstd: std.compress.zstd.Decompress,
717		720	none: *std.io.Reader,
718	pub const Compression = union(enum) {
719	deflate: std.compress.flate.Decompressor,
720	gzip: std.compress.flate.Decompressor,
721	zstd: std.compress.zstd.Decompress,
722	none: void,
723	};
724		721
725	pub fn reader(	722	pub fn init(
726	decompressor: *Decompressor,	723	decompressor: *Decompressor,
727	transfer_reader: std.io.Reader,	724	transfer_reader: *std.io.Reader,
728	buffer: []u8,	725	buffer: []u8,
729	content_encoding: ContentEncoding,	726	content_encoding: ContentEncoding,
730	) std.io.Reader {	727	) *std.io.Reader {
731	switch (content_encoding) {	728	switch (content_encoding) {
732	.identity => {	729	.identity => {
733	decompressor.compression = .none;	730	decompressor.* = .{ .none = transfer_reader };
734	return transfer_reader;	731	return transfer_reader;
735	},	732	},
736	.deflate => {	733	.deflate => {
737	decompressor.buffered_reader = transfer_reader.buffered(buffer);	734	decompressor.* = .{ .flate = .init(transfer_reader, .raw, buffer) };
738	decompressor.compression = .{ .deflate = .init(&decompressor.buffered_reader) };	735	return &decompressor.flate.reader;
739	return decompressor.compression.deflate.reader();
740	},	736	},
741	.gzip => {	737	.gzip => {
742	decompressor.buffered_reader = transfer_reader.buffered(buffer);	738	decompressor.* = .{ .flate = .init(transfer_reader, .gzip, buffer) };
743	decompressor.compression = .{ .gzip = .init(&decompressor.buffered_reader) };	739	return &decompressor.flate.reader;
744	return decompressor.compression.gzip.reader();
745	},	740	},
746	.zstd => {	741	.zstd => {
747	decompressor.buffered_reader = transfer_reader.buffered(buffer);	742	decompressor.* = .{ .zstd = .init(transfer_reader, buffer, .{ .verify_checksum = false }) };
748	decompressor.compression = .{ .zstd = .init(&decompressor.buffered_reader, .{}) };	743	return &decompressor.zstd.reader;
749	return decompressor.compression.gzip.reader();
750	},	744	},
751	.compress => unreachable,	745	.compress => unreachable,
752	}	746	}
...	@@ -759,7 +753,7 @@ pub const BodyWriter = struct {	...	@@ -759,7 +753,7 @@ pub const BodyWriter = struct {
759	/// state of this other than via methods of `BodyWriter`.	753	/// state of this other than via methods of `BodyWriter`.
760	http_protocol_output: *Writer,	754	http_protocol_output: *Writer,
761	state: State,	755	state: State,
762	interface: Writer,	756	writer: Writer,
763		757
764	pub const Error = Writer.Error;	758	pub const Error = Writer.Error;
765		759
...	@@ -797,7 +791,7 @@ pub const BodyWriter = struct {	...	@@ -797,7 +791,7 @@ pub const BodyWriter = struct {
797	};	791	};
798		792
799	pub fn isEliding(w: *const BodyWriter) bool {	793	pub fn isEliding(w: *const BodyWriter) bool {
800	return w.interface.vtable.drain == Writer.discardingDrain;	794	return w.writer.vtable.drain == Writer.discardingDrain;
801	}	795	}
802		796
803	/// Sends all buffered data across `BodyWriter.http_protocol_output`.	797	/// Sends all buffered data across `BodyWriter.http_protocol_output`.
...	@@ -924,42 +918,42 @@ pub const BodyWriter = struct {	...	@@ -924,42 +918,42 @@ pub const BodyWriter = struct {
924	w.state = .end;	918	w.state = .end;
925	}	919	}
926		920
927	fn contentLengthDrain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {	921	pub fn contentLengthDrain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {
928	const bw: *BodyWriter = @fieldParentPtr("interface", w);	922	const bw: *BodyWriter = @fieldParentPtr("writer", w);
929	assert(!bw.isEliding());	923	assert(!bw.isEliding());
930	const out = w.http_protocol_output;	924	const out = bw.http_protocol_output;
931	const n = try w.drainTo(out, data, splat);	925	const n = try w.drainTo(out, data, splat);
932	w.state.content_length -= n;	926	bw.state.content_length -= n;
933	return n;	927	return n;
934	}	928	}
935		929
936	fn noneDrain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {	930	pub fn noneDrain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {
937	const bw: *BodyWriter = @fieldParentPtr("interface", w);	931	const bw: *BodyWriter = @fieldParentPtr("writer", w);
938	assert(!bw.isEliding());	932	assert(!bw.isEliding());
939	const out = w.http_protocol_output;	933	const out = bw.http_protocol_output;
940	return try w.drainTo(out, data, splat);	934	return try w.drainTo(out, data, splat);
941	}	935	}
942		936
943	/// Returns `null` if size cannot be computed without making any syscalls.	937	/// Returns `null` if size cannot be computed without making any syscalls.
944	fn noneSendFile(w: Writer, file_reader: File.Reader, limit: std.io.Limit) Writer.FileError!usize {	938	pub fn noneSendFile(w: Writer, file_reader: File.Reader, limit: std.io.Limit) Writer.FileError!usize {
945	const bw: *BodyWriter = @fieldParentPtr("interface", w);	939	const bw: *BodyWriter = @fieldParentPtr("writer", w);
946	assert(!bw.isEliding());	940	assert(!bw.isEliding());
947	return w.sendFileTo(bw.http_protocol_output, file_reader, limit);	941	return w.sendFileTo(bw.http_protocol_output, file_reader, limit);
948	}	942	}
949		943
950	fn contentLengthSendFile(w: Writer, file_reader: File.Reader, limit: std.io.Limit) Writer.FileError!usize {	944	pub fn contentLengthSendFile(w: Writer, file_reader: File.Reader, limit: std.io.Limit) Writer.FileError!usize {
951	const bw: *BodyWriter = @fieldParentPtr("interface", w);	945	const bw: *BodyWriter = @fieldParentPtr("writer", w);
952	assert(!bw.isEliding());	946	assert(!bw.isEliding());
953	const n = try w.sendFileTo(bw.http_protocol_output, file_reader, limit);	947	const n = try w.sendFileTo(bw.http_protocol_output, file_reader, limit);
954	bw.state.content_length -= n;	948	bw.state.content_length -= n;
955	return n;	949	return n;
956	}	950	}
957		951
958	fn chunkedSendFile(w: Writer, file_reader: File.Reader, limit: std.io.Limit) Writer.FileError!usize {	952	pub fn chunkedSendFile(w: Writer, file_reader: File.Reader, limit: std.io.Limit) Writer.FileError!usize {
959	const bw: *BodyWriter = @fieldParentPtr("interface", w);	953	const bw: *BodyWriter = @fieldParentPtr("writer", w);
960	assert(!bw.isEliding());	954	assert(!bw.isEliding());
961	const data_len = w.countSendFileUpperBound(file_reader, limit) orelse {	955	const data_len = if (file_reader.getSize()) \|x\| w.end + x else \|_\| {
962	// If the file size is unknown, we cannot lower to a `writeFile` since we would	956	// If the file size is unknown, we cannot lower to a `sendFile` since we would
963	// have to flush the chunk header before knowing the chunk length.	957	// have to flush the chunk header before knowing the chunk length.
964	return error.Unimplemented;	958	return error.Unimplemented;
965	};	959	};
...	@@ -1003,10 +997,10 @@ pub const BodyWriter = struct {	...	@@ -1003,10 +997,10 @@ pub const BodyWriter = struct {
1003	}	997	}
1004	}	998	}
1005		999
1006	fn chunkedDrain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {	1000	pub fn chunkedDrain(w: *Writer, data: []const []const u8, splat: usize) Error!usize {
1007	const bw: *BodyWriter = @fieldParentPtr("interface", w);	1001	const bw: *BodyWriter = @fieldParentPtr("writer", w);
1008	assert(!bw.isEliding());	1002	assert(!bw.isEliding());
1009	const out = w.http_protocol_output;	1003	const out = bw.http_protocol_output;
1010	const data_len = Writer.countSplat(w.end, data, splat);	1004	const data_len = Writer.countSplat(w.end, data, splat);
1011	const chunked = &bw.state.chunked;	1005	const chunked = &bw.state.chunked;
1012	state: switch (chunked.*) {	1006	state: switch (chunked.*) {
...	@@ -1018,7 +1012,7 @@ pub const BodyWriter = struct {	...	@@ -1018,7 +1012,7 @@ pub const BodyWriter = struct {
1018	const buffered_len = out.end - offset - chunk_header_template.len;	1012	const buffered_len = out.end - offset - chunk_header_template.len;
1019	const chunk_len = data_len + buffered_len;	1013	const chunk_len = data_len + buffered_len;
1020	writeHex(out.buffer[offset..][0..chunk_len_digits], chunk_len);	1014	writeHex(out.buffer[offset..][0..chunk_len_digits], chunk_len);
1021	const n = try w.drainTo(w, data, splat);	1015	const n = try w.drainTo(out, data, splat);
1022	chunked.* = .{ .chunk_len = data_len + 2 - n };	1016	chunked.* = .{ .chunk_len = data_len + 2 - n };
1023	return n;	1017	return n;
1024	},	1018	},
...	@@ -1041,7 +1035,7 @@ pub const BodyWriter = struct {	...	@@ -1041,7 +1035,7 @@ pub const BodyWriter = struct {
1041	continue :l 1;	1035	continue :l 1;
1042	},	1036	},
1043	else => {	1037	else => {
1044	const n = try w.drainToLimit(data, splat, .limited(chunk_len - 2));	1038	const n = try w.drainToLimit(out, data, splat, .limited(chunk_len - 2));
1045	chunked.chunk_len = chunk_len - n;	1039	chunked.chunk_len = chunk_len - n;
1046	return n;	1040	return n;
1047	},	1041	},

lib/std/http/Client.zig+28-26

 @@ -408,7 +408,7 @@ pub const Connection = struct {
     /// HTTP protocol from server to client.
     /// This either comes directly from `stream_reader`, or from a TLS client.
-    pub fn reader(c: *const Connection) *Reader {
+    pub fn reader(c: *Connection) *Reader {
         return switch (c.protocol) {
             .tls => {
                 if (disable_tls) unreachable;
 @@ -682,7 +682,7 @@ pub const Response = struct {
     ///
     /// See also:
     /// * `readerDecompressing`
-    pub fn reader(response: *Response, buffer: []u8) Reader {
+    pub fn reader(response: *Response, buffer: []u8) *Reader {
         const req = response.request;
         if (!req.method.responseHasBody()) return .ending;
         const head = &response.head;
 @@ -702,7 +702,7 @@ pub const Response = struct {
         response: *Response,
         decompressor: *http.Decompressor,
         decompression_buffer: []u8,
-    ) Reader {
+    ) *Reader {
         const head = &response.head;
         return response.request.reader.bodyReaderDecompressing(
             head.transfer_encoding,
 @@ -864,14 +864,14 @@ pub const Request = struct {
     pub fn sendBodyUnflushed(r: *Request, buffer: []u8) Writer.Error!http.BodyWriter {
         assert(r.method.requestHasBody());
         try sendHead(r);
-        const http_protocol_output = &r.connection.?.writer;
+        const http_protocol_output = r.connection.?.writer();
         return switch (r.transfer_encoding) {
             .chunked => .{
                 .http_protocol_output = http_protocol_output,
                 .state = .{ .chunked = .init },
-                .interface = .{
+                .writer = .{
                     .buffer = buffer,
-                    .interface = &.{
+                    .vtable = &.{
                         .drain = http.BodyWriter.chunkedDrain,
                         .sendFile = http.BodyWriter.chunkedSendFile,
                     },
 @@ -880,9 +880,9 @@ pub const Request = struct {
             .content_length => |len| .{
                 .http_protocol_output = http_protocol_output,
                 .state = .{ .content_length = len },
-                .interface = .{
+                .writer = .{
                     .buffer = buffer,
-                    .interface = &.{
+                    .vtable = &.{
                         .drain = http.BodyWriter.contentLengthDrain,
                         .sendFile = http.BodyWriter.contentLengthSendFile,
                     },
 @@ -891,9 +891,9 @@ pub const Request = struct {
             .none => .{
                 .http_protocol_output = http_protocol_output,
                 .state = .none,
-                .interface = .{
+                .writer = .{
                     .buffer = buffer,
-                    .interface = &.{
+                    .vtable = &.{
                         .drain = http.BodyWriter.noneDrain,
                         .sendFile = http.BodyWriter.noneSendFile,
                     },
 @@ -906,7 +906,7 @@ pub const Request = struct {
     fn sendHead(r: *Request) Writer.Error!void {
         const uri = r.uri;
         const connection = r.connection.?;
-        const w = &connection.writer;
+        const w = connection.writer();
         try r.method.write(w);
         try w.writeByte(' ');
 @@ -1085,7 +1085,7 @@ pub const Request = struct {
             if (head.status.class() == .redirect and r.redirect_behavior != .unhandled) {
                 if (r.redirect_behavior == .not_allowed) {
                     // Connection can still be reused by skipping the body.
-                    var reader = r.reader.bodyReader(head.transfer_encoding, head.content_length);
+                    const reader = r.reader.bodyReader(&.{}, head.transfer_encoding, head.content_length);
                     _ = reader.discardRemaining() catch |err| switch (err) {
                         error.ReadFailed => connection.closing = true,
                     };
 @@ -1117,7 +1117,7 @@ pub const Request = struct {
         {
             // Skip the body of the redirect response to leave the connection in
             // the correct state. This causes `new_location` to be invalidated.
-            var reader = r.reader.bodyReader(head.transfer_encoding, head.content_length);
+            const reader = r.reader.bodyReader(&.{}, head.transfer_encoding, head.content_length);
             _ = reader.discardRemaining() catch |err| switch (err) {
                 error.ReadFailed => return r.reader.body_err.?,
             };
 @@ -1169,8 +1169,10 @@ pub const Request = struct {
         r.uri = new_uri;
         r.connection = new_connection;
         r.reader = .{
-            .in = &new_connection.reader,
+            .in = new_connection.reader(),
             .state = .ready,
+            // Populated when `http.Reader.bodyReader` is called.
+            .interface = undefined,
         };
         r.redirect_behavior.subtractOne();
     }
 @@ -1292,12 +1294,12 @@ pub const basic_authorization = struct {
     pub fn write(uri: Uri, out: *Writer) Writer.Error!void {
         var buf: [max_user_len + ":".len + max_password_len]u8 = undefined;
-        var bw: Writer = .fixed(&buf);
+        var w: Writer = .fixed(&buf);
-        bw.print("{fuser}:{fpassword}", .{
+        w.print("{fuser}:{fpassword}", .{
             uri.user orelse Uri.Component.empty,
             uri.password orelse Uri.Component.empty,
         }) catch unreachable;
-        try out.print("Basic {b64}", .{bw.getWritten()});
+        try out.print("Basic {b64}", .{w.buffered()});
     }
 };
 @@ -1622,8 +1624,10 @@ pub fn request(
         .client = client,
         .connection = connection,
         .reader = .{
-            .in = &connection.reader,
+            .in = connection.reader(),
             .state = .ready,
+            // Populated when `http.Reader.bodyReader` is called.
+            .interface = undefined,
         },
         .keep_alive = options.keep_alive,
         .method = method,
 @@ -1711,9 +1715,8 @@ pub fn fetch(client: *Client, options: FetchOptions) FetchError!FetchResult {
     if (options.payload) |payload| {
         req.transfer_encoding = .{ .content_length = payload.len };
-        var body = try req.sendBody();
+        var body = try req.sendBody(&.{});
-        var bw = body.writer().unbuffered();
+        try body.writer.writeAll(payload);
-        try bw.writeAll(payload);
         try body.end();
     } else {
         try req.sendBodiless();
 @@ -1726,7 +1729,7 @@ pub fn fetch(client: *Client, options: FetchOptions) FetchError!FetchResult {
     var response = try req.receiveHead(redirect_buffer);
     const storage = options.response_storage orelse {
-        var reader = response.reader();
+        const reader = response.reader(&.{});
         _ = reader.discardRemaining() catch |err| switch (err) {
             error.ReadFailed => return response.bodyErr().?,
         };
 @@ -1741,18 +1744,17 @@ pub fn fetch(client: *Client, options: FetchOptions) FetchError!FetchResult {
     defer if (options.decompress_buffer == null) client.allocator.free(decompress_buffer);
     var decompressor: http.Decompressor = undefined;
-    var reader = response.readerDecompressing(&decompressor, decompress_buffer);
+    const reader = response.readerDecompressing(&decompressor, decompress_buffer);
     const list = storage.list;
     if (storage.allocator) |allocator| {
-        reader.readRemainingArrayList(allocator, null, list, storage.append_limit, 128) catch |err| switch (err) {
+        reader.appendRemaining(allocator, null, list, storage.append_limit) catch |err| switch (err) {
             error.ReadFailed => return response.bodyErr().?,
             else => |e| return e,
         };
     } else {
-        var br = reader.unbuffered();
         const buf = storage.append_limit.slice(list.unusedCapacitySlice());
-        list.items.len += br.readSliceShort(buf) catch |err| switch (err) {
+        list.items.len += reader.readSliceShort(buf) catch |err| switch (err) {
             error.ReadFailed => return response.bodyErr().?,
         };
     }

lib/std/http/Server.zig+17-12

 @@ -26,6 +26,8 @@ pub fn init(in: *std.io.Reader, out: *Writer) Server {
         .reader = .{
             .in = in,
             .state = .ready,
+            // Populated when `http.Reader.bodyReader` is called.
+            .interface = undefined,
         },
         .out = out,
     };
 @@ -58,7 +60,7 @@ pub const Request = struct {
     /// Pointers in this struct are invalidated with the next call to
     /// `receiveHead`.
     head: Head,
-    respond_err: ?RespondError,
+    respond_err: ?RespondError = null,
     pub const RespondError = error{
         /// The request contained an `expect` header with an unrecognized value.
 @@ -243,6 +245,7 @@ pub const Request = struct {
                 .in = undefined,
                 .state = .received_head,
                 .head_buffer = @constCast(request_bytes),
+                .interface = undefined,
             },
             .out = undefined,
         };
 @@ -381,8 +384,6 @@ pub const Request = struct {
         content_length: ?u64 = null,
         /// Options that are shared with the `respond` method.
         respond_options: RespondOptions = .{},
-        /// Used by `http.BodyWriter`.
-        buffer: []u8,
     };
     /// The header is not guaranteed to be sent until `BodyWriter.flush` or
 @@ -400,7 +401,11 @@ pub const Request = struct {
     /// be done to satisfy the request.
     ///
     /// Asserts status is not `continue`.
-    pub fn respondStreaming(request: *Request, options: RespondStreamingOptions) Writer.Error!http.BodyWriter {
+    pub fn respondStreaming(
+        request: *Request,
+        buffer: []u8,
+        options: RespondStreamingOptions,
+    ) ExpectContinueError!http.BodyWriter {
         try writeExpectContinue(request);
         const o = options.respond_options;
         assert(o.status != .@"continue");
 @@ -448,12 +453,12 @@ pub const Request = struct {
         return if (elide_body) .{
             .http_protocol_output = request.server.out,
             .state = state,
-            .interface = .discarding(options.buffer),
+            .writer = .discarding(buffer),
         } else .{
             .http_protocol_output = request.server.out,
             .state = state,
-            .interface = .{
+            .writer = .{
-                .buffer = options.buffer,
+                .buffer = buffer,
                 .vtable = switch (state) {
                     .none => &.{
                         .drain = http.BodyWriter.noneDrain,
 @@ -559,11 +564,11 @@ pub const Request = struct {
     ///
     /// See `readerExpectNone` for an infallible alternative that cannot write
     /// to the server output stream.
-    pub fn readerExpectContinue(request: *Request) ExpectContinueError!std.io.Reader {
+    pub fn readerExpectContinue(request: *Request, buffer: []u8) ExpectContinueError!*std.io.Reader {
         const flush = request.head.expect != null;
         try writeExpectContinue(request);
         if (flush) try request.server.out.flush();
-        return readerExpectNone(request);
+        return readerExpectNone(request, buffer);
     }
     /// Asserts the expect header is `null`. The caller must handle the
 @@ -571,11 +576,11 @@ pub const Request = struct {
     /// this function.
     ///
     /// Asserts that this function is only called once.
-    pub fn readerExpectNone(request: *Request) std.io.Reader {
+    pub fn readerExpectNone(request: *Request, buffer: []u8) *std.io.Reader {
         assert(request.server.reader.state == .received_head);
         assert(request.head.expect == null);
         if (!request.head.method.requestHasBody()) return .ending;
-        return request.server.reader.bodyReader(request.head.transfer_encoding, request.head.content_length);
+        return request.server.reader.bodyReader(buffer, request.head.transfer_encoding, request.head.content_length);
     }
     pub const ExpectContinueError = error{
 @@ -611,7 +616,7 @@ pub const Request = struct {
             .received_head => {
                 if (request.head.method.requestHasBody()) {
                     assert(request.head.transfer_encoding != .none or request.head.content_length != null);
-                    const reader_interface = request.reader() catch return false;
+                    const reader_interface = request.readerExpectContinue(&.{}) catch return false;
                     _ = reader_interface.discardRemaining() catch return false;
                     assert(r.state == .ready);
                 } else {

lib/std/http/test.zig+97-117

 @@ -21,7 +21,7 @@ test "trailers" {
                 var connection_br = connection.stream.reader(&recv_buffer);
                 var connection_bw = connection.stream.writer(&send_buffer);
-                var server = http.Server.init(&connection_br, &connection_bw);
+                var server = http.Server.init(connection_br.interface(), &connection_bw.interface);
                 try expectEqual(.ready, server.reader.state);
                 var request = try server.receiveHead();
 @@ -33,11 +33,10 @@ test "trailers" {
         fn serve(request: *http.Server.Request) !void {
             try expectEqualStrings(request.head.target, "/trailer");
-            var response = try request.respondStreaming(.{});
+            var response = try request.respondStreaming(&.{}, .{});
-            var bw = response.writer().unbuffered();
+            try response.writer.writeAll("Hello, ");
-            try bw.writeAll("Hello, ");
             try response.flush();
-            try bw.writeAll("World!\n");
+            try response.writer.writeAll("World!\n");
             try response.flush();
             try response.endChunked(.{
                 .trailers = &.{
 @@ -66,7 +65,7 @@ test "trailers" {
         try req.sendBodiless();
         var response = try req.receiveHead(&.{});
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -104,13 +103,13 @@ test "HTTP server handles a chunked transfer coding request" {
             var connection_br = connection.stream.reader(&recv_buffer);
             var connection_bw = connection.stream.writer(&send_buffer);
-            var server = http.Server.init(&connection_br, &connection_bw);
+            var server = http.Server.init(connection_br.interface(), &connection_bw.interface);
             var request = try server.receiveHead();
             try expect(request.head.transfer_encoding == .chunked);
             var buf: [128]u8 = undefined;
-            var br = (try request.reader()).unbuffered();
+            var br = try request.readerExpectContinue(&.{});
             const n = try br.readSliceShort(&buf);
             try expectEqualStrings("ABCD", buf[0..n]);
 @@ -141,9 +140,8 @@ test "HTTP server handles a chunked transfer coding request" {
     const gpa = std.testing.allocator;
     const stream = try std.net.tcpConnectToHost(gpa, "127.0.0.1", test_server.port());
     defer stream.close();
-    var stream_writer = stream.writer();
+    var stream_writer = stream.writer(&.{});
-    var writer = stream_writer.interface().unbuffered();
+    try stream_writer.interface.writeAll(request_bytes);
-    try writer.writeAll(request_bytes);
     const expected_response =
         "HTTP/1.1 200 OK\r\n" ++
 @@ -152,8 +150,8 @@ test "HTTP server handles a chunked transfer coding request" {
         "content-type: text/plain\r\n" ++
         "\r\n" ++
         "message from server!\n";
-    var stream_reader = stream.reader();
+    var stream_reader = stream.reader(&.{});
-    const response = try stream_reader.interface().readRemainingAlloc(gpa, .limited(expected_response.len));
+    const response = try stream_reader.interface().allocRemaining(gpa, .limited(expected_response.len));
     defer gpa.free(response);
     try expectEqualStrings(expected_response, response);
 }
 @@ -169,11 +167,9 @@ test "echo content server" {
                 const connection = try net_server.accept();
                 defer connection.stream.close();
-                var stream_reader = connection.stream.reader();
+                var connection_br = connection.stream.reader(&recv_buffer);
-                var stream_writer = connection.stream.writer();
+                var connection_bw = connection.stream.writer(&send_buffer);
-                var connection_br = stream_reader.interface().buffered(&recv_buffer);
+                var http_server = http.Server.init(connection_br.interface(), &connection_bw.interface);
-                var connection_bw = stream_writer.interface().buffered(&send_buffer);
-                var http_server = http.Server.init(&connection_br, &connection_bw);
                 while (http_server.reader.state == .ready) {
                     var request = http_server.receiveHead() catch |err| switch (err) {
 @@ -185,7 +181,7 @@ test "echo content server" {
                     }
                     if (request.head.expect) |expect_header_value| {
                         if (mem.eql(u8, expect_header_value, "garbage")) {
-                            try expectError(error.HttpExpectationFailed, request.reader());
+                            try expectError(error.HttpExpectationFailed, request.readerExpectContinue(&.{}));
                             try request.respond("", .{ .keep_alive = false });
                             continue;
                         }
 @@ -207,14 +203,14 @@ test "echo content server" {
             //    request.head.target,
             //});
-            const body = try (try request.reader()).readRemainingAlloc(std.testing.allocator, .limited(8192));
+            const body = try (try request.readerExpectContinue(&.{})).allocRemaining(std.testing.allocator, .limited(8192));
             defer std.testing.allocator.free(body);
             try expect(mem.startsWith(u8, request.head.target, "/echo-content"));
             try expectEqualStrings("Hello, World!\n", body);
             try expectEqualStrings("text/plain", request.head.content_type.?);
-            var response = try request.respondStreaming(.{
+            var response = try request.respondStreaming(&.{}, .{
                 .content_length = switch (request.head.transfer_encoding) {
                     .chunked => null,
                     .none => len: {
 @@ -224,9 +220,9 @@ test "echo content server" {
                 },
             });
             try response.flush(); // Test an early flush to send the HTTP headers before the body.
-            var bw = response.writer().unbuffered();
+            const w = &response.writer;
-            try bw.writeAll("Hello, ");
+            try w.writeAll("Hello, ");
-            try bw.writeAll("World!\n");
+            try w.writeAll("World!\n");
             try response.end();
             //std.debug.print("  server finished responding\n", .{});
         }
 @@ -259,27 +255,25 @@ test "Server.Request.respondStreaming non-chunked, unknown content-length" {
                 const connection = try net_server.accept();
                 defer connection.stream.close();
-                var stream_reader = connection.stream.reader();
+                var connection_br = connection.stream.reader(&recv_buffer);
-                var stream_writer = connection.stream.writer();
+                var connection_bw = connection.stream.writer(&send_buffer);
-                var connection_br = stream_reader.interface().buffered(&recv_buffer);
+                var server = http.Server.init(connection_br.interface(), &connection_bw.interface);
-                var connection_bw = stream_writer.interface().buffered(&send_buffer);
-                var server = http.Server.init(&connection_br, &connection_bw);
                 try expectEqual(.ready, server.reader.state);
                 var request = try server.receiveHead();
                 try expectEqualStrings(request.head.target, "/foo");
-                var response = try request.respondStreaming(.{
+                var buf: [30]u8 = undefined;
+                var response = try request.respondStreaming(&buf, .{
                     .respond_options = .{
                         .transfer_encoding = .none,
                     },
                 });
-                var buf: [30]u8 = undefined;
+                const w = &response.writer;
-                var bw = response.writer().buffered(&buf);
                 for (0..500) |i| {
-                    try bw.print("{d}, ah ha ha!\n", .{i});
+                    try w.print("{d}, ah ha ha!\n", .{i});
                 }
-                try expectEqual(7390, bw.count);
+                try expectEqual(7390, w.count);
-                try bw.flush();
+                try w.flush();
                 try response.end();
                 try expectEqual(.closing, server.reader.state);
             }
 @@ -291,12 +285,11 @@ test "Server.Request.respondStreaming non-chunked, unknown content-length" {
     const gpa = std.testing.allocator;
     const stream = try std.net.tcpConnectToHost(gpa, "127.0.0.1", test_server.port());
     defer stream.close();
-    var stream_writer = stream.writer();
+    var stream_writer = stream.writer(&.{});
-    var writer = stream_writer.interface().unbuffered();
+    try stream_writer.interface.writeAll(request_bytes);
-    try writer.writeAll(request_bytes);
-    var stream_reader = stream.reader();
+    var stream_reader = stream.reader(&.{});
-    const response = try stream_reader.interface().readRemainingAlloc(gpa, .limited(8192));
+    const response = try stream_reader.interface().allocRemaining(gpa, .limited(8192));
     defer gpa.free(response);
     var expected_response = std.ArrayList(u8).init(gpa);
 @@ -329,11 +322,9 @@ test "receiving arbitrary http headers from the client" {
                 const connection = try net_server.accept();
                 defer connection.stream.close();
-                var stream_reader = connection.stream.reader();
+                var connection_br = connection.stream.reader(&recv_buffer);
-                var stream_writer = connection.stream.writer();
+                var connection_bw = connection.stream.writer(&send_buffer);
-                var connection_br = stream_reader.interface().buffered(&recv_buffer);
+                var server = http.Server.init(connection_br.interface(), &connection_bw.interface);
-                var connection_bw = stream_writer.interface().buffered(&send_buffer);
-                var server = http.Server.init(&connection_br, &connection_bw);
                 try expectEqual(.ready, server.reader.state);
                 var request = try server.receiveHead();
 @@ -364,12 +355,11 @@ test "receiving arbitrary http headers from the client" {
     const gpa = std.testing.allocator;
     const stream = try std.net.tcpConnectToHost(gpa, "127.0.0.1", test_server.port());
     defer stream.close();
-    var stream_writer = stream.writer();
+    var stream_writer = stream.writer(&.{});
-    var writer = stream_writer.interface().unbuffered();
+    try stream_writer.interface.writeAll(request_bytes);
-    try writer.writeAll(request_bytes);
-    var stream_reader = stream.reader();
+    var stream_reader = stream.reader(&.{});
-    const response = try stream_reader.interface().readRemainingAlloc(gpa, .limited(8192));
+    const response = try stream_reader.interface().allocRemaining(gpa, .limited(8192));
     defer gpa.free(response);
     var expected_response = std.ArrayList(u8).init(gpa);
 @@ -397,11 +387,9 @@ test "general client/server API coverage" {
                 var connection = try net_server.accept();
                 defer connection.stream.close();
-                var stream_reader = connection.stream.reader();
+                var connection_br = connection.stream.reader(&recv_buffer);
-                var stream_writer = connection.stream.writer();
+                var connection_bw = connection.stream.writer(&send_buffer);
-                var connection_br = stream_reader.interface().buffered(&recv_buffer);
+                var http_server = http.Server.init(connection_br.interface(), &connection_bw.interface);
-                var connection_bw = stream_writer.interface().buffered(&send_buffer);
-                var http_server = http.Server.init(&connection_br, &connection_bw);
                 while (http_server.reader.state == .ready) {
                     var request = http_server.receiveHead() catch |err| switch (err) {
 @@ -424,11 +412,11 @@ test "general client/server API coverage" {
             });
             const gpa = std.testing.allocator;
-            const body = try (try request.reader()).readRemainingAlloc(gpa, .limited(8192));
+            const body = try (try request.readerExpectContinue(&.{})).allocRemaining(gpa, .limited(8192));
             defer gpa.free(body);
             if (mem.startsWith(u8, request.head.target, "/get")) {
-                var response = try request.respondStreaming(.{
+                var response = try request.respondStreaming(&.{}, .{
                     .content_length = if (mem.indexOf(u8, request.head.target, "?chunked") == null)
                         14
                     else
 @@ -439,35 +427,35 @@ test "general client/server API coverage" {
                         },
                     },
                 });
-                var bw = response.writer().unbuffered();
+                const w = &response.writer;
-                try bw.writeAll("Hello, ");
+                try w.writeAll("Hello, ");
-                try bw.writeAll("World!\n");
+                try w.writeAll("World!\n");
                 try response.end();
                 // Writing again would cause an assertion failure.
             } else if (mem.startsWith(u8, request.head.target, "/large")) {
-                var response = try request.respondStreaming(.{
+                var response = try request.respondStreaming(&.{}, .{
                     .content_length = 14 * 1024 + 14 * 10,
                 });
                 try response.flush(); // Test an early flush to send the HTTP headers before the body.
-                var bw = response.writer().unbuffered();
+                const w = &response.writer;
                 var i: u32 = 0;
                 while (i < 5) : (i += 1) {
-                    try bw.writeAll("Hello, World!\n");
+                    try w.writeAll("Hello, World!\n");
                 }
-                try bw.writeAll("Hello, World!\n" ** 1024);
+                try w.writeAll("Hello, World!\n" ** 1024);
                 i = 0;
                 while (i < 5) : (i += 1) {
-                    try bw.writeAll("Hello, World!\n");
+                    try w.writeAll("Hello, World!\n");
                 }
                 try response.end();
             } else if (mem.eql(u8, request.head.target, "/redirect/1")) {
-                var response = try request.respondStreaming(.{
+                var response = try request.respondStreaming(&.{}, .{
                     .respond_options = .{
                         .status = .found,
                         .extra_headers = &.{
 @@ -476,9 +464,9 @@ test "general client/server API coverage" {
                     },
                 });
-                var bw = response.writer().unbuffered();
+                const w = &response.writer;
-                try bw.writeAll("Hello, ");
+                try w.writeAll("Hello, ");
-                try bw.writeAll("Redirected!\n");
+                try w.writeAll("Redirected!\n");
                 try response.end();
             } else if (mem.eql(u8, request.head.target, "/redirect/2")) {
                 try request.respond("Hello, Redirected!\n", .{
 @@ -567,7 +555,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -590,7 +578,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192 * 1024));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192 * 1024));
         defer gpa.free(body);
         try expectEqual(@as(usize, 14 * 1024 + 14 * 10), body.len);
 @@ -612,7 +600,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("", body);
 @@ -636,7 +624,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -659,7 +647,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("", body);
 @@ -685,7 +673,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -714,7 +702,7 @@ test "general client/server API coverage" {
         try std.testing.expectEqual(.ok, response.head.status);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("", body);
 @@ -751,7 +739,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -773,7 +761,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -795,7 +783,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -836,7 +824,7 @@ test "general client/server API coverage" {
         try req.sendBodiless();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Encoded redirect successful!\n", body);
 @@ -878,20 +866,18 @@ test "Server streams both reading and writing" {
             const connection = try net_server.accept();
             defer connection.stream.close();
-            var stream_reader = connection.stream.reader();
+            var connection_br = connection.stream.reader(&recv_buffer);
-            var stream_writer = connection.stream.writer();
+            var connection_bw = connection.stream.writer(&send_buffer);
-            var connection_br = stream_reader.interface().buffered(&recv_buffer);
+            var server = http.Server.init(connection_br.interface(), &connection_bw.interface);
-            var connection_bw = stream_writer.interface().buffered(&send_buffer);
-            var server = http.Server.init(&connection_br, &connection_bw);
             var request = try server.receiveHead();
             var read_buffer: [100]u8 = undefined;
-            var br = (try request.reader()).buffered(&read_buffer);
+            var br = try request.readerExpectContinue(&read_buffer);
-            var response = try request.respondStreaming(.{
+            var response = try request.respondStreaming(&.{}, .{
                 .respond_options = .{
                     .transfer_encoding = .none, // Causes keep_alive=false
                 },
             });
-            var bw = response.writer().unbuffered();
+            const w = &response.writer;
             while (true) {
                 try response.flush();
 @@ -901,7 +887,7 @@ test "Server streams both reading and writing" {
                 };
                 br.toss(buf.len);
                 for (buf) |*b| b.* = std.ascii.toUpper(b.*);
-                try bw.writeAll(buf);
+                try w.writeAll(buf);
             }
             try response.end();
         }
 @@ -921,15 +907,14 @@ test "Server streams both reading and writing" {
     defer req.deinit();
     req.transfer_encoding = .chunked;
-    var body_writer = try req.sendBody();
+    var body_writer = try req.sendBody(&.{});
     var response = try req.receiveHead(&redirect_buffer);
-    var w = body_writer.writer().unbuffered();
+    try body_writer.writer.writeAll("one ");
-    try w.writeAll("one ");
+    try body_writer.writer.writeAll("fish");
-    try w.writeAll("fish");
     try body_writer.end();
-    const body = try response.reader().readRemainingAlloc(std.testing.allocator, .limited(8192));
+    const body = try response.reader(&.{}).allocRemaining(std.testing.allocator, .limited(8192));
     defer std.testing.allocator.free(body);
     try expectEqualStrings("ONE FISH", body);
 @@ -954,15 +939,14 @@ fn echoTests(client: *http.Client, port: u16) !void {
         req.transfer_encoding = .{ .content_length = 14 };
-        var body_writer = try req.sendBody();
+        var body_writer = try req.sendBody(&.{});
-        var w = body_writer.writer().unbuffered();
+        try body_writer.writer.writeAll("Hello, ");
-        try w.writeAll("Hello, ");
+        try body_writer.writer.writeAll("World!\n");
-        try w.writeAll("World!\n");
         try body_writer.end();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -988,15 +972,14 @@ fn echoTests(client: *http.Client, port: u16) !void {
         req.transfer_encoding = .chunked;
-        var body_writer = try req.sendBody();
+        var body_writer = try req.sendBody(&.{});
-        var w = body_writer.writer().unbuffered();
+        try body_writer.writer.writeAll("Hello, ");
-        try w.writeAll("Hello, ");
+        try body_writer.writer.writeAll("World!\n");
-        try w.writeAll("World!\n");
         try body_writer.end();
         var response = try req.receiveHead(&redirect_buffer);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -1042,16 +1025,15 @@ fn echoTests(client: *http.Client, port: u16) !void {
         req.transfer_encoding = .chunked;
-        var body_writer = try req.sendBody();
+        var body_writer = try req.sendBody(&.{});
-        var w = body_writer.writer().unbuffered();
+        try body_writer.writer.writeAll("Hello, ");
-        try w.writeAll("Hello, ");
+        try body_writer.writer.writeAll("World!\n");
-        try w.writeAll("World!\n");
         try body_writer.end();
         var response = try req.receiveHead(&redirect_buffer);
         try expectEqual(.ok, response.head.status);
-        const body = try response.reader().readRemainingAlloc(gpa, .limited(8192));
+        const body = try response.reader(&.{}).allocRemaining(gpa, .limited(8192));
         defer gpa.free(body);
         try expectEqualStrings("Hello, World!\n", body);
 @@ -1073,11 +1055,11 @@ fn echoTests(client: *http.Client, port: u16) !void {
         req.transfer_encoding = .chunked;
-        var body_writer = try req.sendBody();
+        var body_writer = try req.sendBody(&.{});
         try body_writer.flush();
         var response = try req.receiveHead(&redirect_buffer);
         try expectEqual(.expectation_failed, response.head.status);
-        _ = try response.reader().discardRemaining();
+        _ = try response.reader(&.{}).discardRemaining();
     }
 }
 @@ -1128,11 +1110,9 @@ test "redirect to different connection" {
             const connection = try net_server.accept();
             defer connection.stream.close();
-            var stream_reader = connection.stream.reader();
+            var connection_br = connection.stream.reader(&recv_buffer);
-            var stream_writer = connection.stream.writer();
+            var connection_bw = connection.stream.writer(&send_buffer);
-            var connection_br = stream_reader.interface().buffered(&recv_buffer);
+            var server = http.Server.init(connection_br.interface(), &connection_bw.interface);
-            var connection_bw = stream_writer.interface().buffered(&send_buffer);
-            var server = http.Server.init(&connection_br, &connection_bw);
             var request = try server.receiveHead();
             try expectEqualStrings(request.head.target, "/ok");
             try request.respond("good job, you pass", .{});
 @@ -1161,7 +1141,7 @@ test "redirect to different connection" {
             var connection_br = connection.stream.reader(&recv_buffer);
             var connection_bw = connection.stream.writer(&send_buffer);
-            var server = http.Server.init(&connection_br, &connection_bw);
+            var server = http.Server.init(connection_br.interface(), &connection_bw.interface);
             var request = try server.receiveHead();
             try expectEqualStrings(request.head.target, "/help");
             try request.respond("", .{

lib/std/io/Reader.zig+4-1

 @@ -96,7 +96,10 @@ pub const failing: Reader = .{
     .end = 0,
 };
-pub const ending: Reader = .fixed(&.{});
+/// This is generally safe to `@constCast` because it has an empty buffer, so
+/// there is not really a way to accidentally attempt mutation of these fields.
+const ending_state: Reader = .fixed(&.{});
+pub const ending: *Reader = @constCast(&ending_state);
 pub fn limited(r: *Reader, limit: Limit, buffer: []u8) Limited {
     return Limited.init(r, limit, buffer);

lib/std/io/Writer.zig+79-10

...	@@ -221,11 +221,12 @@ pub fn writeSplatLimit(	...	@@ -221,11 +221,12 @@ pub fn writeSplatLimit(
221	/// `end`.	221	/// `end`.
222	pub fn flush(w: *Writer) Error!void {	222	pub fn flush(w: *Writer) Error!void {
223	assert(0 == try w.vtable.drain(w, &.{}, 0));	223	assert(0 == try w.vtable.drain(w, &.{}, 0));
		224	if (w.end != 0) assert(w.vtable.drain == &fixedDrain);
224	}	225	}
225		226
226	/// Calls `VTable.drain` but hides the last `preserve_length` bytes from the	227	/// Calls `VTable.drain` but hides the last `preserve_length` bytes from the
227	/// implementation, keeping them buffered.	228	/// implementation, keeping them buffered.
228	pub fn drainLimited(w: *Writer, preserve_length: usize) Error!void {	229	pub fn drainPreserve(w: *Writer, preserve_length: usize) Error!void {
229	const temp_end = w.end -\| preserve_length;	230	const temp_end = w.end -\| preserve_length;
230	const preserved = w.buffer[temp_end..w.end];	231	const preserved = w.buffer[temp_end..w.end];
231	w.end = temp_end;	232	w.end = temp_end;
...	@@ -235,6 +236,67 @@ pub fn drainLimited(w: *Writer, preserve_length: usize) Error!void {	...	@@ -235,6 +236,67 @@ pub fn drainLimited(w: *Writer, preserve_length: usize) Error!void {
235	@memmove(w.buffer[w.end..][0..preserved.len], preserved);	236	@memmove(w.buffer[w.end..][0..preserved.len], preserved);
236	}	237	}
237		238
		239	/// Forwards a `drain` to a second `Writer` instance. `w` is only used for its
		240	/// buffer, but it has its `end` and `count` adjusted accordingly depending on
		241	/// how much was consumed.
		242	///
		243	/// Returns how many bytes from `data` were consumed.
		244	pub fn drainTo(noalias w: Writer, noalias other: Writer, data: []const []const u8, splat: usize) Error!usize {
		245	assert(w != other);
		246	const header = w.buffered();
		247	const new_end = other.end + header.len;
		248	if (new_end <= other.buffer.len) {
		249	@memcpy(other.buffer[other.end..][0..header.len], header);
		250	other.end = new_end;
		251	other.count += header.len;
		252	w.end = 0;
		253	const n = try other.vtable.drain(other, data, splat);
		254	other.count += n;
		255	return n;
		256	}
		257	if (other.vtable == &VectorWrapper.vtable) {
		258	const wrapper: *VectorWrapper = @fieldParentPtr("writer", w);
		259	while (wrapper.it.next()) \|dest\| {
		260	_ = dest;
		261	@panic("TODO");
		262	}
		263	}
		264	var vecs: [8][]const u8 = undefined; // Arbitrarily chosen size.
		265	var i: usize = 1;
		266	vecs[0] = header;
		267	for (data) \|buf\| {
		268	if (buf.len == 0) continue;
		269	vecs[i] = buf;
		270	i += 1;
		271	if (vecs.len - i == 0) break;
		272	}
		273	const new_splat = if (vecs[i - 1].ptr == data[data.len - 1].ptr) splat else 1;
		274	const n = try other.vtable.drain(other, vecs[0..i], new_splat);
		275	other.count += n;
		276	if (n < header.len) {
		277	const remaining = w.buffer[n..w.end];
		278	@memmove(w.buffer[0..remaining.len], remaining);
		279	w.end = remaining.len;
		280	return 0;
		281	}
		282	defer w.end = 0;
		283	return n - header.len;
		284	}
		285
		286	pub fn drainToLimit(
		287	noalias w: *Writer,
		288	noalias other: *Writer,
		289	data: []const []const u8,
		290	splat: usize,
		291	limit: Limit,
		292	) Error!usize {
		293	assert(w != other);
		294	_ = data;
		295	_ = splat;
		296	_ = limit;
		297	@panic("TODO");
		298	}
		299
238	pub fn unusedCapacitySlice(w: *const Writer) []u8 {	300	pub fn unusedCapacitySlice(w: *const Writer) []u8 {
239	return w.buffer[w.end..];	301	return w.buffer[w.end..];
240	}	302	}
...	@@ -285,10 +347,10 @@ pub fn writableSliceGreedy(w: *Writer, minimum_length: usize) Error![]u8 {	...	@@ -285,10 +347,10 @@ pub fn writableSliceGreedy(w: *Writer, minimum_length: usize) Error![]u8 {
285	/// remain buffered.	347	/// remain buffered.
286	///	348	///
287	/// If `preserve_length` is zero, this is equivalent to `writableSliceGreedy`.	349	/// If `preserve_length` is zero, this is equivalent to `writableSliceGreedy`.
288	pub fn writableSliceGreedyPreserving(w: *Writer, preserve_length: usize, minimum_length: usize) Error![]u8 {	350	pub fn writableSliceGreedyPreserve(w: *Writer, preserve_length: usize, minimum_length: usize) Error![]u8 {
289	assert(w.buffer.len >= preserve_length + minimum_length);	351	assert(w.buffer.len >= preserve_length + minimum_length);
290	while (w.buffer.len - w.end < minimum_length) {	352	while (w.buffer.len - w.end < minimum_length) {
291	try drainLimited(w, preserve_length);	353	try drainPreserve(w, preserve_length);
292	} else {	354	} else {
293	@branchHint(.likely);	355	@branchHint(.likely);
294	return w.buffer[w.end..];	356	return w.buffer[w.end..];
...	@@ -444,7 +506,7 @@ pub fn write(w: *Writer, bytes: []const u8) Error!usize {	...	@@ -444,7 +506,7 @@ pub fn write(w: *Writer, bytes: []const u8) Error!usize {
444	}	506	}
445		507
446	/// Asserts `buffer` capacity exceeds `preserve_length`.	508	/// Asserts `buffer` capacity exceeds `preserve_length`.
447	pub fn writePreserving(w: *Writer, preserve_length: usize, bytes: []const u8) Error!usize {	509	pub fn writePreserve(w: *Writer, preserve_length: usize, bytes: []const u8) Error!usize {
448	assert(preserve_length <= w.buffer.len);	510	assert(preserve_length <= w.buffer.len);
449	if (w.end + bytes.len <= w.buffer.len) {	511	if (w.end + bytes.len <= w.buffer.len) {
450	@branchHint(.likely);	512	@branchHint(.likely);
...	@@ -478,9 +540,9 @@ pub fn writeAll(w: *Writer, bytes: []const u8) Error!void {	...	@@ -478,9 +540,9 @@ pub fn writeAll(w: *Writer, bytes: []const u8) Error!void {
478	/// remain buffered.	540	/// remain buffered.
479	///	541	///
480	/// Asserts `buffer` capacity exceeds `preserve_length`.	542	/// Asserts `buffer` capacity exceeds `preserve_length`.
481	pub fn writeAllPreserving(w: *Writer, preserve_length: usize, bytes: []const u8) Error!void {	543	pub fn writeAllPreserve(w: *Writer, preserve_length: usize, bytes: []const u8) Error!void {
482	var index: usize = 0;	544	var index: usize = 0;
483	while (index < bytes.len) index += try w.writePreserving(preserve_length, bytes[index..]);	545	while (index < bytes.len) index += try w.writePreserve(preserve_length, bytes[index..]);
484	}	546	}
485		547
486	pub fn print(w: *Writer, comptime format: []const u8, args: anytype) Error!void {	548	pub fn print(w: *Writer, comptime format: []const u8, args: anytype) Error!void {
...	@@ -505,9 +567,9 @@ pub fn writeByte(w: *Writer, byte: u8) Error!void {	...	@@ -505,9 +567,9 @@ pub fn writeByte(w: *Writer, byte: u8) Error!void {
505		567
506	/// When draining the buffer, ensures that at least `preserve_length` bytes	568	/// When draining the buffer, ensures that at least `preserve_length` bytes
507	/// remain buffered.	569	/// remain buffered.
508	pub fn writeBytePreserving(w: *Writer, preserve_length: usize, byte: u8) Error!void {	570	pub fn writeBytePreserve(w: *Writer, preserve_length: usize, byte: u8) Error!void {
509	while (w.buffer.len - w.end == 0) {	571	while (w.buffer.len - w.end == 0) {
510	try drainLimited(w, preserve_length);	572	try drainPreserve(w, preserve_length);
511	} else {	573	} else {
512	@branchHint(.likely);	574	@branchHint(.likely);
513	w.buffer[w.end] = byte;	575	w.buffer[w.end] = byte;
...	@@ -615,19 +677,26 @@ pub fn sendFile(w: Writer, file_reader: File.Reader, limit: Limit) FileError!u	...	@@ -615,19 +677,26 @@ pub fn sendFile(w: Writer, file_reader: File.Reader, limit: Limit) FileError!u
615	/// on how much was consumed.	677	/// on how much was consumed.
616	///	678	///
617	/// Returns how many bytes from `file_reader` were consumed.	679	/// Returns how many bytes from `file_reader` were consumed.
618	pub fn sendFileTo(w: Writer, other: Writer, file_reader: *File.Reader, limit: Limit) FileError!usize {	680	pub fn sendFileTo(
		681	noalias w: *Writer,
		682	noalias other: *Writer,
		683	file_reader: *File.Reader,
		684	limit: Limit,
		685	) FileError!usize {
		686	assert(w != other);
619	const header = w.buffered();	687	const header = w.buffered();
620	const new_end = other.end + header.len;	688	const new_end = other.end + header.len;
621	if (new_end <= other.buffer.len) {	689	if (new_end <= other.buffer.len) {
622	@memcpy(other.buffer[other.end..][0..header.len], header);	690	@memcpy(other.buffer[other.end..][0..header.len], header);
623	other.end = new_end;	691	other.end = new_end;
		692	other.count += header.len;
624	w.end = 0;	693	w.end = 0;
625	return other.vtable.sendFile(other, file_reader, limit);	694	return other.vtable.sendFile(other, file_reader, limit);
626	}	695	}
627	assert(header.len > 0);	696	assert(header.len > 0);
628	var vec_buf: [2][]const u8 = .{ header, undefined };	697	var vec_buf: [2][]const u8 = .{ header, undefined };
629	var vec_i: usize = 1;	698	var vec_i: usize = 1;
630	const buffered_contents = limit.slice(file_reader.buffered());	699	const buffered_contents = limit.slice(file_reader.interface.buffered());
631	if (buffered_contents.len > 0) {	700	if (buffered_contents.len > 0) {
632	vec_buf[vec_i] = buffered_contents;	701	vec_buf[vec_i] = buffered_contents;
633	vec_i += 1;	702	vec_i += 1;

...	@@ -1788,7 +1788,7 @@ fn evalGeneric(run: Run, child: std.process.Child) !StdIoResult {	...	@@ -1788,7 +1788,7 @@ fn evalGeneric(run: Run, child: std.process.Child) !StdIoResult {
1788	stderr_bytes = poller.reader(.stderr).buffered();	1788	stderr_bytes = poller.reader(.stderr).buffered();
1789	} else {	1789	} else {
1790	var fr = stdout.readerStreaming();	1790	var fr = stdout.readerStreaming();
1791	stdout_bytes = fr.interface().readRemainingAlloc(arena, run.stdio_limit) catch \|err\| switch (err) {	1791	stdout_bytes = fr.interface().allocRemaining(arena, run.stdio_limit) catch \|err\| switch (err) {
1792	error.OutOfMemory => return error.OutOfMemory,	1792	error.OutOfMemory => return error.OutOfMemory,
1793	error.ReadFailed => return fr.err.?,	1793	error.ReadFailed => return fr.err.?,
1794	error.StreamTooLong => return error.StdoutStreamTooLong,	1794	error.StreamTooLong => return error.StdoutStreamTooLong,
...	@@ -1796,7 +1796,7 @@ fn evalGeneric(run: Run, child: std.process.Child) !StdIoResult {	...	@@ -1796,7 +1796,7 @@ fn evalGeneric(run: Run, child: std.process.Child) !StdIoResult {
1796	}	1796	}
1797	} else if (child.stderr) \|stderr\| {	1797	} else if (child.stderr) \|stderr\| {
1798	var fr = stderr.readerStreaming();	1798	var fr = stderr.readerStreaming();
1799	stderr_bytes = fr.interface().readRemainingAlloc(arena, run.stdio_limit) catch \|err\| switch (err) {	1799	stderr_bytes = fr.interface().allocRemaining(arena, run.stdio_limit) catch \|err\| switch (err) {
1800	error.OutOfMemory => return error.OutOfMemory,	1800	error.OutOfMemory => return error.OutOfMemory,
1801	error.ReadFailed => return fr.err.?,	1801	error.ReadFailed => return fr.err.?,
1802	error.StreamTooLong => return error.StderrStreamTooLong,	1802	error.StreamTooLong => return error.StderrStreamTooLong,

...	@@ -8,7 +8,7 @@ const Writer = std.io.Writer;	...	@@ -8,7 +8,7 @@ const Writer = std.io.Writer;
8	const Reader = std.io.Reader;	8	const Reader = std.io.Reader;
9		9
10	input: *Reader,	10	input: *Reader,
11	interface: Reader,	11	reader: Reader,
12	/// Hashes, produces checksum, of uncompressed data for gzip/zlib footer.	12	/// Hashes, produces checksum, of uncompressed data for gzip/zlib footer.
13	hasher: Container.Hasher,	13	hasher: Container.Hasher,
14		14
...	@@ -51,7 +51,7 @@ pub const Error = Container.Error \|\| error{	...	@@ -51,7 +51,7 @@ pub const Error = Container.Error \|\| error{
51		51
52	pub fn init(input: *Reader, container: Container, buffer: []u8) Decompress {	52	pub fn init(input: *Reader, container: Container, buffer: []u8) Decompress {
53	return .{	53	return .{
54	.interface = .{	54	.reader = .{
55	// TODO populate discard so that when an amount is discarded that	55	// TODO populate discard so that when an amount is discarded that
56	// includes an entire frame, skip decoding that frame.	56	// includes an entire frame, skip decoding that frame.
57	.vtable = &.{ .stream = stream },	57	.vtable = &.{ .stream = stream },
...	@@ -130,7 +130,7 @@ fn decodeSymbol(self: *Decompress, decoder: anytype) !Symbol {	...	@@ -130,7 +130,7 @@ fn decodeSymbol(self: *Decompress, decoder: anytype) !Symbol {
130	}	130	}
131		131
132	pub fn stream(r: Reader, w: Writer, limit: std.io.Limit) Reader.StreamError!usize {	132	pub fn stream(r: Reader, w: Writer, limit: std.io.Limit) Reader.StreamError!usize {
133	const d: *Decompress = @alignCast(@fieldParentPtr("interface", r));	133	const d: *Decompress = @alignCast(@fieldParentPtr("reader", r));
134	return readInner(d, w, limit) catch \|err\| switch (err) {	134	return readInner(d, w, limit) catch \|err\| switch (err) {
135	error.EndOfStream => return error.EndOfStream,	135	error.EndOfStream => return error.EndOfStream,
136	error.WriteFailed => return error.WriteFailed,	136	error.WriteFailed => return error.WriteFailed,
...	@@ -247,7 +247,7 @@ fn readInner(d: Decompress, w: Writer, limit: std.io.Limit) (Error \|\| Reader.S	...	@@ -247,7 +247,7 @@ fn readInner(d: Decompress, w: Writer, limit: std.io.Limit) (Error \|\| Reader.S
247	}	247	}
248	},	248	},
249	.stored_block => \|remaining_len\| {	249	.stored_block => \|remaining_len\| {
250	const out = try w.writableSliceGreedyPreserving(flate.history_len, 1);	250	const out = try w.writableSliceGreedyPreserve(flate.history_len, 1);
251	const limited_out = limit.min(.limited(remaining_len)).slice(out);	251	const limited_out = limit.min(.limited(remaining_len)).slice(out);
252	const n = try d.input.readVec(&.{limited_out});	252	const n = try d.input.readVec(&.{limited_out});
253	if (remaining_len - n == 0) {	253	if (remaining_len - n == 0) {
...	@@ -263,7 +263,7 @@ fn readInner(d: Decompress, w: Writer, limit: std.io.Limit) (Error \|\| Reader.S	...	@@ -263,7 +263,7 @@ fn readInner(d: Decompress, w: Writer, limit: std.io.Limit) (Error \|\| Reader.S
263	while (@intFromEnum(limit) > w.count - start) {	263	while (@intFromEnum(limit) > w.count - start) {
264	const code = try d.readFixedCode();	264	const code = try d.readFixedCode();
265	switch (code) {	265	switch (code) {
266	0...255 => try w.writeBytePreserving(flate.history_len, @intCast(code)),	266	0...255 => try w.writeBytePreserve(flate.history_len, @intCast(code)),
267	256 => {	267	256 => {
268	d.state = if (d.final_block) .protocol_footer else .block_header;	268	d.state = if (d.final_block) .protocol_footer else .block_header;
269	return w.count - start;	269	return w.count - start;
...	@@ -289,7 +289,7 @@ fn readInner(d: Decompress, w: Writer, limit: std.io.Limit) (Error \|\| Reader.S	...	@@ -289,7 +289,7 @@ fn readInner(d: Decompress, w: Writer, limit: std.io.Limit) (Error \|\| Reader.S
289	const sym = try d.decodeSymbol(&d.lit_dec);	289	const sym = try d.decodeSymbol(&d.lit_dec);
290		290
291	switch (sym.kind) {	291	switch (sym.kind) {
292	.literal => try w.writeBytePreserving(flate.history_len, sym.symbol),	292	.literal => try w.writeBytePreserve(flate.history_len, sym.symbol),
293	.match => {	293	.match => {
294	// Decode match backreference <length, distance>	294	// Decode match backreference <length, distance>
295	const length = try d.decodeLength(sym.symbol);	295	const length = try d.decodeLength(sym.symbol);