Skip to content
Standard libraryZig 0.17.1Official documentation
Sourcestd/zig/WindowsSdk.zig

Source line 1

Fields

windows10sdk: ?Installation
windows81sdk: ?Installation
msvc_lib_dir: ?[]const u8

std.zig.WindowsSdk.Allocator

alias

Source line 8

Alias of std.mem.Allocator

std.zig.WindowsSdk.builtin

constant

Source line 2

std.zig.WindowsSdk.Dir

alias

Source line 6

Alias of std.Io.Dir

std.zig.WindowsSdk.Environ

alias

Source line 9

Alias of std.process.Environ

std.zig.WindowsSdk.find

function

Source line 29

Find path and version of Windows 10 SDK and Windows 8.1 SDK, and find path to MSVC's lib/ directory. Caller owns the result's fields. Returns memory allocated by gpa

pub fn find( gpa: Allocator, io: Io, arch: std.Target.Cpu.Arch, environ_map: *const Environ.Map, ) error{ OutOfMemory, NotFound, PathTooLong }!WindowsSdk

Parameters

gpa: Allocator
io: Io
arch: std.Target.Cpu.Arch
environ_map: *const Environ.Map

Errors

NotFound
OutOfMemory
PathTooLong

std.zig.WindowsSdk.free

function

Source line 75

pub fn free(sdk: WindowsSdk, gpa: Allocator) void

Parameters

sdk: WindowsSdk
gpa: Allocator

std.zig.WindowsSdk.Installation

container

Source line 458

Fields

path: []const u8
version: []const u8

std.zig.WindowsSdk.Installation.find

function

Source line 464

Find path and version of Windows SDK. Caller owns the result's fields.

fn find( gpa: Allocator, io: Io, registry: *Registry, roots_key: Registry.Key, roots_subkey: []const u16, prefix: []const u8, version_key_name: []const u16, ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation

Parameters

gpa: Allocator
io: Io
registry: *Registry
roots_key: Registry.Key
roots_subkey: []const u16
prefix: []const u8
version_key_name: []const u16

Errors

InstallationNotFound
OutOfMemory
PathTooLong
VersionTooLong

std.zig.WindowsSdk.Installation.findFromInstallationFolder

function

Source line 544

fn findFromInstallationFolder( gpa: Allocator, registry: *Registry, version_key_name: []const u16, ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation

Parameters

gpa: Allocator
registry: *Registry
version_key_name: []const u16

Errors

InstallationNotFound
OutOfMemory
PathTooLong
VersionTooLong

std.zig.WindowsSdk.Installation.findFromRoot

function

Source line 487

fn findFromRoot( gpa: Allocator, io: Io, roots_key: Registry.Key, roots_subkey: []const u16, prefix: []const u8, ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation

Parameters

gpa: Allocator
io: Io
roots_key: Registry.Key
roots_subkey: []const u16
prefix: []const u8

Errors

InstallationNotFound
OutOfMemory
PathTooLong
VersionTooLong

std.zig.WindowsSdk.Installation.free

function

Source line 647

fn free(install: Installation, gpa: Allocator) void

Parameters

install: Installation
gpa: Allocator

std.zig.WindowsSdk.Installation.isValidVersion

function

Source line 618

Check whether this version is enumerated in registry.

fn isValidVersion(installation: Installation, roots_key: Registry.Key) bool

Parameters

installation: Installation
roots_key: Registry.Key

std.zig.WindowsSdk.Io

alias

Source line 5

Alias of std.Io

std.zig.WindowsSdk.is_32_bit

constant

Source line 11

std.zig.WindowsSdk.iterateAndFilterByVersion

function

Source line 90

Iterates via iterator and collects all folders with names starting with strip_prefix and a version. Returns slice of version strings sorted in descending order. Caller owns result.

fn iterateAndFilterByVersion( iterator: *Dir.Iterator, gpa: Allocator, io: Io, prefix: []const u8, ) error{OutOfMemory}![][]const u8

Parameters

iterator: *Dir.Iterator
gpa: Allocator
io: Io
prefix: []const u8

Errors

OutOfMemory

std.zig.WindowsSdk.iterateAndFilterByVersion.lessThan

function

Source line 145

pub fn lessThan(context: @This(), lhs: usize, rhs: usize) bool

Parameters

context: @This()
lhs: usize
rhs: usize

std.zig.WindowsSdk.iterateAndFilterByVersion.order

function

Source line 105

fn order(lhs: @This(), rhs: @This()) std.math.Order

Parameters

lhs: @This()
rhs: @This()

std.zig.WindowsSdk.iterateAndFilterByVersion.parseNum

function

Source line 100

fn parseNum(num: []const u8) ?u32

Parameters

num: []const u8

std.zig.WindowsSdk.iterateAndFilterByVersion.swap

function

Source line 148

pub fn swap(context: @This(), lhs: usize, rhs: usize) void

Parameters

context: @This()
lhs: usize
rhs: usize

std.zig.WindowsSdk.L

alias

Source line 10

Alias of std.unicode.wtf8ToWtf16LeStringLiteral

std.zig.WindowsSdk.MsvcLibDir

namespace

Source line 653

std.zig.WindowsSdk.MsvcLibDir.find

function

Source line 1173

Find path to MSVC's lib/ directory. Caller owns the result.

pub fn find( gpa: Allocator, io: Io, registry: *Registry, arch: std.Target.Cpu.Arch, environ_map: *const Environ.Map, ) error{ OutOfMemory, MsvcLibDirNotFound }![]const u8

Parameters

gpa: Allocator
io: Io
registry: *Registry
arch: std.Target.Cpu.Arch
environ_map: *const Environ.Map

Errors

MsvcLibDirNotFound
OutOfMemory

std.zig.WindowsSdk.MsvcLibDir.findInstancesDir

function

Source line 734

fn findInstancesDir( gpa: Allocator, io: Io, registry: *Registry, environ_map: *const Environ.Map, ) error{ OutOfMemory, PathNotFound }!Dir

Parameters

gpa: Allocator
io: Io
registry: *Registry
environ_map: *const Environ.Map

Errors

OutOfMemory
PathNotFound

std.zig.WindowsSdk.MsvcLibDir.findInstancesDirViaCLSID

function

Source line 679

fn findInstancesDirViaCLSID(gpa: Allocator, io: Io, registry: *Registry) error{ OutOfMemory, PathNotFound }!Dir

Parameters

gpa: Allocator
io: Io
registry: *Registry

Errors

OutOfMemory
PathNotFound

std.zig.WindowsSdk.MsvcLibDir.findInstancesDirViaSetup

function

Source line 654

fn findInstancesDirViaSetup(gpa: Allocator, io: Io, registry: *Registry) error{ OutOfMemory, PathNotFound }!Dir

Parameters

gpa: Allocator
io: Io
registry: *Registry

Errors

OutOfMemory
PathNotFound

std.zig.WindowsSdk.MsvcLibDir.findViaCOM

function

Source line 819

Intended to be equivalent to ISetupConfiguration.EnumInstances: https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualstudio.setup.configuration but without the use of COM in order to avoid a dependency on ole32.dll

The logic in this function is intended to match what ISetupConfiguration does under-the-hood, as verified using Procmon.

fn findViaCOM( gpa: Allocator, io: Io, registry: *Registry, arch: std.Target.Cpu.Arch, environ_map: *const Environ.Map, ) error{ OutOfMemory, PathNotFound }![]const u8

Parameters

gpa: Allocator
io: Io
registry: *Registry
arch: std.Target.Cpu.Arch
environ_map: *const Environ.Map

Errors

OutOfMemory
PathNotFound

std.zig.WindowsSdk.MsvcLibDir.findViaRegistry

function

Source line 927

fn findViaRegistry( gpa: Allocator, io: Io, arch: std.Target.Cpu.Arch, environ_map: *const Environ.Map, ) error{ OutOfMemory, PathNotFound }![]const u8

Parameters

gpa: Allocator
io: Io
arch: std.Target.Cpu.Arch
environ_map: *const Environ.Map

Errors

OutOfMemory
PathNotFound

std.zig.WindowsSdk.MsvcLibDir.findViaVs7Key

function

Source line 1094

fn findViaVs7Key( gpa: Allocator, io: Io, registry: *Registry, arch: std.Target.Cpu.Arch, environ_map: *const Environ.Map, ) error{ OutOfMemory, PathNotFound }![]const u8

Parameters

gpa: Allocator
io: Io
registry: *Registry
arch: std.Target.Cpu.Arch
environ_map: *const Environ.Map

Errors

OutOfMemory
PathNotFound

std.zig.WindowsSdk.MsvcLibDir.libDirFromInstallationPath

function

Source line 883

fn libDirFromInstallationPath( gpa: Allocator, io: Io, installation_path: []const u8, arch: std.Target.Cpu.Arch, ) error{ OutOfMemory, PathNotFound }![]const u8

Parameters

gpa: Allocator
io: Io
installation_path: []const u8
arch: std.Target.Cpu.Arch

Errors

OutOfMemory
PathNotFound

std.zig.WindowsSdk.MsvcLibDir.parseVersionQuad

function

Source line 775

Intended to be equivalent to ISetupHelper.ParseVersion Example: 17.4.33205.214 -> 0x0011000481b500d6

fn parseVersionQuad(version: []const u8) error{InvalidVersion}!u64

Parameters

version: []const u8

Errors

InvalidVersion

std.zig.WindowsSdk.MsvcLibDir.verifyLibDir

function

Source line 1158

fn verifyLibDir(io: Io, lib_dir_path: []const u8) bool

Parameters

io: Io
lib_dir_path: []const u8

std.zig.WindowsSdk.product_version_max_length

constant

Source line 24

std.zig.WindowsSdk.Registry

container

Source line 184

Not a general purpose implementation of an ntdll-based Registry API. Only intended to support the particular calls necessary for the purposes of finding the SDK/MSVC installation paths.

The advapi32 APIs internally open and cache \Registry\Machine and the current user key when HKEY_LOCAL_MACHINE (HKLM) and HKEY_CURRENT_USER (HKCU) are passed, and also rewrite key path values to go through WOW6432Node when appropriate.

For example, when opening Software\Foo relative to HKEY_LOCAL_MACHINE with the WOW64_32KEY option set, that will end up as a call to NtLoadKeyEx with the path rewritten to Software\WOW6432Node\Foo relative to a cached \REGISTRY\Machine key.

For our purposes, we really only care about 4 potential variations of the Software key:

  • Relative to HKLM, no redirection through WOW6432Node
  • Relative to HKLM, redirected through WOW6432Node
  • Relative to HKCU, no redirection through WOW6432Node
  • Relative to HKCU, redirected through WOW6432Node (e.g. all the values we care about are within one of those Software keys)

So, we cache those variants of the Software keys instead of HKLM/HKCU and treat them as the "root" keys that the user can specify, which in turn (1) allows all provided key paths to be agnostic to WOW6432Node, (2) avoids the need for internal path rewriting, and (3) works correctly on 32-bit targets without any special support.

For example, instead of an advapi32 call with Software\Foo relative to HKEY_LOCAL_MACHINE which may get rewritten to Software\WOW6432Node\Foo, the equivalent is now a call to open Foo relative to some Software key variant.

Fields

cache: Cache = .{}

std.zig.WindowsSdk.Registry.Cache

container

Source line 197

Fields

hklm_software_foreign: if (is_32_bit) void else ?windows.HANDLE = if (is_32_bit) {} else null
hkcu_software_foreign: if (is_32_bit) void else ?windows.HANDLE = if (is_32_bit) {} else null
hklm_software_native: ?windows.HANDLE = null
hkcu_software_native: ?windows.HANDLE = null
hkcu: ?windows.HANDLE = null

std.zig.WindowsSdk.Registry.Cache.getSoftware

function

Source line 204

fn getSoftware(cache: *const Cache, variant: Software) ?windows.HANDLE

Parameters

cache: *const Cache
variant: Software

std.zig.WindowsSdk.Registry.deinit

function

Source line 187

pub fn deinit(self: Registry) void

Parameters

self: Registry

std.zig.WindowsSdk.Registry.Key

container

Source line 321

Fields

handle: windows.HANDLE

std.zig.WindowsSdk.Registry.Key.close

function

Source line 324

fn close(self: Key) void

Parameters

self: Key

std.zig.WindowsSdk.Registry.Key.getDword

function

Source line 424

fn getDword(key: Key, entry: ValueEntry) error{ ValueNameNotFound, NotADword, DwordNotFound }!windows.DWORD

Parameters

key: Key
entry: ValueEntry

Errors

DwordNotFound
NotADword
ValueNameNotFound

std.zig.WindowsSdk.Registry.Key.getString

function

Source line 359

fn getString( key: Key, gpa: Allocator, entry: ValueEntry, comptime result_encoding: enum { wtf16, wtf8 }, ) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }!(switch (result_encoding) { .wtf8 => []u8, .wtf16 => []u16, })

Parameters

key: Key
gpa: Allocator
entry: ValueEntry
result_encoding: enum { wtf16, wtf8 }

Errors

NotAString
OutOfMemory
StringNotFound
ValueNameNotFound

std.zig.WindowsSdk.Registry.Key.open

function

Source line 328

fn open(self: Key, sub_path: []const u16) error{KeyNotFound}!Key

Parameters

self: Key
sub_path: []const u16

Errors

KeyNotFound

std.zig.WindowsSdk.Registry.Key.ValueEntry

container

Source line 354

Fields

default: void
name: []const u16

std.zig.WindowsSdk.Registry.openSoftwareKey

function

Source line 316

fn openSoftwareKey(registry: *Registry, software: Software, sub_path: []const u16) error{KeyNotFound}!Key

Parameters

registry: *Registry
software: Software
sub_path: []const u16

Errors

KeyNotFound

std.zig.WindowsSdk.Registry.Software

container

Source line 224

Fields

root: Root
wow64: Wow64 = .native

std.zig.WindowsSdk.Registry.Software.getOrOpenKey

function

Source line 233

fn getOrOpenKey(self: Software, registry: *Registry) !Key

Parameters

self: Software
registry: *Registry

std.zig.WindowsSdk.Registry.Software.Root

container

Source line 228

Fields

local_machine
current_user

std.zig.WindowsSdk.Registry.tryOpenSoftwareKeyWithPrecedence

function

Source line 309

fn tryOpenSoftwareKeyWithPrecedence(registry: *Registry, variants: []const Software, sub_path: []const u16) error{KeyNotFound}!Key

Parameters

registry: *Registry
variants: []const Software
sub_path: []const u16

Errors

KeyNotFound

std.zig.WindowsSdk.Registry.Wow64

container

Source line 299

For 32-bit programs on a 64-bit operating system, the WOW64 version of ntdll.dll handles the WOW6432Node redirection before calling into ntdll.dll proper, so no special handling is needed and this setting is irrelevant in that case.

Fields

native

Use 64-bit registry on 64-bit targets and 32-bit registry on 32-bit targets.

wow64_32

Go through WOW6432Node on both 32-bit and 64-bit targets, if relevant (ignored for 32-bit programs executed on a 32-bit OS).

std.zig.WindowsSdk.std

alias

Source line 4

Alias of std

std.zig.WindowsSdk.version_major_minor_max_length

constant

Source line 22

std.zig.WindowsSdk.windows

alias

Source line 17

Alias of std.os.windows

std.zig.WindowsSdk.windows_kits_reg_key

constant

Source line 19

std.zig.WindowsSdk.WindowsSdk

alias

Source line 1

Alias of std.zig.WindowsSdk

std.zig.WindowsSdk.Writer

alias

Source line 7

Alias of std.Io.Writer

Source code

std/zig/WindowsSdk.zig

const WindowsSdk = @This();
const builtin = @import("builtin");

const std = @import("std");
const Io = std.Io;
const Dir = std.Io.Dir;
const Writer = std.Io.Writer;
const Allocator = std.mem.Allocator;
const Environ = std.process.Environ;
const L = std.unicode.wtf8ToWtf16LeStringLiteral;
const is_32_bit = @bitSizeOf(usize) == 32;

windows10sdk: ?Installation,
windows81sdk: ?Installation,
msvc_lib_dir: ?[]const u8,

const windows = std.os.windows;

const windows_kits_reg_key = "Microsoft\\Windows Kits\\Installed Roots";

// https://learn.microsoft.com/en-us/windows/win32/msi/productversion
const version_major_minor_max_length = "255.255".len;
// ProductVersion in registry (created by Visual Studio installer) probably also follows this rule
const product_version_max_length = version_major_minor_max_length + ".65535".len;

/// Find path and version of Windows 10 SDK and Windows 8.1 SDK, and find path to MSVC's `lib/` directory.
/// Caller owns the result's fields.
/// Returns memory allocated by `gpa`
pub fn find(
    gpa: Allocator,
    io: Io,
    arch: std.Target.Cpu.Arch,
    environ_map: *const Environ.Map,
) error{ OutOfMemory, NotFound, PathTooLong }!WindowsSdk {
    if (builtin.os.tag != .windows) return error.NotFound;

    var registry: Registry = .{};
    defer registry.deinit();

    // If this key doesn't exist, neither the Win 8 SDK nor the Win 10 SDK is installed
    const roots_key = registry.openSoftwareKey(.{ .root = .local_machine, .wow64 = .wow64_32 }, L(windows_kits_reg_key)) catch |err| switch (err) {
        error.KeyNotFound => return error.NotFound,
    };
    defer roots_key.close();

    const windows10sdk = Installation.find(gpa, io, &registry, roots_key, L("KitsRoot10"), "", L("v10.0")) catch |err| switch (err) {
        error.InstallationNotFound => null,
        error.PathTooLong => null,
        error.VersionTooLong => null,
        error.OutOfMemory => |e| return e,
    };
    errdefer if (windows10sdk) |*w| w.free(gpa);

    const windows81sdk = Installation.find(gpa, io, &registry, roots_key, L("KitsRoot81"), "winver", L("v8.1")) catch |err| switch (err) {
        error.InstallationNotFound => null,
        error.PathTooLong => null,
        error.VersionTooLong => null,
        error.OutOfMemory => |e| return e,
    };
    errdefer if (windows81sdk) |*w| w.free(gpa);

    const msvc_lib_dir: ?[]const u8 = MsvcLibDir.find(gpa, io, &registry, arch, environ_map) catch |err| switch (err) {
        error.MsvcLibDirNotFound => null,
        error.OutOfMemory => |e| return e,
    };
    errdefer gpa.free(msvc_lib_dir);

    return .{
        .windows10sdk = windows10sdk,
        .windows81sdk = windows81sdk,
        .msvc_lib_dir = msvc_lib_dir,
    };
}

pub fn free(sdk: WindowsSdk, gpa: Allocator) void {
    if (sdk.windows10sdk) |*w10sdk| {
        w10sdk.free(gpa);
    }
    if (sdk.windows81sdk) |*w81sdk| {
        w81sdk.free(gpa);
    }
    if (sdk.msvc_lib_dir) |msvc_lib_dir| {
        gpa.free(msvc_lib_dir);
    }
}

/// Iterates via `iterator` and collects all folders with names starting with `strip_prefix`
/// and a version. Returns slice of version strings sorted in descending order.
/// Caller owns result.
fn iterateAndFilterByVersion(
    iterator: *Dir.Iterator,
    gpa: Allocator,
    io: Io,
    prefix: []const u8,
) error{OutOfMemory}![][]const u8 {
    const Version = struct {
        nums: [4]u32,
        build: []const u8,

        fn parseNum(num: []const u8) ?u32 {
            if (num[0] == '0' and num.len > 1) return null;
            return std.fmt.parseInt(u32, num, 10) catch null;
        }

        fn order(lhs: @This(), rhs: @This()) std.math.Order {
            return std.mem.order(u32, &lhs.nums, &rhs.nums).differ() orelse
                std.mem.order(u8, lhs.build, rhs.build);
        }
    };
    var versions = std.array_list.Managed(Version).init(gpa);
    var dirs = std.array_list.Managed([]const u8).init(gpa);
    defer {
        versions.deinit();
        for (dirs.items) |filtered_dir| gpa.free(filtered_dir);
        dirs.deinit();
    }

    iterate: while (iterator.next(io) catch null) |entry| {
        if (entry.kind != .directory) continue;
        if (!std.mem.startsWith(u8, entry.name, prefix)) continue;

        var version: Version = .{
            .nums = @splat(0),
            .build = "",
        };
        const suffix = entry.name[prefix.len..];
        const underscore = std.mem.findScalar(u8, entry.name, '_');
        var num_it = std.mem.splitScalar(u8, suffix[0 .. underscore orelse suffix.len], '.');
        version.nums[0] = Version.parseNum(num_it.first()) orelse continue;
        for (version.nums[1..]) |*num|
            num.* = Version.parseNum(num_it.next() orelse break) orelse continue :iterate
        else if (num_it.next()) |_| continue;

        const name = try gpa.dupe(u8, suffix);
        errdefer gpa.free(name);
        if (underscore) |pos| version.build = name[pos + 1 ..];

        try versions.append(version);
        try dirs.append(name);
    }

    std.mem.sortUnstableContext(0, dirs.items.len, struct {
        versions: []Version,
        dirs: [][]const u8,
        pub fn lessThan(context: @This(), lhs: usize, rhs: usize) bool {
            return context.versions[lhs].order(context.versions[rhs]).compare(.gt);
        }
        pub fn swap(context: @This(), lhs: usize, rhs: usize) void {
            std.mem.swap(Version, &context.versions[lhs], &context.versions[rhs]);
            std.mem.swap([]const u8, &context.dirs[lhs], &context.dirs[rhs]);
        }
    }{ .versions = versions.items, .dirs = dirs.items });
    return dirs.toOwnedSlice();
}

/// Not a general purpose implementation of an ntdll-based Registry API.
/// Only intended to support the particular calls necessary for the purposes of finding
/// the SDK/MSVC installation paths.
///
/// The advapi32 APIs internally open and cache `\Registry\Machine` and the current user
/// key when HKEY_LOCAL_MACHINE (HKLM) and HKEY_CURRENT_USER (HKCU) are passed, and also
/// rewrite key path values to go through WOW6432Node when appropriate.
///
/// For example, when opening `Software\Foo` relative to `HKEY_LOCAL_MACHINE` with
/// the WOW64_32KEY option set, that will end up as a call to NtLoadKeyEx with the path
/// rewritten to `Software\WOW6432Node\Foo` relative to a cached `\REGISTRY\Machine`
/// key.
///
/// For our purposes, we really only care about 4 potential variations of the `Software` key:
/// - Relative to HKLM, no redirection through WOW6432Node
/// - Relative to HKLM, redirected through WOW6432Node
/// - Relative to HKCU, no redirection through WOW6432Node
/// - Relative to HKCU, redirected through WOW6432Node
/// (e.g. all the values we care about are within one of those `Software` keys)
///
/// So, we cache those variants of the Software keys instead of HKLM/HKCU and treat them
/// as the "root" keys that the user can specify, which in turn (1) allows all provided key
/// paths to be agnostic to WOW6432Node, (2) avoids the need for internal path rewriting,
/// and (3) works correctly on 32-bit targets without any special support.
///
/// For example, instead of an advapi32 call with `Software\Foo` relative to
/// `HKEY_LOCAL_MACHINE` which may get rewritten to `Software\WOW6432Node\Foo`,
/// the equivalent is now a call to open `Foo` relative to some Software key variant.
const Registry = struct {
    cache: Cache = .{},

    pub fn deinit(self: Registry) void {
        if (!is_32_bit) {
            if (self.cache.hklm_software_foreign) |key| windows.CloseHandle(key);
            if (self.cache.hkcu_software_foreign) |key| windows.CloseHandle(key);
        }
        if (self.cache.hklm_software_native) |key| windows.CloseHandle(key);
        if (self.cache.hkcu_software_native) |key| windows.CloseHandle(key);
        if (self.cache.hkcu) |key| windows.CloseHandle(key);
    }

    const Cache = struct {
        hklm_software_foreign: if (is_32_bit) void else ?windows.HANDLE = if (is_32_bit) {} else null,
        hkcu_software_foreign: if (is_32_bit) void else ?windows.HANDLE = if (is_32_bit) {} else null,
        hklm_software_native: ?windows.HANDLE = null,
        hkcu_software_native: ?windows.HANDLE = null,
        hkcu: ?windows.HANDLE = null,

        fn getSoftware(cache: *const Cache, variant: Software) ?windows.HANDLE {
            if (!is_32_bit and variant.wow64 == .wow64_32) {
                return switch (variant.root) {
                    .local_machine => cache.hklm_software_foreign,
                    .current_user => cache.hkcu_software_foreign,
                };
            }
            return switch (variant.root) {
                .local_machine => cache.hklm_software_native,
                .current_user => cache.hkcu_software_native,
            };
        }
    };

    // This does not correspond to HKEY_LOCAL_MACHINE/HKEY_CURRENT_USER
    // since WOW64 redirection is applicable to e.g. `HKLM\Software` instead of
    // HKLM/HKCU directly. Since we are only ever interested in the
    // `Software` key, it makes more sense to treat `Software` as the "root"
    // since that allows us to work entirely with relative paths that are agnostic
    // to WOW6432Node redirection.
    const Software = struct {
        root: Root,
        wow64: Wow64 = .native,

        const Root = enum {
            local_machine,
            current_user,
        };

        fn getOrOpenKey(self: Software, registry: *Registry) !Key {
            if (registry.cache.getSoftware(self)) |handle| {
                return .{ .handle = handle };
            }

            const is_foreign = !is_32_bit and self.wow64 == .wow64_32;
            switch (self.root) {
                .local_machine => {
                    const path = if (is_foreign) L("\\Registry\\Machine\\Software\\WOW6432Node") else L("\\Registry\\Machine\\Software");
                    var key: Key = undefined;
                    const attr: windows.OBJECT.ATTRIBUTES = .{
                        .RootDirectory = null,
                        .Attributes = .{},
                        .ObjectName = @constCast(&windows.UNICODE_STRING.init(path)),
                        .SecurityDescriptor = null,
                        .SecurityQualityOfService = null,
                    };
                    const status = windows.ntdll.NtOpenKeyEx(
                        &key.handle,
                        .{ .MAXIMUM_ALLOWED = true },
                        &attr,
                        .{},
                    );
                    switch (status) {
                        .SUCCESS => {},
                        else => return error.KeyNotFound,
                    }
                    if (is_foreign) {
                        registry.cache.hklm_software_foreign = key.handle;
                    } else {
                        registry.cache.hklm_software_native = key.handle;
                    }
                    return key;
                },
                .current_user => {
                    const cu_handle: windows.HANDLE = registry.cache.hkcu orelse hkcu: {
                        var cu_handle: windows.HANDLE = undefined;
                        const status = windows.ntdll.RtlOpenCurrentUser(
                            .{ .MAXIMUM_ALLOWED = true },
                            &cu_handle,
                        );
                        switch (status) {
                            .SUCCESS => {},
                            else => return error.KeyNotFound,
                        }
                        registry.cache.hkcu = cu_handle;
                        break :hkcu cu_handle;
                    };
                    const cu_key: Registry.Key = .{ .handle = cu_handle };
                    const path = if (is_foreign) L("Software\\WOW6432Node") else L("Software");
                    const key = try cu_key.open(path);
                    if (is_foreign) {
                        registry.cache.hkcu_software_foreign = key.handle;
                    } else {
                        registry.cache.hkcu_software_native = key.handle;
                    }
                    return key;
                },
            }
        }
    };

    /// For 32-bit programs on a 64-bit operating system, the WOW64
    /// version of ntdll.dll handles the WOW6432Node redirection before
    /// calling into ntdll.dll proper, so no special handling is needed
    /// and this setting is irrelevant in that case.
    const Wow64 = enum {
        /// Use 64-bit registry on 64-bit targets and 32-bit registry on
        /// 32-bit targets.
        native,
        /// Go through WOW6432Node on both 32-bit and 64-bit targets,
        /// if relevant (ignored for 32-bit programs executed on a 32-bit
        /// OS).
        wow64_32,
    };

    fn tryOpenSoftwareKeyWithPrecedence(registry: *Registry, variants: []const Software, sub_path: []const u16) error{KeyNotFound}!Key {
        for (variants) |variant| {
            return registry.openSoftwareKey(variant, sub_path) catch continue;
        }
        return error.KeyNotFound;
    }

    fn openSoftwareKey(registry: *Registry, software: Software, sub_path: []const u16) error{KeyNotFound}!Key {
        const software_key = try software.getOrOpenKey(registry);
        return software_key.open(sub_path);
    }

    const Key = struct {
        handle: windows.HANDLE,

        fn close(self: Key) void {
            windows.CloseHandle(self.handle);
        }

        fn open(self: Key, sub_path: []const u16) error{KeyNotFound}!Key {
            var key: Key = undefined;
            const attr: windows.OBJECT.ATTRIBUTES = .{
                .RootDirectory = self.handle,
                .Attributes = .{},
                .ObjectName = @constCast(&windows.UNICODE_STRING.init(sub_path)),
                .SecurityDescriptor = null,
                .SecurityQualityOfService = null,
            };
            const status = windows.ntdll.NtOpenKeyEx(
                &key.handle,
                .{ .SPECIFIC = .{
                    .KEY = .{
                        .QUERY_VALUE = true,
                        .ENUMERATE_SUB_KEYS = true,
                    },
                } },
                &attr,
                .{},
            );
            switch (status) {
                .SUCCESS => return key,
                else => return error.KeyNotFound,
            }
        }

        const ValueEntry = union(enum) {
            default: void,
            name: []const u16,
        };

        fn getString(
            key: Key,
            gpa: Allocator,
            entry: ValueEntry,
            comptime result_encoding: enum { wtf16, wtf8 },
        ) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }!(switch (result_encoding) {
            .wtf8 => []u8,
            .wtf16 => []u16,
        }) {
            const num_data_bytes = windows.MAX_PATH * 2;
            const stack_buf_len = @sizeOf(windows.KEY.VALUE.PARTIAL_INFORMATION) + num_data_bytes;
            var stack_info_buf: [stack_buf_len]u8 align(@alignOf(windows.KEY.VALUE.PARTIAL_INFORMATION)) = undefined;
            var result_len: windows.ULONG = undefined;
            const rc = windows.ntdll.NtQueryValueKey(
                key.handle,
                switch (entry) {
                    .name => |name| @constCast(&windows.UNICODE_STRING.init(name)),
                    .default => @constCast(&windows.UNICODE_STRING.empty),
                },
                .Partial,
                &stack_info_buf,
                stack_buf_len,
                &result_len,
            );
            var heap_info_buf: ?[]align(@alignOf(windows.KEY.VALUE.PARTIAL_INFORMATION)) u8 = null;
            defer if (heap_info_buf) |buf| gpa.free(buf);

            const info: *const windows.KEY.VALUE.PARTIAL_INFORMATION = switch (rc) {
                .SUCCESS => @ptrCast(&stack_info_buf),
                .BUFFER_OVERFLOW, .BUFFER_TOO_SMALL => heap_info: {
                    heap_info_buf = try gpa.alignedAlloc(u8, .of(windows.KEY.VALUE.PARTIAL_INFORMATION), result_len);
                    const heap_rc = windows.ntdll.NtQueryValueKey(
                        key.handle,
                        switch (entry) {
                            .name => |name| @constCast(&windows.UNICODE_STRING.init(name)),
                            .default => @constCast(&windows.UNICODE_STRING.empty),
                        },
                        .Partial,
                        heap_info_buf.?.ptr,
                        @intCast(heap_info_buf.?.len),
                        &result_len,
                    );
                    switch (heap_rc) {
                        .SUCCESS => break :heap_info @ptrCast(heap_info_buf.?.ptr),
                        .OBJECT_NAME_NOT_FOUND => return error.ValueNameNotFound,
                        else => return error.StringNotFound,
                    }
                },
                .OBJECT_NAME_NOT_FOUND => return error.ValueNameNotFound,
                else => return error.StringNotFound,
            };

            switch (info.Type) {
                .SZ => {},
                else => return error.NotAString,
            }

            const data_wtf16_with_nul = @as([*]const u16, @ptrCast(@alignCast(info.data())))[0..@divExact(info.DataLength, 2)];
            const data_wtf16 = std.mem.trimEnd(u16, data_wtf16_with_nul, L("\x00"));
            switch (result_encoding) {
                .wtf16 => return gpa.dupe(u16, data_wtf16),
                .wtf8 => return std.unicode.wtf16LeToWtf8Alloc(gpa, data_wtf16),
            }
        }

        fn getDword(key: Key, entry: ValueEntry) error{ ValueNameNotFound, NotADword, DwordNotFound }!windows.DWORD {
            const num_data_bytes = @sizeOf(windows.DWORD);
            const buf_len = @sizeOf(windows.KEY.VALUE.PARTIAL_INFORMATION) + num_data_bytes;
            var info_buf: [buf_len]u8 align(@alignOf(windows.KEY.VALUE.PARTIAL_INFORMATION)) = undefined;
            var result_len: windows.ULONG = undefined;
            const rc = windows.ntdll.NtQueryValueKey(
                key.handle,
                switch (entry) {
                    .name => |name| @constCast(&windows.UNICODE_STRING.init(name)),
                    .default => @constCast(&windows.UNICODE_STRING.empty),
                },
                .Partial,
                &info_buf,
                buf_len,
                &result_len,
            );
            switch (rc) {
                .SUCCESS => {},
                .OBJECT_NAME_NOT_FOUND => return error.ValueNameNotFound,
                else => return error.DwordNotFound,
            }

            const info: *const windows.KEY.VALUE.PARTIAL_INFORMATION = @ptrCast(&info_buf);

            switch (info.Type) {
                .DWORD => {},
                else => return error.NotADword,
            }

            return std.mem.bytesToValue(windows.DWORD, info.data());
        }
    };
};

pub const Installation = struct {
    path: []const u8,
    version: []const u8,

    /// Find path and version of Windows SDK.
    /// Caller owns the result's fields.
    fn find(
        gpa: Allocator,
        io: Io,
        registry: *Registry,
        roots_key: Registry.Key,
        roots_subkey: []const u16,
        prefix: []const u8,
        version_key_name: []const u16,
    ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation {
        roots: {
            const installation = findFromRoot(gpa, io, roots_key, roots_subkey, prefix) catch
                break :roots;
            if (installation.isValidVersion(roots_key)) return installation;
            installation.free(gpa);
        }
        {
            const installation = try findFromInstallationFolder(gpa, registry, version_key_name);
            if (installation.isValidVersion(roots_key)) return installation;
            installation.free(gpa);
        }
        return error.InstallationNotFound;
    }

    fn findFromRoot(
        gpa: Allocator,
        io: Io,
        roots_key: Registry.Key,
        roots_subkey: []const u16,
        prefix: []const u8,
    ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation {
        const path = path: {
            const path_w_maybe_with_trailing_slash = roots_key.getString(gpa, .{ .name = roots_subkey }, .wtf16) catch |err| switch (err) {
                error.NotAString,
                error.ValueNameNotFound,
                error.StringNotFound,
                => return error.InstallationNotFound,

                error.OutOfMemory => |e| return e,
            };
            defer gpa.free(path_w_maybe_with_trailing_slash);

            if (!std.fs.path.isAbsoluteWindowsWtf16(path_w_maybe_with_trailing_slash)) {
                return error.InstallationNotFound;
            }

            const path_w = std.mem.trimEnd(u16, path_w_maybe_with_trailing_slash, L("\\/"));
            break :path try std.unicode.wtf16LeToWtf8Alloc(gpa, path_w);
        };
        errdefer gpa.free(path);

        const version = version: {
            var buf: [Dir.max_path_bytes]u8 = undefined;
            const sdk_lib_dir_path = std.mem.print(buf[0..], "{s}\\Lib\\", .{path}) catch |err| switch (err) {
                error.NoSpaceLeft => return error.PathTooLong,
            };
            if (!Dir.path.isAbsolute(sdk_lib_dir_path)) return error.InstallationNotFound;

            // enumerate files in sdk path looking for latest version
            var sdk_lib_dir = Dir.openDirAbsolute(io, sdk_lib_dir_path, .{
                .iterate = true,
            }) catch |err| switch (err) {
                error.NameTooLong => return error.PathTooLong,
                else => return error.InstallationNotFound,
            };
            defer sdk_lib_dir.close(io);

            var iterator = sdk_lib_dir.iterate();
            const versions = try iterateAndFilterByVersion(&iterator, gpa, io, prefix);
            if (versions.len == 0) return error.InstallationNotFound;
            defer {
                for (versions[1..]) |version| gpa.free(version);
                gpa.free(versions);
            }
            break :version versions[0];
        };
        errdefer gpa.free(version);

        return .{ .path = path, .version = version };
    }

    fn findFromInstallationFolder(
        gpa: Allocator,
        registry: *Registry,
        version_key_name: []const u16,
    ) error{ OutOfMemory, InstallationNotFound, PathTooLong, VersionTooLong }!Installation {
        const key_name = try std.mem.concat(gpa, u16, &.{ L("Microsoft\\Microsoft SDKs\\Windows\\"), version_key_name });
        defer gpa.free(key_name);

        const key = registry.tryOpenSoftwareKeyWithPrecedence(switch (is_32_bit) {
            true => &.{
                .{ .root = .local_machine },
                .{ .root = .current_user },
            },
            false => &.{
                .{ .root = .local_machine, .wow64 = .wow64_32 },
                .{ .root = .current_user, .wow64 = .wow64_32 },
                .{ .root = .local_machine, .wow64 = .native },
                .{ .root = .current_user, .wow64 = .native },
            },
        }, key_name) catch {
            return error.InstallationNotFound;
        };
        defer key.close();

        const path: []const u8 = path: {
            const path_w_maybe_with_trailing_slash = key.getString(gpa, .{ .name = L("InstallationFolder") }, .wtf16) catch |err| switch (err) {
                error.NotAString,
                error.ValueNameNotFound,
                error.StringNotFound,
                => return error.InstallationNotFound,

                error.OutOfMemory => |e| return e,
            };
            defer gpa.free(path_w_maybe_with_trailing_slash);

            if (!std.fs.path.isAbsoluteWindowsWtf16(path_w_maybe_with_trailing_slash)) {
                return error.InstallationNotFound;
            }

            const path_w = std.mem.trimEnd(u16, path_w_maybe_with_trailing_slash, L("\\/"));
            break :path try std.unicode.wtf16LeToWtf8Alloc(gpa, path_w);
        };
        errdefer gpa.free(path);

        const version: []const u8 = version: {
            // Microsoft doesn't include the .0 in the ProductVersion key
            const version_without_0 = key.getString(gpa, .{ .name = L("ProductVersion") }, .wtf16) catch |err| switch (err) {
                error.NotAString,
                error.ValueNameNotFound,
                error.StringNotFound,
                => return error.InstallationNotFound,

                error.OutOfMemory => |e| return e,
            };
            defer gpa.free(version_without_0);

            if (version_without_0.len + ".0".len > product_version_max_length) {
                return error.VersionTooLong;
            }

            var version: std.array_list.Managed(u8) = try .initCapacity(gpa, version_without_0.len + 2);
            errdefer version.deinit();

            try std.unicode.wtf16LeToWtf8ArrayList(&version, version_without_0);
            try version.appendSlice(".0");

            break :version try version.toOwnedSlice();
        };
        errdefer gpa.free(version);

        return .{ .path = path, .version = version };
    }

    /// Check whether this version is enumerated in registry.
    fn isValidVersion(installation: Installation, roots_key: Registry.Key) bool {
        var version_buf: [product_version_max_length]u16 = undefined;
        const version_len = std.unicode.wtf8ToWtf16Le(&version_buf, installation.version) catch return false;
        const version = version_buf[0..version_len];
        const options_key_name = "Installed Options";
        const buf_len = product_version_max_length + options_key_name.len + 2;
        var buf: [buf_len]u16 = undefined;
        var query: std.ArrayList(u16) = .initBuffer(&buf);
        query.appendSliceAssumeCapacity(version);
        query.appendAssumeCapacity('\\');
        query.appendSliceAssumeCapacity(L(options_key_name));

        const options_key = roots_key.open(query.items) catch |err| switch (err) {
            error.KeyNotFound => return false,
        };
        defer options_key.close();

        const option_name = comptime switch (builtin.target.cpu.arch) {
            .thumb => "OptionId.DesktopCPParm",
            .aarch64 => "OptionId.DesktopCPParm64",
            .x86 => "OptionId.DesktopCPPx86",
            .x86_64 => "OptionId.DesktopCPPx64",
            else => |tag| @compileError("Windows SDK cannot be detected on architecture " ++ tag),
        };

        const reg_value = options_key.getDword(.{ .name = L(option_name) }) catch return false;
        return (reg_value == 1);
    }

    fn free(install: Installation, gpa: Allocator) void {
        gpa.free(install.path);
        gpa.free(install.version);
    }
};

const MsvcLibDir = struct {
    fn findInstancesDirViaSetup(gpa: Allocator, io: Io, registry: *Registry) error{ OutOfMemory, PathNotFound }!Dir {
        const vs_setup_key_path = L("Microsoft\\VisualStudio\\Setup");
        const vs_setup_key = registry.openSoftwareKey(.{ .root = .local_machine }, vs_setup_key_path) catch |err| switch (err) {
            error.KeyNotFound => return error.PathNotFound,
        };
        defer vs_setup_key.close();

        const packages_path = vs_setup_key.getString(gpa, .{ .name = L("CachePath") }, .wtf8) catch |err| switch (err) {
            error.NotAString,
            error.ValueNameNotFound,
            error.StringNotFound,
            => return error.PathNotFound,

            error.OutOfMemory => |e| return e,
        };
        defer gpa.free(packages_path);

        if (!std.fs.path.isAbsolute(packages_path)) return error.PathNotFound;

        const instances_path = try std.fs.path.join(gpa, &.{ packages_path, "_Instances" });
        defer gpa.free(instances_path);

        return Dir.openDirAbsolute(io, instances_path, .{ .iterate = true }) catch return error.PathNotFound;
    }

    fn findInstancesDirViaCLSID(gpa: Allocator, io: Io, registry: *Registry) error{ OutOfMemory, PathNotFound }!Dir {
        const setup_configuration_clsid = "{177f0c4a-1cd3-4de7-a32c-71dbbb9fa36d}";

        // HKEY_CLASSES_ROOT is not a single key but instead a combination of
        // HKCU\Software\Classes and HKLM\Software\Classes with HKCU taking precedent
        // https://learn.microsoft.com/en-us/windows/win32/sysinfo/hkey-classes-root-key
        //
        // Instead of a CLASSES_ROOT abstraction, we emulate the behavior with a more
        // general abstraction, which also means we need to include `Classes` in the path since
        // we're starting from the `Software` keys instead of the "classes root".
        //
        // The advapi32 APIs with `HKEY_CLASSES_ROOT` go through `\REGISTRY\USER\<SID>_Classes`
        // instead of `\REGISTRY\USER\<SID>\Software\Classes`, but we go through the latter
        // because it allows us to take advantage of `RtlOpenCurrentUser` to avoid needing to implement
        // the logic for getting the current user registry path, and it appears that the two keys are
        // effectively equivalent. Further investigation of the relationship of these keys would probably
        // be beneficial, though.
        const setup_config_key = registry.tryOpenSoftwareKeyWithPrecedence(&.{
            .{ .root = .current_user },
            .{ .root = .local_machine },
        }, L("Classes\\CLSID\\" ++ setup_configuration_clsid)) catch |err| switch (err) {
            error.KeyNotFound => return error.PathNotFound,
        };
        defer setup_config_key.close();

        const inproc_server = setup_config_key.open(L("InprocServer32")) catch return error.PathNotFound;
        const dll_path = inproc_server.getString(gpa, .default, .wtf8) catch |err| switch (err) {
            error.NotAString,
            error.ValueNameNotFound,
            error.StringNotFound,
            => return error.PathNotFound,

            error.OutOfMemory => |e| return e,
        };
        defer gpa.free(dll_path);

        if (!std.fs.path.isAbsolute(dll_path)) return error.PathNotFound;

        var path_it = std.fs.path.componentIterator(dll_path);
        // the .dll filename
        _ = path_it.last();
        const root_path = while (path_it.previous()) |dir_component| {
            if (std.ascii.eqlIgnoreCase(dir_component.name, "VisualStudio")) {
                break dir_component.path;
            }
        } else {
            return error.PathNotFound;
        };

        const instances_path = try std.fs.path.join(gpa, &.{ root_path, "Packages", "_Instances" });
        defer gpa.free(instances_path);

        return Dir.openDirAbsolute(io, instances_path, .{ .iterate = true }) catch return error.PathNotFound;
    }

    fn findInstancesDir(
        gpa: Allocator,
        io: Io,
        registry: *Registry,
        environ_map: *const Environ.Map,
    ) error{ OutOfMemory, PathNotFound }!Dir {
        // First, try getting the packages cache path from the registry.
        // This only seems to exist when the path is different from the default.
        method1: {
            return findInstancesDirViaSetup(gpa, io, registry) catch |err| switch (err) {
                error.OutOfMemory => |e| return e,
                error.PathNotFound => break :method1,
            };
        }
        // Otherwise, try to get the path from the .dll that would have been
        // loaded via COM for SetupConfiguration.
        method2: {
            return findInstancesDirViaCLSID(gpa, io, registry) catch |err| switch (err) {
                error.OutOfMemory => |e| return e,
                error.PathNotFound => break :method2,
            };
        }
        // If that can't be found, fall back to manually appending
        // `Microsoft\VisualStudio\Packages\_Instances` to %PROGRAMDATA%
        method3: {
            const program_data = std.zig.EnvVar.PROGRAMDATA.get(environ_map) orelse break :method3;

            if (!std.fs.path.isAbsolute(program_data)) break :method3;

            const instances_path = try Dir.path.join(gpa, &.{
                program_data, "Microsoft", "VisualStudio", "Packages", "_Instances",
            });
            defer gpa.free(instances_path);

            return Dir.openDirAbsolute(io, instances_path, .{ .iterate = true }) catch break :method3;
        }
        return error.PathNotFound;
    }

    /// Intended to be equivalent to `ISetupHelper.ParseVersion`
    /// Example: 17.4.33205.214 -> 0x0011000481b500d6
    fn parseVersionQuad(version: []const u8) error{InvalidVersion}!u64 {
        var it = std.mem.splitScalar(u8, version, '.');
        const a = it.first();
        const b = it.next() orelse return error.InvalidVersion;
        const c = it.next() orelse return error.InvalidVersion;
        const d = it.next() orelse return error.InvalidVersion;
        if (it.next()) |_| return error.InvalidVersion;
        var result: u64 = undefined;
        var result_bytes = std.mem.asBytes(&result);

        std.mem.writeInt(
            u16,
            result_bytes[0..2],
            std.fmt.parseUnsigned(u16, d, 10) catch return error.InvalidVersion,
            .little,
        );
        std.mem.writeInt(
            u16,
            result_bytes[2..4],
            std.fmt.parseUnsigned(u16, c, 10) catch return error.InvalidVersion,
            .little,
        );
        std.mem.writeInt(
            u16,
            result_bytes[4..6],
            std.fmt.parseUnsigned(u16, b, 10) catch return error.InvalidVersion,
            .little,
        );
        std.mem.writeInt(
            u16,
            result_bytes[6..8],
            std.fmt.parseUnsigned(u16, a, 10) catch return error.InvalidVersion,
            .little,
        );

        return result;
    }

    /// Intended to be equivalent to ISetupConfiguration.EnumInstances:
    /// https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualstudio.setup.configuration
    /// but without the use of COM in order to avoid a dependency on ole32.dll
    ///
    /// The logic in this function is intended to match what ISetupConfiguration does
    /// under-the-hood, as verified using Procmon.
    fn findViaCOM(
        gpa: Allocator,
        io: Io,
        registry: *Registry,
        arch: std.Target.Cpu.Arch,
        environ_map: *const Environ.Map,
    ) error{ OutOfMemory, PathNotFound }![]const u8 {
        // Typically `%PROGRAMDATA%\Microsoft\VisualStudio\Packages\_Instances`
        // This will contain directories with names of instance IDs like 80a758ca,
        // which will contain `state.json` files that have the version and
        // installation directory.
        var instances_dir = try findInstancesDir(gpa, io, registry, environ_map);
        defer instances_dir.close(io);

        var state_subpath_buf: [Dir.max_name_bytes + 32]u8 = undefined;
        var latest_version_lib_dir: std.ArrayList(u8) = .empty;
        errdefer latest_version_lib_dir.deinit(gpa);

        var latest_version: u64 = 0;
        var instances_dir_it = instances_dir.iterateAssumeFirstIteration();
        while (instances_dir_it.next(io) catch return error.PathNotFound) |entry| {
            if (entry.kind != .directory) continue;

            var writer: Writer = .fixed(&state_subpath_buf);

            writer.writeAll(entry.name) catch unreachable;
            writer.writeByte(Dir.path.sep) catch unreachable;
            writer.writeAll("state.json") catch unreachable;

            const json_contents = instances_dir.readFileAlloc(io, writer.buffered(), gpa, .limited(std.math.maxInt(usize))) catch continue;
            defer gpa.free(json_contents);

            var parsed = std.json.parseFromSlice(std.json.Value, gpa, json_contents, .{}) catch continue;
            defer parsed.deinit();

            if (parsed.value != .object) continue;
            const catalog_info = parsed.value.object.get("catalogInfo") orelse continue;
            if (catalog_info != .object) continue;
            const product_version_value = catalog_info.object.get("buildVersion") orelse continue;
            if (product_version_value != .string) continue;
            const product_version_text = product_version_value.string;
            const parsed_version = parseVersionQuad(product_version_text) catch continue;

            // We want to end up with the most recent version installed
            if (parsed_version <= latest_version) continue;

            const installation_path = parsed.value.object.get("installationPath") orelse continue;
            if (installation_path != .string) continue;

            const lib_dir_path = libDirFromInstallationPath(gpa, io, installation_path.string, arch) catch |err| switch (err) {
                error.OutOfMemory => |e| return e,
                error.PathNotFound => continue,
            };
            defer gpa.free(lib_dir_path);

            latest_version_lib_dir.clearRetainingCapacity();
            try latest_version_lib_dir.appendSlice(gpa, lib_dir_path);
            latest_version = parsed_version;
        }

        if (latest_version_lib_dir.items.len == 0) return error.PathNotFound;
        return latest_version_lib_dir.toOwnedSlice(gpa);
    }

    fn libDirFromInstallationPath(
        gpa: Allocator,
        io: Io,
        installation_path: []const u8,
        arch: std.Target.Cpu.Arch,
    ) error{ OutOfMemory, PathNotFound }![]const u8 {
        var lib_dir_buf = try std.array_list.Managed(u8).initCapacity(gpa, installation_path.len + 64);
        errdefer lib_dir_buf.deinit();

        lib_dir_buf.appendSliceAssumeCapacity(installation_path);

        if (!Dir.path.isSep(lib_dir_buf.last().?)) {
            try lib_dir_buf.append('\\');
        }
        const installation_path_with_trailing_sep_len = lib_dir_buf.items.len;

        try lib_dir_buf.appendSlice("VC\\Auxiliary\\Build\\Microsoft.VCToolsVersion.default.txt");
        var default_tools_version_buf: [512]u8 = undefined;
        const default_tools_version_contents = Dir.cwd().readFile(io, lib_dir_buf.items, &default_tools_version_buf) catch {
            return error.PathNotFound;
        };
        var tokenizer = std.mem.tokenizeAny(u8, default_tools_version_contents, " \r\n");
        const default_tools_version = tokenizer.next() orelse return error.PathNotFound;

        lib_dir_buf.shrinkRetainingCapacity(installation_path_with_trailing_sep_len);
        try lib_dir_buf.appendSlice("VC\\Tools\\MSVC\\");
        try lib_dir_buf.appendSlice(default_tools_version);
        try lib_dir_buf.appendSlice("\\Lib\\");
        try lib_dir_buf.appendSlice(switch (arch) {
            .thumb => "arm",
            .aarch64 => "arm64",
            .x86 => "x86",
            .x86_64 => "x64",
            else => unreachable,
        });

        if (!verifyLibDir(io, lib_dir_buf.items)) {
            return error.PathNotFound;
        }

        return lib_dir_buf.toOwnedSlice();
    }

    // https://learn.microsoft.com/en-us/visualstudio/install/tools-for-managing-visual-studio-instances?view=vs-2022#editing-the-registry-for-a-visual-studio-instance
    fn findViaRegistry(
        gpa: Allocator,
        io: Io,
        arch: std.Target.Cpu.Arch,
        environ_map: *const Environ.Map,
    ) error{ OutOfMemory, PathNotFound }![]const u8 {
        // %localappdata%\Microsoft\VisualStudio\
        // %appdata%\Local\Microsoft\VisualStudio\
        const local_app_data_path = std.zig.EnvVar.LOCALAPPDATA.get(environ_map) orelse return error.PathNotFound;
        const visualstudio_folder_path = try Dir.path.join(gpa, &.{
            local_app_data_path, "Microsoft\\VisualStudio\\",
        });
        defer gpa.free(visualstudio_folder_path);

        if (!Dir.path.isAbsolute(visualstudio_folder_path)) return error.PathNotFound;
        // To make things easier later on, we open the VisualStudio directory here which
        // allows us to pass relative paths to NtLoadKeyEx in order to avoid dealing with
        // conversion to NT namespace paths.
        var visualstudio_folder = Dir.openDirAbsolute(io, visualstudio_folder_path, .{
            .iterate = true,
        }) catch return error.PathNotFound;
        defer visualstudio_folder.close(io);

        const vs_versions: []const []const u8 = vs_versions: {
            // enumerate folders that contain `privateregistry.bin`, looking for all versions
            // f.i. %localappdata%\Microsoft\VisualStudio\17.0_9e9cbb98\
            var iterator = visualstudio_folder.iterate();
            break :vs_versions try iterateAndFilterByVersion(&iterator, gpa, io, "");
        };
        defer {
            for (vs_versions) |vs_version| gpa.free(vs_version);
            gpa.free(vs_versions);
        }
        var key_path_buf: [windows.NAME_MAX * 2]u16 = undefined;
        var sub_path_buf: [windows.NAME_MAX * 2]u16 = undefined;
        const source_directories: []const u8 = source_directories: for (vs_versions) |vs_version| {
            const sub_path = blk: {
                var buf: std.ArrayList(u16) = .initBuffer(&sub_path_buf);
                buf.items.len += std.unicode.wtf8ToWtf16Le(buf.unusedCapacitySlice(), vs_version) catch unreachable;
                buf.appendSliceAssumeCapacity(L("\\privateregistry.bin"));
                break :blk buf.items;
            };

            // The goal is to emulate advapi32.RegLoadAppKeyW with a direct call
            // to NtLoadKeyEx instead.
            //
            // RegLoadAppKeyW loads the hive into a registry key of the format:
            // \REGISTRY\A\{fdb2baa5-8ca8-ef03-78d0-3b1f868fd2a9}
            // where `\REGISTRY\A` is a special unenumerable location intended for
            // per-app hives, and the GUID is randomly generated (in testing, it
            // was different for each run of the program).
            //
            // The OS is responsible for cleaning up `\REGISTRY\A` whenever all handles
            // to one of its keys are closed, so we don't have to do anything special
            // with regards to that.

            const temp_key_path = blk: {
                var guid: windows.GUID = undefined;
                io.random(std.mem.asBytes(&guid));

                var guid_buf: [38]u8 = undefined;
                const guid_str = std.mem.print(&guid_buf, "{f}", .{guid}) catch unreachable;

                var buf: std.ArrayList(u16) = .initBuffer(&key_path_buf);
                buf.appendSliceAssumeCapacity(L("\\REGISTRY\\A\\"));
                buf.items.len += std.unicode.wtf8ToWtf16Le(buf.unusedCapacitySlice(), guid_str) catch unreachable;
                break :blk buf.items;
            };

            const target_key: windows.OBJECT.ATTRIBUTES = .{
                .RootDirectory = null,
                .Attributes = .{},
                .ObjectName = @constCast(&windows.UNICODE_STRING.init(temp_key_path)),
                .SecurityDescriptor = null,
            };
            const source_file: windows.OBJECT.ATTRIBUTES = .{
                .RootDirectory = visualstudio_folder.handle,
                .Attributes = .{},
                .ObjectName = @constCast(&windows.UNICODE_STRING.init(sub_path)),
                .SecurityDescriptor = null,
            };
            var root_key: Registry.Key = undefined;
            const rc = windows.ntdll.NtLoadKeyEx(
                &target_key,
                &source_file,
                .{
                    .APP_HIVE = true,
                    // This wasn't set by RegLoadAppKeyW, but it seems relevant
                    // since we aren't intending to do any modifcation of the hive.
                    .OPEN_READ_ONLY = true,
                },
                null,
                null,
                .{ .SPECIFIC = .{
                    .KEY = .{
                        .QUERY_VALUE = true,
                        .ENUMERATE_SUB_KEYS = true,
                    },
                } },
                &root_key.handle,
                null,
            );
            switch (rc) {
                .SUCCESS => {},
                else => continue,
            }
            defer root_key.close();

            const config_path = blk: {
                var buf: std.ArrayList(u16) = .initBuffer(&key_path_buf);
                buf.appendSliceAssumeCapacity(L("Software\\Microsoft\\VisualStudio\\"));
                buf.items.len += std.unicode.wtf8ToWtf16Le(buf.unusedCapacitySlice(), vs_version) catch unreachable;
                buf.appendSliceAssumeCapacity(L("_Config"));
                break :blk buf.items;
            };
            const config_key = root_key.open(config_path) catch continue;

            const source_directories_value = config_key.getString(gpa, .{ .name = L("Source Directories") }, .wtf8) catch |err| switch (err) {
                error.OutOfMemory => |e| return e,
                else => continue,
            };

            break :source_directories source_directories_value;
        } else return error.PathNotFound;
        defer gpa.free(source_directories);

        var source_directories_split = std.mem.splitScalar(u8, source_directories, ';');

        const msvc_dir: []const u8 = msvc_dir: {
            const msvc_include_dir_maybe_with_trailing_slash = try gpa.dupe(u8, source_directories_split.first());

            if (msvc_include_dir_maybe_with_trailing_slash.len > Dir.max_path_bytes or !Dir.path.isAbsolute(msvc_include_dir_maybe_with_trailing_slash)) {
                gpa.free(msvc_include_dir_maybe_with_trailing_slash);
                return error.PathNotFound;
            }

            var msvc_dir = std.array_list.Managed(u8).fromOwnedSlice(gpa, msvc_include_dir_maybe_with_trailing_slash);
            errdefer msvc_dir.deinit();

            // String might contain trailing slash, so trim it here
            if (msvc_dir.items.len > "C:\\".len and msvc_dir.last().? == '\\') _ = msvc_dir.pop();

            // Remove `\include` at the end of path
            if (std.mem.endsWith(u8, msvc_dir.items, "\\include")) {
                msvc_dir.shrinkRetainingCapacity(msvc_dir.items.len - "\\include".len);
            }

            try msvc_dir.appendSlice("\\Lib\\");
            try msvc_dir.appendSlice(switch (arch) {
                .thumb => "arm",
                .aarch64 => "arm64",
                .x86 => "x86",
                .x86_64 => "x64",
                else => unreachable,
            });
            const msvc_dir_with_arch = try msvc_dir.toOwnedSlice();
            break :msvc_dir msvc_dir_with_arch;
        };
        errdefer gpa.free(msvc_dir);

        if (!verifyLibDir(io, msvc_dir)) {
            return error.PathNotFound;
        }

        return msvc_dir;
    }

    fn findViaVs7Key(
        gpa: Allocator,
        io: Io,
        registry: *Registry,
        arch: std.Target.Cpu.Arch,
        environ_map: *const Environ.Map,
    ) error{ OutOfMemory, PathNotFound }![]const u8 {
        var base_path: std.array_list.Managed(u8) = base_path: {
            try_env: {
                if (environ_map.get("VS140COMNTOOLS")) |VS140COMNTOOLS| {
                    if (VS140COMNTOOLS.len < "C:\\Common7\\Tools".len) break :try_env;
                    if (!Dir.path.isAbsolute(VS140COMNTOOLS)) break :try_env;
                    var list = std.array_list.Managed(u8).init(gpa);
                    errdefer list.deinit();

                    try list.appendSlice(VS140COMNTOOLS); // C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\Tools
                    // String might contain trailing slash, so trim it here
                    if (list.items.len > "C:\\".len and list.last().? == '\\') _ = list.pop();
                    list.shrinkRetainingCapacity(list.items.len - "\\Common7\\Tools".len); // C:\Program Files (x86)\Microsoft Visual Studio 14.0
                    break :base_path list;
                }
            }

            const vs7_key = registry.openSoftwareKey(.{ .root = .local_machine, .wow64 = .wow64_32 }, L("Microsoft\\VisualStudio\\SxS\\VS7")) catch return error.PathNotFound;
            defer vs7_key.close();
            try_vs7_key: {
                const path_maybe_with_trailing_slash = vs7_key.getString(gpa, .{ .name = L("14.0") }, .wtf8) catch |err| switch (err) {
                    error.OutOfMemory => |e| return e,
                    else => break :try_vs7_key,
                };

                if (path_maybe_with_trailing_slash.len > Dir.max_path_bytes or !Dir.path.isAbsolute(path_maybe_with_trailing_slash)) {
                    gpa.free(path_maybe_with_trailing_slash);
                    break :try_vs7_key;
                }

                var path = std.array_list.Managed(u8).fromOwnedSlice(gpa, path_maybe_with_trailing_slash);
                errdefer path.deinit();

                // String might contain trailing slash, so trim it here
                if (path.items.len > "C:\\".len and path.last().? == '\\') _ = path.pop();
                break :base_path path;
            }
            return error.PathNotFound;
        };
        errdefer base_path.deinit();

        try base_path.appendSlice("\\VC\\lib\\");
        try base_path.appendSlice(switch (arch) {
            .thumb => "arm",
            .aarch64 => "arm64",
            .x86 => "", //x86 is in the root of the Lib folder
            .x86_64 => "amd64",
            else => unreachable,
        });

        if (!verifyLibDir(io, base_path.items)) {
            return error.PathNotFound;
        }

        const full_path = try base_path.toOwnedSlice();
        return full_path;
    }

    fn verifyLibDir(io: Io, lib_dir_path: []const u8) bool {
        std.debug.assert(Dir.path.isAbsolute(lib_dir_path)); // should be already handled in `findVia*`

        var dir = Dir.openDirAbsolute(io, lib_dir_path, .{}) catch return false;
        defer dir.close(io);

        const stat = dir.statFile(io, "vcruntime.lib", .{}) catch return false;
        if (stat.kind != .file)
            return false;

        return true;
    }

    /// Find path to MSVC's `lib/` directory.
    /// Caller owns the result.
    pub fn find(
        gpa: Allocator,
        io: Io,
        registry: *Registry,
        arch: std.Target.Cpu.Arch,
        environ_map: *const Environ.Map,
    ) error{ OutOfMemory, MsvcLibDirNotFound }![]const u8 {
        const full_path = MsvcLibDir.findViaCOM(gpa, io, registry, arch, environ_map) catch |err1| switch (err1) {
            error.OutOfMemory => |e| return e,
            error.PathNotFound => MsvcLibDir.findViaRegistry(gpa, io, arch, environ_map) catch |err2| switch (err2) {
                error.OutOfMemory => |e| return e,
                error.PathNotFound => MsvcLibDir.findViaVs7Key(gpa, io, registry, arch, environ_map) catch |err3| switch (err3) {
                    error.OutOfMemory => |e| return e,
                    error.PathNotFound => return error.MsvcLibDirNotFound,
                },
            },
        };
        errdefer gpa.free(full_path);

        return full_path;
    }
};