S575 · R2 supported-profile bağımsız fiziksel tekrar

//! S575 records the first independent R2 repeat of the retained S571
//! `board-rpi5` physical UART baseline.
//!
//! The S574 package remained byte-equal to the S570/S571 payload, but S575
//! used a fresh campaign, evidence root, one-shot transaction lock, compiled
//! capture binary and immutable raw. The exact card was written/read back and
//! ejected before UART was exclusively pre-armed. One operator-reported power
//! cycle produced the exact BOOT8G/BOOT8H/S541/S538/BOOT_TO_UI marker matrix.
//!
//! This simulation-only record closes supported-profile repeatability at two
//! retained observations (S571 + S575). It does not claim visible scanout,
//! physical input, cross-profile coverage or R2 field acceptance.

#![allow(dead_code)]

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s571_r1_frozen_manifest_physical_boot_uart_run::{
    S571_PHYSICAL_GATE_STATUS, S571_PHYSICAL_OBSERVATIONS, S571_RAW_SHA256,
    S571_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s574_r2_supported_profile_repeat_candidate_freeze::{
    S574_CAMPAIGN_ID, S574_EVIDENCE_TRANSPORT, S574_GATE_STATUS, S574_IMAGE_BYTES,
    S574_IMAGE_SHA256, S574_SEQUENCE, S574_SUPPORTED_PROFILE, S574_TARGET_ARCH,
};

pub const S575_SEQUENCE: usize = 575;
pub const S575_EXPECTED_PREDECESSOR: usize = S574_SEQUENCE;
pub const S575_NEXT_SEQUENCE: usize = 576;
pub const S575_R2_TRANSITION_FIRST: usize = 572;
pub const S575_R2_TRANSITION_LAST: usize = 707;
pub const S575_R2_WORKSTREAM_ORDINAL: usize = 1;
pub const S575_GATE_STATUS: &str = "PASS";
pub const S575_ACCEPTANCE_DOMAIN: &str = "supported_profile_independent_physical_repeat";
pub const S575_SUPPORTED_PROFILE: &str = S574_SUPPORTED_PROFILE;
pub const S575_TARGET_ARCH: &str = S574_TARGET_ARCH;
pub const S575_EVIDENCE_TRANSPORT: &str = S574_EVIDENCE_TRANSPORT;
pub const S575_CAMPAIGN_ID: &str = S574_CAMPAIGN_ID;
pub const S575_EVIDENCE_ROOT: &str = "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01";
pub const S575_TRANSACTION_LOCK_PATH: &str =
    "/private/tmp/aselsanos-s575-r2-repeat-01-425001fa.lock";
pub const S575_RETAINED_S571_LOCK_PATH: &str = "/private/tmp/aselsanos-s571-r1-425001fa.lock";

pub const S575_CANDIDATE_IMAGE_BYTES: u64 = S574_IMAGE_BYTES;
pub const S575_CANDIDATE_IMAGE_SHA256: &str = S574_IMAGE_SHA256;
pub const S575_TRANSACTION_TOOL_PATH: &str = "scripts/flash-rpi5-s575-r2-repeat-candidate.sh";
pub const S575_TRANSACTION_TOOL_BYTES: u64 = 30_039;
pub const S575_TRANSACTION_TOOL_SHA256: &str =
    "aadf8df5e85d977bd9dd73d69d905d2e95c9a7cbe51f2c32ae71a2a2ee63f2f3";
pub const S575_CAPTURE_WRAPPER_PATH: &str = "scripts/capture-rpi5-s575-r2-repeat-uart.c";
pub const S575_CAPTURE_WRAPPER_BYTES: u64 = 249;
pub const S575_CAPTURE_WRAPPER_SHA256: &str =
    "e4325ae7c9eef419aadc86cabdc2fcf94035d1026b3656d27ec1227060328c82";
pub const S575_CAPTURE_ENGINE_PATH: &str = "scripts/capture-rpi5-s540-r1-uart.c";
pub const S575_CAPTURE_ENGINE_BYTES: u64 = 20_572;
pub const S575_CAPTURE_ENGINE_SHA256: &str =
    "9f001c4cec407bbb4310ca0f89d9cc7e8a1be32307ba8d7ea0541e315ff1efec";
pub const S575_CAPTURE_BINARY_BYTES: u64 = 35_232;
pub const S575_CAPTURE_BINARY_SHA256: &str =
    "ffa2287ebb2ea836b91b922e94fe21522adc178911254423c7be8486338137d7";

pub const S575_INITIAL_INVENTORY_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-initial-read-only-inventory.log";
pub const S575_INITIAL_INVENTORY_BYTES: u64 = 1_096;
pub const S575_INITIAL_INVENTORY_SHA256: &str =
    "673b9b8cb0e2d046cef95a4cbc2674529144479228a6ea6c292c7c00a306f136";
pub const S575_TOOL_SOURCE_CHECK_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-tool-source-check.log";
pub const S575_TOOL_SOURCE_CHECK_BYTES: u64 = 1_053;
pub const S575_TOOL_SOURCE_CHECK_SHA256: &str =
    "2231cc5ee16d08dd65d274a4f0f82111f28ba9e4e1a3c9bb2d3405c71229ad9d";
pub const S575_PORTABILITY_AMENDMENT_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-probe-portability-amendment.log";
pub const S575_PORTABILITY_AMENDMENT_BYTES: u64 = 1_592;
pub const S575_PORTABILITY_AMENDMENT_SHA256: &str =
    "4137fbcbb655e1356031a6d9605caebe1d46d9fac1ebaf915bf7591b64d3d18a";
pub const S575_CARD_PREFLIGHT_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-card-preflight.log";
pub const S575_CARD_PREFLIGHT_BYTES: u64 = 2_531;
pub const S575_CARD_PREFLIGHT_SHA256: &str =
    "ad7d42f09598394c6dc182a3db3c9c34f87f3d15d5af37db0e14064dad189a58";
pub const S575_FLASH_LOG_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-flash.log";
pub const S575_FLASH_LOG_BYTES: u64 = 1_583;
pub const S575_FLASH_LOG_SHA256: &str =
    "27e481141c0e561c6e3e448f13b9daf6698d8f5dd7e868471cef10e646ea02ca";
pub const S575_CAPTURE_BUILD_LOG_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-capture-build.log";
pub const S575_CAPTURE_BUILD_LOG_BYTES: u64 = 1_304;
pub const S575_CAPTURE_BUILD_LOG_SHA256: &str =
    "5fb0c969902aa8dd7f4f6eba21d6260b5981a8483cd146d8e054e4dd18df30ba";
pub const S575_CAPTURE_LOG_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-capture.log";
pub const S575_CAPTURE_LOG_BYTES: u64 = 1_560;
pub const S575_CAPTURE_LOG_SHA256: &str =
    "a36e4757fb21b38dfde816e456f9bde01cb24cf9467479ec042ddd060f348c7c";
pub const S575_CLOSEOUT_LOG_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-run-closeout.log";
pub const S575_CLOSEOUT_LOG_BYTES: u64 = 2_037;
pub const S575_CLOSEOUT_LOG_SHA256: &str =
    "dcc44f560c13098e89c0f425cda629b89dca41e7e487c9ab482e1bb567b2052b";
pub const S575_EVIDENCE_MANIFEST_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/EVIDENCE_SHA256SUMS";
pub const S575_EVIDENCE_MANIFEST_BYTES: u64 = 810;
pub const S575_EVIDENCE_MANIFEST_SHA256: &str =
    "b022ace1aa67252153bc14a108222a7d2c790db998f3f3d2257e0fd390dbf9ae";
pub const S575_EVIDENCE_README_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/README.md";
pub const S575_EVIDENCE_README_BYTES: u64 = 7_093;
pub const S575_EVIDENCE_README_SHA256: &str =
    "ae7029affab8b034f7cbd558166e9d1c688f43d856fe518d43fec2b59f03c78d";
pub const S575_RAW_PATH: &str =
    "evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-uart.raw";
pub const S575_RAW_BYTES: u64 = 20_610;
pub const S575_RAW_SHA256: &str =
    "96bc5fe999115e10f8b4603868f58a055d3dc1d41b4d08e59b021a0f5ff77602";
pub const S575_RAW_MODE_OCTAL: &str = "0444";
pub const S575_RAW_LINK_COUNT: usize = 1;
pub const S575_RAW_NUL_BYTES: usize = 10;
pub const S575_RAW_CR_BYTES: usize = 204;
pub const S575_RAW_LF_BYTES: usize = 204;

pub const S575_EXPECTED_CARD_SERIAL: u32 = 0x4250_01fa;
pub const S575_EXPECTED_CARD_BYTES: u64 = 62_549_655_552;
pub const S575_EXPECTED_CARD_RAW_CID: &str = "009f5449534436344761425001fa01a1";
pub const S575_EXPECTED_PROBE_SERIAL: &str = "E6647C74033F9131";
pub const S575_OBSERVED_UART_CALLOUT: &str = "/dev/cu.usbmodem214402";
pub const S575_OBSERVED_UART_DIALIN: &str = "/dev/tty.usbmodem214402";
pub const S575_AUTHORIZATION_TOKEN: &str =
    "S575_AUTHORIZE_FRESH_FREEZE_SD_WRITE_READBACK_EJECT_UART_PREARM_ONE_POWER_ON_a24f4d24e838cd7d1a6b2ff217d864e9c4b08f12ce7dd165b302e8073a980b04_425001fa_62549655552_r2-ws01-board-rpi5-repeat-01";
pub const S575_AUTHORIZATION_TOKEN_SHA256: &str =
    "e1a2a66ec19f27d583058387bb90195421c04907f16a0b878b01ce60fd68e403";

pub const S575_READ_ONLY_PREFLIGHT_REPEATS: usize = 2;
pub const S575_SD_WRITE_TRANSACTIONS: usize = 1;
pub const S575_SD_WRITES: usize = 4;
pub const S575_SD_READBACKS: usize = 4;
pub const S575_SD_EJECTS: usize = 1;
pub const S575_UART_OPENS: usize = 1;
pub const S575_POWER_TRANSITIONS_OPERATOR_REPORTED: usize = 2;
pub const S575_POWER_TRANSITIONS_INDEPENDENTLY_OBSERVED: usize = 0;
pub const S575_NEW_IMMUTABLE_RAW_CAPTURES: usize = 1;
pub const S575_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 1;
pub const S575_NEW_PHYSICAL_OBSERVATIONS: usize = 1;
pub const S575_NEW_INDEPENDENT_PHYSICAL_REPEATS: usize = 1;
pub const S575_TOTAL_SUPPORTED_PROFILE_RUNTIME_BASELINES: usize =
    S571_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS + S575_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS;
pub const S575_TOTAL_PHYSICAL_OBSERVATIONS: usize =
    S571_PHYSICAL_OBSERVATIONS + S575_NEW_PHYSICAL_OBSERVATIONS;
pub const S575_PHYSICAL_OR_DEVICE_OPERATIONS: usize = 1;
pub const S575_SUPPORTED_PROFILE_REPEATABILITY_COMPLETE: bool = true;
pub const S575_BOOT_TO_UI_PHYSICALLY_OBSERVED: bool = true;
pub const S575_VISIBLE_SCANOUT_OBSERVED: bool = false;
pub const S575_PHYSICAL_INPUT_OBSERVED: bool = false;
pub const S575_CROSS_PROFILE_COVERAGE_COMPLETE: bool = false;
pub const S575_R2_FIELD_ACCEPTANCE_COMPLETE: bool = false;
pub const S575_AUTOMATIC_PROMOTION: bool = false;
pub const RUNBOOK_EXECUTED_IN_S575: bool = true;

pub const S575_BOOT8G_MARKER: &str = "ASELSAN/BOOT8G";
pub const S575_BOOT8H_MARKER: &str = "ASELSAN/BOOT8H";
pub const S575_S541_HANDOFF_MARKER: &str = "ASELSAN/S541 HANDOFF=CPU1_PREFLIGHT_ARMED";
pub const S575_S538_ROUTE_MARKER: &str = "ASELSAN/S538 ROUTE=PRIOR_BOOT_TO_UI";
pub const S575_TERMINAL_MARKER: &str = "[R1:S536] BOOT_TO_UI_READY";
pub const S575_G8H_ERROR_MARKER: &str = "ASELSAN/G8HERR REPORTER=CPU0";
pub const S575_S541_ERROR_MARKER: &str = "ASELSAN/S541ERR";
pub const S575_S538_ERROR_MARKER: &str = "ASELSAN/S538ERR";

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS575ArtifactIdentity {
    pub bytes: u64,
    pub sha256: &'static str,
}

pub const fn s575_identity(bytes: u64, sha256: &'static str) -> G8lS575ArtifactIdentity {
    G8lS575ArtifactIdentity { bytes, sha256 }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS575EvidenceIdentities {
    pub transaction_tool: G8lS575ArtifactIdentity,
    pub capture_wrapper: G8lS575ArtifactIdentity,
    pub capture_engine: G8lS575ArtifactIdentity,
    pub capture_binary: G8lS575ArtifactIdentity,
    pub initial_inventory: G8lS575ArtifactIdentity,
    pub tool_source_check: G8lS575ArtifactIdentity,
    pub portability_amendment: G8lS575ArtifactIdentity,
    pub card_preflight: G8lS575ArtifactIdentity,
    pub flash_log: G8lS575ArtifactIdentity,
    pub capture_build_log: G8lS575ArtifactIdentity,
    pub capture_log: G8lS575ArtifactIdentity,
    pub closeout_log: G8lS575ArtifactIdentity,
    pub evidence_manifest: G8lS575ArtifactIdentity,
    pub evidence_readme: G8lS575ArtifactIdentity,
    pub raw: G8lS575ArtifactIdentity,
}

pub const S575_EXPECTED_EVIDENCE: G8lS575EvidenceIdentities = G8lS575EvidenceIdentities {
    transaction_tool: s575_identity(S575_TRANSACTION_TOOL_BYTES, S575_TRANSACTION_TOOL_SHA256),
    capture_wrapper: s575_identity(S575_CAPTURE_WRAPPER_BYTES, S575_CAPTURE_WRAPPER_SHA256),
    capture_engine: s575_identity(S575_CAPTURE_ENGINE_BYTES, S575_CAPTURE_ENGINE_SHA256),
    capture_binary: s575_identity(S575_CAPTURE_BINARY_BYTES, S575_CAPTURE_BINARY_SHA256),
    initial_inventory: s575_identity(S575_INITIAL_INVENTORY_BYTES, S575_INITIAL_INVENTORY_SHA256),
    tool_source_check: s575_identity(S575_TOOL_SOURCE_CHECK_BYTES, S575_TOOL_SOURCE_CHECK_SHA256),
    portability_amendment: s575_identity(
        S575_PORTABILITY_AMENDMENT_BYTES,
        S575_PORTABILITY_AMENDMENT_SHA256,
    ),
    card_preflight: s575_identity(S575_CARD_PREFLIGHT_BYTES, S575_CARD_PREFLIGHT_SHA256),
    flash_log: s575_identity(S575_FLASH_LOG_BYTES, S575_FLASH_LOG_SHA256),
    capture_build_log: s575_identity(S575_CAPTURE_BUILD_LOG_BYTES, S575_CAPTURE_BUILD_LOG_SHA256),
    capture_log: s575_identity(S575_CAPTURE_LOG_BYTES, S575_CAPTURE_LOG_SHA256),
    closeout_log: s575_identity(S575_CLOSEOUT_LOG_BYTES, S575_CLOSEOUT_LOG_SHA256),
    evidence_manifest: s575_identity(S575_EVIDENCE_MANIFEST_BYTES, S575_EVIDENCE_MANIFEST_SHA256),
    evidence_readme: s575_identity(S575_EVIDENCE_README_BYTES, S575_EVIDENCE_README_SHA256),
    raw: s575_identity(S575_RAW_BYTES, S575_RAW_SHA256),
};

pub const fn count_s575_substring(haystack: &[u8], needle: &[u8]) -> usize {
    if needle.is_empty() || haystack.len() < needle.len() {
        return 0;
    }
    let mut count = 0;
    let mut index = 0;
    while index + needle.len() <= haystack.len() {
        let mut matched = true;
        let mut offset = 0;
        while offset < needle.len() {
            if haystack[index + offset] != needle[offset] {
                matched = false;
                break;
            }
            offset += 1;
        }
        if matched {
            count += 1;
        }
        index += 1;
    }
    count
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS575RawMarkerCounts {
    pub boot8g: usize,
    pub boot8h: usize,
    pub s541_handoff: usize,
    pub s538_route: usize,
    pub terminal: usize,
    pub g8h_error: usize,
    pub s541_error: usize,
    pub s538_error: usize,
    pub panic_lower: usize,
    pub panic_upper: usize,
    pub unknown_lower: usize,
    pub unknown_irq_turkish: usize,
    pub card_raw_cid: usize,
}

pub const fn s575_raw_marker_counts(raw: &[u8]) -> G8lS575RawMarkerCounts {
    G8lS575RawMarkerCounts {
        boot8g: count_s575_substring(raw, S575_BOOT8G_MARKER.as_bytes()),
        boot8h: count_s575_substring(raw, S575_BOOT8H_MARKER.as_bytes()),
        s541_handoff: count_s575_substring(raw, S575_S541_HANDOFF_MARKER.as_bytes()),
        s538_route: count_s575_substring(raw, S575_S538_ROUTE_MARKER.as_bytes()),
        terminal: count_s575_substring(raw, S575_TERMINAL_MARKER.as_bytes()),
        g8h_error: count_s575_substring(raw, S575_G8H_ERROR_MARKER.as_bytes()),
        s541_error: count_s575_substring(raw, S575_S541_ERROR_MARKER.as_bytes()),
        s538_error: count_s575_substring(raw, S575_S538_ERROR_MARKER.as_bytes()),
        panic_lower: count_s575_substring(raw, b"panic"),
        panic_upper: count_s575_substring(raw, b"PANIC"),
        unknown_lower: count_s575_substring(raw, b"unknown"),
        unknown_irq_turkish: count_s575_substring(raw, b"Bilinmeyen IRQ"),
        card_raw_cid: count_s575_substring(raw, S575_EXPECTED_CARD_RAW_CID.as_bytes()),
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS575RawVerdict {
    Pass,
    RedPanic,
    RedUnknownIrq,
    RedG8hError,
    RedS541Error,
    RedS538Error,
    RedMarkerMatrix,
}

pub const fn classify_s575_raw(raw: &[u8]) -> G8lS575RawVerdict {
    let counts = s575_raw_marker_counts(raw);
    if counts.panic_lower != 0 || counts.panic_upper != 0 {
        return G8lS575RawVerdict::RedPanic;
    }
    if counts.unknown_lower != 0 || counts.unknown_irq_turkish != 0 {
        return G8lS575RawVerdict::RedUnknownIrq;
    }
    if counts.g8h_error != 0 {
        return G8lS575RawVerdict::RedG8hError;
    }
    if counts.s541_error != 0 {
        return G8lS575RawVerdict::RedS541Error;
    }
    if counts.s538_error != 0 {
        return G8lS575RawVerdict::RedS538Error;
    }
    if counts.boot8g == 1
        && counts.boot8h == 1
        && counts.s541_handoff == 1
        && counts.s538_route == 1
        && counts.terminal == 1
        && counts.card_raw_cid == 1
    {
        G8lS575RawVerdict::Pass
    } else {
        G8lS575RawVerdict::RedMarkerMatrix
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS575PhysicalObservation<'a> {
    pub predecessor_sequence: usize,
    pub predecessor_status: &'a str,
    pub baseline_status: &'a str,
    pub profile: &'a str,
    pub target_arch: &'a str,
    pub transport: &'a str,
    pub campaign_id: &'a str,
    pub evidence_root: &'a str,
    pub transaction_lock_path: &'a str,
    pub candidate: G8lS575ArtifactIdentity,
    pub evidence: G8lS575EvidenceIdentities,
    pub authorization_token: &'a str,
    pub authorization_token_sha256: &'a str,
    pub card_serial: u32,
    pub card_bytes: u64,
    pub probe_serial: &'a str,
    pub uart_callout: &'a str,
    pub uart_dialin: &'a str,
    pub preflight_repeats: usize,
    pub preflight_outputs_byte_equal: bool,
    pub pi_unpowered_before_write: bool,
    pub s571_history_retained: bool,
    pub s571_lock_retained: bool,
    pub s575_lock_retained: bool,
    pub rerun_forbidden: bool,
    pub sd_write_transactions: usize,
    pub sd_writes: usize,
    pub sd_readbacks: usize,
    pub sd_ejects: usize,
    pub uart_opens: usize,
    pub capture_armed_before_power: bool,
    pub capture_closed: bool,
    pub terminal_grace_complete: bool,
    pub capture_durable: bool,
    pub operator_power_on_reported: bool,
    pub operator_power_off_reported: bool,
    pub power_transitions_operator_reported: usize,
    pub power_transitions_independently_observed: usize,
    pub uart_holders_at_closeout: usize,
    pub card_present_on_macos_at_closeout: bool,
    pub raw: &'a [u8],
    pub raw_identity: G8lS575ArtifactIdentity,
    pub raw_mode_octal: &'a str,
    pub raw_link_count: usize,
    pub raw_nul_bytes: usize,
    pub raw_cr_bytes: usize,
    pub raw_lf_bytes: usize,
    pub new_runtime_observations: usize,
    pub new_physical_observations: usize,
    pub new_independent_physical_repeats: usize,
    pub total_runtime_baselines: usize,
    pub total_physical_observations: usize,
    pub repeatability_complete: bool,
    pub visible_scanout_observed: bool,
    pub physical_input_observed: bool,
    pub cross_profile_coverage_complete: bool,
    pub r2_field_acceptance_complete: bool,
    pub automatic_promotion: bool,
    pub runbook_executed: bool,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS575PhysicalReceipt {
    pub sequence: usize,
    pub predecessor_sequence: usize,
    pub status: &'static str,
    pub acceptance_domain: &'static str,
    pub campaign_id: &'static str,
    pub candidate: G8lS575ArtifactIdentity,
    pub raw: G8lS575ArtifactIdentity,
    pub raw_verdict: G8lS575RawVerdict,
    pub card_serial: u32,
    pub probe_serial: &'static str,
    pub sd_writes: usize,
    pub sd_readbacks: usize,
    pub sd_ejects: usize,
    pub uart_opens: usize,
    pub power_transitions_operator_reported: usize,
    pub power_transitions_independently_observed: usize,
    pub new_runtime_observations: usize,
    pub new_physical_observations: usize,
    pub new_independent_physical_repeats: usize,
    pub total_runtime_baselines: usize,
    pub total_physical_observations: usize,
    pub repeatability_complete: bool,
    pub boot_to_ui_physically_observed: bool,
    pub visible_scanout_observed: bool,
    pub physical_input_observed: bool,
    pub cross_profile_coverage_complete: bool,
    pub r2_field_acceptance_complete: bool,
    pub automatic_promotion: bool,
    pub runbook_executed: bool,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS575PhysicalState {
    receipt: Option<G8lS575PhysicalReceipt>,
}

impl G8lS575PhysicalState {
    pub const fn new() -> Self {
        Self { receipt: None }
    }

    pub const fn receipt(&self) -> Option<G8lS575PhysicalReceipt> {
        self.receipt
    }
}

impl Default for G8lS575PhysicalState {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS575PhysicalOutcome {
    PhysicalRepeatRecorded(G8lS575PhysicalReceipt),
    PhysicalRepeatRetained(G8lS575PhysicalReceipt),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS575PhysicalError {
    PredecessorRejected,
    BaselineRejected,
    CampaignDrift,
    EvidenceIdentityDrift,
    AuthorizationRejected,
    DeviceIdentityDrift,
    PreflightRejected,
    HistoryRejected,
    SdTransactionRejected,
    CaptureRejected,
    PowerAccountingRejected,
    RawIdentityDrift,
    RawContentRejected,
    ObservationAccountingRejected,
    BoundaryOverclaim,
    PublishedStateDrift,
}

impl G8lS575PhysicalError {
    pub const fn diagnostic_code(self) -> u64 {
        match self {
            Self::PredecessorRejected => 0x5751_01,
            Self::BaselineRejected => 0x5751_02,
            Self::CampaignDrift => 0x5751_03,
            Self::EvidenceIdentityDrift => 0x5751_04,
            Self::AuthorizationRejected => 0x5751_05,
            Self::DeviceIdentityDrift => 0x5751_06,
            Self::PreflightRejected => 0x5751_07,
            Self::HistoryRejected => 0x5751_08,
            Self::SdTransactionRejected => 0x5751_09,
            Self::CaptureRejected => 0x5751_0a,
            Self::PowerAccountingRejected => 0x5751_0b,
            Self::RawIdentityDrift => 0x5751_0c,
            Self::RawContentRejected => 0x5751_0d,
            Self::ObservationAccountingRejected => 0x5751_0e,
            Self::BoundaryOverclaim => 0x5751_0f,
            Self::PublishedStateDrift => 0x5751_10,
        }
    }
}

pub fn service_s575_model_supported_profile_independent_physical_repeat(
    state: &mut G8lS575PhysicalState,
    observation: G8lS575PhysicalObservation<'_>,
) -> Result<G8lS575PhysicalOutcome, G8lS575PhysicalError> {
    if observation.predecessor_sequence != S575_EXPECTED_PREDECESSOR
        || observation.predecessor_status != S574_GATE_STATUS
    {
        return Err(G8lS575PhysicalError::PredecessorRejected);
    }
    if observation.baseline_status != S571_PHYSICAL_GATE_STATUS || S571_RAW_SHA256.is_empty() {
        return Err(G8lS575PhysicalError::BaselineRejected);
    }
    if observation.profile != S575_SUPPORTED_PROFILE
        || observation.target_arch != S575_TARGET_ARCH
        || observation.transport != S575_EVIDENCE_TRANSPORT
        || observation.campaign_id != S575_CAMPAIGN_ID
        || observation.evidence_root != S575_EVIDENCE_ROOT
        || observation.transaction_lock_path != S575_TRANSACTION_LOCK_PATH
    {
        return Err(G8lS575PhysicalError::CampaignDrift);
    }
    if observation.candidate
        != s575_identity(S575_CANDIDATE_IMAGE_BYTES, S575_CANDIDATE_IMAGE_SHA256)
        || observation.evidence != S575_EXPECTED_EVIDENCE
    {
        return Err(G8lS575PhysicalError::EvidenceIdentityDrift);
    }
    if observation.authorization_token != S575_AUTHORIZATION_TOKEN
        || observation.authorization_token_sha256 != S575_AUTHORIZATION_TOKEN_SHA256
    {
        return Err(G8lS575PhysicalError::AuthorizationRejected);
    }
    if observation.card_serial != S575_EXPECTED_CARD_SERIAL
        || observation.card_bytes != S575_EXPECTED_CARD_BYTES
        || observation.probe_serial != S575_EXPECTED_PROBE_SERIAL
        || observation.uart_callout != S575_OBSERVED_UART_CALLOUT
        || observation.uart_dialin != S575_OBSERVED_UART_DIALIN
    {
        return Err(G8lS575PhysicalError::DeviceIdentityDrift);
    }
    if observation.preflight_repeats != S575_READ_ONLY_PREFLIGHT_REPEATS
        || !observation.preflight_outputs_byte_equal
        || !observation.pi_unpowered_before_write
    {
        return Err(G8lS575PhysicalError::PreflightRejected);
    }
    if !observation.s571_history_retained
        || !observation.s571_lock_retained
        || !observation.s575_lock_retained
        || !observation.rerun_forbidden
    {
        return Err(G8lS575PhysicalError::HistoryRejected);
    }
    if observation.sd_write_transactions != S575_SD_WRITE_TRANSACTIONS
        || observation.sd_writes != S575_SD_WRITES
        || observation.sd_readbacks != S575_SD_READBACKS
        || observation.sd_ejects != S575_SD_EJECTS
    {
        return Err(G8lS575PhysicalError::SdTransactionRejected);
    }
    if observation.uart_opens != S575_UART_OPENS
        || !observation.capture_armed_before_power
        || !observation.capture_closed
        || !observation.terminal_grace_complete
        || !observation.capture_durable
        || observation.uart_holders_at_closeout != 0
        || observation.card_present_on_macos_at_closeout
    {
        return Err(G8lS575PhysicalError::CaptureRejected);
    }
    if !observation.operator_power_on_reported
        || !observation.operator_power_off_reported
        || observation.power_transitions_operator_reported
            != S575_POWER_TRANSITIONS_OPERATOR_REPORTED
        || observation.power_transitions_independently_observed
            != S575_POWER_TRANSITIONS_INDEPENDENTLY_OBSERVED
    {
        return Err(G8lS575PhysicalError::PowerAccountingRejected);
    }
    if observation.raw_identity != s575_identity(S575_RAW_BYTES, S575_RAW_SHA256)
        || observation.raw.len() as u64 != S575_RAW_BYTES
        || observation.raw_mode_octal != S575_RAW_MODE_OCTAL
        || observation.raw_link_count != S575_RAW_LINK_COUNT
    {
        return Err(G8lS575PhysicalError::RawIdentityDrift);
    }
    if classify_s575_raw(observation.raw) != G8lS575RawVerdict::Pass
        || observation.raw_nul_bytes != S575_RAW_NUL_BYTES
        || observation.raw_cr_bytes != S575_RAW_CR_BYTES
        || observation.raw_lf_bytes != S575_RAW_LF_BYTES
    {
        return Err(G8lS575PhysicalError::RawContentRejected);
    }
    if observation.new_runtime_observations != S575_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS
        || observation.new_physical_observations != S575_NEW_PHYSICAL_OBSERVATIONS
        || observation.new_independent_physical_repeats != S575_NEW_INDEPENDENT_PHYSICAL_REPEATS
        || observation.total_runtime_baselines != S575_TOTAL_SUPPORTED_PROFILE_RUNTIME_BASELINES
        || observation.total_physical_observations != S575_TOTAL_PHYSICAL_OBSERVATIONS
        || !observation.repeatability_complete
        || !observation.runbook_executed
    {
        return Err(G8lS575PhysicalError::ObservationAccountingRejected);
    }
    if observation.visible_scanout_observed
        || observation.physical_input_observed
        || observation.cross_profile_coverage_complete
        || observation.r2_field_acceptance_complete
        || observation.automatic_promotion
    {
        return Err(G8lS575PhysicalError::BoundaryOverclaim);
    }

    let receipt = G8lS575PhysicalReceipt {
        sequence: S575_SEQUENCE,
        predecessor_sequence: observation.predecessor_sequence,
        status: S575_GATE_STATUS,
        acceptance_domain: S575_ACCEPTANCE_DOMAIN,
        campaign_id: S575_CAMPAIGN_ID,
        candidate: observation.candidate,
        raw: observation.raw_identity,
        raw_verdict: G8lS575RawVerdict::Pass,
        card_serial: observation.card_serial,
        probe_serial: S575_EXPECTED_PROBE_SERIAL,
        sd_writes: observation.sd_writes,
        sd_readbacks: observation.sd_readbacks,
        sd_ejects: observation.sd_ejects,
        uart_opens: observation.uart_opens,
        power_transitions_operator_reported: observation.power_transitions_operator_reported,
        power_transitions_independently_observed: observation
            .power_transitions_independently_observed,
        new_runtime_observations: observation.new_runtime_observations,
        new_physical_observations: observation.new_physical_observations,
        new_independent_physical_repeats: observation.new_independent_physical_repeats,
        total_runtime_baselines: observation.total_runtime_baselines,
        total_physical_observations: observation.total_physical_observations,
        repeatability_complete: S575_SUPPORTED_PROFILE_REPEATABILITY_COMPLETE,
        boot_to_ui_physically_observed: S575_BOOT_TO_UI_PHYSICALLY_OBSERVED,
        visible_scanout_observed: S575_VISIBLE_SCANOUT_OBSERVED,
        physical_input_observed: S575_PHYSICAL_INPUT_OBSERVED,
        cross_profile_coverage_complete: S575_CROSS_PROFILE_COVERAGE_COMPLETE,
        r2_field_acceptance_complete: S575_R2_FIELD_ACCEPTANCE_COMPLETE,
        automatic_promotion: S575_AUTOMATIC_PROMOTION,
        runbook_executed: RUNBOOK_EXECUTED_IN_S575,
    };

    match state.receipt {
        None => {
            state.receipt = Some(receipt);
            Ok(G8lS575PhysicalOutcome::PhysicalRepeatRecorded(receipt))
        }
        Some(existing) if existing == receipt => {
            Ok(G8lS575PhysicalOutcome::PhysicalRepeatRetained(existing))
        }
        Some(_) => Err(G8lS575PhysicalError::PublishedStateDrift),
    }
}

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s571_r1_frozen_manifest_physical_boot_uart_run::{
    S571_PHYSICAL_GATE_STATUS, S571_RAW_BYTES, S571_RAW_SHA256,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s575_r2_supported_profile_independent_physical_repeat::*;
use sha2::{Digest, Sha256};
use std::collections::HashSet;
use std::fs;
use std::os::unix::fs::{MetadataExt, PermissionsExt};
use std::path::{Path, PathBuf};

const SOURCE: &str = include_str!(
    "../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s575_r2_supported_profile_independent_physical_repeat.rs"
);
const MAIN: &str = include_str!("../../kernel/src/main.rs");
const SIMULATION_LIB: &str = include_str!("../src/lib.rs");
const TRANSACTION_TOOL: &str = include_str!("../../scripts/flash-rpi5-s575-r2-repeat-candidate.sh");
const CAPTURE_WRAPPER: &str = include_str!("../../scripts/capture-rpi5-s575-r2-repeat-uart.c");
const CAPTURE_ENGINE: &str = include_str!("../../scripts/capture-rpi5-s540-r1-uart.c");
const INITIAL_INVENTORY: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-initial-read-only-inventory.log"
);
const TOOL_SOURCE_CHECK: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-tool-source-check.log"
);
const PORTABILITY_AMENDMENT: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-probe-portability-amendment.log"
);
const CARD_PREFLIGHT: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-card-preflight.log"
);
const FLASH_LOG: &str =
    include_str!("../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-flash.log");
const CAPTURE_BUILD_LOG: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-capture-build.log"
);
const CAPTURE_LOG: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-capture.log"
);
const CLOSEOUT_LOG: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-run-closeout.log"
);
const EVIDENCE_MANIFEST: &str = include_str!(
    "../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/EVIDENCE_SHA256SUMS"
);
const EVIDENCE_README: &str =
    include_str!("../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/README.md");
const PHYSICAL_RAW: &[u8] =
    include_bytes!("../../evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-uart.raw");
const S571_RAW: &[u8] =
    include_bytes!("../../evidence/rpi5/r1/sequence-571-physical-boot-uart/s571-uart.raw");
const S574_IMAGE: &[u8] = include_bytes!(
    "../../evidence/rpi5/r2/sequence-574-supported-profile-repeat-candidate-freeze/package/aselsanos-rpi5.img"
);
const S570_IMAGE: &[u8] = include_bytes!(
    "../../evidence/rpi5/r1/sequence-570-candidate-freeze/package/aselsanos-rpi5.img"
);

fn sha256(bytes: &[u8]) -> String {
    format!("{:x}", Sha256::digest(bytes))
}

fn repository_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
}

fn repository_path(path: &str) -> PathBuf {
    repository_root().join(path)
}

fn byte_composition(bytes: &[u8]) -> (usize, usize, usize) {
    bytes.iter().fold((0, 0, 0), |(nul, cr, lf), byte| {
        (
            nul + usize::from(*byte == 0),
            cr + usize::from(*byte == b'\r'),
            lf + usize::from(*byte == b'\n'),
        )
    })
}

fn observation() -> G8lS575PhysicalObservation<'static> {
    G8lS575PhysicalObservation {
        predecessor_sequence: S575_EXPECTED_PREDECESSOR,
        predecessor_status: "PASS",
        baseline_status: S571_PHYSICAL_GATE_STATUS,
        profile: S575_SUPPORTED_PROFILE,
        target_arch: S575_TARGET_ARCH,
        transport: S575_EVIDENCE_TRANSPORT,
        campaign_id: S575_CAMPAIGN_ID,
        evidence_root: S575_EVIDENCE_ROOT,
        transaction_lock_path: S575_TRANSACTION_LOCK_PATH,
        candidate: s575_identity(S575_CANDIDATE_IMAGE_BYTES, S575_CANDIDATE_IMAGE_SHA256),
        evidence: S575_EXPECTED_EVIDENCE,
        authorization_token: S575_AUTHORIZATION_TOKEN,
        authorization_token_sha256: S575_AUTHORIZATION_TOKEN_SHA256,
        card_serial: S575_EXPECTED_CARD_SERIAL,
        card_bytes: S575_EXPECTED_CARD_BYTES,
        probe_serial: S575_EXPECTED_PROBE_SERIAL,
        uart_callout: S575_OBSERVED_UART_CALLOUT,
        uart_dialin: S575_OBSERVED_UART_DIALIN,
        preflight_repeats: S575_READ_ONLY_PREFLIGHT_REPEATS,
        preflight_outputs_byte_equal: true,
        pi_unpowered_before_write: true,
        s571_history_retained: true,
        s571_lock_retained: true,
        s575_lock_retained: true,
        rerun_forbidden: true,
        sd_write_transactions: S575_SD_WRITE_TRANSACTIONS,
        sd_writes: S575_SD_WRITES,
        sd_readbacks: S575_SD_READBACKS,
        sd_ejects: S575_SD_EJECTS,
        uart_opens: S575_UART_OPENS,
        capture_armed_before_power: true,
        capture_closed: true,
        terminal_grace_complete: true,
        capture_durable: true,
        operator_power_on_reported: true,
        operator_power_off_reported: true,
        power_transitions_operator_reported: S575_POWER_TRANSITIONS_OPERATOR_REPORTED,
        power_transitions_independently_observed: S575_POWER_TRANSITIONS_INDEPENDENTLY_OBSERVED,
        uart_holders_at_closeout: 0,
        card_present_on_macos_at_closeout: false,
        raw: PHYSICAL_RAW,
        raw_identity: s575_identity(S575_RAW_BYTES, S575_RAW_SHA256),
        raw_mode_octal: S575_RAW_MODE_OCTAL,
        raw_link_count: S575_RAW_LINK_COUNT,
        raw_nul_bytes: S575_RAW_NUL_BYTES,
        raw_cr_bytes: S575_RAW_CR_BYTES,
        raw_lf_bytes: S575_RAW_LF_BYTES,
        new_runtime_observations: S575_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS,
        new_physical_observations: S575_NEW_PHYSICAL_OBSERVATIONS,
        new_independent_physical_repeats: S575_NEW_INDEPENDENT_PHYSICAL_REPEATS,
        total_runtime_baselines: S575_TOTAL_SUPPORTED_PROFILE_RUNTIME_BASELINES,
        total_physical_observations: S575_TOTAL_PHYSICAL_OBSERVATIONS,
        repeatability_complete: S575_SUPPORTED_PROFILE_REPEATABILITY_COMPLETE,
        visible_scanout_observed: false,
        physical_input_observed: false,
        cross_profile_coverage_complete: false,
        r2_field_acceptance_complete: false,
        automatic_promotion: false,
        runbook_executed: true,
    }
}

#[test]
fn sequence_profile_campaign_and_r2_workstream_are_exact() {
    assert_eq!(S575_SEQUENCE, 575);
    assert_eq!(S575_EXPECTED_PREDECESSOR, 574);
    assert_eq!(S575_NEXT_SEQUENCE, 576);
    assert_eq!(S575_R2_TRANSITION_FIRST, 572);
    assert_eq!(S575_R2_TRANSITION_LAST, 707);
    assert_eq!(S575_R2_WORKSTREAM_ORDINAL, 1);
    assert_eq!(S575_GATE_STATUS, "PASS");
    assert_eq!(
        S575_ACCEPTANCE_DOMAIN,
        "supported_profile_independent_physical_repeat"
    );
    assert_eq!(S575_SUPPORTED_PROFILE, "board-rpi5");
    assert_eq!(S575_TARGET_ARCH, "aarch64");
    assert_eq!(S575_EVIDENCE_TRANSPORT, "uart-115200-8n1");
    assert_eq!(S575_CAMPAIGN_ID, "r2-ws01-board-rpi5-repeat-01");
}

#[test]
fn physical_operation_and_repeatability_accounting_are_exact() {
    assert_eq!(S575_SD_WRITE_TRANSACTIONS, 1);
    assert_eq!(S575_SD_WRITES, 4);
    assert_eq!(S575_SD_READBACKS, 4);
    assert_eq!(S575_SD_EJECTS, 1);
    assert_eq!(S575_UART_OPENS, 1);
    assert_eq!(S575_POWER_TRANSITIONS_OPERATOR_REPORTED, 2);
    assert_eq!(S575_POWER_TRANSITIONS_INDEPENDENTLY_OBSERVED, 0);
    assert_eq!(S575_NEW_IMMUTABLE_RAW_CAPTURES, 1);
    assert_eq!(S575_NEW_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 1);
    assert_eq!(S575_NEW_PHYSICAL_OBSERVATIONS, 1);
    assert_eq!(S575_NEW_INDEPENDENT_PHYSICAL_REPEATS, 1);
    assert_eq!(S575_TOTAL_SUPPORTED_PROFILE_RUNTIME_BASELINES, 2);
    assert_eq!(S575_TOTAL_PHYSICAL_OBSERVATIONS, 2);
    assert_eq!(S575_PHYSICAL_OR_DEVICE_OPERATIONS, 1);
    assert!(S575_SUPPORTED_PROFILE_REPEATABILITY_COMPLETE);
    assert!(RUNBOOK_EXECUTED_IN_S575);
}

#[test]
fn retained_s571_baseline_and_fresh_s574_candidate_are_exact() {
    assert_eq!(S571_PHYSICAL_GATE_STATUS, "PASS");
    assert_eq!(S571_RAW.len() as u64, S571_RAW_BYTES);
    assert_eq!(sha256(S571_RAW), S571_RAW_SHA256);
    assert_eq!(S574_IMAGE, S570_IMAGE);
    assert_eq!(S574_IMAGE.len() as u64, S575_CANDIDATE_IMAGE_BYTES);
    assert_eq!(sha256(S574_IMAGE), S575_CANDIDATE_IMAGE_SHA256);
    assert_ne!(S571_RAW, PHYSICAL_RAW);
    assert_ne!(S571_RAW_SHA256, S575_RAW_SHA256);
}

#[test]
fn model_is_simulation_only_and_has_no_device_execution_surface() {
    let module = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s575_r2_supported_profile_independent_physical_repeat";
    assert!(!MAIN.contains(module));
    assert_eq!(
        SIMULATION_LIB
            .matches(&format!("pub mod {module};"))
            .count(),
        1
    );
    for forbidden in [
        "unsafe {",
        "asm!(",
        "global_asm!(",
        "std::process",
        "diskutil",
        "TIOCEXCL",
        "tcsetattr",
        "Command::new",
    ] {
        assert!(!SOURCE.contains(forbidden), "{forbidden}");
    }
}

#[test]
fn diagnostic_codes_are_unique_and_nonzero() {
    let errors = [
        G8lS575PhysicalError::PredecessorRejected,
        G8lS575PhysicalError::BaselineRejected,
        G8lS575PhysicalError::CampaignDrift,
        G8lS575PhysicalError::EvidenceIdentityDrift,
        G8lS575PhysicalError::AuthorizationRejected,
        G8lS575PhysicalError::DeviceIdentityDrift,
        G8lS575PhysicalError::PreflightRejected,
        G8lS575PhysicalError::HistoryRejected,
        G8lS575PhysicalError::SdTransactionRejected,
        G8lS575PhysicalError::CaptureRejected,
        G8lS575PhysicalError::PowerAccountingRejected,
        G8lS575PhysicalError::RawIdentityDrift,
        G8lS575PhysicalError::RawContentRejected,
        G8lS575PhysicalError::ObservationAccountingRejected,
        G8lS575PhysicalError::BoundaryOverclaim,
        G8lS575PhysicalError::PublishedStateDrift,
    ];
    let mut unique = HashSet::new();
    for code in errors
        .into_iter()
        .map(G8lS575PhysicalError::diagnostic_code)
    {
        assert_ne!(code, 0);
        assert!(unique.insert(code));
    }
    assert_eq!(unique.len(), 16);
}

#[test]
fn all_repository_artifact_identities_are_byte_exact() {
    let artifacts = [
        (
            S575_TRANSACTION_TOOL_PATH,
            S575_TRANSACTION_TOOL_BYTES,
            S575_TRANSACTION_TOOL_SHA256,
        ),
        (
            S575_CAPTURE_WRAPPER_PATH,
            S575_CAPTURE_WRAPPER_BYTES,
            S575_CAPTURE_WRAPPER_SHA256,
        ),
        (
            S575_CAPTURE_ENGINE_PATH,
            S575_CAPTURE_ENGINE_BYTES,
            S575_CAPTURE_ENGINE_SHA256,
        ),
        (
            S575_INITIAL_INVENTORY_PATH,
            S575_INITIAL_INVENTORY_BYTES,
            S575_INITIAL_INVENTORY_SHA256,
        ),
        (
            S575_TOOL_SOURCE_CHECK_PATH,
            S575_TOOL_SOURCE_CHECK_BYTES,
            S575_TOOL_SOURCE_CHECK_SHA256,
        ),
        (
            S575_PORTABILITY_AMENDMENT_PATH,
            S575_PORTABILITY_AMENDMENT_BYTES,
            S575_PORTABILITY_AMENDMENT_SHA256,
        ),
        (
            S575_CARD_PREFLIGHT_PATH,
            S575_CARD_PREFLIGHT_BYTES,
            S575_CARD_PREFLIGHT_SHA256,
        ),
        (
            S575_FLASH_LOG_PATH,
            S575_FLASH_LOG_BYTES,
            S575_FLASH_LOG_SHA256,
        ),
        (
            S575_CAPTURE_BUILD_LOG_PATH,
            S575_CAPTURE_BUILD_LOG_BYTES,
            S575_CAPTURE_BUILD_LOG_SHA256,
        ),
        (
            S575_CAPTURE_LOG_PATH,
            S575_CAPTURE_LOG_BYTES,
            S575_CAPTURE_LOG_SHA256,
        ),
        (
            S575_CLOSEOUT_LOG_PATH,
            S575_CLOSEOUT_LOG_BYTES,
            S575_CLOSEOUT_LOG_SHA256,
        ),
        (
            S575_EVIDENCE_MANIFEST_PATH,
            S575_EVIDENCE_MANIFEST_BYTES,
            S575_EVIDENCE_MANIFEST_SHA256,
        ),
        (
            S575_EVIDENCE_README_PATH,
            S575_EVIDENCE_README_BYTES,
            S575_EVIDENCE_README_SHA256,
        ),
        (S575_RAW_PATH, S575_RAW_BYTES, S575_RAW_SHA256),
    ];
    for (path, expected_bytes, expected_sha) in artifacts {
        let bytes = fs::read(repository_path(path)).unwrap();
        assert_eq!(bytes.len() as u64, expected_bytes, "{path}");
        assert_eq!(sha256(&bytes), expected_sha, "{path}");
    }
}

#[test]
fn manifest_listed_evidence_is_immutable_and_rehashes_nine_of_nine() {
    assert_eq!(EVIDENCE_MANIFEST.lines().count(), 9);
    let mut names = HashSet::new();
    for line in EVIDENCE_MANIFEST.lines() {
        let (digest, name) = line.split_once("  ").unwrap();
        assert_eq!(digest.len(), 64);
        assert!(names.insert(name));
        let path = repository_path(S575_EVIDENCE_ROOT).join(name);
        let bytes = fs::read(&path).unwrap();
        assert_eq!(sha256(&bytes), digest);
        let metadata = fs::symlink_metadata(path).unwrap();
        assert!(metadata.file_type().is_file());
        assert!(!metadata.file_type().is_symlink());
        assert_eq!(metadata.permissions().mode() & 0o777, 0o444);
        assert_eq!(metadata.nlink(), 1);
    }
    assert_eq!(names.len(), 9);
    assert!(names.contains("s575-uart.raw"));
}

#[test]
fn evidence_readme_states_the_narrow_physical_boundary() {
    for required in [
        "Physical gate status: PASS",
        "Supported-profile repeatability: complete",
        "Cross-profile coverage: incomplete",
        "R2 field acceptance: incomplete",
        "Power-on and power-off are",
        "operator attestations; independent electrical observations remain zero",
        "Visible scanout physically observed: false",
        "Physical input/touch observed: false",
        "RUNBOOK_EXECUTED_IN_S575=YES",
    ] {
        assert!(EVIDENCE_README.contains(required), "{required}");
    }
}

#[test]
fn transaction_tool_is_candidate_card_campaign_and_portable_uart_bound() {
    assert_eq!(TRANSACTION_TOOL.len() as u64, S575_TRANSACTION_TOOL_BYTES);
    assert_eq!(
        sha256(TRANSACTION_TOOL.as_bytes()),
        S575_TRANSACTION_TOOL_SHA256
    );
    for required in [
        "EXPECTED_IMAGE_SHA256=a24f4d24e838cd7d1a6b2ff217d864e9c4b08f12ce7dd165b302e8073a980b04",
        "EXPECTED_CARD_SERIAL_HEX=0x425001fa",
        "EXPECTED_DISK_BYTES=62549655552",
        "EXPECTED_CAMPAIGN_ID=r2-ws01-board-rpi5-repeat-01",
        S575_AUTHORIZATION_TOKEN,
        "--probe-check",
        "PORTABLE_UART_RESOLUTION=YES",
        "AppleUSBACMData",
        "RERUN_FORBIDDEN=YES",
    ] {
        assert!(TRANSACTION_TOOL.contains(required), "{required}");
    }
    let preflight = TRANSACTION_TOOL
        .find("if [ \"${1:-}\" = --preflight ]")
        .unwrap();
    let authorization = TRANSACTION_TOOL
        .find("[ \"$AUTH\" = \"$EXPECTED_AUTH\" ]")
        .unwrap();
    let final_transaction = TRANSACTION_TOOL.rfind("run_transaction").unwrap();
    assert!(preflight < authorization);
    assert!(authorization < final_transaction);
    assert!(!TRANSACTION_TOOL.contains("/dev/cu.usbmodem21302"));
}

#[test]
fn capture_sources_and_double_build_record_are_exact() {
    assert_eq!(CAPTURE_WRAPPER.len() as u64, S575_CAPTURE_WRAPPER_BYTES);
    assert_eq!(
        sha256(CAPTURE_WRAPPER.as_bytes()),
        S575_CAPTURE_WRAPPER_SHA256
    );
    assert_eq!(CAPTURE_ENGINE.len() as u64, S575_CAPTURE_ENGINE_BYTES);
    assert_eq!(
        sha256(CAPTURE_ENGINE.as_bytes()),
        S575_CAPTURE_ENGINE_SHA256
    );
    assert_eq!(
        CAPTURE_WRAPPER
            .matches("capture-rpi5-s540-r1-uart.c")
            .count(),
        1
    );
    for required in [
        "TIOCEXCL",
        "B115200",
        "TCIFLUSH",
        "O_CREAT | O_EXCL",
        "TERMINAL_GRACE_SECONDS 3.0",
        "fchmod(output_fd, 0444)",
    ] {
        assert!(CAPTURE_ENGINE.contains(required), "{required}");
    }
    for required in [
        "INDEPENDENT_BUILD_BYTE_EQUAL=YES",
        "BUILD_A_BYTES=35232",
        S575_CAPTURE_BINARY_SHA256,
        "BINARY_EXECUTED=NO",
        "UART_OPENED=NO",
    ] {
        assert!(CAPTURE_BUILD_LOG.contains(required), "{required}");
    }
}

#[test]
fn physical_raw_identity_mode_link_and_byte_composition_are_exact() {
    assert_eq!(PHYSICAL_RAW.len() as u64, S575_RAW_BYTES);
    assert_eq!(sha256(PHYSICAL_RAW), S575_RAW_SHA256);
    assert_eq!(byte_composition(PHYSICAL_RAW), (10, 204, 204));
    let metadata = fs::symlink_metadata(repository_path(S575_RAW_PATH)).unwrap();
    assert_eq!(metadata.permissions().mode() & 0o777, 0o444);
    assert_eq!(metadata.nlink(), 1);
    assert_eq!(metadata.ino(), 34_414_571);
}

#[test]
fn real_raw_marker_matrix_is_the_only_recorded_pass_shape() {
    let counts = s575_raw_marker_counts(PHYSICAL_RAW);
    assert_eq!(counts.boot8g, 1);
    assert_eq!(counts.boot8h, 1);
    assert_eq!(counts.s541_handoff, 1);
    assert_eq!(counts.s538_route, 1);
    assert_eq!(counts.terminal, 1);
    assert_eq!(counts.g8h_error, 0);
    assert_eq!(counts.s541_error, 0);
    assert_eq!(counts.s538_error, 0);
    assert_eq!(counts.panic_lower, 0);
    assert_eq!(counts.panic_upper, 0);
    assert_eq!(counts.unknown_lower, 0);
    assert_eq!(counts.unknown_irq_turkish, 0);
    assert_eq!(counts.card_raw_cid, 1);
    assert_eq!(classify_s575_raw(PHYSICAL_RAW), G8lS575RawVerdict::Pass);
}

fn synthetic_pass_raw() -> Vec<u8> {
    format!(
        "{}\n{}\n{}\n{}\n{}\n{}\n",
        S575_EXPECTED_CARD_RAW_CID,
        S575_BOOT8G_MARKER,
        S575_BOOT8H_MARKER,
        S575_S541_HANDOFF_MARKER,
        S575_S538_ROUTE_MARKER,
        S575_TERMINAL_MARKER,
    )
    .into_bytes()
}

#[test]
fn synthetic_classifier_is_fail_closed_with_error_precedence() {
    let pass = synthetic_pass_raw();
    assert_eq!(classify_s575_raw(&pass), G8lS575RawVerdict::Pass);
    let mut missing = pass.clone();
    missing.truncate(missing.len() - S575_TERMINAL_MARKER.len() - 1);
    assert_eq!(
        classify_s575_raw(&missing),
        G8lS575RawVerdict::RedMarkerMatrix
    );
    for (marker, expected) in [
        (
            b"ASELSAN/S538ERR".as_slice(),
            G8lS575RawVerdict::RedS538Error,
        ),
        (
            b"ASELSAN/S541ERR".as_slice(),
            G8lS575RawVerdict::RedS541Error,
        ),
        (
            b"ASELSAN/G8HERR REPORTER=CPU0".as_slice(),
            G8lS575RawVerdict::RedG8hError,
        ),
        (
            b"Bilinmeyen IRQ".as_slice(),
            G8lS575RawVerdict::RedUnknownIrq,
        ),
        (b"PANIC".as_slice(), G8lS575RawVerdict::RedPanic),
    ] {
        let mut raw = pass.clone();
        raw.extend_from_slice(marker);
        assert_eq!(classify_s575_raw(&raw), expected);
    }
}

#[test]
fn exact_physical_observation_records_pass_receipt() {
    let mut state = G8lS575PhysicalState::new();
    let G8lS575PhysicalOutcome::PhysicalRepeatRecorded(receipt) =
        service_s575_model_supported_profile_independent_physical_repeat(&mut state, observation())
            .unwrap()
    else {
        panic!("first exact physical observation must record")
    };
    assert_eq!(receipt.sequence, 575);
    assert_eq!(receipt.predecessor_sequence, 574);
    assert_eq!(receipt.status, "PASS");
    assert_eq!(receipt.raw_verdict, G8lS575RawVerdict::Pass);
    assert_eq!(receipt.card_serial, 0x4250_01fa);
    assert_eq!(receipt.probe_serial, "E6647C74033F9131");
    assert_eq!(
        (receipt.sd_writes, receipt.sd_readbacks, receipt.sd_ejects),
        (4, 4, 1)
    );
    assert_eq!(receipt.uart_opens, 1);
    assert_eq!(receipt.total_runtime_baselines, 2);
    assert_eq!(receipt.total_physical_observations, 2);
    assert!(receipt.repeatability_complete);
    assert!(receipt.boot_to_ui_physically_observed);
    assert!(!receipt.visible_scanout_observed);
    assert!(!receipt.physical_input_observed);
    assert!(!receipt.cross_profile_coverage_complete);
    assert!(!receipt.r2_field_acceptance_complete);
    assert!(receipt.runbook_executed);
    assert_eq!(state.receipt(), Some(receipt));
}

#[test]
fn exact_replay_is_idempotent() {
    let mut state = G8lS575PhysicalState::new();
    let G8lS575PhysicalOutcome::PhysicalRepeatRecorded(receipt) =
        service_s575_model_supported_profile_independent_physical_repeat(&mut state, observation())
            .unwrap()
    else {
        panic!("record")
    };
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(&mut state, observation()),
        Ok(G8lS575PhysicalOutcome::PhysicalRepeatRetained(receipt))
    );
}

#[test]
fn predecessor_and_baseline_drift_fail_before_publication() {
    let mut predecessor = observation();
    predecessor.predecessor_sequence = 573;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            predecessor,
        ),
        Err(G8lS575PhysicalError::PredecessorRejected)
    );
    let mut baseline = observation();
    baseline.baseline_status = "RED";
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            baseline,
        ),
        Err(G8lS575PhysicalError::BaselineRejected)
    );
}

#[test]
fn campaign_and_evidence_drift_fail_closed() {
    let mut campaign = observation();
    campaign.campaign_id = "wrong";
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            campaign,
        ),
        Err(G8lS575PhysicalError::CampaignDrift)
    );
    let mut evidence = observation();
    evidence.evidence.flash_log.bytes += 1;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            evidence,
        ),
        Err(G8lS575PhysicalError::EvidenceIdentityDrift)
    );
}

#[test]
fn authorization_and_device_drift_fail_closed() {
    let mut authorization = observation();
    authorization.authorization_token = "S571 token reuse";
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            authorization,
        ),
        Err(G8lS575PhysicalError::AuthorizationRejected)
    );
    let mut device = observation();
    device.uart_callout = "/dev/cu.usbmodem21302";
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            device,
        ),
        Err(G8lS575PhysicalError::DeviceIdentityDrift)
    );
}

#[test]
fn preflight_and_history_drift_fail_closed() {
    let mut preflight = observation();
    preflight.preflight_repeats = 1;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            preflight,
        ),
        Err(G8lS575PhysicalError::PreflightRejected)
    );
    let mut history = observation();
    history.rerun_forbidden = false;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            history,
        ),
        Err(G8lS575PhysicalError::HistoryRejected)
    );
}

#[test]
fn sd_and_capture_claim_drift_fail_closed() {
    let mut sd = observation();
    sd.sd_readbacks = 3;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            sd,
        ),
        Err(G8lS575PhysicalError::SdTransactionRejected)
    );
    let mut capture = observation();
    capture.capture_armed_before_power = false;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            capture,
        ),
        Err(G8lS575PhysicalError::CaptureRejected)
    );
}

#[test]
fn power_and_raw_identity_drift_fail_closed() {
    let mut power = observation();
    power.power_transitions_independently_observed = 1;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            power,
        ),
        Err(G8lS575PhysicalError::PowerAccountingRejected)
    );
    let mut raw = observation();
    raw.raw_identity.bytes += 1;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            raw,
        ),
        Err(G8lS575PhysicalError::RawIdentityDrift)
    );
}

#[test]
fn raw_content_and_observation_accounting_drift_fail_closed() {
    let mut raw = observation();
    raw.raw_nul_bytes += 1;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            raw,
        ),
        Err(G8lS575PhysicalError::RawContentRejected)
    );
    let mut accounting = observation();
    accounting.total_physical_observations = 1;
    assert_eq!(
        service_s575_model_supported_profile_independent_physical_repeat(
            &mut G8lS575PhysicalState::new(),
            accounting,
        ),
        Err(G8lS575PhysicalError::ObservationAccountingRejected)
    );
}

#[test]
fn product_boundary_overclaims_are_rejected() {
    for case in 0..5 {
        let mut overclaim = observation();
        match case {
            0 => overclaim.visible_scanout_observed = true,
            1 => overclaim.physical_input_observed = true,
            2 => overclaim.cross_profile_coverage_complete = true,
            3 => overclaim.r2_field_acceptance_complete = true,
            4 => overclaim.automatic_promotion = true,
            _ => unreachable!(),
        }
        assert_eq!(
            service_s575_model_supported_profile_independent_physical_repeat(
                &mut G8lS575PhysicalState::new(),
                overclaim,
            ),
            Err(G8lS575PhysicalError::BoundaryOverclaim)
        );
    }
}

#[test]
fn phase_logs_preserve_no_authority_then_authorized_execution_order() {
    assert!(INITIAL_INVENTORY.contains("AUTHORIZATION_RECEIVED=NO"));
    assert!(INITIAL_INVENTORY.contains("RUNBOOK_EXECUTED_IN_S575=NO"));
    assert!(TOOL_SOURCE_CHECK.contains("EXECUTION_PERMIT=0"));
    assert!(PORTABILITY_AMENDMENT.contains("S574_BOUND_PREFLIGHT_RETAINED_UNCHANGED=YES"));
    assert!(PORTABILITY_AMENDMENT.contains("S575_READ_ONLY_PROBE_CHECK=PASS"));
    assert!(CARD_PREFLIGHT.contains("PREFLIGHT_REPEATS=2"));
    assert!(CARD_PREFLIGHT.contains("AUTHORIZATION_RECEIVED=NO"));
    assert!(FLASH_LOG.contains("AUTHORIZATION_RECEIVED=YES"));
    assert!(FLASH_LOG.contains("SD_FILE_WRITES=4"));
    assert!(FLASH_LOG.contains("UART_OPENS=0"));
    assert!(CAPTURE_LOG.contains("CAPTURE_ARMED_BEFORE_POWER=YES"));
    assert!(CAPTURE_LOG.contains("CAPTURE_EXIT=0"));
    assert!(CLOSEOUT_LOG.contains("PHYSICAL_GATE_VERDICT=PASS"));
    assert!(CLOSEOUT_LOG.contains("POWER_TRANSITIONS_INDEPENDENTLY_OBSERVED=0"));
    assert!(CLOSEOUT_LOG.contains("RUNBOOK_EXECUTED_IN_S575=YES"));
}

#[test]
fn final_acceptance_boundary_keeps_unobserved_products_false() {
    assert!(S575_BOOT_TO_UI_PHYSICALLY_OBSERVED);
    assert!(!S575_VISIBLE_SCANOUT_OBSERVED);
    assert!(!S575_PHYSICAL_INPUT_OBSERVED);
    assert!(!S575_CROSS_PROFILE_COVERAGE_COMPLETE);
    assert!(!S575_R2_FIELD_ACCEPTANCE_COMPLETE);
    assert!(!S575_AUTOMATIC_PROMOTION);
}

  {
    id: "g8l-s575-r2-supported-profile-independent-physical-repeat",
    date: "2026-08-31",
    sequence: 575,
    status: "passed",
    umbrella_status: "partial",
    title: "S575 · R2 supported-profile bağımsız fiziksel tekrar",
    summary:
      "S575, S574 aday dondurmasının ayrı kampanya kimliğiyle yapılan tek ve yetkili board-rpi5 fiziksel tekrarını PASS olarak arşivler. Dört exact4 SD yazımı, dört byte-eş read-back, bir eject, bir UART capture ve operatör tarafından bildirilen güç aç/kapa geçişleri tamamlandı; ham UART çıktısı değişmez ve yeniden çalıştırılamaz kanıttır. PASS yalnız supported-profile Boot-to-UI-ready gözlemidir; görünür scanout, input, modem, ses, üretim veya R2 saha kabulü iddiası taşımaz.",
    evidence: [
      "Campaign=r2-ws01-board-rpi5-repeat-01; predecessor=S574 PASS; candidate image=945920 B / a24f4d24e838cd7d1a6b2ff217d864e9c4b08f12ce7dd165b302e8073a980b04.",
      "Card TISD64G serial=0x425001fa, raw CID=009f5449534436344761425001fa01a1, size=62549655552 B; Debug Probe serial=E6647C74033F9131; UART=/dev/cu.usbmodem214402 and /dev/tty.usbmodem214402.",
      "SD transaction=1; file writes=4; byte-exact read-backs=4; manifest read-back=PASS; ejects=1; UART opens=1; operator power transitions=2; independently observed power transitions=0.",
      "Raw UART=evidence/rpi5/r2/sequence-575-supported-profile-repeat-01/s575-uart.raw; 20610 B; SHA-256=96bc5fe999115e10f8b4603868f58a055d3dc1d41b4d08e59b021a0f5ff77602; mode=0444; nlink=1.",
      "Markers BOOT8G=1, BOOT8H=1, S541 handoff=1, S538 route=1, BOOT_TO_UI_READY=1; G8H/S541/S538 errors, panic and unknown IRQ markers=0.",
      "Focused proof=25/25; implementation 28142 B / 08e9912b7882bd2acb2cb730e02663bea35536c09fb259414686368a1ea62cd7; focused test 27996 B / 4c62aad02aee639ceeb40fca8baacef82af5598846c157de2394ca9c1d55a6a1; proof 6536 B / 14bd464c744462e4b72aa599d821d7873ec1cb3dfca116968b2fdc3c7665c400.",
      "Evidence manifest EVIDENCE_SHA256SUMS=810 B / b022ace1aa67252153bc14a108222a7d2c790db998f3f3d2257e0fd390dbf9ae; package is immutable (directory=0700, files=0444, nlink=1).",
    ],
    commands: [
      "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s575_r2_supported_profile_independent_physical_repeat -- --test-threads=1",
      "scripts/flash-rpi5-s575-r2-repeat-candidate.sh --authorize <S575_AUTHORIZE_TOKEN>",
      "scripts/capture-rpi5-s575-r2-repeat-uart.c (115200 8N1, armed before power)",
      "cd evidence/rpi5/r2/sequence-575-supported-profile-repeat-01 && shasum -a 256 -c EVIDENCE_SHA256SUMS",
      "python3 scripts/render-project-status.py --check",
      "node website/scripts/generate-code-gates.mjs --check",
      "cd website && npm test && npx tsc --noEmit && npm run lint && npm run build",
    ],
    terminalSessions: [
      {
        id: "s575-focused",
        title: "S575 focused source and evidence contract",
        commandLines: [
          "CARGO_INCREMENTAL=0 cargo test -p aselsan_microkernel_simulation --test g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s575_r2_supported_profile_independent_physical_repeat -- --test-threads=1",
        ],
        outputLines: [
          "test result: ok. 25 passed; 0 failed; 0 ignored; 0 filtered out",
          "source/test/proof/evidence identities exact; runtime and physical scope are explicit",
        ],
        exitCode: 0,
        outputMode: "complete",
      },
      {
        id: "s575-physical-repeat",
        title: "S575 one-shot supported-profile physical repeat",
        commandLines: [
          "fresh SD preflight → 4 writes → 4 read-backs → eject → UART pre-arm → one power-on → capture closeout",
        ],
        outputLines: [
          "PASS_IMMUTABLE_ARCHIVED; raw=20610 B / 96bc5fe999115e10f8b4603868f58a055d3dc1d41b4d08e59b021a0f5ff77602",
          "BOOT_TO_UI_READY=1; BOOT8H=1; errors/panic/unknown=0; operator power transitions=2, independent=0",
        ],
        exitCode: 0,
        outputMode: "complete",
        outputNote: "Fiziksel koşu tamamlandı; S575 yeniden çalıştırılamaz.",
      },
    ],
    terminalSessionsNote:
      "S575 fiziksel oturumu kaynak/test oturumundan ayrıdır; ham UART dosyası değişmez ankraj olarak saklanır.",
    limitations: [
      "Bu PASS yalnız board-rpi5 supported-profile Boot-to-UI-ready fiziksel tekrarını kapsar; görünür ekran scanout'u ve dokunmatik input gözlenmedi.",
      "Güç geçişleri operatör tarafından bildirildi; bağımsız elektriksel gözlem sayısı sıfırdır.",
      "S546 fiziksel RED ve S540/S543 sınırları değişmeden korunur; S575 bunları yeniden yazmaz.",
      "S576–S707 runtime gözlemleri, modem, ses, güncelleme, üretim, RF/EMC/SAR ve saha kabulü tamamlanmış değildir.",
      "RUNBOOK_EXECUTED_IN_S575=YES; yeni fiziksel koşu ve ham çıktı yeniden okuması yasaktır.",
    ],
  },