// Copyright (c) 2026 Rigless Labs.
// SPDX-License-Identifier: MIT OR Apache-2.0
//! Each processor family: its core, and the blocks its architecture puts at a fixed address rather
//! than the part.
//!
//! A part's peripherals live beside the part, under [`crate::soc`], because the vendor decides which
//! exist and where. The processor brings its own, at addresses the architecture fixes: the same block
//! answers at the same address on every core of a family, whoever built the chip around it. Those live
//! here, one module per family, so a second part of the same family reaches them without copying.
//!
//! **A block here is a peripheral in every other respect.** It implements
//! [`Device`](crate::device::Device) against a register layout, it keeps its state in the register file,
//! it cites the manual by section, and the MCU holds it as a field like any other. What separates it is
//! only where it is written down and which manual it is written against.
//!
//! **The family's half of the core answers this address space unless the machine says otherwise.**
//! The processor's own peripheral bus doesn't reach the models by default. The family's module here
//! implements the blocks the core family brings with it there, its interrupt controller among them,
//! and answers the rest itself, so a block modeled here is reached only where the machine module
//! claims its window.
//!
//! **A family's module makes its core too.** Its `processor` function makes an
//! [`emulator::Processor`](crate::emulator::Processor) from a
//! [`CoreSpec`](crate::emulator::CoreSpec), and the family's machine module puts that
//! function in every spec it renders. The runner calls whatever the spec carries, so it keeps
//! no list of families, and a family in a crate of your own plugs in the same way.