Message

pub const Message = struct {
    pub const Header = extern struct {
        tag: Tag,
        /// Size of the body only; does not include this Header.
        bytes_len: u32,
    };

    pub const Tag = enum(u32) {
        /// Body is a UTF-8 string.
        zig_version,
        /// Body is an ErrorBundle.
        error_bundle,
        /// Body is a EmitDigest.
        emit_digest,
        /// Body is a TestMetadata
        test_metadata,
        /// Body is a TestResults
        test_results,
        /// Does not have a body.
        /// Notifies the build runner that the next test (requested by `Client.Message.Tag.run_test`)
        /// is starting execution. This message helps to ensure that the timestamp used by the build
        /// runner to enforce unit test time limits is relatively accurate under extreme system load
        /// (where there may be a non-trivial delay before the test process is scheduled).
        test_started,
        /// Body is a series of strings, delimited by null bytes.
        /// Each string is a prefixed file path.
        /// The first byte indicates the file prefix path (see prefixes fields
        /// of Cache). This byte is sent over the wire incremented so that null
        /// bytes are not confused with string terminators.
        /// The remaining bytes is the file path relative to that prefix.
        /// The prefixes are hard-coded in Compilation.create (cwd, zig lib dir, local cache dir)
        file_system_inputs,
        /// Body is:
        /// - a u64le that indicates the file path within the cache used
        ///   to store coverage information. The integer is a hash of the PCs
        ///   stored within that file.
        /// - u64le of total runs accumulated
        /// - u64le of unique runs accumulated
        /// - u64le of coverage accumulated
        coverage_id,
        /// Body is a u64le that indicates the function pointer virtual memory
        /// address of the fuzz unit test. This is used to provide a starting
        /// point to view coverage.
        fuzz_start_addr,
        /// Body is:
        /// - u32le test index.
        fuzz_test_change,
        /// Body is:
        /// - u32le test index
        /// - input in remaining bytes
        broadcast_fuzz_input,
        /// Body is a TimeReport.
        time_report,

        /// The first message sent by the server over the build system protocol.
        /// Body is a `Handshake`.
        /// This message only applies to the build system protocol.
        bsp_handshake = 0x80000000,
        /// Notifies that a new configuration file is available.
        /// Body is a cwd relative path to the configuration file.
        /// This message only applies to the build system protocol.
        bsp_configuration,
        /// Does not have a body.
        /// This message only applies to the build system protocol.
        bsp_build_started,
        /// Does not have a body.
        /// This message only applies to the build system protocol.
        bsp_build_completed,
        /// Body is a `Configuration.Step.Index`.
        /// This message only applies to the build system protocol.
        bsp_step_started,
        /// Body is a `BuildStepCompleted`.
        /// This message only applies to the build system protocol.
        bsp_step_completed,

        _,
    };

    /// Trailing:
    /// * base_paths: BasePaths,
    pub const Handshake = extern struct {
        /// See `build_system_version`.
        version: u32,
        flags: Flags,

        pub const Flags = packed struct(u32) {
            file_system_watch_supported: bool,
            _: u31 = 0,
        };
    };

    /// Trailing:
    /// * error_bundle: ErrorBundle,
    pub const BuildStepCompleted = extern struct {
        step_index: std.Build.Configuration.Step.Index,
        status: Status,
        error_bundle: ErrorBundle,
        // TODO result_error_msgs
        // TODO result_stderr
        // TODO result_peak_rss
        // TODO result_duration_ns

        pub const Status = enum(u32) {
            success,
            failure,
            skipped,
            skipped_oom,
        };
    };

    pub const PathPrefix = enum(u8) {
        cwd,
        zig_lib,
        local_cache,
        global_cache,
        build_root,
    };

    /// Trailing:
    /// * extra: [extra_len]u32,
    /// * string_bytes: [string_bytes_len]u8,
    /// See `std.zig.ErrorBundle`.
    pub const ErrorBundle = extern struct {
        extra_len: u32,
        string_bytes_len: u32,
    };

    /// Trailing:
    /// * name: [tests_len]u32
    ///   - null-terminated string_bytes index
    /// * expected_panic_msg: [tests_len]u32,
    ///   - null-terminated string_bytes index
    ///   - 0 means does not expect panic
    /// * string_bytes: [string_bytes_len]u8,
    pub const TestMetadata = extern struct {
        string_bytes_len: u32,
        tests_len: u32,
    };

    pub const TestResults = extern struct {
        index: u32,
        flags: Flags align(4),

        pub const Flags = packed struct(u64) {
            status: Status,
            fuzz: bool,
            log_err_count: u30,
            leak_count: u31,
        };

        pub const Status = enum(u2) { pass, fail, skip };
    };

    /// Trailing is the same as in `std.Build.abi.time_report.CompileResult`, excluding `step_name`.
    pub const TimeReport = extern struct {
        stats: std.Build.abi.time_report.CompileResult.Stats align(4),
        llvm_pass_timings_len: u32,
        files_len: u32,
        decls_len: u32,
        flags: Flags,
        pub const Flags = packed struct(u32) {
            use_llvm: bool,
            _: u31 = 0,
        };
    };

    /// Trailing:
    /// * the hex digest of the cache directory within the /o/ subdirectory.
    pub const EmitDigest = extern struct {
        flags: Flags,

        pub const Flags = packed struct(u8) {
            cache_hit: bool,
            reserved: u7 = 0,
        };
    };
}