In `@cd/protection.ixx`:
- Around line 287-290: The existence check uses the wrong extension: change the
check that currently tests for image_prefix + ".sdram" to instead test for
image_prefix + ".scram" so it matches the file opened later; update the
condition that checks std::filesystem::exists(image_prefix + ".sdram") to
std::filesystem::exists(image_prefix + ".scram") (working with image_prefix
built from options.image_path and options.image_name).

In `@dvd/dvd_scrambler.ixx`:
- Around line 45-48: The current offset calculation mixes floating point by
using +7.5; change it to pure integer math: compute the nibble value (e.g.,
uint32_t nibble = (*key) ^ ((psn >> 4) & 0xF)) and then compute offset using the
integer equivalent of +7.5 as (15/2), i.e. offset = ((2 * nibble + 15) *
FORM1_DATA_SIZE) / 2, ensuring offset and intermediate values are uint32_t to
avoid any implicit floating-point conversions.

In `@systems/gc.ixx`:
- Around line 2-37: The code in SystemGC::printInfo currently casts
header_data.data() to Header* which breaks strict aliasing and can misalign
fields; add `#include` <cstring> and replace the cast with a local Header variable
(e.g., Header header{}), then std::memcpy(&header, header_data.data(),
sizeof(Header)); and update all uses of header->... to header.... Ensure
comparisons using _GC_MAGIC and subsequent field accesses reference the copied
header instance.

In `@systems/wii.ixx`:
- Around line 2-37: The code in SystemWII::printInfo currently casts
header_data.data() to Header*, which is undefined on architectures with stricter
alignment; instead allocate a local Header variable, call data_reader->read into
header_data as before, then use std::memcpy to copy sizeof(Header) bytes from
header_data.data() into the local Header, and use that local Header for checks
(e.g., comparing header.wii_magic to _WII_MAGIC) and subsequent accesses to
avoid misaligned reads.

In `@utils/misc.ixx`:
- Around line 274-278: The function digits_count(T value) can invoke undefined
behavior when negating the smallest signed value; instead compute the absolute
magnitude by converting value to an unsigned type: use std::make_unsigned_t<T>
(or a safe fixed unsigned type) to hold the magnitude, assign magnitude =
static_cast<std::make_unsigned_t<T>>(value < 0 ?
-static_cast<std::make_unsigned_t<T>>(value) : value), then compute and return
(magnitude ? log10(magnitude) : 0) + 1; update digits_count to use that unsigned
magnitude and add the needed <type_traits> include.

In `@dvd/dvd_dump.ixx`:
- Around line 491-496: In progress_output, avoid division-by-zero when computing
percent_dumped: compute int64_t denom = (int64_t)lba_end - (int64_t)lba_start
and if denom == 0 set percent_dumped to a safe value (e.g., 100 when lba ==
lba_end else 0) otherwise compute percent_dumped = (int64_t)(lba - lba_start) *
100 / denom; update the logic in progress_output to use these checks and the
denom variable to prevent divide-by-zero while keeping the existing
spinner_animation and LOGC_RF call.

In `@dvd/dvd_dump.ixx`:
- Around line 882-889: The vector allocation under std::vector<State>
state_buffer(lba_end - lba_start) can underflow when lba_end <= lba_start; guard
the allocation and subsequent read_entry/count logic by checking that lba_end >
lba_start (e.g. only construct state_buffer and call read_entry when the range
length is positive), otherwise skip allocation and ensure errors.scsi remains
zero; update the block around dump_mode / DumpMode::DUMP to perform this range
check before touching state_buffer, read_entry, or computing errors.scsi.
- Around line 828-858: The dvd_raw option must only affect DVD media: change the
computation and use of the local raw flag so it is true only when
options.dvd_raw is set, omnidrive_firmware is present, and the current disc type
(ctx.disc_type) is actually DVD; use that guarded raw everywhere (including the
dump_get_config(ctx.disc_type, raw) call and the branch that sets rom_update =
false / fs_ctx.search = false) so Blu‑ray or other media won’t have metadata/ROM
update disabled by the dvd_raw option.

In `@dvd/dvd_scrambler.ixx`:
- Around line 47-76: In descramble, avoid reading frame->edc or computing the
EDC when the provided buffer is smaller than a full DataFrame: add a guard
(check size >= sizeof(DataFrame)) before the code that accesses frame->edc and
calls DVD_EDC().update(...).final(), and only compare the EDC (and set
unscrambled / call the fallback process to re-scramble) when that size check
passes; keep all other validation and the process(...) calls for partial buffers
unchanged. Ensure references to DataFrame, descramble, DVD_EDC::update, and
offsetof(DataFrame, edc) are used to locate and gate the EDC access.

In `@dvd/dvd_dump.ixx`:
- Around line 874-884: The code currently throws when lba_start >= lba_end;
instead preserve the previous no-op behavior by removing the throw_line and
guarding allocations and read_entry so they only run when lba_end > lba_start
and dump_mode != DumpMode::DUMP; specifically, in the block using Errors,
std::vector<State> state_buffer, and read_entry, wrap the allocation/read in an
if (lba_end > lba_start) check (or skip allocation when the computed size would
be zero/negative), ensure errors.scsi is set appropriately (e.g. zero) when
skipped, and leave the FIXME about chunking for separate follow-up work
(references: lba_start, lba_end, DumpMode::DUMP, state_buffer, read_entry,
cfg.lba_zero, State::ERROR_SKIP).
- Around line 512-525: The code allocates std::vector<DataFrame> data_frames but
passes sector_size bytes per sector to cmd_read_omnidrive, which can overflow
when sector_size > sizeof(DataFrame); replace the DataFrame vector with a byte
buffer sized sectors_count * sector_size (e.g., std::vector<uint8_t>
raw_buf(sectors_count * sector_size)), call cmd_read_omnidrive(...,
raw_buf.data(), sector_size, ...), then in the loop for each i reinterpret a
DataFrame from raw_buf.data() + i*sector_size (or memcpy into a DataFrame
instance) and convert it with DataFrame_to_RecordingFrame into the output buffer
at sectors + i*sector_size (avoid the current incorrect cast using sectors[i *
sizeof(RecordingFrame)]). Ensure all pointer arithmetic uses sector_size and no
buffer overrun occurs.

In `@dvd/dvd_dump.ixx`:
- Around line 512-529: The loop in read_dvd_sectors casts the byte buffer to
RecordingFrame& when writing converted frames; replace that with a memcpy
pattern: for each i, create a RecordingFrame tmp =
DataFrame_to_RecordingFrame(data_frames[i]) (or construct the RecordingFrame),
then memcpy the bytes into the destination buffer at sectors + i *
sizeof(RecordingFrame) using sizeof(RecordingFrame). This keeps behavior
identical to DataFrame_to_RecordingFrame while following the codebase's
established memcpy pattern and avoiding direct reference casting.