@zigc/lib 0.17.0-dev.39 → 0.17.0-dev.56

package/std/Io/Uring.zig

@@ -779,7 +779,6 @@ pub fn io(ev: *Evented) Io {
             .netConnectUnix = netConnectUnixUnavailable,
             .netSocketCreatePair = netSocketCreatePairUnavailable,
             .netSend = netSendUnavailable,
-            .netRead = netReadUnavailable,
             .netWrite = netWriteUnavailable,
             .netWriteFile = netWriteFileUnavailable,
             .netClose = netClose,
@@ -2105,6 +2104,12 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
                 };
             },
         },
+        .net_read => |o| .{
+            .net_read = r: {
+                _ = o;
+                break :r error.NetworkDown; // TODO
+            },
+        },
     };
 }
 
@@ -2392,6 +2397,10 @@ fn batchDrainSubmitted(
                 _ = o;
                 @panic("TODO implement batchDrainSubmitted for net_receive");
             },
+            .net_read => |o| {
+                _ = o;
+                @panic("TODO implement batchDrainSubmitted for net_read");
+            },
         })) |result| {
             switch (batch.completed.tail) {
                 .none => batch.completed.head = index,
@@ -2493,6 +2502,7 @@ fn batchDrainReady(batch: *Io.Batch) Io.Timeout.Error!void {
                 },
                 .device_io_control => unreachable,
                 .net_receive => @panic("TODO"),
+                .net_read => @panic("TODO"),
             })) |result| {
                 switch (batch.completed.tail) {
                     .none => batch.completed.head = index,
@@ -5142,18 +5152,6 @@ fn netReceive(
     }
 }
 
-fn netReadUnavailable(
-    userdata: ?*anyopaque,
-    fd: net.Socket.Handle,
-    data: [][]u8,
-) net.Stream.Reader.Error!usize {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = fd;
-    _ = data;
-    return error.NetworkDown;
-}
-
 fn netWriteUnavailable(
     userdata: ?*anyopaque,
     handle: net.Socket.Handle,

package/std/Io/net.zig

@@ -1245,6 +1245,15 @@ pub const Stream = struct {
 
     const max_iovecs_len = 8;
 
+    /// This is a low-level API that calls the `Io` interface function directly.
+    /// For a higher level API, see `reader`.
+    pub fn read(s: *const Stream, io: Io, data: [][]u8) Reader.Error!usize {
+        return (try io.operate(.{ .net_read = .{
+            .socket_handle = s.socket.handle,
+            .data = data,
+        } })).net_read;
+    }
+
     pub fn close(s: *const Stream, io: Io) void {
         io.vtable.netClose(io.userdata, (&s.socket.handle)[0..1]);
     }
@@ -1259,16 +1268,7 @@ pub const Stream = struct {
         stream: Stream,
         err: ?Error,
 
-        pub const Error = error{
-            SystemResources,
-            ConnectionResetByPeer,
-            Timeout,
-            SocketUnconnected,
-            /// The file descriptor does not hold the required rights to read
-            /// from it.
-            AccessDenied,
-            NetworkDown,
-        } || Io.Cancelable || Io.UnexpectedError;
+        pub const Error = Io.Operation.NetRead.Error || Io.Cancelable;
 
         pub fn init(stream: Stream, io: Io, buffer: []u8) Reader {
             return .{
@@ -1302,7 +1302,7 @@ pub const Stream = struct {
             const dest_n, const data_size = try io_r.writableVector(&iovecs_buffer, data);
             const dest = iovecs_buffer[0..dest_n];
             assert(dest[0].len > 0);
-            const n = io.vtable.netRead(io.userdata, r.stream.socket.handle, dest) catch |err| {
+            const n = r.stream.read(io, dest) catch |err| {
                 r.err = err;
                 return error.ReadFailed;
             };

package/std/Io.zig

@@ -243,8 +243,6 @@ pub const VTable = struct {
     netConnectUnix: *const fn (?*anyopaque, *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle,
     netSocketCreatePair: *const fn (?*anyopaque, net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket,
     netSend: *const fn (?*anyopaque, net.Socket.Handle, []net.OutgoingMessage, net.SendFlags) struct { ?net.Socket.SendError, usize },
-    /// Returns 0 on end of stream.
-    netRead: *const fn (?*anyopaque, src: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize,
     netWrite: *const fn (?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize,
     netWriteFile: *const fn (?*anyopaque, net.Socket.Handle, header: []const u8, *Io.File.Reader, Io.Limit) net.Stream.Writer.WriteFileError!usize,
     netClose: *const fn (?*anyopaque, handle: []const net.Socket.Handle) void,
@@ -261,6 +259,7 @@ pub const Operation = union(enum) {
     /// other systems this tag is unreachable.
     device_io_control: DeviceIoControl,
     net_receive: NetReceive,
+    net_read: NetRead,
 
     pub const Tag = @typeInfo(Operation).@"union".tag_type.?;
 
@@ -386,6 +385,23 @@ pub const Operation = union(enum) {
         pub const Result = struct { ?net.Socket.ReceiveError, usize };
     };
 
+    pub const NetRead = struct {
+        socket_handle: net.Socket.Handle,
+        data: [][]u8,
+
+        pub const Error = error{
+            SystemResources,
+            ConnectionResetByPeer,
+            SocketUnconnected,
+            /// The file descriptor does not hold the required rights to read
+            /// from it.
+            AccessDenied,
+            NetworkDown,
+        } || Io.UnexpectedError;
+
+        pub const Result = Error!usize;
+    };
+
     pub const Result = Result: {
         const operation_fields = @typeInfo(Operation).@"union".fields;
         var field_names: [operation_fields.len][]const u8 = undefined;
@@ -2626,7 +2642,6 @@ pub const failing: std.Io = .{
         .netConnectUnix = failingNetConnectUnix,
         .netSocketCreatePair = failingNetSocketCreatePair,
         .netSend = failingNetSend,
-        .netRead = failingNetRead,
         .netWrite = failingNetWrite,
         .netWriteFile = failingNetWriteFile,
         .netClose = unreachableNetClose,
@@ -2774,6 +2789,7 @@ pub fn failingOperate(userdata: ?*anyopaque, operation: Operation) Cancelable!Op
         .file_write_streaming => .{ .file_write_streaming = error.InputOutput },
         .device_io_control => unreachable,
         .net_receive => .{ .net_receive = .{ error.NetworkDown, 0 } },
+        .net_read => .{ .net_read = error.NetworkDown },
     };
 }
 
@@ -3377,13 +3393,6 @@ pub fn failingNetSend(userdata: ?*anyopaque, handle: net.Socket.Handle, messages
     return .{ error.NetworkDown, 0 };
 }
 
-pub fn failingNetRead(userdata: ?*anyopaque, src: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize {
-    _ = userdata;
-    _ = src;
-    _ = data;
-    return error.NetworkDown;
-}
-
 pub fn failingNetWrite(userdata: ?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize {
     _ = userdata;
     _ = dest;

package/std/Target.zig

@@ -68,6 +68,8 @@ pub const Os = struct {
         opengl,
         vulkan,
 
+        tios,
+
         // LLVM tags deliberately omitted:
         // - bridgeos
         // - cheriotrtos
@@ -207,6 +209,8 @@ pub const Os = struct {
                 .opencl,
                 .opengl,
                 .vulkan,
+
+                .tios,
                 => .semver,
 
                 .hurd => .hurd,
@@ -670,6 +674,12 @@ pub const Os = struct {
                         .max = .{ .major = 4, .minor = 6, .patch = 0 },
                     },
                 },
+                .tios => .{
+                    .semver = .{
+                        .min = .{ .major = 5, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 5, .minor = 8, .patch = 4 },
+                    },
+                },
                 .vulkan => .{
                     .semver = .{
                         .min = .{ .major = 1, .minor = 2, .patch = 0 },
@@ -758,6 +768,7 @@ pub const wasm = @import("Target/wasm.zig");
 pub const x86 = @import("Target/x86.zig");
 pub const xcore = @import("Target/xcore.zig");
 pub const xtensa = @import("Target/xtensa.zig");
+pub const z80 = @import("Target/generic.zig");
 
 pub const Abi = enum {
     none,
@@ -942,6 +953,7 @@ pub const Abi = enum {
             .opencl,
             .opengl,
             .vulkan,
+            .tios,
             => .none,
         };
     }
@@ -1068,6 +1080,7 @@ pub fn toElfMachine(target: *const Target) std.elf.EM {
         .avr => .AVR,
         .bpfeb, .bpfel => .BPF,
         .csky => .CSKY,
+        .ez80 => .Z80,
         .hexagon => .QDSP6,
         .hppa, .hppa64 => .PARISC,
         .kalimba => .CSR_KALIMBA,
@@ -1130,6 +1143,7 @@ pub fn toCoffMachine(target: *const Target) std.coff.IMAGE.FILE.MACHINE {
         .bpfeb,
         .bpfel,
         .csky,
+        .ez80,
         .hexagon,
         .hppa,
         .hppa64,
@@ -1336,6 +1350,7 @@ pub const Cpu = struct {
         bpfeb,
         bpfel,
         csky,
+        ez80,
         hexagon,
         hppa,
         hppa64,
@@ -1437,6 +1452,7 @@ pub const Cpu = struct {
             x86,
             xcore,
             xtensa,
+            z80,
         };
 
         pub inline fn family(arch: Arch) Family {
@@ -1449,6 +1465,7 @@ pub const Cpu = struct {
                 .avr => .avr,
                 .bpfeb, .bpfel => .bpf,
                 .csky => .csky,
+                .ez80 => .z80,
                 .hexagon => .hexagon,
                 .hppa, .hppa64 => .hppa,
                 .kalimba => .kalimba,
@@ -1678,6 +1695,7 @@ pub const Cpu = struct {
                 .x86_64,
                 .xcore,
                 .xtensa,
+                .ez80,
                 => .little,
 
                 .aarch64_be,
@@ -1948,6 +1966,10 @@ pub const Cpu = struct {
                 .spirv_fragment,
                 .spirv_vertex,
                 => &.{ .spirv32, .spirv64 },
+
+                .ez80_cet,
+                .ez80_tiflags,
+                => &.{.ez80},
             };
         }
     };
@@ -2236,6 +2258,7 @@ pub fn requiresLibC(target: *const Target) bool {
         .plan9,
         .other,
         .@"3ds",
+        .tios,
         => false,
     };
 }
@@ -2398,6 +2421,8 @@ pub const DynamicLinker = struct {
             .ps5,
             .psp,
             .vita,
+
+            .tios,
             => .none,
         };
     }
@@ -2815,6 +2840,8 @@ pub const DynamicLinker = struct {
             .opencl,
             .opengl,
             .vulkan,
+
+            .tios,
             => none,
 
             // TODO go over each item in this list and either move it to the above list, or
@@ -2849,6 +2876,9 @@ pub fn ptrBitWidth_arch_abi(cpu_arch: Cpu.Arch, abi: Abi) u16 {
         .x86_16,
         => 16,
 
+        .ez80,
+        => 24,
+
         .arc,
         .arceb,
         .arm,
@@ -2917,6 +2947,8 @@ pub fn ptrBitWidth(target: *const Target) u16 {
 pub fn stackAlignment(target: *const Target) u16 {
     // Overrides for when the stack alignment is not equal to the pointer width.
     switch (target.cpu.arch) {
+        .ez80,
+        => return 1,
         .m68k,
         => return 2,
         .amdgcn,
@@ -2997,6 +3029,7 @@ pub fn cCharSignedness(target: *const Target) std.builtin.Signedness {
         .arc,
         .arceb,
         .csky,
+        .ez80,
         .hexagon,
         .msp430,
         .powerpc,
@@ -3049,8 +3082,6 @@ pub fn cTypeByteSize(t: *const Target, c_type: CType) u16 {
         => @divExact(cTypeBitSize(t, c_type), 8),
 
         .longdouble => switch (cTypeBitSize(t, c_type)) {
-            16 => 2,
-            32 => 4,
             64 => 8,
             80 => @intCast(std.mem.alignForward(usize, 10, cTypeAlignment(t, .longdouble))),
             128 => 16,
@@ -3364,6 +3395,13 @@ pub fn cTypeBitSize(target: *const Target, c_type: CType) u16 {
             .long, .ulong => return 64,
             .longlong, .ulonglong, .double, .longdouble => return 64,
         },
+        .tios => switch (c_type) {
+            .char => return 8,
+            .short, .ushort => return 16,
+            .int, .uint => return 24,
+            .long, .ulong, .float, .double => return 32,
+            .longlong, .ulonglong, .longdouble => return 64,
+        },
 
         .ps3,
         .contiki,
@@ -3376,7 +3414,7 @@ pub fn cTypeBitSize(target: *const Target, c_type: CType) u16 {
 pub fn cTypeAlignment(target: *const Target, c_type: CType) u16 {
     // Overrides for unusual alignments
     switch (target.cpu.arch) {
-        .avr => return 1,
+        .avr, .ez80 => return 1,
         .x86 => switch (target.os.tag) {
             .windows, .uefi => switch (c_type) {
                 .longlong, .ulonglong, .double => return 8,
@@ -3406,6 +3444,8 @@ pub fn cTypeAlignment(target: *const Target, c_type: CType) u16 {
     return @min(
         std.math.ceilPowerOfTwoAssert(u16, (cTypeBitSize(target, c_type) + 7) / 8),
         @as(u16, switch (target.cpu.arch) {
+            .ez80 => 1,
+
             .msp430,
             .x86_16,
             => 2,
@@ -3484,7 +3524,7 @@ pub fn cTypePreferredAlignment(target: *const Target, c_type: CType) u16 {
             .longdouble => return 4,
             else => {},
         },
-        .avr => return 1,
+        .avr, .ez80 => return 1,
         .x86 => switch (target.os.tag) {
             .windows, .uefi => switch (c_type) {
                 .longdouble => switch (target.abi) {
@@ -3516,6 +3556,8 @@ pub fn cTypePreferredAlignment(target: *const Target, c_type: CType) u16 {
     return @min(
         std.math.ceilPowerOfTwoAssert(u16, (cTypeBitSize(target, c_type) + 7) / 8),
         @as(u16, switch (target.cpu.arch) {
+            .ez80 => 1,
+
             .x86_16, .msp430 => 2,
 
             .arc,
@@ -3587,7 +3629,9 @@ pub fn cTypePreferredAlignment(target: *const Target, c_type: CType) u16 {
 
 pub fn cMaxIntAlignment(target: *const Target) u16 {
     return switch (target.cpu.arch) {
-        .avr => 1,
+        .avr,
+        .ez80,
+        => 1,
 
         .msp430, .x86_16 => 2,
 
@@ -3726,6 +3770,7 @@ pub fn cCallingConvention(target: *const Target) ?std.builtin.CallingConvention
         .amdgcn => .{ .amdgcn_device = .{} },
         .nvptx, .nvptx64 => .nvptx_device,
         .spirv32, .spirv64 => .spirv_device,
+        .ez80 => .ez80_cet,
     };
 }
 

package/std/builtin.zig

@@ -341,6 +341,10 @@ pub const CallingConvention = union(enum(u8)) {
     spirv_fragment,
     spirv_vertex,
 
+    // Calling conventions for the `ez80` architecture.
+    ez80_cet,
+    ez80_tiflags,
+
     /// Options shared across most calling conventions.
     pub const CommonOptions = struct {
         /// The boundary the stack is aligned to when the function is called.

package/std/c/haiku.zig

@@ -6,6 +6,7 @@ const iovec = std.posix.iovec;
 const iovec_const = std.posix.iovec_const;
 const socklen_t = std.c.socklen_t;
 const fd_t = std.c.fd_t;
+const off_t = std.c.off_t;
 const PATH_MAX = std.c.PATH_MAX;
 const uid_t = std.c.uid_t;
 const gid_t = std.c.gid_t;
@@ -28,6 +29,8 @@ pub extern "root" fn _kern_open_dir(fd: fd_t, path: [*:0]const u8) fd_t;
 pub extern "root" fn _kern_read_dir(fd: fd_t, buffer: [*]u8, bufferSize: usize, maxCount: u32) isize;
 pub extern "root" fn _kern_rewind_dir(fd: fd_t) status_t;
 pub extern "root" fn _kern_read_stat(fd: fd_t, path: [*:0]const u8, traverseLink: bool, stat: *std.c.Stat, statSize: usize) status_t;
+pub extern "root" fn readv_pos(fd: fd_t, pos: off_t, vec: [*]const std.c.iovec, count: i32) isize;
+pub extern "root" fn writev_pos(fd: fd_t, pos: off_t, vec: [*]const std.c.iovec_const, count: i32) isize;
 
 pub const area_info = extern struct {
     area: u32,

package/std/c.zig

@@ -3260,8 +3260,8 @@ pub const Sigaction = switch (native_os) {
 
         /// signal handler
         handler: extern union {
-            handler: handler_fn,
-            sigaction: sigaction_fn,
+            handler: ?handler_fn,
+            sigaction: ?sigaction_fn,
         },
 
         /// signal mask to apply
@@ -11102,6 +11102,14 @@ pub const ioctl = switch (native_os) {
     else => private.ioctl,
 };
 
+// Math
+pub extern "c" fn atan(x: f64) callconv(.c) f64;
+pub extern "c" fn copysign(x: f64, y: f64) callconv(.c) f64;
+pub extern "c" fn fdim(x: f64, y: f64) callconv(.c) f64;
+pub extern "c" fn frexp(x: f64, e: *c_int) callconv(.c) f64;
+pub extern "c" fn hypot(x: f64, y: f64) callconv(.c) f64;
+pub extern "c" fn modf(x: f64, iptr: *f64) callconv(.c) f64;
+
 // OS-specific bits. These are protected from being used on the wrong OS by
 // comptime assertions inside each OS-specific file.
 
@@ -11142,6 +11150,8 @@ pub const _kern_open_dir = haiku._kern_open_dir;
 pub const _kern_read_dir = haiku._kern_read_dir;
 pub const _kern_read_stat = haiku._kern_read_stat;
 pub const _kern_rewind_dir = haiku._kern_rewind_dir;
+pub const readv_pos = haiku.readv_pos;
+pub const writev_pos = haiku.writev_pos;
 pub const area_id = haiku.area_id;
 pub const area_info = haiku.area_info;
 pub const directory_which = haiku.directory_which;

package/std/debug.zig

@@ -1576,12 +1576,12 @@ fn handleSegfaultPosix(sig: posix.SIG, info: *const posix.siginfo_t, ctx_ptr: ?*
             .tvos,
             .visionos,
             .watchos,
+            .haiku,
             => @intFromPtr(info.addr),
             .linux,
             => @intFromPtr(info.fields.sigfault.addr),
             .netbsd,
             => @intFromPtr(info.info.reason.fault.addr),
-            .haiku,
             .openbsd,
             => @intFromPtr(info.data.fault.addr),
             .illumos,

package/std/fmt.zig

@@ -1342,9 +1342,9 @@ pub const hex_charset = "0123456789abcdef";
 
 /// Converts an unsigned integer of any multiple of u8 to an array of lowercase
 /// hex bytes, little endian.
-pub fn hex(x: anytype) [@sizeOf(@TypeOf(x)) * 2]u8 {
+pub fn hex(x: anytype) [@typeInfo(@TypeOf(x)).int.bits / 4]u8 {
     comptime assert(@typeInfo(@TypeOf(x)).int.signedness == .unsigned);
-    var result: [@sizeOf(@TypeOf(x)) * 2]u8 = undefined;
+    var result: [@typeInfo(@TypeOf(x)).int.bits / 4]u8 = undefined;
     var i: usize = 0;
     while (i < result.len / 2) : (i += 1) {
         const byte: u8 = @truncate(x >> @intCast(8 * i));
@@ -1360,6 +1360,11 @@ test hex {
         try std.testing.expect(x.len == 8);
         try std.testing.expectEqualStrings("efbeadde", &x);
     }
+    {
+        const s = "[" ++ hex(@as(u48, 0x12345678_abcd)) ++ "]";
+        try std.testing.expect(s.len == 14);
+        try std.testing.expectEqualStrings("[cdab78563412]", s);
+    }
     {
         const s = "[" ++ hex(@as(u64, 0x12345678_abcdef00)) ++ "]";
         try std.testing.expect(s.len == 18);

package/std/http/Client.zig

@@ -4,8 +4,6 @@
 //!
 //! TLS support may be disabled via `std.options.http_disable_tls`.
 //!
-//! TODO all the lockUncancelable in this file should be changed to regular lock and
-//! `error.Canceled` added to more error sets.
 const Client = @This();
 
 const builtin = @import("builtin");
@@ -84,8 +82,8 @@ pub const ConnectionPool = struct {
     /// If no connection is found, null is returned.
     ///
     /// Threadsafe.
-    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) ?*Connection {
-        pool.mutex.lockUncancelable(io);
+    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) Io.Cancelable!?*Connection {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         var next = pool.free.last;
@@ -113,8 +111,8 @@ pub const ConnectionPool = struct {
     }
 
     /// Acquires an existing connection from the connection pool. This function is threadsafe.
-    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         return pool.acquireUnsafe(connection);
@@ -150,8 +148,8 @@ pub const ConnectionPool = struct {
     }
 
     /// Adds a newly created node to the pool of used connections. This function is threadsafe.
-    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         pool.used.append(&connection.pool_node);
@@ -162,18 +160,15 @@ pub const ConnectionPool = struct {
     /// If the new size is smaller than the current size, then idle connections will be closed until the pool is the new size.
     ///
     /// Threadsafe.
-    pub fn resize(pool: *ConnectionPool, io: Io, allocator: Allocator, new_size: usize) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn resize(pool: *ConnectionPool, io: Io, new_size: usize) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
-        const next = pool.free.first;
-        _ = next;
         while (pool.free_len > new_size) {
-            const popped = pool.free.popFirst() orelse unreachable;
+            const popped: *Connection = @alignCast(@fieldParentPtr("pool_node", pool.free.popFirst().?));
             pool.free_len -= 1;
 
-            popped.data.close(allocator);
-            allocator.destroy(popped);
+            popped.destroy(io);
         }
 
         pool.free_size = new_size;
@@ -1323,7 +1318,7 @@ pub fn initDefaultProxies(client: *Client, arena: Allocator, environ_map: *const
     const io = client.io;
 
     // Prevent any new connections from being created.
-    client.connection_pool.mutex.lockUncancelable(io);
+    try client.connection_pool.mutex.lock(io);
     defer client.connection_pool.mutex.unlock(io);
 
     assert(client.connection_pool.used.first == null); // There are active requests.
@@ -1418,7 +1413,7 @@ pub const basic_authorization = struct {
 
 pub const ConnectTcpError = error{
     TlsInitializationFailed,
-} || Allocator.Error || HostName.ConnectError;
+} || Allocator.Error || HostName.ConnectError || Io.Cancelable;
 
 /// Reuses a `Connection` if one matching `host` and `port` is already open.
 ///
@@ -1451,7 +1446,7 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
     const proxied_host = options.proxied_host orelse host;
     const proxied_port = options.proxied_port orelse port;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = protocol,
@@ -1469,18 +1464,20 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
                 error.Canceled => |e| return e,
                 else => return error.TlsInitializationFailed,
             };
-            client.connection_pool.addUsed(io, &tc.connection);
+            errdefer tc.destroy();
+            try client.connection_pool.addUsed(io, &tc.connection);
             return &tc.connection;
         },
         .plain => {
             const pc = try Connection.Plain.create(client, proxied_host, proxied_port, stream);
-            client.connection_pool.addUsed(io, &pc.connection);
+            errdefer pc.destroy();
+            try client.connection_pool.addUsed(io, &pc.connection);
             return &pc.connection;
         },
     }
 }
 
-pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{NameTooLong} || std.posix.ConnectError;
+pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{NameTooLong} || std.posix.ConnectError || Io.Cancelable;
 
 /// Connect to `path` as a unix domain socket. This will reuse a connection if one is already open.
 ///
@@ -1488,7 +1485,7 @@ pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{N
 pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connection {
     const io = client.io;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = path,
         .port = 0,
         .protocol = .plain,
@@ -1512,7 +1509,7 @@ pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connecti
     };
     errdefer client.allocator.free(conn.data.host);
 
-    client.connection_pool.addUsed(conn);
+    try client.connection_pool.addUsed(conn);
 
     return &conn.data;
 }
@@ -1530,7 +1527,7 @@ pub fn connectProxied(
     const io = client.io;
     if (!proxy.supports_connect) return error.TunnelNotSupported;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = proxy.protocol,

package/std/sort.zig

@@ -749,9 +749,9 @@ test partitionPoint {
 
 /// Returns a tuple of the lower and upper indices in `items` between which all
 /// elements return `.eq` when given to `compareFn`.
-/// - If no element in `items` returns `.eq`, both indices are the
-/// index of the first element in `items` returning `.gt`.
-/// - If no element in `items` returns `.gt`, both indices equal `items.len`.
+/// If no element in `items` returns `.eq`, both indices are the index of the
+/// first element in `items` which returns `.gt`, or if no element returns `.gt`,
+/// both indices are `items.len`.
 ///
 /// `items` must be sorted in ascending order with respect to `compareFn`:
 /// ```

package/std/zig/LibCInstallation.zig

@@ -459,6 +459,7 @@ fn findNativeCrtDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, args:
 
 fn findNativeGccDirHaiku(self: *LibCInstallation, gpa: Allocator, io: Io, args: FindNativeOptions) FindError!void {
     self.gcc_dir = try ccPrintFileName(gpa, io, .{
+        .environ_map = args.environ_map,
         .search_basename = "crtbeginS.o",
         .want_dirname = .only_dir,
         .verbose = args.verbose,