fix(filemeta): fence unsafe heal key components

crates/common/src/metrics.rs

@@ -901,10 +901,6 @@ pub struct Metrics {
     scanner_cycle_max_duration_millis: AtomicU64,
     scanner_cycle_max_objects: AtomicU64,
     scanner_cycle_max_directories: AtomicU64,
-    scanner_cycle_timeout_total: AtomicU64,
-    scanner_cycle_recovery_required_total: AtomicU64,
-    scanner_cycle_last_progress_age_seconds: AtomicU64,
-    scanner_leader_lease_without_progress: AtomicBool,
     scanner_bitrot_cycle_enabled: AtomicBool,
     scanner_bitrot_cycle_millis: AtomicU64,
     scanner_checkpoint: Mutex<Option<ScannerCheckpointReport>>,
@@ -1374,14 +1370,6 @@ pub struct ScannerMetricsReport {
     #[serde(default)]
     pub cycle_max_directories: u64,
     #[serde(default)]
-    pub cycle_timeout_total: u64,
-    #[serde(default)]
-    pub cycle_recovery_required_total: u64,
-    #[serde(default)]
-    pub cycle_last_progress_age: u64,
-    #[serde(default)]
-    pub leader_lease_without_progress: bool,
-    #[serde(default)]
     pub bitrot_cycle_enabled: bool,
     #[serde(default)]
     pub bitrot_cycle_seconds: f64,
@@ -1442,9 +1430,6 @@ const OTEL_SCANNER_BUCKETS_SCANNED: &str = "rustfs_scanner_buckets_scanned_total
 const OTEL_SCANNER_CYCLES: &str = "rustfs_scanner_cycles_total";
 const OTEL_SCANNER_CYCLE_DURATION_SECONDS: &str = "rustfs_scanner_cycle_duration_seconds";
 const OTEL_SCANNER_BUCKET_DRIVE_DURATION_SECONDS: &str = "rustfs_scanner_bucket_drive_duration_seconds";
-const OTEL_SCANNER_CYCLE_TIMEOUT_TOTAL: &str = "rustfs_scanner_cycle_timeout_total";
-const OTEL_SCANNER_CYCLE_LAST_PROGRESS_AGE: &str = "rustfs_scanner_cycle_last_progress_age";
-const OTEL_SCANNER_LEADER_LEASE_WITHOUT_PROGRESS: &str = "rustfs_scanner_leader_lease_without_progress";
 
 fn scan_cycle_result_label(result: u8) -> &'static str {
     match result {
@@ -1928,10 +1913,6 @@ impl Metrics {
             scanner_cycle_max_duration_millis: AtomicU64::new(0),
             scanner_cycle_max_objects: AtomicU64::new(0),
             scanner_cycle_max_directories: AtomicU64::new(0),
-            scanner_cycle_timeout_total: AtomicU64::new(0),
-            scanner_cycle_recovery_required_total: AtomicU64::new(0),
-            scanner_cycle_last_progress_age_seconds: AtomicU64::new(0),
-            scanner_leader_lease_without_progress: AtomicBool::new(false),
             scanner_bitrot_cycle_enabled: AtomicBool::new(false),
             scanner_bitrot_cycle_millis: AtomicU64::new(0),
             scanner_checkpoint: Mutex::new(None),
@@ -2431,29 +2412,12 @@ impl Metrics {
             .store(cycle_max_objects.unwrap_or_default(), Ordering::Relaxed);
         self.scanner_cycle_max_directories
             .store(cycle_max_directories.unwrap_or_default(), Ordering::Relaxed);
-        self.scanner_leader_lease_without_progress.store(false, Ordering::Relaxed);
-        self.scanner_cycle_last_progress_age_seconds.store(0, Ordering::Relaxed);
-        metrics::gauge!(OTEL_SCANNER_LEADER_LEASE_WITHOUT_PROGRESS).set(0.0);
-        metrics::gauge!(OTEL_SCANNER_CYCLE_LAST_PROGRESS_AGE).set(0.0);
         self.scanner_bitrot_cycle_enabled
             .store(bitrot_cycle.is_some(), Ordering::Relaxed);
         self.scanner_bitrot_cycle_millis
             .store(bitrot_cycle.map(duration_millis_saturated).unwrap_or_default(), Ordering::Relaxed);
     }
 
-    pub fn record_scanner_cycle_timeout(&self, recovery_required: bool, progress_age: Duration) {
-        self.scanner_cycle_timeout_total.fetch_add(1, Ordering::Relaxed);
-        if recovery_required {
-            self.scanner_cycle_recovery_required_total.fetch_add(1, Ordering::Relaxed);
-        }
-        self.scanner_cycle_last_progress_age_seconds
-            .store(progress_age.as_secs(), Ordering::Relaxed);
-        self.scanner_leader_lease_without_progress.store(true, Ordering::Relaxed);
-        metrics::counter!(OTEL_SCANNER_CYCLE_TIMEOUT_TOTAL).increment(1);
-        metrics::gauge!(OTEL_SCANNER_CYCLE_LAST_PROGRESS_AGE).set(progress_age.as_secs_f64());
-        metrics::gauge!(OTEL_SCANNER_LEADER_LEASE_WITHOUT_PROGRESS).set(1.0);
-    }
-
     pub fn record_scanner_set_scan_state(&self, concurrency_limit: Option<usize>, queued: Option<usize>, active: Option<usize>) {
         if let Some(concurrency_limit) = concurrency_limit {
             self.scanner_set_scan_concurrency_limit
@@ -3301,10 +3265,6 @@ impl Metrics {
         m.cycle_max_duration_seconds = self.scanner_cycle_max_duration_millis.load(Ordering::Relaxed) as f64 / 1000.0;
         m.cycle_max_objects = self.scanner_cycle_max_objects.load(Ordering::Relaxed);
         m.cycle_max_directories = self.scanner_cycle_max_directories.load(Ordering::Relaxed);
-        m.cycle_timeout_total = self.scanner_cycle_timeout_total.load(Ordering::Relaxed);
-        m.cycle_recovery_required_total = self.scanner_cycle_recovery_required_total.load(Ordering::Relaxed);
-        m.cycle_last_progress_age = self.scanner_cycle_last_progress_age_seconds.load(Ordering::Relaxed);
-        m.leader_lease_without_progress = self.scanner_leader_lease_without_progress.load(Ordering::Relaxed);
         m.bitrot_cycle_enabled = self.scanner_bitrot_cycle_enabled.load(Ordering::Relaxed);
         m.bitrot_cycle_seconds = self.scanner_bitrot_cycle_millis.load(Ordering::Relaxed) as f64 / 1000.0;
         m.scan_checkpoint = match self.scanner_checkpoint.lock() {
@@ -4966,20 +4926,4 @@ mod tests {
         assert!(!report.bitrot_cycle_enabled);
         assert_eq!(report.bitrot_cycle_seconds, 0.0);
     }
-
-    #[tokio::test]
-    async fn scanner_cycle_timeout_metrics_reset_for_a_new_cycle() {
-        let metrics = Metrics::new();
-        metrics.record_scanner_cycle_timeout(true, Duration::from_secs(17));
-        let timed_out = metrics.report().await;
-        assert_eq!(timed_out.cycle_timeout_total, 1);
-        assert_eq!(timed_out.cycle_last_progress_age, 17);
-        assert!(timed_out.leader_lease_without_progress);
-
-        metrics.record_scanner_cycle_config(Duration::from_secs(60), None, Some(Duration::from_secs(1)), None, None);
-        let current = metrics.report().await;
-        assert_eq!(current.cycle_timeout_total, 1);
-        assert_eq!(current.cycle_last_progress_age, 0);
-        assert!(!current.leader_lease_without_progress);
-    }
 }

crates/config/README.md

@@ -84,12 +84,6 @@ Current guidance:
 - `RUSTFS_SCANNER_CYCLE_MAX_OBJECTS` (canonical)
 - `RUSTFS_SCANNER_CYCLE_MAX_DIRECTORIES` (canonical)
 
-Scanner cycle budget controls:
-
-- When `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` is unset, the finite default is 1800 seconds (30 minutes), matching the scanner benchmark guidance.
-- An explicit `0` preserves the compatibility behavior of an unbounded runtime budget. Object and directory budgets likewise remain unbounded when explicitly set to `0`.
-- A timed-out cycle cancels cooperative scanner work, then fences its leader epoch before releasing the lease. An uncooperative I/O operation is dropped after the bounded shutdown window; its cursor is not claimed to be durable and the scanner reports `recovery-required` when the worker cannot stop cooperatively, the cycle state was not confirmed durable, or epoch fencing cannot be persisted.
-
 ## Mmap read environment aliases
 
 - `RUSTFS_OBJECT_MMAP_READ_ENABLE` (canonical)

crates/config/src/constants/scanner.rs

@@ -143,12 +143,9 @@ pub const ENV_SCANNER_MAX_WAIT_SECS: &str = "RUSTFS_SCANNER_MAX_WAIT_SECS";
 /// Default scanner speed preset.
 pub const DEFAULT_SCANNER_SPEED: &str = "default";
 
-/// Default scanner cycle runtime budget when no override is configured.
-///
-/// An explicit `0` remains the compatibility escape hatch for an unbounded
-/// cycle. Keeping the unset default finite prevents a stalled scanner I/O
-/// operation from holding the leader lease forever.
-pub const DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS: u64 = 30 * 60;
+/// Default scanner cycle runtime budget.
+/// `0` keeps the existing unbounded per-cycle behavior.
+pub const DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS: u64 = 0;
 
 /// Default scanner per-cycle object budget.
 /// `0` keeps the existing unbounded per-cycle behavior.

crates/data-usage/src/data_usage.rs

@@ -48,11 +48,6 @@ pub const DATA_USAGE_OBSERVED_OBJECT_NAME: &str = ".usage.observed.json";
 // RUSTFS_COMPAT_TODO(scanner-usage-v2): keep .usage.json readable and removable during rolling upgrades from pre-v2 scanners. Remove after supported direct-upgrade sources all write .usage.v2.json.
 pub const LEGACY_DATA_USAGE_OBJECT_NAME: &str = ".usage.json";
 
-/// Fixed bucket for objects whose storage class is not in the scanner's
-/// cycle-local tier registry.  Keeping this key fixed prevents untrusted or
-/// stale tier names from growing persisted per-tier maps without bound.
-pub const UNKNOWN_TIER: &str = "UNKNOWN_TIER";
-
 /// Returns true when `existing_last_update` is ahead of `now` by more than
 /// [`USAGE_LAST_UPDATE_FUTURE_TOLERANCE`], i.e. the persisted timestamp cannot be
 /// trusted for staleness comparisons and a fresh snapshot save must be allowed.
@@ -83,146 +78,12 @@ impl TierStats {
             && self.num_objects.checked_add(u.num_objects).is_some()
     }
 
-    /// Add tier counters without allowing a counter to wrap.
-    pub fn checked_add(&self, u: &TierStats) -> Option<TierStats> {
-        Some(TierStats {
-            total_size: self.total_size.checked_add(u.total_size)?,
-            num_versions: self.num_versions.checked_add(u.num_versions)?,
-            num_objects: self.num_objects.checked_add(u.num_objects)?,
-        })
-    }
-
     /// True when this tier contributed nothing, i.e. merging it is a no-op.
     pub fn is_empty(&self) -> bool {
         self.total_size == 0 && self.num_versions == 0 && self.num_objects == 0
     }
 }
 
-/// Bounded diagnostics for objects whose tier is absent from the cycle
-/// registry. Counters are authoritative; diagnostics are only a small,
-/// redacted reconciliation aid and may be dropped at the configured caps.
-pub const UNKNOWN_TIER_DIAGNOSTIC_ENTRY_CAP: usize = 64;
-pub const UNKNOWN_TIER_DIAGNOSTIC_BYTE_CAP: usize = 4096;
-pub const UNKNOWN_TIER_DIAGNOSTIC_TTL: Duration = Duration::from_secs(60 * 60);
-const UNKNOWN_TIER_DIAGNOSTIC_KEY_BYTES: usize = 256;
-
-#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
-pub struct UnknownTierStats {
-    /// Logical bytes retained in the scanner's normal usage total.
-    pub unknown_bytes: u64,
-    /// Physical bytes recorded in the per-tier accounting dimension.
-    ///
-    /// Older writers only had `unknown_bytes`; decoding those snapshots keeps
-    /// this field at zero and the scanner fills it for new observations.
-    #[serde(default)]
-    pub unknown_physical_bytes: u64,
-    pub unknown_objects: u64,
-    pub unknown_versions: u64,
-    pub diagnostics_dropped: u64,
-    #[serde(default)]
-    pub diagnostics: Vec<String>,
-    #[serde(default)]
-    pub diagnostics_at: Option<SystemTime>,
-}
-
-impl UnknownTierStats {
-    /// Record one observation where the logical and physical dimensions are
-    /// the same. Kept as a small compatibility helper for callers that only
-    /// have one size value.
-    pub fn record(&mut self, tier: &str, bytes: u64, versions: u64, objects: u64) {
-        self.record_dimensions(tier, bytes, bytes, versions, objects);
-    }
-
-    /// Record one observation without conflating logical usage with physical
-    /// tier bytes. Both counters are saturating so malformed metadata cannot
-    /// wrap an aggregate.
-    pub fn record_dimensions(&mut self, tier: &str, logical_bytes: u64, physical_bytes: u64, versions: u64, objects: u64) {
-        self.unknown_bytes = self.unknown_bytes.saturating_add(logical_bytes);
-        self.unknown_physical_bytes = self.unknown_physical_bytes.saturating_add(physical_bytes);
-        self.unknown_objects = self.unknown_objects.saturating_add(objects);
-        self.unknown_versions = self.unknown_versions.saturating_add(versions);
-
-        let digest = {
-            let mut hasher = DefaultHasher::new();
-            // Bound hashing work for hostile metadata while retaining enough
-            // length/prefix entropy to reconcile repeated observations.
-            hasher.write_usize(tier.len());
-            hasher.write(&tier.as_bytes()[..tier.len().min(UNKNOWN_TIER_DIAGNOSTIC_KEY_BYTES)]);
-            hasher.write_u8(u8::from(tier.bytes().any(|byte| byte.is_ascii_control())));
-            format!("tier-hash:{:016x}", hasher.finish())
-        };
-        let now = SystemTime::now();
-        if self
-            .diagnostics_at
-            .is_some_and(|at| now.duration_since(at).unwrap_or_default() > UNKNOWN_TIER_DIAGNOSTIC_TTL)
-        {
-            self.diagnostics.clear();
-        }
-        self.diagnostics_at = Some(now);
-        if self.diagnostics.iter().any(|entry| entry == &digest) {
-            return;
-        }
-        let current_bytes: usize = self.diagnostics.iter().map(String::len).sum();
-        if self.diagnostics.len() >= UNKNOWN_TIER_DIAGNOSTIC_ENTRY_CAP
-            || current_bytes.saturating_add(digest.len()) > UNKNOWN_TIER_DIAGNOSTIC_BYTE_CAP
-        {
-            self.diagnostics_dropped = self.diagnostics_dropped.saturating_add(1);
-            return;
-        }
-        self.diagnostics.push(digest);
-    }
-
-    pub fn merge(&mut self, other: &Self) {
-        self.unknown_bytes = self.unknown_bytes.saturating_add(other.unknown_bytes);
-        self.unknown_physical_bytes = self.unknown_physical_bytes.saturating_add(other.unknown_physical_bytes);
-        self.unknown_objects = self.unknown_objects.saturating_add(other.unknown_objects);
-        self.unknown_versions = self.unknown_versions.saturating_add(other.unknown_versions);
-        self.diagnostics_dropped = self.diagnostics_dropped.saturating_add(other.diagnostics_dropped);
-        let now = SystemTime::now();
-        if self
-            .diagnostics_at
-            .zip(other.diagnostics_at)
-            .is_some_and(|(left, right)| now.duration_since(left.max(right)).unwrap_or_default() > UNKNOWN_TIER_DIAGNOSTIC_TTL)
-        {
-            self.diagnostics.clear();
-        }
-        self.diagnostics_at = Some(now);
-        for diagnostic in &other.diagnostics {
-            if self.diagnostics.iter().any(|entry| entry == diagnostic) {
-                continue;
-            }
-            let current_bytes: usize = self.diagnostics.iter().map(String::len).sum();
-            if self.diagnostics.len() >= UNKNOWN_TIER_DIAGNOSTIC_ENTRY_CAP
-                || current_bytes.saturating_add(diagnostic.len()) > UNKNOWN_TIER_DIAGNOSTIC_BYTE_CAP
-            {
-                self.diagnostics_dropped = self.diagnostics_dropped.saturating_add(1);
-                continue;
-            }
-            self.diagnostics.push(diagnostic.clone());
-        }
-    }
-
-    pub fn fits_add(&self, other: &Self) -> bool {
-        self.unknown_bytes.checked_add(other.unknown_bytes).is_some()
-            && self
-                .unknown_physical_bytes
-                .checked_add(other.unknown_physical_bytes)
-                .is_some()
-            && self.unknown_objects.checked_add(other.unknown_objects).is_some()
-            && self.unknown_versions.checked_add(other.unknown_versions).is_some()
-            && self.diagnostics_dropped.checked_add(other.diagnostics_dropped).is_some()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.unknown_bytes == 0
-            && self.unknown_physical_bytes == 0
-            && self.unknown_objects == 0
-            && self.unknown_versions == 0
-            && self.diagnostics_dropped == 0
-            && self.diagnostics.is_empty()
-    }
-}
-
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
 pub struct AllTierStats {
     pub tiers: HashMap<String, TierStats>,
@@ -263,31 +124,6 @@ impl AllTierStats {
             .iter()
             .all(|(tier, right)| self.tiers.get(tier).is_none_or(|left| left.fits_add(right)))
     }
-
-    /// Fold keys from an older cache that are no longer present in the
-    /// current registry into the fixed unknown bucket. Built-in storage
-    /// classes remain known even when no remote tier is configured.
-    pub fn fold_unknown_tiers<'a, I>(&mut self, known_tiers: I)
-    where
-        I: IntoIterator<Item = &'a str>,
-    {
-        let known: HashSet<&str> = known_tiers.into_iter().collect();
-        let mut unknown = self.tiers.remove(UNKNOWN_TIER).unwrap_or_default();
-        let retired: Vec<String> = self
-            .tiers
-            .keys()
-            .filter(|tier| tier.as_str() != "STANDARD" && tier.as_str() != "REDUCED_REDUNDANCY" && !known.contains(tier.as_str()))
-            .cloned()
-            .collect();
-        for tier in retired {
-            if let Some(stats) = self.tiers.remove(&tier) {
-                unknown = unknown.add(&stats);
-            }
-        }
-        if !unknown.is_empty() {
-            self.tiers.insert(UNKNOWN_TIER.to_string(), unknown);
-        }
-    }
 }
 
 /// Bucket target usage info provides replication statistics
@@ -375,10 +211,6 @@ pub struct DataUsageInfo {
     /// tier exists, so an absent value means "not accounted", never "zero".
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub tier_stats: Option<AllTierStats>,
-    /// Bounded diagnostics and separate logical/physical counters for objects
-    /// classified into [`UNKNOWN_TIER`].
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub unknown_tier_stats: Option<UnknownTierStats>,
 
     /// Total number of buckets in this cluster
     pub buckets_count: u64,
@@ -504,8 +336,6 @@ pub struct SizeSummary {
     pub repl_target_stats: HashMap<String, ReplTargetSizeSummary>,
     /// Per-tier accounting, keyed by storage class or remote tier name
     pub tier_stats: HashMap<String, TierStats>,
-    /// Counters and bounded diagnostics for unknown tiers in this summary.
-    pub unknown_tier_stats: UnknownTierStats,
 }
 
 /// Replication target size summary
@@ -755,12 +585,9 @@ impl VersionsHistogram {
     }
 }
 
-/// Replication statistics for a single target.
-///
-/// Renamed from `ReplicationStats`; serde field names are preserved
-/// byte-identically to maintain wire compatibility with existing snapshots.
-#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct ReplicationTargetUsage {
+/// Replication statistics for a single target
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct ReplicationStats {
     pub pending_size: u64,
     pub replicated_size: u64,
     pub failed_size: u64,
@@ -773,7 +600,7 @@ pub struct ReplicationTargetUsage {
     pub replicated_count: u64,
 }
 
-impl ReplicationTargetUsage {
+impl ReplicationStats {
     pub fn is_empty(&self) -> bool {
         let Self {
             pending_size,
@@ -809,7 +636,7 @@ impl ReplicationTargetUsage {
 /// Replication statistics for all targets
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct ReplicationAllStats {
-    pub targets: HashMap<String, ReplicationTargetUsage>,
+    pub targets: HashMap<String, ReplicationStats>,
     pub replica_size: u64,
     pub replica_count: u64,
 }
@@ -822,7 +649,7 @@ impl ReplicationAllStats {
             targets,
         } = self;
 
-        *replica_size == 0 && *replica_count == 0 && targets.values().all(ReplicationTargetUsage::is_empty)
+        *replica_size == 0 && *replica_count == 0 && targets.values().all(ReplicationStats::is_empty)
     }
 
     #[deprecated(note = "use is_empty instead")]
@@ -851,9 +678,6 @@ pub struct DataUsageEntry {
     /// observed tier-classified objects.
     #[serde(default)]
     pub all_tier_stats: Option<AllTierStats>,
-    /// Bounded unknown-tier reconciliation state for this cache entry.
-    #[serde(default)]
-    pub unknown_tier_stats: Option<UnknownTierStats>,
 }
 
 impl Serialize for DataUsageEntry {
@@ -864,7 +688,7 @@ impl Serialize for DataUsageEntry {
         // Keep entries map-encoded so older readers can ignore fields appended
         // by newer scanner versions during rolling upgrades. The derived
         // (array) encoding made any appended field a decode error for them.
-        let mut state = serializer.serialize_map(Some(12))?;
+        let mut state = serializer.serialize_map(Some(11))?;
         state.serialize_entry("children", &self.children)?;
         state.serialize_entry("size", &self.size)?;
         state.serialize_entry("objects", &self.objects)?;
@@ -876,7 +700,6 @@ impl Serialize for DataUsageEntry {
         state.serialize_entry("compacted", &self.compacted)?;
         state.serialize_entry("failed_objects", &self.failed_objects)?;
         state.serialize_entry("all_tier_stats", &self.all_tier_stats)?;
-        state.serialize_entry("unknown_tier_stats", &self.unknown_tier_stats)?;
         state.end()
     }
 }
@@ -918,11 +741,6 @@ impl DataUsageEntry {
         if let Some(o_tiers) = other.all_tier_stats.as_ref().filter(|tiers| !tiers.is_empty()) {
             self.all_tier_stats.get_or_insert_with(AllTierStats::new).merge(o_tiers);
         }
-        if let Some(other_unknown) = other.unknown_tier_stats.as_ref() {
-            self.unknown_tier_stats
-                .get_or_insert_with(UnknownTierStats::default)
-                .merge(other_unknown);
-        }
 
         self.obj_sizes.merge_from(&other.obj_sizes);
         self.obj_versions.merge_from(&other.obj_versions);
@@ -936,15 +754,6 @@ impl DataUsageEntry {
         self.all_tier_stats.get_or_insert_with(AllTierStats::new).add_sizes(tiers);
     }
 
-    pub fn add_unknown_tier_stats(&mut self, stats: &UnknownTierStats) {
-        if stats.is_empty() {
-            return;
-        }
-        self.unknown_tier_stats
-            .get_or_insert_with(UnknownTierStats::default)
-            .merge(stats);
-    }
-
     pub fn checked_merge(&mut self, other: &DataUsageEntry) -> bool {
         let scalar_counts_fit = self.objects.checked_add(other.objects).is_some()
             && self.versions.checked_add(other.versions).is_some()
@@ -1008,12 +817,8 @@ impl DataUsageEntry {
             (_, None) | (None, Some(_)) => true,
             (Some(left), Some(right)) => left.fits_merge(right),
         };
-        let unknown_tier_stats_fit = match (&self.unknown_tier_stats, &other.unknown_tier_stats) {
-            (_, None) | (None, Some(_)) => true,
-            (Some(left), Some(right)) => left.fits_add(right),
-        };
 
-        if !scalar_counts_fit || !histograms_fit || !replication_fits || !tier_stats_fit || !unknown_tier_stats_fit {
+        if !scalar_counts_fit || !histograms_fit || !replication_fits || !tier_stats_fit {
             return false;
         }
         self.merge(other);
@@ -1531,7 +1336,6 @@ impl DataUsageCache {
             delete_markers_total_count: flat.delete_markers as u64,
             objects_total_size: flat.size as u64,
             tier_stats: flat.all_tier_stats.filter(|tiers| !tiers.is_empty()),
-            unknown_tier_stats: flat.unknown_tier_stats,
             buckets_count: u64::try_from(buckets.len()).unwrap_or(u64::MAX),
             buckets_usage,
             usage_snapshot_complete: self.info.snapshot_complete,
@@ -1959,16 +1763,6 @@ impl SizeSummary {
         self.replica_count = self.replica_count.saturating_add(other.replica_count);
         self.pending_count = self.pending_count.saturating_add(other.pending_count);
         self.failed_count = self.failed_count.saturating_add(other.failed_count);
-        self.unknown_tier_stats.merge(&other.unknown_tier_stats);
-
-        // A disk/bucket aggregate is assembled from many object summaries.
-        // Keep the per-tier dimension in lockstep with the scalar counters;
-        // dropping this map here would recreate the original silent-loss bug
-        // at the cross-disk merge boundary.
-        for (tier, stats) in &other.tier_stats {
-            let entry = self.tier_stats.entry(tier.clone()).or_default();
-            *entry = entry.add(stats);
-        }
 
         // Merge replication target stats
         for (target, stats) in &other.repl_target_stats {
@@ -2081,33 +1875,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn retired_tier_stats_fold_into_fixed_unknown_bucket() {
-        let mut stats = AllTierStats::default();
-        stats.tiers.insert(
-            "RETIRED".to_string(),
-            TierStats {
-                total_size: 9,
-                num_versions: 2,
-                num_objects: 1,
-            },
-        );
-        stats.tiers.insert(
-            "WARM".to_string(),
-            TierStats {
-                total_size: 4,
-                num_versions: 1,
-                num_objects: 1,
-            },
-        );
-
-        stats.fold_unknown_tiers(["WARM"]);
-
-        assert!(!stats.tiers.contains_key("RETIRED"));
-        assert_eq!(stats.tiers.get("WARM").map(|v| v.total_size), Some(4));
-        assert_eq!(stats.tiers.get(UNKNOWN_TIER).map(|v| v.total_size), Some(9));
-    }
-
     #[test]
     fn checked_merge_rejects_overflowing_tier_totals() {
         let mut left = tier_entry(
@@ -2699,7 +2466,7 @@ mod tests {
 
     #[test]
     fn replication_stats_empty_checks_every_field() {
-        type SetField = fn(&mut ReplicationTargetUsage);
+        type SetField = fn(&mut ReplicationStats);
 
         let cases: [(&str, SetField); 10] = [
             ("pending_size", |stats| stats.pending_size = 1),
@@ -2714,9 +2481,9 @@ mod tests {
             ("replicated_count", |stats| stats.replicated_count = 1),
         ];
 
-        assert!(ReplicationTargetUsage::default().is_empty());
+        assert!(ReplicationStats::default().is_empty());
         for (field, set_nonzero) in cases {
-            let mut stats = ReplicationTargetUsage::default();
+            let mut stats = ReplicationStats::default();
             set_nonzero(&mut stats);
             assert!(!stats.is_empty(), "{field} must make replication stats non-empty");
         }
@@ -2747,17 +2514,17 @@ mod tests {
         }
 
         let empty_targets = ReplicationAllStats {
-            targets: HashMap::from([("arn:test:empty".to_string(), ReplicationTargetUsage::default())]),
+            targets: HashMap::from([("arn:test:empty".to_string(), ReplicationStats::default())]),
             ..Default::default()
         };
         assert!(empty_targets.is_empty(), "all-empty targets must keep aggregate stats empty");
 
         let stats = ReplicationAllStats {
             targets: HashMap::from([
-                ("arn:test:empty".to_string(), ReplicationTargetUsage::default()),
+                ("arn:test:empty".to_string(), ReplicationStats::default()),
                 (
                     "arn:test:non-empty".to_string(),
-                    ReplicationTargetUsage {
+                    ReplicationStats {
                         pending_count: 1,
                         ..Default::default()
                     },
@@ -2798,7 +2565,7 @@ mod tests {
                 replication_stats: Some(ReplicationAllStats {
                     targets: HashMap::from([(
                         "arn:test:pending".to_string(),
-                        ReplicationTargetUsage {
+                        ReplicationStats {
                             pending_count: 1,
                             ..Default::default()
                         },
@@ -2947,7 +2714,7 @@ mod tests {
                 targets: HashMap::from([
                     (
                         "arn:self-only".to_string(),
-                        ReplicationTargetUsage {
+                        ReplicationStats {
                             pending_size: 7,
                             pending_count: 1,
                             ..Default::default()
@@ -2955,7 +2722,7 @@ mod tests {
                     ),
                     (
                         "arn:shared".to_string(),
-                        ReplicationTargetUsage {
+                        ReplicationStats {
                             failed_size: 3,
                             failed_count: 1,
                             missed_threshold_size: 2,
@@ -2974,7 +2741,7 @@ mod tests {
                 targets: HashMap::from([
                     (
                         "arn:shared".to_string(),
-                        ReplicationTargetUsage {
+                        ReplicationStats {
                             failed_size: 5,
                             failed_count: 2,
                             after_threshold_size: 4,
@@ -2984,7 +2751,7 @@ mod tests {
                     ),
                     (
                         "arn:other-only".to_string(),
-                        ReplicationTargetUsage {
+                        ReplicationStats {
                             replicated_size: 11,
                             replicated_count: 3,
                             ..Default::default()
@@ -3226,9 +2993,7 @@ mod tests {
     fn replication_target_deserialization_preserves_large_historical_maps() {
         let mut stats = ReplicationAllStats::default();
         for index in 0..=1024 {
-            stats
-                .targets
-                .insert(format!("target-{index}"), ReplicationTargetUsage::default());
+            stats.targets.insert(format!("target-{index}"), ReplicationStats::default());
         }
         let encoded = rmp_serde::to_vec_named(&stats).expect("large replication target fixture should encode");
         let decoded = rmp_serde::from_slice::<ReplicationAllStats>(&encoded)
@@ -3237,47 +3002,6 @@ mod tests {
         assert_eq!(decoded.targets.len(), stats.targets.len());
     }
 
-    /// Round-trip test: encoding a [`ReplicationTargetUsage`] and decoding it back
-    /// must produce the exact same value.  This guards against accidental serde
-    /// field-name drift during the `ReplicationStats` -> `ReplicationTargetUsage`
-    /// rename.  Wire-level field names are the serialized Rust field identifiers,
-    /// which must remain byte-identical.
-    #[test]
-    fn replication_target_usage_rmp_round_trip() {
-        let original = ReplicationTargetUsage {
-            pending_size: 100,
-            replicated_size: 2_000,
-            failed_size: 50,
-            failed_count: 3,
-            pending_count: 7,
-            missed_threshold_size: 11,
-            after_threshold_size: 22,
-            missed_threshold_count: 1,
-            after_threshold_count: 2,
-            replicated_count: 99,
-        };
-
-        let buf = rmp_serde::to_vec_named(&original).expect("encode ReplicationTargetUsage to msgpack");
-        let decoded: ReplicationTargetUsage = rmp_serde::from_slice(&buf).expect("decode ReplicationTargetUsage from msgpack");
-        assert_eq!(original, decoded, "round-trip through rmp must preserve every field");
-
-        // Also verify that encoding as an unnamed sequence and then decoding
-        // with named fields produces the correct mapping (this catches reordering).
-        let named_buf = rmp_serde::to_vec_named(&original).expect("re-encode for field-name pinning");
-        // Spot-check that known field names appear in the named encoding.
-        let named_str = String::from_utf8_lossy(&named_buf);
-        assert!(named_str.contains("pending_size"), "field 'pending_size' must survive the rename");
-        assert!(named_str.contains("replicated_size"), "field 'replicated_size' must survive the rename");
-        assert!(
-            named_str.contains("missed_threshold_size"),
-            "field 'missed_threshold_size' must survive the rename"
-        );
-        assert!(
-            named_str.contains("after_threshold_count"),
-            "field 'after_threshold_count' must survive the rename"
-        );
-    }
-
     #[test]
     fn checked_merge_rejects_noncanonical_histograms_without_mutation() {
         let mut entry = DataUsageEntry {

crates/e2e_test/src/heal_erasure_disk_rebuild_test.rs

@@ -380,24 +380,10 @@ mod tests {
         cluster.start_node(1).await?;
 
         let status_url = format!("{}/rustfs/admin/v3/background-heal/status", cluster.nodes[0].url);
-        let mut recovered = serde_json::Value::Null;
-        for _ in 0..60 {
-            let status_body = signed_admin_post(&status_url, None, &cluster.access_key, &cluster.secret_key).await?;
-            assert!(
-                !status_body.contains("MissingContentLength"),
-                "background heal status should not fail without an explicit Content-Length: {status_body}"
-            );
-            recovered = serde_json::from_str(&status_body)
-                .map_err(|err| format!("background heal status is not JSON ({err}): {status_body}"))?;
-            if recovered["clusterStatusComplete"] == serde_json::Value::Bool(true) {
-                break;
-            }
-            sleep(Duration::from_secs(1)).await;
-        }
-        assert_eq!(
-            recovered["clusterStatusComplete"],
-            serde_json::Value::Bool(true),
-            "cluster heal status should recover before root heal starts: {recovered}"
+        let status_body = signed_admin_post(&status_url, None, &cluster.access_key, &cluster.secret_key).await?;
+        assert!(
+            !status_body.contains("MissingContentLength"),
+            "background heal status should not fail without an explicit Content-Length: {status_body}"
         );
 
         let heal_body = r#"{"recursive":true,"dryRun":false,"remove":false,"recreate":true,"scanMode":2,"updateParity":false,"nolock":false}"#;

crates/ecstore/src/api/mod.rs

@@ -317,6 +317,8 @@ pub mod config {
 }
 
 pub mod data_usage {
+    #[cfg(feature = "test-util")]
+    pub use crate::data_usage::seed_bucket_usage_memory_for_test;
     pub use crate::data_usage::{
         DATA_USAGE_CACHE_NAME, apply_bucket_usage_memory_overlay, compute_bucket_usage,
         init_compression_total_memory_from_backend, invalidate_admin_data_usage_snapshot_cache,
@@ -328,8 +330,6 @@ pub mod data_usage {
         remove_bucket_usage_from_backend, replace_bucket_usage_memory_from_info, store_compression_total_in_backend,
         store_data_usage_in_backend,
     };
-    #[cfg(feature = "test-util")]
-    pub use crate::data_usage::{get_bucket_usage_memory, seed_bucket_usage_memory_for_test};
 }
 
 pub mod disk {

crates/ecstore/src/bucket/bucket_target_sys.rs

@@ -3425,44 +3425,6 @@ mod tests {
         assert!(mutexes.contains_key("second"));
     }
 
-    #[tokio::test]
-    async fn update_all_targets_publishes_disable_proxy_on_target_client() {
-        // The read-proxy selector (replication_proxy::get_proxy_targets) skips
-        // targets whose TargetClient carries disable_proxy — the persisted
-        // per-target opt-out must survive client publication.
-        let sys = BucketTargetSys::default();
-        let target = |arn: &str, disable_proxy: bool| BucketTarget {
-            arn: arn.to_string(),
-            endpoint: "192.168.1.10:9000".to_string(),
-            target_bucket: "target-bucket".to_string(),
-            region: "us-east-1".to_string(),
-            disable_proxy,
-            credentials: Some(Credentials {
-                access_key: "access".to_string(),
-                secret_key: "secret".to_string(),
-                session_token: None,
-                expiration: None,
-            }),
-            ..Default::default()
-        };
-        let targets = BucketTargets {
-            targets: vec![target("arn:proxied", false), target("arn:opted-out", true)],
-        };
-
-        sys.update_all_targets("bucket", Some(&targets)).await;
-
-        let proxied = sys
-            .get_remote_target_client("bucket", "arn:proxied")
-            .await
-            .expect("client should be published");
-        assert!(!proxied.disable_proxy);
-        let opted_out = sys
-            .get_remote_target_client("bucket", "arn:opted-out")
-            .await
-            .expect("client should be published");
-        assert!(opted_out.disable_proxy, "disable_proxy must reach the published TargetClient");
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn target_updates_serialize_client_build_through_publication_per_bucket() {
         let sys = Arc::new(BucketTargetSys::default());

crates/ecstore/src/bucket/replication/replication_pool.rs

@@ -2855,7 +2855,7 @@ fn replicate_object_info_from_object_info(
         .map(|v| OffsetDateTime::parse(&v, &Rfc3339).unwrap_or(OffsetDateTime::UNIX_EPOCH));
     let mut rstate = oi.replication_state();
     rstate.replicate_decision_str = dsc.to_string();
-    let asz = oi.get_actual_size_or_physical();
+    let asz = oi.get_actual_size().unwrap_or_default();
     let ssec = replication_object_is_ssec_encrypted(&oi.user_defined);
     let checksum = if ssec { oi.checksum.clone() } else { None };
 

crates/ecstore/src/bucket/replication/replication_resyncer.rs

@@ -1412,7 +1412,7 @@ pub async fn get_heal_replicate_object_info(oi: &ObjectInfo, rcfg: &ReplicationC
     };
     let mut replication_state = oi.replication_state();
     replication_state.replicate_decision_str = dsc.to_string();
-    let actual_size = oi.get_actual_size_or_physical();
+    let actual_size = oi.get_actual_size().unwrap_or_default();
 
     Ok(ReplicateObjectInfo {
         name: oi.name.clone(),

crates/ecstore/src/bucket/replication/replication_target_boundary.rs

@@ -389,7 +389,7 @@ fn replication_source_object(object_info: &ObjectInfo) -> ReplicationSourceObjec
             .map(|mod_time| OffsetDateTime::from_unix_timestamp(mod_time.unix_timestamp()).unwrap_or(mod_time)),
         version_id: object_info.version_id.map(|version_id| version_id.to_string()),
         etag: object_info.etag.as_deref(),
-        actual_size: object_info.get_actual_size_or_physical(),
+        actual_size: object_info.get_actual_size().unwrap_or_default(),
         delete_marker: object_info.delete_marker,
         content_type: object_info.content_type.as_deref(),
         content_encoding: object_info.content_encoding.as_deref(),
@@ -542,20 +542,6 @@ mod tests {
         assert!(replication_target_head_is_newer_null_version(&source, &target));
     }
 
-    #[test]
-    fn replication_source_uses_physical_size_for_unknown_compressed_object() {
-        let mut metadata = HashMap::new();
-        rustfs_utils::http::insert_str(&mut metadata, rustfs_utils::http::SUFFIX_COMPRESSION, "zstd".to_string());
-        let source = ObjectInfo {
-            size: 128,
-            actual_size: -1,
-            user_defined: Arc::new(metadata),
-            ..Default::default()
-        };
-
-        assert_eq!(replication_source_object(&source).actual_size, 128);
-    }
-
     #[test]
     fn replication_target_head_content_matches_compare_etag_only() {
         let source = ObjectInfo {

crates/ecstore/src/config/storageclass.rs

@@ -248,13 +248,10 @@ impl Config {
         let shard_size = shard_size as usize;
         // Keep the historical two-data-shard object budget while preventing
         // wider EC layouts from multiplying the maximum inline object size.
-        // Use div_ceil to match the shard_file_size calculation (which also uses
-        // div_ceil), avoiding a 1-byte rounding discrepancy that prevents inline
-        // for objects right at the threshold.
         let inline_block = if self.initialized && self.inline_block_explicit {
             self.inline_block
         } else {
-            DEFAULT_INLINE_OBJECT_BUDGET.div_ceil(data_shards).min(DEFAULT_INLINE_BLOCK)
+            (DEFAULT_INLINE_OBJECT_BUDGET / data_shards).min(DEFAULT_INLINE_BLOCK)
         };
 
         if versioned {

crates/ecstore/src/core/sets.rs

@@ -21,7 +21,7 @@ use crate::storage_api_contracts::{
     bucket::{BucketInfo, BucketOperations, BucketOptions, DeleteBucketOptions, MakeBucketOptions},
     list::{StorageListObjectVersionsInfo, StorageListObjectsV2Info, StorageObjectInfoOrErr, StorageWalkOptions},
     multipart::{CompletePart, ListMultipartsInfo, ListPartsInfo, MultipartInfo, MultipartUploadResult, PartInfo},
-    object::{DeleteAccounting, DeletedObject, ObjectIO as _, ObjectOperations as _, ObjectToDelete},
+    object::{DeletedObject, ObjectIO as _, ObjectOperations as _, ObjectToDelete},
     range::HTTPRangeSpec,
 };
 use crate::{
@@ -414,66 +414,6 @@ fn apply_delete_objects_results(
     }
 }
 
-fn apply_delete_accounting_results(
-    accounting: &mut [Option<DeleteAccounting>],
-    set_objects: &[DelObj],
-    set_accounting: &[Option<DeleteAccounting>],
-) {
-    for (obj, value) in set_objects.iter().zip(set_accounting.iter()) {
-        accounting[obj.orig_idx] = value.clone();
-    }
-}
-
-impl Sets {
-    pub(crate) async fn delete_objects_with_accounting(
-        &self,
-        bucket: &str,
-        objects: Vec<ObjectToDelete>,
-        opts: ObjectOptions,
-    ) -> (Vec<DeletedObject>, Vec<Option<Error>>, Vec<Option<DeleteAccounting>>) {
-        let mut del_objects = vec![DeletedObject::default(); objects.len()];
-        let mut del_errs = vec![None; objects.len()];
-        let mut accounting = vec![None; objects.len()];
-        let mut set_obj_map = HashMap::new();
-
-        for (i, obj) in objects.iter().enumerate() {
-            let idx = self.get_hashed_set_index(obj.object_name.as_str());
-            set_obj_map.entry(idx).or_insert_with(Vec::new).push(DelObj {
-                orig_idx: i,
-                obj: obj.clone(),
-            });
-        }
-
-        let max_concurrent = set_obj_map.len().min(num_cpus::get()).max(1);
-        let semaphore = Arc::new(tokio::sync::Semaphore::new(max_concurrent));
-        let mut futures = FuturesUnordered::new();
-        let bucket = bucket.to_owned();
-
-        for (set_index, set_objects) in set_obj_map {
-            let disks = self.get_disks(set_index);
-            let objects = set_objects.iter().map(|entry| entry.obj.clone()).collect::<Vec<_>>();
-            let bucket = bucket.clone();
-            let opts = opts.clone();
-            let semaphore = semaphore.clone();
-            futures.push(async move {
-                let _permit = semaphore
-                    .acquire_owned()
-                    .await
-                    .expect("delete_objects semaphore should remain open");
-                let (deleted, errors, accounting) = disks.delete_objects_with_accounting(&bucket, objects, opts).await;
-                (set_objects, deleted, errors, accounting)
-            });
-        }
-
-        while let Some((set_objects, deleted, errors, set_accounting)) = futures.next().await {
-            apply_delete_objects_results(&mut del_objects, &mut del_errs, &set_objects, &deleted, errors);
-            apply_delete_accounting_results(&mut accounting, &set_objects, &set_accounting);
-        }
-
-        (del_objects, del_errs, accounting)
-    }
-}
-
 #[async_trait::async_trait]
 impl crate::storage_api_contracts::object::ObjectIO for Sets {
     type Error = Error;
@@ -715,8 +655,65 @@ impl crate::storage_api_contracts::object::ObjectOperations for Sets {
         objects: Vec<ObjectToDelete>,
         opts: ObjectOptions,
     ) -> (Vec<DeletedObject>, Vec<Option<Error>>) {
-        let (deleted, errors, _) = self.delete_objects_with_accounting(bucket, objects, opts).await;
-        (deleted, errors)
+        // Default return value
+        let mut del_objects = vec![DeletedObject::default(); objects.len()];
+
+        let mut del_errs = Vec::with_capacity(objects.len());
+        for _ in 0..objects.len() {
+            del_errs.push(None)
+        }
+
+        let mut set_obj_map = HashMap::new();
+
+        // hash key
+        for (i, obj) in objects.iter().enumerate() {
+            let idx = self.get_hashed_set_index(obj.object_name.as_str());
+
+            if !set_obj_map.contains_key(&idx) {
+                set_obj_map.insert(
+                    idx,
+                    vec![DelObj {
+                        // set_idx: idx,
+                        orig_idx: i,
+                        obj: obj.clone(),
+                    }],
+                );
+            } else if let Some(val) = set_obj_map.get_mut(&idx) {
+                val.push(DelObj {
+                    // set_idx: idx,
+                    orig_idx: i,
+                    obj: obj.clone(),
+                });
+            }
+        }
+
+        let max_concurrent = set_obj_map.len().min(num_cpus::get()).max(1);
+        let semaphore = Arc::new(tokio::sync::Semaphore::new(max_concurrent));
+        let mut futures = FuturesUnordered::new();
+        let bucket = bucket.to_string();
+
+        for (k, v) in set_obj_map {
+            let disks = self.get_disks(k);
+            let objs: Vec<ObjectToDelete> = v.iter().map(|v| v.obj.clone()).collect();
+            let bucket = bucket.clone();
+            let opts = opts.clone();
+            let semaphore = semaphore.clone();
+
+            futures.push(async move {
+                let _permit = semaphore
+                    .acquire_owned()
+                    .await
+                    .expect("delete_objects semaphore should remain open");
+                let (dobjects, errs) = disks.delete_objects(&bucket, objs, opts).await;
+                (v, dobjects, errs)
+            });
+        }
+
+        while let Some((v, dobjects, errs)) = futures.next().await {
+            apply_delete_objects_results(&mut del_objects, &mut del_errs, &v, &dobjects, errs);
+        }
+
+        (del_objects, del_errs)
     }
 
     #[tracing::instrument(skip(self))]

crates/ecstore/src/data_usage/mod.rs

@@ -1391,37 +1391,7 @@ impl BucketUsageAccumulator {
 }
 
 pub fn quota_object_size(object: &ObjectInfo) -> Result<u64, Error> {
-    // A compressed object may carry -1 while the transformed size is unknown
-    // (legacy streaming sentinel). In that case the persisted physical size
-    // is still a valid accounting floor; every other negative value is corrupt.
-    // An explicit negative `actual-size` metadata value is corrupt, however:
-    // the sentinel is only valid in the in-memory/object-part field written by
-    // the legacy streaming path, not as a persisted declared size.
-    let compressed = object.is_compressed();
-    if object.actual_size < -1 || (object.actual_size == -1 && !compressed) {
-        return Err(Error::PartMissingOrCorrupt);
-    }
-    if object
-        .parts
-        .iter()
-        .any(|part| part.actual_size < -1 || (part.actual_size < 0 && !compressed))
-    {
-        return Err(Error::PartMissingOrCorrupt);
-    }
-    let declared_actual_size = rustfs_utils::http::get_str(&object.user_defined, rustfs_utils::http::SUFFIX_ACTUAL_SIZE)
-        .filter(|value| !value.is_empty());
-    if declared_actual_size
-        .as_deref()
-        .and_then(|value| value.parse::<i64>().ok())
-        .is_some_and(|size| size < 0)
-    {
-        return Err(Error::PartMissingOrCorrupt);
-    }
-    let logical_size = match object.get_actual_size().map_err(Error::other)? {
-        size if size == -1 && compressed && declared_actual_size.is_none() => None,
-        size if size >= 0 => Some(u64::try_from(size).map_err(|_| Error::PartMissingOrCorrupt)?),
-        _ => return Err(Error::PartMissingOrCorrupt),
-    };
+    let logical_size = u64::try_from(object.get_actual_size().map_err(Error::other)?).map_err(|_| Error::PartMissingOrCorrupt)?;
     let persisted_part_size = if object.parts.is_empty() {
         u64::try_from(object.size).map_err(|_| Error::PartMissingOrCorrupt)?
     } else {
@@ -1429,8 +1399,12 @@ pub fn quota_object_size(object: &ObjectInfo) -> Result<u64, Error> {
             // Compressed streaming objects persist -1 when the transformed
             // part size is unknown. The physical part size remains a valid
             // quota floor; reject only non-negative values that overflow.
-            let actual_size = if part.actual_size == -1 {
-                0
+            let actual_size = if part.actual_size < 0 {
+                if object.is_compressed() {
+                    0
+                } else {
+                    return Err(Error::PartMissingOrCorrupt);
+                }
             } else {
                 u64::try_from(part.actual_size).map_err(|_| Error::PartMissingOrCorrupt)?
             };
@@ -1438,7 +1412,7 @@ pub fn quota_object_size(object: &ObjectInfo) -> Result<u64, Error> {
             total.checked_add(part_size).ok_or(Error::PartMissingOrCorrupt)
         })?
     };
-    Ok(logical_size.unwrap_or(0).max(persisted_part_size))
+    Ok(logical_size.max(persisted_part_size))
 }
 
 type UsageVersionPage = StorageListObjectVersionsInfo<ObjectInfo>;
@@ -3346,80 +3320,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn quota_object_size_accepts_compressed_unknown_actual_size_sentinel() {
-        let mut metadata = HashMap::new();
-        rustfs_utils::http::insert_str(
-            &mut metadata,
-            rustfs_utils::http::SUFFIX_COMPRESSION,
-            "klauspost/compress/s2".to_string(),
-        );
-        let object = ObjectInfo {
-            size: 400,
-            actual_size: -1,
-            user_defined: Arc::new(metadata),
-            ..Default::default()
-        };
-
-        assert_eq!(quota_object_size(&object).expect("compressed sentinel is valid"), 400);
-    }
-
-    #[test]
-    fn quota_object_size_rejects_compressed_part_sum_overflow() {
-        let mut metadata = HashMap::new();
-        rustfs_utils::http::insert_str(
-            &mut metadata,
-            rustfs_utils::http::SUFFIX_COMPRESSION,
-            "klauspost/compress/s2".to_string(),
-        );
-        let object = ObjectInfo {
-            size: 1,
-            user_defined: Arc::new(metadata),
-            parts: Arc::new(vec![
-                rustfs_filemeta::ObjectPartInfo {
-                    actual_size: i64::MAX,
-                    ..Default::default()
-                },
-                rustfs_filemeta::ObjectPartInfo {
-                    actual_size: 1,
-                    ..Default::default()
-                },
-            ]),
-            ..Default::default()
-        };
-
-        assert!(matches!(quota_object_size(&object), Err(Error::Io(_))));
-    }
-
-    #[test]
-    fn quota_object_size_rejects_negative_values_other_than_the_compressed_sentinel() {
-        let mut metadata = HashMap::new();
-        rustfs_utils::http::insert_str(
-            &mut metadata,
-            rustfs_utils::http::SUFFIX_COMPRESSION,
-            "klauspost/compress/s2".to_string(),
-        );
-        let corrupt_object = ObjectInfo {
-            size: 400,
-            actual_size: -2,
-            user_defined: Arc::new(metadata.clone()),
-            ..Default::default()
-        };
-        assert!(matches!(quota_object_size(&corrupt_object), Err(Error::PartMissingOrCorrupt)));
-
-        let corrupt_part = ObjectInfo {
-            size: 400,
-            user_defined: Arc::new(metadata),
-            parts: Arc::new(vec![rustfs_filemeta::ObjectPartInfo {
-                size: 400,
-                actual_size: -2,
-                ..Default::default()
-            }]),
-            ..Default::default()
-        };
-        assert!(matches!(quota_object_size(&corrupt_part), Err(Error::PartMissingOrCorrupt)));
-    }
-
     #[tokio::test]
     #[serial]
     async fn live_bucket_usage_refreshes_are_coalesced_only_while_in_flight() {

crates/ecstore/src/object_api/types.rs

@@ -689,9 +689,6 @@ impl ObjectInfo {
     }
 
     pub fn get_actual_size(&self) -> std::io::Result<i64> {
-        if self.actual_size < -1 || (self.actual_size == -1 && !self.is_compressed()) {
-            return Err(std::io::Error::other("invalid negative actual size"));
-        }
         if self.actual_size > 0 {
             return Ok(self.actual_size);
         }
@@ -703,25 +700,10 @@ impl ObjectInfo {
                 let size = size_str.parse::<i64>().map_err(|e| std::io::Error::other(e.to_string()))?;
                 return Ok(size);
             }
-            if self.actual_size == -1 && self.parts.is_empty() {
-                return Ok(-1);
-            }
-            let mut actual_size = 0_i64;
-            let mut unknown = false;
-            for part in self.parts.iter() {
-                match part.actual_size {
-                    -1 => unknown = true,
-                    size if size >= 0 => {
-                        actual_size = actual_size
-                            .checked_add(size)
-                            .ok_or_else(|| std::io::Error::other("compressed actual size overflow"))?;
-                    }
-                    _ => return Err(std::io::Error::other("invalid negative compressed part size")),
-                }
-            }
-            if unknown {
-                return Ok(-1);
-            }
+            let mut actual_size = 0;
+            self.parts.iter().for_each(|part| {
+                actual_size += part.actual_size;
+            });
             if actual_size == 0 && actual_size != self.size {
                 return Err(std::io::Error::other(format!("invalid decompressed size {} {}", actual_size, self.size)));
             }
@@ -736,18 +718,6 @@ impl ObjectInfo {
         Ok(self.size)
     }
 
-    /// Returns a non-negative size for client and replication boundaries.
-    ///
-    /// Compressed legacy metadata can retain the internal `-1` unknown-size
-    /// sentinel. Those boundaries cannot emit a negative length, so they use
-    /// the persisted physical size while quota accounting keeps the sentinel
-    /// distinction in [`crate::data_usage::quota_object_size`].
-    pub fn get_actual_size_or_physical(&self) -> i64 {
-        self.get_actual_size()
-            .map(|size| if size >= 0 { size } else { self.size.max(0) })
-            .unwrap_or_else(|_| self.size.max(0))
-    }
-
     pub fn from_file_info(fi: &FileInfo, bucket: &str, object: &str, versioned: bool) -> ObjectInfo {
         let mut version_id = fi.version_id;
 

crates/ecstore/src/services/metrics_realtime.rs

@@ -256,10 +256,6 @@ fn to_madmin_scanner_metrics(metrics: rustfs_common::metrics::ScannerMetricsRepo
         cycle_max_duration_seconds: metrics.cycle_max_duration_seconds,
         cycle_max_objects: metrics.cycle_max_objects,
         cycle_max_directories: metrics.cycle_max_directories,
-        cycle_timeout_total: metrics.cycle_timeout_total,
-        cycle_recovery_required_total: metrics.cycle_recovery_required_total,
-        cycle_last_progress_age: metrics.cycle_last_progress_age,
-        leader_lease_without_progress: metrics.leader_lease_without_progress,
         bitrot_cycle_enabled: metrics.bitrot_cycle_enabled,
         bitrot_cycle_seconds: metrics.bitrot_cycle_seconds,
         scan_checkpoint: metrics.scan_checkpoint.map(|checkpoint| MadminScannerCheckpointReport {
@@ -615,10 +611,6 @@ mod test {
             current_started: chrono_to_jiff_timestamp(current_started),
             last_cycle_partial_source: "usage".to_string(),
             last_cycle_partial_source_code: 1,
-            cycle_timeout_total: 3,
-            cycle_recovery_required_total: 2,
-            cycle_last_progress_age: 17,
-            leader_lease_without_progress: true,
             partial_cycles_by_source: vec![rustfs_common::metrics::ScannerSourceCycleSnapshot {
                 source: "usage".to_string(),
                 cycles: 2,
@@ -630,10 +622,6 @@ mod test {
         assert_eq!(scanner.current_started, chrono_to_jiff_timestamp(current_started));
         assert_eq!(scanner.last_cycle_partial_source, "usage");
         assert_eq!(scanner.last_cycle_partial_source_code, 1);
-        assert_eq!(scanner.cycle_timeout_total, 3);
-        assert_eq!(scanner.cycle_recovery_required_total, 2);
-        assert_eq!(scanner.cycle_last_progress_age, 17);
-        assert!(scanner.leader_lease_without_progress);
         let usage = scanner
             .partial_cycles_by_source
             .iter()

crates/ecstore/src/set_disk/mod.rs

@@ -97,7 +97,7 @@ use crate::storage_api_contracts::{
         CompletePart, ListMultipartsInfo, ListPartsInfo, MultipartInfo, MultipartOperations as _, MultipartUploadResult, PartInfo,
     },
     namespace::NamespaceLocking as _,
-    object::{DeleteAccounting, DeletedObject, HTTPPreconditions, ObjectIO as _, ObjectOperations as _, ObjectToDelete},
+    object::{DeletedObject, HTTPPreconditions, ObjectIO as _, ObjectOperations as _, ObjectToDelete},
     range::HTTPRangeSpec,
 };
 use crate::store::utils::is_reserved_or_invalid_bucket;

crates/ecstore/src/set_disk/ops/object.rs

@@ -45,7 +45,6 @@ use crate::bucket::replication::{
     DeleteReplicationConfigSnapshot, ReplicationLifecycleBridge, ReplicationStatusType, VersionPurgeStatusType,
     replication_state_to_filemeta, replication_status_from_filemeta, version_purge_status_to_filemeta,
 };
-use crate::data_usage::quota_object_size;
 use crate::diagnostics::get::GetObjectFailureReason;
 use crate::disk::{DataDirDeleteStatus, OldCurrentSize};
 use crate::error::is_err_invalid_upload_id;
@@ -2123,27 +2122,14 @@ impl SetDisks {
             let erasure = Arc::new(erasure_from_file_info(&fi, false)?);
 
             let put_object_size = known_put_object_storage_size(data.size());
-            let shard_file_size_raw = erasure.shard_file_size(put_object_size);
             let is_inline_buffer =
-                storage_class_config.should_inline(shard_file_size_raw, erasure.data_shards, opts.versioned);
+                storage_class_config.should_inline(erasure.shard_file_size(put_object_size), erasure.data_shards, opts.versioned);
 
             let collect_stage_timing = rustfs_io_metrics::put_stage_metrics_enabled() || issue3031_diag_enabled();
-            let shard_file_size = shard_file_size_raw;
+            let shard_file_size = erasure.shard_file_size(put_object_size);
             let shard_size = erasure.shard_size();
             let write_path = classify_put_write_path(is_inline_buffer, put_object_size, fi.erasure.block_size);
             let direct_inline_commit = matches!(write_path, SmallWritePath::Inline);
-            {
-                use std::io::Write;
-                let msg = format!(
-                    "INLINE_DEBUG: bucket={} obj={} size={} shard_fs={} ds={} bs={} inline={} direct={} path={} iblock={} ver={}\n",
-                    bucket, object, put_object_size, shard_file_size_raw, erasure.data_shards, fi.erasure.block_size,
-                    is_inline_buffer, direct_inline_commit, write_path.metric_label(), storage_class_config.inline_block(), opts.versioned
-                );
-                if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open("/tmp/rustfs_inline_debug.log") {
-                    let _ = f.write_all(msg.as_bytes());
-                }
-                let _ = std::io::stderr().write_all(msg.as_bytes());
-            }
             rustfs_io_metrics::record_put_object_path(write_path.metric_label());
             let writer_setup_stage_start = collect_stage_timing.then(Instant::now);
             let (mut writers, errors) = if direct_inline_commit {
@@ -5669,18 +5655,7 @@ impl crate::storage_api_contracts::object::ObjectOperations for SetDisks {
         objects: Vec<ObjectToDelete>,
         opts: ObjectOptions,
     ) -> (Vec<DeletedObject>, Vec<Option<Error>>) {
-        let (deleted, errors, _) = self.delete_objects_with_accounting(bucket, objects, opts).await;
-        (deleted, errors)
-    }
-
-    async fn delete_objects_with_accounting(
-        &self,
-        bucket: &str,
-        objects: Vec<ObjectToDelete>,
-        opts: ObjectOptions,
-    ) -> (Vec<DeletedObject>, Vec<Option<Error>>, Vec<Option<DeleteAccounting>>) {
         let mut del_objects = vec![DeletedObject::default(); objects.len()];
-        let mut accounting = vec![None; objects.len()];
         let delete_config_snapshot = opts
             .delete_replication_config_snapshot
             .clone()
@@ -5770,7 +5745,7 @@ impl crate::storage_api_contracts::object::ObjectOperations for SetDisks {
                                 *item = Some(Error::other(message.clone()));
                             }
                         }
-                        return (del_objects, del_errs, accounting);
+                        return (del_objects, del_errs);
                     }
                 },
             }
@@ -5817,22 +5792,6 @@ impl crate::storage_api_contracts::object::ObjectOperations for SetDisks {
             let source_missing = gerr
                 .as_ref()
                 .is_some_and(|err| is_err_object_not_found(err) || is_err_version_not_found(err));
-            // Resolve accounting from the generation selected under this
-            // object's write lock. A request-layer pre-stat is only an
-            // optimization and cannot identify a concurrent overwrite.
-            let (accounting_size, accounting_version_id, removed_current_object) = if source_missing
-                || dobj.synthetic_version_id
-                || set_disk_delete_creates_delete_marker(&check_opts)
-                || goi.delete_marker
-            {
-                (None, None, false)
-            } else {
-                (
-                    quota_object_size(&goi).ok(),
-                    goi.version_id.filter(|version_id| !version_id.is_nil()),
-                    (dobj.version_id.is_none() || is_explicit_null_version(dobj.version_id)) && !dobj.synthetic_version_id,
-                )
-            };
             // Normalize both sides before comparing. `goi.version_id` is the
             // client-facing identity, where `from_file_info` synthesizes
             // `Some(Uuid::nil())` for a null version on a versioned or
@@ -5961,12 +5920,7 @@ impl crate::storage_api_contracts::object::ObjectOperations for SetDisks {
                     },
                     replication_state: vr.replication_state_internal.clone(),
                     ..Default::default()
-                };
-                accounting[i] = Some(DeleteAccounting {
-                    size: accounting_size,
-                    version_id: accounting_version_id,
-                    removed_current_object,
-                });
+                }
             }
 
             // Only add to vers_map if we hold the lock
@@ -6012,7 +5966,7 @@ impl crate::storage_api_contracts::object::ObjectOperations for SetDisks {
                     });
                 }
             }
-            return (del_objects, del_errs, accounting);
+            return (del_objects, del_errs);
         }
 
         let mut persisted_journal_entries = Vec::with_capacity(journal_entries.len());
@@ -6250,16 +6204,7 @@ impl crate::storage_api_contracts::object::ObjectOperations for SetDisks {
             }
         }
 
-        // An accounting identity is actionable only when the delete result is
-        // successful. Never let a failed commit (including a partial quorum
-        // failure) reach the request-layer fast delta path.
-        for (index, err) in del_errs.iter().enumerate() {
-            if err.is_some() {
-                accounting[index] = None;
-            }
-        }
-
-        (del_objects, del_errs, accounting)
+        (del_objects, del_errs)
     }
 
     #[tracing::instrument(skip(self))]
@@ -6588,12 +6533,6 @@ impl crate::storage_api_contracts::object::ObjectOperations for SetDisks {
 
         let mut obj_info = ObjectInfo::from_file_info(&dfi, bucket, object, opts.versioned || opts.version_suspended);
         obj_info.size = goi.size;
-        // Keep the committed source metadata on the internal delete result so
-        // the request layer can derive canonical accounting for this exact
-        // generation. Delete responses do not expose these fields.
-        obj_info.actual_size = goi.actual_size;
-        obj_info.user_defined = Arc::clone(&goi.user_defined);
-        obj_info.parts = Arc::clone(&goi.parts);
         obj_info.user_tags = Arc::clone(&goi.user_tags);
         self.invalidate_get_object_metadata_cache(bucket, object).await;
         Ok(obj_info)
@@ -7885,113 +7824,6 @@ mod replication_quota_safety_tests {
         assert_eq!(stored.get_actual_size().expect("stored logical size should parse"), 1);
     }
 
-    #[tokio::test]
-    async fn delete_returns_canonical_compressed_accounting_size() {
-        let (_temp_dirs, disks, set_disks) = hermetic_set_disks(4).await;
-        let bucket = "compressed-delete-accounting";
-        for disk in &disks {
-            disk.make_volume(bucket).await.expect("bucket volume should be created");
-        }
-
-        let mut user_defined = HashMap::new();
-        insert_str(
-            &mut user_defined,
-            rustfs_utils::http::SUFFIX_COMPRESSION,
-            "klauspost/compress/s2".to_string(),
-        );
-        insert_str(&mut user_defined, SUFFIX_ACTUAL_SIZE, "1000".to_string());
-        let mut reader = PutObjReader::new(
-            HashReader::from_stream(Cursor::new(vec![0x5a; 400]), 400, 1000, None, None, false)
-                .expect("compressed fixture reader should be valid"),
-        );
-        set_disks
-            .put_object(
-                bucket,
-                "object",
-                &mut reader,
-                &ObjectOptions {
-                    user_defined,
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("compressed object should be written");
-
-        let (deleted, errors, accounting) = set_disks
-            .delete_objects_with_accounting(
-                bucket,
-                vec![ObjectToDelete {
-                    object_name: "object".to_string(),
-                    ..Default::default()
-                }],
-                ObjectOptions {
-                    object_lock_config_snapshot: Some(Arc::new(ObjectLockConfigSnapshot::new(
-                        ObjectLockConfigState::ConfirmedAbsent,
-                    ))),
-                    ..Default::default()
-                },
-            )
-            .await;
-
-        assert!(errors[0].is_none(), "compressed delete should succeed: {:?}", errors[0]);
-        assert!(deleted[0].found, "the committed object must be reported as found");
-        assert_eq!(accounting[0].as_ref().and_then(|value| value.size), Some(1000));
-        assert!(accounting[0].as_ref().is_some_and(|value| value.version_id.is_none()));
-        assert!(accounting[0].as_ref().is_some_and(|value| value.removed_current_object));
-    }
-
-    #[tokio::test]
-    async fn suspended_delete_marker_does_not_return_body_accounting() {
-        let (_temp_dirs, disks, set_disks) = hermetic_set_disks(4).await;
-        let bucket = "suspended-delete-accounting";
-        for disk in &disks {
-            disk.make_volume(bucket).await.expect("bucket volume should be created");
-        }
-
-        let mut user_defined = HashMap::new();
-        insert_str(
-            &mut user_defined,
-            rustfs_utils::http::SUFFIX_COMPRESSION,
-            "klauspost/compress/s2".to_string(),
-        );
-        insert_str(&mut user_defined, SUFFIX_ACTUAL_SIZE, "1000".to_string());
-        let mut reader = PutObjReader::new(
-            HashReader::from_stream(Cursor::new(vec![0x5a; 400]), 400, 1000, None, None, false)
-                .expect("compressed fixture reader should be valid"),
-        );
-        let suspended_opts = ObjectOptions {
-            version_suspended: true,
-            delete_replication_config_snapshot: Some(Arc::new(DeleteReplicationConfigSnapshot::from_configs_for_test(
-                s3s::dto::VersioningConfiguration {
-                    status: Some(s3s::dto::BucketVersioningStatus::from_static(s3s::dto::BucketVersioningStatus::SUSPENDED)),
-                    ..Default::default()
-                },
-                None,
-            ))),
-            user_defined,
-            object_lock_config_snapshot: Some(Arc::new(ObjectLockConfigSnapshot::new(ObjectLockConfigState::ConfirmedAbsent))),
-            ..Default::default()
-        };
-        set_disks
-            .put_object(bucket, "object", &mut reader, &suspended_opts)
-            .await
-            .expect("compressed object should be written");
-
-        let (deleted, errors, accounting) = set_disks
-            .delete_objects_with_accounting(
-                bucket,
-                vec![ObjectToDelete {
-                    object_name: "object".to_string(),
-                    ..Default::default()
-                }],
-                suspended_opts,
-            )
-            .await;
-        assert!(errors[0].is_none(), "suspended delete should create a marker: {:?}", errors[0]);
-        assert!(deleted[0].delete_marker);
-        assert!(accounting[0].is_none(), "a delete marker must not carry body accounting");
-    }
-
     #[tokio::test]
     async fn direct_put_cannot_persist_a_tiny_logical_size() {
         let (_temp_dirs, disks, set_disks) = hermetic_set_disks(4).await;

crates/ecstore/src/storage_api_contracts/mod.rs

@@ -62,8 +62,8 @@ pub(crate) mod object {
     use super::{Debug, Error, FileInfo, GetObjectReader, ObjectInfo, ObjectOptions, PutObjReader};
     use crate::storage_api_contracts::range::HTTPRangeSpec;
     pub(crate) use rustfs_storage_api::{
-        DeleteAccounting, DeletedObject, HTTPPreconditions, ObjectIO, ObjectLockDeleteOptions, ObjectLockRetentionOptions,
-        ObjectOperations, ObjectPreconditionError, ObjectPreconditionPart, ObjectPreconditionState, ObjectToDelete,
+        DeletedObject, HTTPPreconditions, ObjectIO, ObjectLockDeleteOptions, ObjectLockRetentionOptions, ObjectOperations,
+        ObjectPreconditionError, ObjectPreconditionPart, ObjectPreconditionState, ObjectToDelete,
     };
 
     pub(crate) trait EcstoreObjectIO:

crates/ecstore/src/store/heal.rs

@@ -297,16 +297,10 @@ impl ECStore {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::bucket::metadata_sys;
     use crate::core::pools::{PoolDecommissionInfo, PoolStatus};
-    use crate::disk::{DeleteOptions, DiskOption, format::FormatV3, new_disk};
-    use crate::layout::endpoints::{EndpointServerPools, Endpoints, PoolEndpoints};
-    use crate::runtime::instance::InstanceContext;
-    use crate::storage_api_contracts::bucket::{BucketOperations, MakeBucketOptions};
-    use crate::storage_api_contracts::object::{ObjectIO as _, ObjectOperations};
+    use crate::disk::{DiskOption, format::FormatV3, new_disk};
+    use crate::layout::endpoints::{Endpoints, PoolEndpoints};
     use crate::store::init_format::{load_format_erasure, save_format_file};
-    use crate::store::init_local_disks_with_instance_ctx;
-    use tokio_util::sync::CancellationToken;
 
     async fn minimal_heal_pool(pool_idx: usize) -> Arc<Sets> {
         let format = FormatV3::new(1, 1);
@@ -353,51 +347,6 @@ mod tests {
         }
     }
 
-    async fn multi_pool_heal_store() -> (tempfile::TempDir, Arc<ECStore>, CancellationToken) {
-        let temp_dir = tempfile::tempdir().expect("multi-pool heal test directory should be created");
-        let mut pool_endpoints = Vec::new();
-        for pool_index in 0..2 {
-            let mut endpoints = Vec::new();
-            for disk_index in 0..4 {
-                let disk_path = temp_dir.path().join(format!("pool{pool_index}-disk{disk_index}"));
-                tokio::fs::create_dir_all(&disk_path)
-                    .await
-                    .expect("multi-pool heal test disk should be created");
-                let mut endpoint = Endpoint::try_from(disk_path.to_str().expect("disk path should be utf8"))
-                    .expect("test endpoint should parse");
-                endpoint.set_pool_index(pool_index);
-                endpoint.set_set_index(0);
-                endpoint.set_disk_index(disk_index);
-                endpoints.push(endpoint);
-            }
-            pool_endpoints.push(PoolEndpoints {
-                legacy: false,
-                set_count: 1,
-                drives_per_set: 4,
-                endpoints: Endpoints::from(endpoints),
-                cmd_line: format!("heal-owner-pool-{pool_index}"),
-                platform: "test".to_string(),
-            });
-        }
-
-        let endpoint_pools = EndpointServerPools::from(pool_endpoints);
-        let instance_ctx = Arc::new(InstanceContext::new());
-        init_local_disks_with_instance_ctx(&instance_ctx, endpoint_pools.clone())
-            .await
-            .expect("multi-pool local disks should initialize");
-        let shutdown = CancellationToken::new();
-        let store = ECStore::new_with_instance_ctx(
-            "127.0.0.1:0".parse().expect("test address should parse"),
-            endpoint_pools,
-            shutdown.clone(),
-            instance_ctx,
-        )
-        .await
-        .expect("multi-pool test store should initialize");
-        metadata_sys::init_bucket_metadata_sys(store.clone(), Vec::new()).await;
-        (temp_dir, store, shutdown)
-    }
-
     #[tokio::test]
     async fn heal_object_pool_scope_selects_only_requested_pool() {
         let store = minimal_heal_store().await;
@@ -557,229 +506,6 @@ mod tests {
         }
     }
 
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn unscoped_heal_object_suspended_owner_semantics() {
-        let (_temp_dir, store, shutdown) = multi_pool_heal_store().await;
-        let bucket = format!("heal-owner-{}", Uuid::new_v4().simple());
-        let active_object = "active-owner";
-        let suspended_only_object = "suspended-only";
-        let duplicate_object = "duplicate-owner";
-        let marker_object = "marker-owner";
-        let quorum_object = "quorum-owner";
-        store
-            .make_bucket(&bucket, &MakeBucketOptions::default())
-            .await
-            .expect("bucket should be created in all pools");
-
-        let mut active_reader = PutObjReader::from_vec(b"active owner".to_vec());
-        store.pools[0]
-            .put_object(&bucket, active_object, &mut active_reader, &ObjectOptions::default())
-            .await
-            .expect("active owner object should be written");
-        let active_disks = store.pools[0].disk_set[0].disks.read().await.clone();
-        let missing_active_disk = active_disks[0].clone().expect("active disk should be online");
-        missing_active_disk
-            .delete(
-                &bucket,
-                active_object,
-                DeleteOptions {
-                    recursive: true,
-                    immediate: true,
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("active owner shard should be removed for repair");
-        assert!(
-            missing_active_disk.read_xl(&bucket, active_object, false).await.is_err(),
-            "the active owner fixture must start with one missing metadata copy"
-        );
-
-        let mut suspended_reader = PutObjReader::from_vec(b"suspended owner".to_vec());
-        store.pools[1]
-            .put_object(&bucket, suspended_only_object, &mut suspended_reader, &ObjectOptions::default())
-            .await
-            .expect("suspended owner object should be written");
-        for (pool_index, mod_time) in [1_i64, 2_i64].into_iter().enumerate() {
-            let mut duplicate_reader = PutObjReader::from_vec(format!("duplicate-pool-{pool_index}").into_bytes());
-            store.pools[pool_index]
-                .put_object(
-                    &bucket,
-                    duplicate_object,
-                    &mut duplicate_reader,
-                    &ObjectOptions {
-                        mod_time: Some(OffsetDateTime::UNIX_EPOCH + time::Duration::seconds(mod_time)),
-                        ..Default::default()
-                    },
-                )
-                .await
-                .expect("duplicate owner object should be written");
-        }
-        let duplicate_missing_disk = store.pools[0].disk_set[0].disks.read().await[0]
-            .clone()
-            .expect("duplicate active owner disk should be online");
-        duplicate_missing_disk
-            .delete(
-                &bucket,
-                duplicate_object,
-                DeleteOptions {
-                    recursive: true,
-                    immediate: true,
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("duplicate active owner shard should be removed for repair");
-        let history_version = Uuid::new_v4();
-        let mut history_reader = PutObjReader::from_vec(b"marker history".to_vec());
-        store.pools[0]
-            .put_object(
-                &bucket,
-                marker_object,
-                &mut history_reader,
-                &ObjectOptions {
-                    versioned: true,
-                    version_id: Some(history_version.to_string()),
-                    mod_time: Some(OffsetDateTime::UNIX_EPOCH + time::Duration::seconds(1)),
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("versioned marker history should be written");
-        store.pools[0]
-            .delete_object(
-                &bucket,
-                marker_object,
-                ObjectOptions {
-                    versioned: true,
-                    mod_time: Some(OffsetDateTime::UNIX_EPOCH + time::Duration::seconds(2)),
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("delete marker should be written");
-        let mut quorum_reader = PutObjReader::from_vec(b"quorum boundary".to_vec());
-        store.pools[0]
-            .put_object(&bucket, quorum_object, &mut quorum_reader, &ObjectOptions::default())
-            .await
-            .expect("quorum boundary object should be written");
-        {
-            let mut pool_meta = store.pool_meta.write().await;
-            let mut next = PoolMeta::new(&store.pools, &pool_meta);
-            next.pools[1].decommission = Some(PoolDecommissionInfo {
-                start_time: Some(OffsetDateTime::UNIX_EPOCH),
-                ..Default::default()
-            });
-            *pool_meta = next;
-        }
-
-        let (_, duplicate_owner) = store
-            .get_latest_object_info_with_idx(&bucket, duplicate_object, &ObjectOptions::default())
-            .await
-            .expect("duplicate owner should resolve");
-        assert_eq!(duplicate_owner, 1, "latest duplicate must win when all pools are eligible");
-        let (_, active_duplicate_owner) = store
-            .get_latest_object_info_with_idx(
-                &bucket,
-                duplicate_object,
-                &ObjectOptions {
-                    skip_decommissioned: true,
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("active duplicate owner should resolve");
-        assert_eq!(
-            active_duplicate_owner, 0,
-            "suspended duplicate must be excluded from active owner selection"
-        );
-        let (duplicate_result, duplicate_err) = store
-            .handle_heal_object(&bucket, duplicate_object, "", &HealOpts::default())
-            .await
-            .expect("duplicate owner heal should complete through the production path");
-        assert_eq!(duplicate_result.object, duplicate_object);
-        assert!(duplicate_err.is_none(), "active duplicate should be repaired: {duplicate_err:?}");
-        assert!(
-            duplicate_missing_disk.read_xl(&bucket, duplicate_object, false).await.is_ok(),
-            "production heal must repair the active duplicate owner rather than the suspended owner"
-        );
-        let (marker_info, marker_owner) = store
-            .get_latest_object_info_with_idx(
-                &bucket,
-                marker_object,
-                &ObjectOptions {
-                    skip_decommissioned: true,
-                    versioned: true,
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("latest delete marker should resolve");
-        assert_eq!(marker_owner, 0);
-        assert!(marker_info.delete_marker, "latest version must preserve delete-marker semantics");
-
-        let (active_result, active_err) = store
-            .handle_heal_object(&bucket, active_object, "", &HealOpts::default())
-            .await
-            .expect("unscoped active-owner heal should complete");
-        assert_eq!(active_result.object, active_object);
-        assert!(active_err.is_none(), "active owner must be selected even with a suspended pool");
-        assert!(
-            missing_active_disk.read_xl(&bucket, active_object, false).await.is_ok(),
-            "active owner heal must write the missing disk metadata: result={active_result:?}, err={active_err:?}"
-        );
-        assert!(
-            store.pools[1]
-                .get_object_info(&bucket, active_object, &ObjectOptions::default())
-                .await
-                .is_err(),
-            "the suspended pool must not be written for an active-owner object"
-        );
-
-        let (suspended_result, suspended_err) = store
-            .handle_heal_object(&bucket, suspended_only_object, "", &HealOpts::default())
-            .await
-            .expect("unscoped suspended-only heal should return a terminal result");
-        assert!(suspended_result.object.is_empty());
-        assert!(matches!(suspended_err, Some(Error::FileNotFound)));
-        assert!(
-            store.pools[1]
-                .get_object_info(&bucket, suspended_only_object, &ObjectOptions::default())
-                .await
-                .is_ok(),
-            "suspended-only data must remain untouched when unscoped heal reports absent"
-        );
-
-        let (_, explicit_err) = store
-            .handle_heal_object(
-                &bucket,
-                suspended_only_object,
-                "",
-                &HealOpts {
-                    pool: Some(1),
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("explicit suspended-owner heal should return a mapped error");
-        assert!(matches!(explicit_err, Some(Error::SlowDown)));
-
-        let original_quorum_disks = store.pools[0].disk_set[0].disks.read().await.clone();
-        let surviving_quorum_disk = original_quorum_disks[3].clone();
-        *store.pools[0].disk_set[0].disks.write().await = vec![None, None, None, surviving_quorum_disk];
-        let (_, quorum_err) = store
-            .handle_heal_object(&bucket, quorum_object, "", &HealOpts::default())
-            .await
-            .expect("quorum boundary heal should return a mapped result");
-        *store.pools[0].disk_set[0].disks.write().await = original_quorum_disks;
-        assert!(
-            matches!(quorum_err, Some(Error::ErasureReadQuorum)),
-            "quorum-boundary heal must preserve quorum error, got {quorum_err:?}"
-        );
-        shutdown.cancel();
-    }
-
     #[tokio::test]
     async fn handle_heal_format_continues_after_a_pool_error() {
         let canonical_format = FormatV3::new(1, 3);

crates/ecstore/src/store/mod.rs

@@ -33,7 +33,7 @@ use crate::bucket::utils::check_put_object_part_args;
 use crate::bucket::utils::{check_valid_bucket_name, check_valid_bucket_name_strict, is_meta_bucketname};
 use crate::cluster::rpc::{RemoteClient, S3PeerSys};
 use crate::config::storageclass;
-use crate::core::pools::{DecommissionCanceler, PoolMeta};
+use crate::core::pools::PoolMeta;
 use crate::disk::endpoint::{Endpoint, EndpointType};
 use crate::disk::{DiskAPI, DiskInfo, DiskInfoOptions};
 use crate::error::{Error, Result};
@@ -176,7 +176,7 @@ pub struct ECStore {
     // pub local_disks: Vec<DiskStore>,
     pub pool_meta: RwLock<PoolMeta>,
     pub rebalance_meta: RwLock<Option<RebalanceMeta>>,
-    pub decommission_cancelers: RwLock<Vec<Option<DecommissionCanceler>>>,
+    pub decommission_cancelers: RwLock<Vec<Option<CancellationToken>>>,
     /// Serializes rebalance/decommission start transitions.
     ///
     /// Lock order: acquire `start_gate` before `pool_meta`, `rebalance_meta`,

crates/ecstore/src/store/object.rs

@@ -41,7 +41,7 @@ use crate::set_disk::{
 };
 use crate::storage_api_contracts::{
     namespace::NamespaceLocking as _,
-    object::{DeleteAccounting, ObjectIO as _, ObjectOperations as _},
+    object::{ObjectIO as _, ObjectOperations as _},
 };
 use parking_lot::Mutex as ParkingMutex;
 use rustfs_io_metrics::{
@@ -1216,14 +1216,6 @@ fn return_batch_delete_lock_error(objects: &[ObjectToDelete], err: Error) -> (Ve
     (del_objects, del_errs)
 }
 
-fn return_batch_delete_lock_error_with_accounting(
-    objects: &[ObjectToDelete],
-    err: Error,
-) -> (Vec<DeletedObject>, Vec<Option<Error>>, Vec<Option<DeleteAccounting>>) {
-    let (deleted, errors) = return_batch_delete_lock_error(objects, err);
-    (deleted, errors, vec![None; objects.len()])
-}
-
 fn sorted_unique_delete_object_names(objects: &[ObjectToDelete]) -> Vec<&str> {
     let mut object_names: Vec<&str> = objects.iter().map(|object| object.object_name.as_str()).collect();
     object_names.sort_unstable();
@@ -2320,22 +2312,6 @@ impl ECStore {
         result
     }
 
-    pub async fn delete_objects_with_tier_delete_journal_and_accounting(
-        self: &Arc<Self>,
-        bucket: &str,
-        objects: Vec<ObjectToDelete>,
-        opts: ObjectOptions,
-    ) -> (Vec<DeletedObject>, Vec<Option<Error>>, Vec<Option<DeleteAccounting>>) {
-        let result = self
-            .handle_delete_objects_with_journal_and_accounting(bucket, objects, opts, Some(Arc::clone(self)))
-            .await;
-        let success_count = result.1.iter().filter(|err| err.is_none()).count();
-        if success_count > 0 {
-            list_objects::observe_list_objects_mutations(self, bucket, success_count).await;
-        }
-        result
-    }
-
     #[instrument(skip(self))]
     pub(super) async fn handle_delete_object(&self, bucket: &str, object: &str, opts: ObjectOptions) -> Result<ObjectInfo> {
         self.handle_delete_object_with_journal(bucket, object, opts, None).await
@@ -2713,19 +2689,6 @@ impl ECStore {
         opts: ObjectOptions,
         tier_journal_api: Option<Arc<ECStore>>,
     ) -> (Vec<DeletedObject>, Vec<Option<Error>>) {
-        let (deleted, errors, _) = self
-            .handle_delete_objects_with_journal_and_accounting(bucket, objects, opts, tier_journal_api)
-            .await;
-        (deleted, errors)
-    }
-
-    pub(super) async fn handle_delete_objects_with_journal_and_accounting(
-        &self,
-        bucket: &str,
-        objects: Vec<ObjectToDelete>,
-        opts: ObjectOptions,
-        tier_journal_api: Option<Arc<ECStore>>,
-    ) -> (Vec<DeletedObject>, Vec<Option<Error>>, Vec<Option<DeleteAccounting>>) {
         // encode object name
         let objects: Vec<ObjectToDelete> = objects
             .iter()
@@ -2738,7 +2701,6 @@ impl ECStore {
 
         // Default return value
         let mut del_objects = vec![DeletedObject::default(); objects.len()];
-        let mut accounting = vec![None; objects.len()];
 
         let mut del_errs = Vec::with_capacity(objects.len());
         for _ in 0..objects.len() {
@@ -2752,7 +2714,7 @@ impl ECStore {
         } else {
             match self.acquire_bucket_lifecycle_read_lock(bucket).await {
                 Ok(guard) => Some(guard),
-                Err(err) => return return_batch_delete_lock_error_with_accounting(objects.as_slice(), err),
+                Err(err) => return return_batch_delete_lock_error(objects.as_slice(), err),
             }
         };
         if let Some(guard) = _bucket_lifecycle_guard.as_ref() {
@@ -2764,21 +2726,21 @@ impl ECStore {
                 Err(err) => {
                     let message = err.to_string();
                     let errors = (0..objects.len()).map(|_| Some(Error::other(message.clone()))).collect();
-                    return (del_objects, errors, accounting);
+                    return (del_objects, errors);
                 }
             }
         }
         if !is_meta_bucketname(bucket)
             && let Err(err) = get_cached_bucket_incarnation_id_in(&self.ctx, bucket).await
         {
-            return return_batch_delete_lock_error_with_accounting(objects.as_slice(), err);
+            return return_batch_delete_lock_error(objects.as_slice(), err);
         }
         let _object_lock_metadata_guard = if is_meta_bucketname(bucket) {
             None
         } else {
             Some(match acquire_bucket_metadata_transaction_read_lock_in(&self.ctx, bucket).await {
                 Ok(guard) => guard,
-                Err(err) => return return_batch_delete_lock_error_with_accounting(objects.as_slice(), err),
+                Err(err) => return return_batch_delete_lock_error(objects.as_slice(), err),
             })
         };
         if let Some(guard) = _object_lock_metadata_guard.as_ref() {
@@ -2788,7 +2750,7 @@ impl ECStore {
             let (state, incarnation_id, config_revision) =
                 match get_object_lock_config_and_incarnation_from_disk_in(&self.ctx, bucket).await {
                     Ok(snapshot) => snapshot,
-                    Err(err) => return return_batch_delete_lock_error_with_accounting(objects.as_slice(), err),
+                    Err(err) => return return_batch_delete_lock_error(objects.as_slice(), err),
                 };
             opts.object_lock_config_snapshot = Some(Arc::new(ObjectLockConfigSnapshot::for_store_bucket(
                 self.id,
@@ -2804,10 +2766,7 @@ impl ECStore {
         if let (Some(expected), Some(current)) = (opts.expected_bucket_incarnation_id, current_bucket_incarnation_id)
             && expected != current
         {
-            return return_batch_delete_lock_error_with_accounting(
-                objects.as_slice(),
-                StorageError::BucketNotFound(bucket.to_string()),
-            );
+            return return_batch_delete_lock_error(objects.as_slice(), StorageError::BucketNotFound(bucket.to_string()));
         }
         #[cfg(test)]
         if current_bucket_incarnation_id.is_some() {
@@ -2815,7 +2774,7 @@ impl ECStore {
         }
         let _object_lock_guards = match self.acquire_delete_objects_write_locks(bucket, &objects, &mut opts).await {
             Ok(guards) => guards,
-            Err(err) => return return_batch_delete_lock_error_with_accounting(objects.as_slice(), err),
+            Err(err) => return return_batch_delete_lock_error(objects.as_slice(), err),
         };
 
         let mut futures = Vec::with_capacity(self.pools.len());
@@ -2824,24 +2783,22 @@ impl ECStore {
             if self.is_pool_rebalancing(pool.pool_idx).await {
                 continue;
             }
-            futures.push(pool.delete_objects_with_accounting(bucket, objects.clone(), opts.clone()));
+            futures.push(pool.delete_objects(bucket, objects.clone(), opts.clone()));
         }
 
         let results = join_all(futures).await;
 
         for idx in 0..del_objects.len() {
-            for (dels, errs, pool_accounting) in results.iter() {
+            for (dels, errs) in results.iter() {
                 if errs[idx].is_none() && dels[idx].found {
                     del_errs[idx] = None;
                     del_objects[idx] = dels[idx].clone();
-                    accounting[idx] = pool_accounting[idx].clone();
                     break;
                 }
 
                 if del_errs[idx].is_none() {
                     del_errs[idx] = errs[idx].clone();
                     del_objects[idx] = dels[idx].clone();
-                    accounting[idx] = pool_accounting[idx].clone();
                 }
             }
         }
@@ -2850,7 +2807,7 @@ impl ECStore {
             v.object_name = decode_dir_object(&v.object_name);
         });
 
-        (del_objects, del_errs, accounting)
+        (del_objects, del_errs)
 
         // let mut futures = Vec::with_capacity(objects.len());
 

crates/filemeta/src/metacache.rs

@@ -21,6 +21,7 @@ use arc_swap::ArcSwapOption;
 use rmp::Marker;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
+use std::collections::{HashMap, HashSet};
 use std::str::from_utf8;
 use std::{
     fmt::Debug,
@@ -37,8 +38,13 @@ use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use tokio::spawn;
 use tokio::sync::Mutex;
 use tracing::{debug, warn};
+use uuid::Uuid;
 
 const SLASH_SEPARATOR: &str = "/";
+pub const MAX_META_CACHE_HEAL_CANDIDATES: usize = 1024;
+/// Keep truncation continuations bounded while still giving the scanner a
+/// safe object-level retry for versions that did not fit in the candidate set.
+pub const MAX_META_CACHE_HEAL_TRUNCATED_OBJECTS: usize = 64;
 
 #[derive(Clone, Debug, Default)]
 pub struct MetadataResolutionParams {
@@ -66,6 +72,47 @@ pub struct MetaCacheEntry {
     pub reusable: bool,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum MetaCacheHealCandidateKind {
+    Object,
+    DeleteMarker,
+    UnversionedObject,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct MetaCacheHealCandidate {
+    pub object: String,
+    pub version_id: Option<Uuid>,
+    pub kind: MetaCacheHealCandidateKind,
+    /// Number of raw disk entries that carried this validated version.
+    pub replica_count: usize,
+}
+
+impl MetaCacheHealCandidate {
+    pub fn validated_version(&self) -> Option<Uuid> {
+        match self.kind {
+            MetaCacheHealCandidateKind::Object | MetaCacheHealCandidateKind::DeleteMarker => self.version_id,
+            MetaCacheHealCandidateKind::UnversionedObject => None,
+        }
+    }
+
+    pub fn is_unversioned(&self) -> bool {
+        self.kind == MetaCacheHealCandidateKind::UnversionedObject
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct MetaCacheHealDiscovery {
+    pub candidates: Vec<MetaCacheHealCandidate>,
+    pub unverified_count: usize,
+    pub truncated: bool,
+    /// Object names whose validated version set exceeded the candidate cap.
+    /// The scanner retries these names without a version and with destructive
+    /// healing disabled; this is an explicit bounded continuation, not a
+    /// version claim.
+    pub truncated_objects: Vec<String>,
+}
+
 impl MetaCacheEntry {
     pub fn marshal_msg(&self) -> Result<Vec<u8>> {
         let mut wr = Vec::new();
@@ -370,6 +417,184 @@ impl MetaCacheEntries {
         })
     }
 
+    /// Discover validated object/delete-marker versions and safe unversioned
+    /// inspection candidates in the raw entries without applying read quorum.
+    /// This is intentionally separate from [`Self::resolve`]: a sub-quorum
+    /// version is a valid heal target even though it must not participate in
+    /// normal reads or writes.
+    ///
+    /// The validated list is bounded and deduplicated by object, version id,
+    /// and metadata kind; each candidate retains the number of raw disk
+    /// entries that carried it so callers can classify sub-quorum versions.
+    /// Entries whose xl.meta cannot be decoded are counted separately for
+    /// discovery accounting; they never become versionless destructive heal
+    /// requests and do not consume the validated quota. An
+    /// [`MetaCacheHealCandidateKind::UnversionedObject`] is always consumed by
+    /// a non-destructive scanner request.
+    pub fn discover_heal_candidates(&self, bucket: &str, max_candidates: usize) -> MetaCacheHealDiscovery {
+        let limit = max_candidates.min(MAX_META_CACHE_HEAL_CANDIDATES);
+        if limit == 0 || bucket.is_empty() {
+            return MetaCacheHealDiscovery::default();
+        }
+
+        let mut discovery = MetaCacheHealDiscovery {
+            candidates: Vec::<MetaCacheHealCandidate>::with_capacity(limit.min(self.0.len())),
+            unverified_count: 0,
+            truncated: false,
+            truncated_objects: Vec::with_capacity(MAX_META_CACHE_HEAL_TRUNCATED_OBJECTS.min(limit)),
+        };
+        let mut seen: HashMap<(String, Option<Uuid>, MetaCacheHealCandidateKind), usize> =
+            HashMap::with_capacity(limit.min(self.0.len()));
+
+        for entry in self.0.iter().flatten() {
+            if !valid_heal_candidate_name(bucket, entry) {
+                continue;
+            }
+
+            let meta = match FileMeta::load(&entry.metadata) {
+                Ok(meta) => meta,
+                Err(_) => {
+                    discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                    continue;
+                }
+            };
+            let mut entry_seen = HashSet::new();
+
+            for shallow in meta.versions {
+                let version = match shallow.parse_version_meta() {
+                    Ok(version) if version.valid() => version,
+                    Ok(_) | Err(_) => {
+                        discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                        continue;
+                    }
+                };
+                if version.free_version() {
+                    continue;
+                }
+
+                let payload_header = version.header();
+                if normalize_version_id(shallow.header.version_id) != normalize_version_id(payload_header.version_id)
+                    || shallow.header.version_type != payload_header.version_type
+                {
+                    discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                    continue;
+                }
+
+                let (kind, version_id) = match version.version_type {
+                    VersionType::Object
+                        if version.object.is_some() && version.delete_marker.is_none() && version.legacy_object.is_none() =>
+                    {
+                        match version.object.as_ref().and_then(|object| object.version_id) {
+                            Some(id) if !id.is_nil() => (MetaCacheHealCandidateKind::Object, Some(id)),
+                            Some(_) | None => (MetaCacheHealCandidateKind::UnversionedObject, None),
+                        }
+                    }
+                    VersionType::Delete
+                        if version.delete_marker.is_some() && version.object.is_none() && version.legacy_object.is_none() =>
+                    {
+                        let Some(id) = version.delete_marker.as_ref().and_then(|marker| marker.version_id) else {
+                            discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                            continue;
+                        };
+                        if id.is_nil() {
+                            discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                            continue;
+                        }
+                        (MetaCacheHealCandidateKind::DeleteMarker, Some(id))
+                    }
+                    VersionType::Legacy
+                        if version.legacy_object.is_some() && version.object.is_none() && version.delete_marker.is_none() =>
+                    {
+                        let Some(legacy) = version.legacy_object.as_ref() else {
+                            continue;
+                        };
+                        if legacy.version_id.is_empty() {
+                            (MetaCacheHealCandidateKind::UnversionedObject, None)
+                        } else {
+                            let Ok(id) = Uuid::parse_str(&legacy.version_id) else {
+                                discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                                continue;
+                            };
+                            if id.is_nil() {
+                                discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                                continue;
+                            }
+                            (MetaCacheHealCandidateKind::Object, Some(id))
+                        }
+                    }
+                    _ => {
+                        discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                        continue;
+                    }
+                };
+
+                if normalize_version_id(payload_header.version_id) != version_id {
+                    discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                    continue;
+                }
+
+                // `all_parts=true` is the trust-boundary check for versioned
+                // candidates. A null/legacy object may still need the old
+                // non-destructive inspection fallback when its part arrays
+                // are parseable but incomplete; never use that fallback for
+                // a candidate carrying a real version id.
+                let file_info = match version.clone().into_fileinfo(bucket, &entry.name, true) {
+                    Ok(file_info) => file_info,
+                    Err(_) if version_id.is_none() && matches!(kind, MetaCacheHealCandidateKind::UnversionedObject) => {
+                        discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                        match version.into_fileinfo(bucket, &entry.name, false) {
+                            Ok(file_info) => file_info,
+                            Err(_) => continue,
+                        }
+                    }
+                    Err(_) => {
+                        discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                        continue;
+                    }
+                };
+                if file_info.volume != bucket || file_info.name != entry.name {
+                    discovery.unverified_count = discovery.unverified_count.saturating_add(1);
+                    continue;
+                }
+
+                let candidate = MetaCacheHealCandidate {
+                    object: entry.name.clone(),
+                    version_id,
+                    kind,
+                    replica_count: 1,
+                };
+                let key = (candidate.object.clone(), candidate.version_id, candidate.kind.clone());
+                if entry_seen.contains(&key) {
+                    continue;
+                }
+                if let Some(index) = seen.get(&key).copied() {
+                    entry_seen.insert(key);
+                    discovery.candidates[index].replica_count = discovery.candidates[index].replica_count.saturating_add(1);
+                } else if discovery.candidates.len() >= limit {
+                    // Keep the validated candidate list bounded, but retain a
+                    // bounded object-level continuation so the scanner cannot
+                    // silently lose every version of a busy object.
+                    discovery.truncated = true;
+                    if discovery.truncated_objects.len() < MAX_META_CACHE_HEAL_TRUNCATED_OBJECTS
+                        && !discovery.truncated_objects.iter().any(|object| object == &candidate.object)
+                    {
+                        discovery.truncated_objects.push(candidate.object.clone());
+                    }
+                    // The remaining versions in this raw entry cannot add a
+                    // bounded candidate; avoid parsing a very long history
+                    // after the safe continuation has been recorded.
+                    break;
+                } else {
+                    entry_seen.insert(key.clone());
+                    seen.insert(key, discovery.candidates.len());
+                    discovery.candidates.push(candidate);
+                }
+            }
+        }
+
+        discovery
+    }
+
     fn resolve_inner(&self, mut params: MetadataResolutionParams, enforce_write_quorum: bool) -> Option<MetaCacheEntry> {
         if self.0.is_empty() {
             debug!(
@@ -546,6 +771,33 @@ impl MetaCacheEntries {
     }
 }
 
+fn valid_heal_candidate_name(bucket: &str, entry: &MetaCacheEntry) -> bool {
+    if bucket.is_empty()
+        || entry.name.is_empty()
+        || entry.is_dir()
+        || entry.name.contains('\\')
+        || entry.name.chars().any(char::is_control)
+    {
+        return false;
+    }
+
+    // Validate raw key components without normalizing them. The scanner maps
+    // accepted keys to filesystem paths later, so dot components and empty
+    // internal components must be rejected before that boundary. A final
+    // empty component is retained for valid keys ending in '/'.
+    let mut components = entry.name.split('/').peekable();
+    while let Some(component) = components.next() {
+        if component == "." || component == ".." || (component.is_empty() && components.peek().is_some()) {
+            return false;
+        }
+    }
+    true
+}
+
+fn normalize_version_id(version_id: Option<Uuid>) -> Option<Uuid> {
+    version_id.filter(|id| !id.is_nil())
+}
+
 #[derive(Debug, Default)]
 pub struct MetaCacheEntriesSortedResult {
     pub entries: Option<MetaCacheEntriesSorted>,
@@ -991,7 +1243,7 @@ impl<T: Clone + Debug + Send + Sync + 'static> Cache<T> {
 mod tests {
     use super::*;
     use crate::test_data::create_real_xlmeta;
-    use crate::{FileMetaVersion, MetaDeleteMarker, TRANSITION_COMPLETE};
+    use crate::{FileMetaVersion, MetaDeleteMarker, MetaObjectV1, MetaObjectV1Erasure, MetaObjectV1Stat, TRANSITION_COMPLETE};
     use std::collections::HashMap;
     use std::io::Cursor;
     use std::sync::{
@@ -1592,6 +1844,348 @@ mod tests {
         );
     }
 
+    #[test]
+    fn discover_heal_candidates_keeps_sub_quorum_versions_and_deduplicates() {
+        let now = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");
+        let entries = MetaCacheEntries(vec![
+            Some(metacache_entry_single_version(1, now, "one")),
+            Some(metacache_entry_single_version(2, now, "two")),
+            Some(metacache_entry_single_version(2, now, "two")),
+            Some(metacache_entry_single_version(3, now, "three")),
+        ]);
+
+        let discovery = entries.discover_heal_candidates("bucket", 16);
+        let ids: std::collections::HashSet<Uuid> = discovery
+            .candidates
+            .iter()
+            .filter_map(|candidate| candidate.version_id)
+            .collect();
+        assert_eq!(
+            ids,
+            [Uuid::from_u128(1), Uuid::from_u128(2), Uuid::from_u128(3)]
+                .into_iter()
+                .collect()
+        );
+        assert_eq!(discovery.candidates.len(), 3, "duplicate tied versions must be emitted once");
+        assert_eq!(
+            discovery
+                .candidates
+                .iter()
+                .find(|candidate| candidate.version_id == Some(Uuid::from_u128(2)))
+                .expect("duplicate version should be discovered")
+                .replica_count,
+            2
+        );
+    }
+
+    #[test]
+    fn discover_heal_candidates_does_not_count_duplicate_versions_within_one_entry() {
+        let now = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");
+        let mut meta = FileMeta::load(&metacache_entry_single_version(1, now, "duplicate").metadata)
+            .expect("duplicate fixture should decode");
+        meta.versions.push(meta.versions[0].clone());
+        let entry = MetaCacheEntry {
+            name: "object".to_string(),
+            metadata: meta.marshal_msg().expect("duplicate metadata should marshal"),
+            cached: Some(meta),
+            reusable: false,
+        };
+
+        let discovery = MetaCacheEntries(vec![Some(entry)]).discover_heal_candidates("bucket", 16);
+        let candidate = discovery
+            .candidates
+            .iter()
+            .find(|candidate| candidate.version_id == Some(Uuid::from_u128(1)))
+            .expect("duplicate fixture should be discovered");
+        assert_eq!(candidate.replica_count, 1);
+    }
+
+    #[test]
+    fn discover_heal_candidates_covers_divergent_quorum_boundaries_n2_n4_n6() {
+        let now = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");
+
+        for (disk_count, quorum) in [(2usize, 1usize), (4, 2), (6, 3)] {
+            let target_id = Uuid::from_u128(0x1000 + disk_count as u128);
+            for target_replicas in [quorum.saturating_sub(1), quorum, quorum + 1] {
+                let entries = (0..disk_count)
+                    .map(|disk| {
+                        let version_id = if disk < target_replicas {
+                            target_id
+                        } else {
+                            Uuid::from_u128(0x2000 + disk as u128)
+                        };
+                        Some(metacache_entry_single_version(version_id.as_u128(), now, "divergent"))
+                    })
+                    .collect();
+                let discovery = MetaCacheEntries(entries).discover_heal_candidates("bucket", 32);
+                let target = discovery
+                    .candidates
+                    .iter()
+                    .find(|candidate| candidate.version_id == Some(target_id));
+                assert_eq!(target.is_some(), target_replicas > 0, "N={disk_count}, replicas={target_replicas}");
+                if let Some(target) = target {
+                    assert_eq!(target.replica_count, target_replicas);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn discover_heal_candidates_separates_delete_markers_and_preserves_unversioned_objects() {
+        let mut marker_meta = FileMeta::new();
+        marker_meta
+            .add_version(FileInfo {
+                volume: "bucket".to_string(),
+                name: "object".to_string(),
+                version_id: Some(Uuid::from_u128(99)),
+                deleted: true,
+                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp")),
+                ..Default::default()
+            })
+            .expect("delete marker should be added");
+        let marker = MetaCacheEntry {
+            name: "object".to_string(),
+            metadata: marker_meta.marshal_msg().expect("delete marker metadata should marshal"),
+            cached: Some(marker_meta),
+            reusable: false,
+        };
+
+        let unversioned_entry = metacache_entry_with_mod_time(
+            OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp"),
+            "unversioned",
+        );
+        let discovery = MetaCacheEntries(vec![Some(marker), Some(unversioned_entry)]).discover_heal_candidates("bucket", 16);
+        assert!(discovery.candidates.iter().any(|candidate| {
+            candidate.kind == MetaCacheHealCandidateKind::DeleteMarker && candidate.version_id == Some(Uuid::from_u128(99))
+        }));
+        assert!(discovery.candidates.iter().any(|candidate| {
+            candidate.kind == MetaCacheHealCandidateKind::UnversionedObject && candidate.version_id.is_none()
+        }));
+    }
+
+    #[test]
+    fn discover_heal_candidates_rejects_delete_markers_without_ids() {
+        let mut marker_meta = FileMeta::new();
+        marker_meta
+            .add_version(FileInfo {
+                volume: "bucket".to_string(),
+                name: "object".to_string(),
+                deleted: true,
+                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp")),
+                ..Default::default()
+            })
+            .expect("nil delete marker should be added");
+        let discovery = MetaCacheEntries(vec![Some(MetaCacheEntry {
+            name: "object".to_string(),
+            metadata: marker_meta.marshal_msg().expect("nil marker metadata should marshal"),
+            cached: Some(marker_meta),
+            reusable: false,
+        })])
+        .discover_heal_candidates("bucket", 16);
+
+        assert!(
+            !discovery
+                .candidates
+                .iter()
+                .any(|candidate| candidate.kind == MetaCacheHealCandidateKind::DeleteMarker)
+        );
+        assert!(discovery.unverified_count >= 1);
+    }
+
+    #[test]
+    fn discover_heal_candidates_skips_free_versions() {
+        let object_id = Uuid::from_u128(100);
+        let free_id = Uuid::from_u128(101);
+        let mut meta = FileMeta::new();
+        meta.add_version(FileInfo {
+            volume: "bucket".to_string(),
+            name: "object".to_string(),
+            version_id: Some(object_id),
+            transition_status: TRANSITION_COMPLETE.to_string(),
+            transitioned_objname: "remote/object".to_string(),
+            transition_version_id: Some(Uuid::from_u128(102)),
+            transition_tier: "WARM".to_string(),
+            mod_time: Some(OffsetDateTime::now_utc()),
+            ..Default::default()
+        })
+        .expect("transitioned object should be added");
+        let mut delete = FileInfo {
+            volume: "bucket".to_string(),
+            name: "object".to_string(),
+            version_id: Some(object_id),
+            mod_time: Some(OffsetDateTime::now_utc()),
+            ..Default::default()
+        };
+        delete.set_tier_free_version_id(&free_id.to_string());
+        meta.delete_version(&delete).expect("free version should be persisted");
+
+        let discovery = MetaCacheEntries(vec![Some(MetaCacheEntry {
+            name: "object".to_string(),
+            metadata: meta.marshal_msg().expect("free version metadata should marshal"),
+            cached: Some(meta),
+            reusable: false,
+        })])
+        .discover_heal_candidates("bucket", 16);
+        assert!(discovery.candidates.is_empty());
+    }
+
+    #[test]
+    fn discover_heal_candidates_preserves_unversioned_legacy_object() {
+        let legacy = MetaObjectV1 {
+            version: "1.0.1".to_string(),
+            format: "xl".to_string(),
+            stat: MetaObjectV1Stat {
+                size: 1,
+                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp")),
+                name: "object".to_string(),
+                ..Default::default()
+            },
+            erasure: MetaObjectV1Erasure {
+                data_blocks: 4,
+                parity_blocks: 2,
+                index: 1,
+                distribution: vec![1, 2, 3, 4, 5, 6],
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let version = FileMetaVersion {
+            version_type: VersionType::Legacy,
+            legacy_object: Some(legacy),
+            ..Default::default()
+        };
+        let mut meta = FileMeta::new();
+        meta.versions
+            .push(FileMetaShallowVersion::try_from(version).expect("legacy metadata should marshal"));
+        let discovery = MetaCacheEntries(vec![Some(MetaCacheEntry {
+            name: "object".to_string(),
+            metadata: meta.marshal_msg().expect("legacy metadata should marshal"),
+            cached: Some(meta),
+            reusable: false,
+        })])
+        .discover_heal_candidates("bucket", 16);
+        assert!(discovery.candidates.iter().any(|candidate| {
+            candidate.kind == MetaCacheHealCandidateKind::UnversionedObject && candidate.version_id.is_none()
+        }));
+    }
+
+    #[test]
+    fn discover_heal_candidates_rejects_nil_and_malformed_metadata_and_is_bounded() {
+        let now = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");
+        let mut nil = metacache_entry_single_version(1, now, "nil");
+        let mut nil_meta = FileMeta::load(&nil.metadata).expect("nil fixture should decode");
+        let mut nil_version = nil_meta.versions[0]
+            .parse_version_meta()
+            .expect("nil fixture version should decode");
+        nil_version.object.as_mut().expect("object fixture").version_id = Some(Uuid::nil());
+        nil_meta.versions[0] = FileMetaShallowVersion::try_from(nil_version).expect("nil fixture should marshal");
+        nil.metadata = nil_meta.marshal_msg().expect("nil fixture metadata should marshal");
+
+        let mut mismatched = metacache_entry_single_version(2, now, "mismatched");
+        let mut mismatched_meta = FileMeta::load(&mismatched.metadata).expect("mismatched fixture should decode");
+        mismatched_meta.versions[0].header.version_id = Some(Uuid::from_u128(200));
+        mismatched.metadata = mismatched_meta.marshal_msg().expect("mismatched metadata should marshal");
+
+        let mut short_parts = metacache_entry_single_version(3, now, "short-parts");
+        let mut short_parts_meta = FileMeta::load(&short_parts.metadata).expect("short-parts fixture should decode");
+        let mut short_parts_version = short_parts_meta.versions[0]
+            .parse_version_meta()
+            .expect("short-parts fixture version should decode");
+        let object = short_parts_version.object.as_mut().expect("object fixture");
+        object.part_numbers = vec![1];
+        object.part_actual_sizes = vec![1];
+        object.part_sizes.clear();
+        short_parts_meta.versions[0] = FileMetaShallowVersion::try_from(short_parts_version).expect("short-parts should marshal");
+        short_parts.metadata = short_parts_meta.marshal_msg().expect("short-parts metadata should marshal");
+
+        let mut short_unversioned = metacache_entry_with_mod_time(now, "short-unversioned");
+        let mut short_unversioned_meta =
+            FileMeta::load(&short_unversioned.metadata).expect("short-unversioned fixture should decode");
+        let mut short_unversioned_version = short_unversioned_meta.versions[0]
+            .parse_version_meta()
+            .expect("short-unversioned version should decode");
+        let unversioned_object = short_unversioned_version.object.as_mut().expect("unversioned object fixture");
+        unversioned_object.part_numbers = vec![1];
+        unversioned_object.part_actual_sizes = vec![1];
+        unversioned_object.part_sizes.clear();
+        short_unversioned_meta.versions[0] =
+            FileMetaShallowVersion::try_from(short_unversioned_version).expect("short-unversioned should marshal");
+        short_unversioned.metadata = short_unversioned_meta
+            .marshal_msg()
+            .expect("short-unversioned metadata should marshal");
+
+        let mut malformed = nil.clone();
+        malformed.name = "malformed".to_string();
+        malformed.metadata = vec![1, 2, 3];
+
+        let entries = MetaCacheEntries(
+            std::iter::once(Some(nil))
+                .chain(std::iter::once(Some(mismatched)))
+                .chain(std::iter::once(Some(short_parts)))
+                .chain(std::iter::once(Some(short_unversioned)))
+                .chain(std::iter::once(Some(malformed)))
+                .chain((0..32).map(|id| Some(metacache_entry_single_version(id + 10, now, "bounded"))))
+                .collect(),
+        );
+        let discovery = entries.discover_heal_candidates("bucket", 5);
+        assert!(discovery.candidates.len() <= 5);
+        assert!(discovery.truncated, "bounded discovery must expose dropped candidates");
+        assert!(
+            discovery.truncated_objects.iter().any(|object| object == "object"),
+            "bounded discovery must expose an object-level safe continuation"
+        );
+        assert!(
+            !discovery
+                .candidates
+                .iter()
+                .any(|candidate| candidate.version_id == Some(Uuid::nil()))
+        );
+        assert!(
+            !discovery
+                .candidates
+                .iter()
+                .any(|candidate| candidate.version_id == Some(Uuid::from_u128(2)))
+        );
+        assert!(
+            !discovery
+                .candidates
+                .iter()
+                .any(|candidate| candidate.version_id == Some(Uuid::from_u128(3)))
+        );
+        assert!(discovery.candidates.iter().any(|candidate| {
+            candidate.kind == MetaCacheHealCandidateKind::UnversionedObject && candidate.version_id.is_none()
+        }));
+        assert!(
+            discovery.unverified_count >= 1,
+            "malformed and rejected metadata must remain observable during discovery"
+        );
+
+        for invalid_name in [
+            "../object",
+            "./object",
+            "object/../other",
+            "object//name",
+            "object\\name",
+            "object\u{0001}name",
+            "object\0name",
+        ] {
+            let mut entry = metacache_entry_single_version(400, now, invalid_name);
+            entry.name = invalid_name.to_string();
+            let discovery = MetaCacheEntries(vec![Some(entry)]).discover_heal_candidates("bucket", 5);
+            assert!(
+                discovery.candidates.is_empty(),
+                "invalid key should not become a heal candidate: {invalid_name:?}"
+            );
+        }
+
+        for valid_name in ["trailing/", "prefix/object"] {
+            let mut entry = metacache_entry_single_version(401, now, valid_name);
+            entry.name = valid_name.to_string();
+            let discovery = MetaCacheEntries(vec![Some(entry)]).discover_heal_candidates("bucket", 5);
+            assert_eq!(discovery.candidates.len(), 1, "raw S3 key should remain opaque: {valid_name:?}");
+        }
+    }
+
     #[test]
     fn resolve_rejects_partial_latest_and_returns_committed_previous_metadata() {
         let old_mod_time = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");

crates/madmin/src/metrics.rs

@@ -689,14 +689,6 @@ pub struct ScannerMetrics {
     pub cycle_max_objects: u64,
     #[serde(rename = "cycle_max_directories", default)]
     pub cycle_max_directories: u64,
-    #[serde(rename = "cycle_timeout_total", default)]
-    pub cycle_timeout_total: u64,
-    #[serde(rename = "cycle_recovery_required_total", default)]
-    pub cycle_recovery_required_total: u64,
-    #[serde(rename = "cycle_last_progress_age", default)]
-    pub cycle_last_progress_age: u64,
-    #[serde(rename = "leader_lease_without_progress", default)]
-    pub leader_lease_without_progress: bool,
     #[serde(rename = "bitrot_cycle_enabled", default)]
     pub bitrot_cycle_enabled: bool,
     #[serde(rename = "bitrot_cycle_seconds", default)]
@@ -772,8 +764,6 @@ impl ScannerMetrics {
             self.cycle_max_duration_seconds = other.cycle_max_duration_seconds;
             self.cycle_max_objects = other.cycle_max_objects;
             self.cycle_max_directories = other.cycle_max_directories;
-            self.cycle_last_progress_age = other.cycle_last_progress_age;
-            self.leader_lease_without_progress = other.leader_lease_without_progress;
             self.bitrot_cycle_enabled = other.bitrot_cycle_enabled;
             self.bitrot_cycle_seconds = other.bitrot_cycle_seconds;
         }
@@ -867,12 +857,6 @@ impl ScannerMetrics {
             .saturating_add(other.last_cycle_replication_checks);
         self.last_cycle_usage_saves = self.last_cycle_usage_saves.saturating_add(other.last_cycle_usage_saves);
         self.failed_cycles = self.failed_cycles.saturating_add(other.failed_cycles);
-        self.cycle_timeout_total = self.cycle_timeout_total.saturating_add(other.cycle_timeout_total);
-        self.cycle_recovery_required_total = self
-            .cycle_recovery_required_total
-            .saturating_add(other.cycle_recovery_required_total);
-        self.cycle_last_progress_age = self.cycle_last_progress_age.max(other.cycle_last_progress_age);
-        self.leader_lease_without_progress |= other.leader_lease_without_progress;
         self.superseded_cycles = self.superseded_cycles.saturating_add(other.superseded_cycles);
         self.partial_cycles_unknown = self.partial_cycles_unknown.saturating_add(other.partial_cycles_unknown);
         self.partial_cycles_runtime = self.partial_cycles_runtime.saturating_add(other.partial_cycles_runtime);

crates/replication/src/config.rs

@@ -60,9 +60,7 @@ pub const REPLICATION_READ_ONLY_HISTORICAL_FIELDS: &[&str] = &[
     "Destination.ReplicationTime",
 ];
 
-// v2: disableProxy moved from unsupported to writable (per-target read-proxy
-// opt-out is accepted by set-remote-target and the `proxy` update op).
-pub const REMOTE_TARGET_CAPABILITY_CONTRACT_VERSION: u32 = 2;
+pub const REMOTE_TARGET_CAPABILITY_CONTRACT_VERSION: u32 = 1;
 
 pub const REMOTE_TARGET_WRITABLE_FIELDS: &[&str] = &[
     "sourcebucket",
@@ -85,12 +83,9 @@ pub const REMOTE_TARGET_WRITABLE_FIELDS: &[&str] = &[
     // madmin default of 60s); the per-target health-check interval is not
     // yet applied — the heartbeat keeps its global env-configured interval.
     "healthCheckDuration",
-    // Per-target read-proxy opt-out, consumed by the proxy-target selector
-    // (contract v2; previously only importable via MinIO bucket-targets.json).
-    "disableProxy",
 ];
 
-pub const REMOTE_TARGET_UNSUPPORTED_FIELDS: &[&str] = &["edge", "edgeSyncBeforeExpiry"];
+pub const REMOTE_TARGET_UNSUPPORTED_FIELDS: &[&str] = &["disableProxy", "edge", "edgeSyncBeforeExpiry"];
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct ObjectOpts {

crates/scanner/src/data_usage_define.rs

@@ -29,8 +29,7 @@ use rustfs_config::ENV_SCANNER_CACHE_SAVE_TIMEOUT_SECS;
 pub use rustfs_data_usage::{
     AllTierStats, BucketTargetUsageInfo, BucketUsageInfo, DATA_USAGE_OBJECT_NAME, DATA_USAGE_OBSERVED_OBJECT_NAME,
     DataUsageEntry, DataUsageHash, DataUsageHashMap, DataUsageInfo, LEGACY_DATA_USAGE_OBJECT_NAME, PrefixUsageEntry,
-    PrefixUsageQuery, PrefixUsageSummary, ReplTargetSizeSummary, SizeSummary, TierStats, UNKNOWN_TIER, UnknownTierStats,
-    hash_path, prefix_usage_in_cache,
+    PrefixUsageQuery, PrefixUsageSummary, ReplTargetSizeSummary, SizeSummary, TierStats, hash_path, prefix_usage_in_cache,
 };
 use rustfs_utils::path::{SLASH_SEPARATOR, path_join_buf};
 use tokio::time::{Duration, Instant, sleep, timeout};
@@ -126,34 +125,6 @@ pub(crate) async fn read_config_with_revision<S: ScannerObjectIO>(
     }
 }
 
-/// Read only the object revision without materializing its body.
-pub(crate) async fn read_config_revision<S: ScannerObjectIO>(store: Arc<S>, path: &str) -> StorageResult<DataUsageCacheRevision> {
-    match store
-        .get_object_reader(
-            RUSTFS_META_BUCKET,
-            path,
-            None,
-            HeaderMap::new(),
-            &ObjectOptions {
-                no_lock: true,
-                ..Default::default()
-            },
-        )
-        .await
-    {
-        Ok(reader) => reader
-            .object_info
-            .etag
-            .filter(|etag| !etag.is_empty())
-            .map(DataUsageCacheRevision::Etag)
-            .ok_or_else(|| StorageError::other(format!("scanner config object {path} has no ETag"))),
-        Err(Error::FileNotFound | Error::VolumeNotFound | Error::ObjectNotFound(_, _) | Error::BucketNotFound(_)) => {
-            Ok(DataUsageCacheRevision::Missing)
-        }
-        Err(err) => Err(err),
-    }
-}
-
 #[derive(Clone, Debug)]
 pub(crate) struct DataUsageCacheRevisions {
     main: DataUsageCacheRevision,
@@ -175,11 +146,6 @@ pub static LEGACY_DATA_USAGE_OBJ_NAME_PATH: LazyLock<String> =
 pub static DATA_USAGE_BLOOM_NAME_PATH: LazyLock<String> =
     LazyLock::new(|| format!("{BUCKET_META_PREFIX}{SLASH_SEPARATOR}{DATA_USAGE_BLOOM_NAME}"));
 
-/// Durable companion object for a cycle-state object which cannot be decoded.
-/// The primary object is deliberately never replaced or deleted by recovery.
-pub static DATA_USAGE_BLOOM_RECOVERY_PATH: LazyLock<String> =
-    LazyLock::new(|| format!("{}.recovery-required.json", DATA_USAGE_BLOOM_NAME_PATH.as_str()));
-
 pub static BACKGROUND_HEAL_INFO_PATH: LazyLock<String> =
     LazyLock::new(|| format!("{BUCKET_META_PREFIX}{SLASH_SEPARATOR}.background-heal.json"));
 
@@ -206,8 +172,7 @@ impl ScannerSizeSummaryExt for SizeSummary {
             self.versions = self.versions.saturating_add(1);
         }
 
-        let logical_size = size.max(0);
-        let size = usize::try_from(logical_size).unwrap_or(usize::MAX);
+        let size = usize::try_from(size.max(0)).unwrap_or(usize::MAX);
         self.total_size = self.total_size.saturating_add(size);
 
         if oi.transitioned_object.free_version {
@@ -219,34 +184,12 @@ impl ScannerSizeSummaryExt for SizeSummary {
             tier = oi.transitioned_object.tier.clone();
         }
 
-        let builtin_tier = tier == storageclass::STANDARD || tier == storageclass::RRS;
-        let tier_registry_is_empty =
-            self.tier_stats.is_empty() || (self.tier_stats.len() == 1 && self.tier_stats.contains_key(UNKNOWN_TIER));
-        let known_tier = tier != UNKNOWN_TIER && (builtin_tier || self.tier_stats.contains_key(&tier));
-
-        // With no configured tier, retain the historical empty-map shape for
-        // ordinary STANDARD/RRS objects. A non-built-in key is still an
-        // observable unknown and must create only the fixed bucket.
-        if tier_registry_is_empty && known_tier {
-            return;
-        }
-
-        let accounting_key = if known_tier { tier.clone() } else { UNKNOWN_TIER.to_string() };
-        let tier_stats = self.tier_stats.entry(accounting_key).or_default();
-        let physical_size = u64::try_from(oi.size.max(0)).unwrap_or(0);
-        *tier_stats = tier_stats.add(&TierStats {
-            total_size: physical_size,
-            num_versions: 1,
-            num_objects: u64::from(oi.is_latest),
-        });
-        if !known_tier {
-            self.unknown_tier_stats.record_dimensions(
-                &tier,
-                u64::try_from(logical_size).unwrap_or(u64::MAX),
-                physical_size,
-                1,
-                u64::from(oi.is_latest),
-            );
+        if let Some(tier_stats) = self.tier_stats.get_mut(&tier) {
+            *tier_stats = tier_stats.add(&TierStats {
+                total_size: u64::try_from(oi.size).unwrap_or(0),
+                num_versions: 1,
+                num_objects: u64::from(oi.is_latest),
+            });
         }
     }
 }
@@ -368,10 +311,6 @@ pub struct DataUsageCacheInfo {
     pub scan_plan_digest: Option<DataUsageScanPlanDigest>,
     #[serde(default)]
     pub cache_key_format: u16,
-    /// Registry generation used for the completed/partial scan. This is
-    /// process-local audit data; older cache writers omit it.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub tier_registry_generation: Option<u64>,
 }
 
 impl Serialize for DataUsageCacheInfo {
@@ -381,7 +320,7 @@ impl Serialize for DataUsageCacheInfo {
     {
         // Keep this metadata map-encoded so older readers can ignore fields
         // appended by newer scanner versions during rolling upgrades.
-        let mut state = serializer.serialize_map(Some(17))?;
+        let mut state = serializer.serialize_map(Some(16))?;
         state.serialize_entry("name", &self.name)?;
         state.serialize_entry("next_cycle", &self.next_cycle)?;
         state.serialize_entry("leader_epoch", &self.leader_epoch)?;
@@ -398,7 +337,6 @@ impl Serialize for DataUsageCacheInfo {
         state.serialize_entry("snapshot_complete", &self.snapshot_complete)?;
         state.serialize_entry("scan_plan_digest", &self.scan_plan_digest)?;
         state.serialize_entry("cache_key_format", &self.cache_key_format)?;
-        state.serialize_entry("tier_registry_generation", &self.tier_registry_generation)?;
         state.end()
     }
 }
@@ -419,17 +357,6 @@ pub(crate) enum DataUsageCachePrepareOutcome {
 }
 
 impl DataUsageCache {
-    /// Reconcile tier keys loaded from an older cache against the registry
-    /// frozen for this scan. New metadata is already routed through
-    /// `UNKNOWN_TIER`; this pass handles retired keys that predate that rule.
-    pub(crate) fn fold_retired_tiers(&mut self, tier_names: &[String]) {
-        for entry in self.cache.values_mut() {
-            if let Some(tiers) = entry.all_tier_stats.as_mut() {
-                tiers.fold_unknown_tiers(tier_names.iter().map(String::as_str));
-            }
-        }
-    }
-
     /// Prefix-level usage query over this (writer-side) cache; see
     /// [`prefix_usage_in_cache`] for the semantics
     /// (rustfs/backlog#1872).
@@ -915,7 +842,6 @@ impl DataUsageCache {
             delete_markers_total_count: flat.delete_markers as u64,
             objects_total_size: flat.size as u64,
             tier_stats: flat.all_tier_stats.filter(|tiers| !tiers.is_empty()),
-            unknown_tier_stats: flat.unknown_tier_stats.filter(|stats| !stats.is_empty()),
             buckets_count: u64::try_from(buckets.len()).unwrap_or(u64::MAX),
             buckets_usage,
             ..Default::default()

crates/scanner/src/data_usage_define/persistence.rs

@@ -74,7 +74,7 @@ impl DataUsageCache {
         let loaded = Self::load_cache(store.clone(), name).await?;
         let backup = match loaded.backup_revision {
             Some(revision) => Some(revision),
-            None => match read_config_revision(store, &backup_path).await {
+            None => match Self::revision_for_path(store, &backup_path).await {
                 Ok(revision) => Some(revision),
                 Err(err) => {
                     counter!(METRIC_CACHE_BACKUP_REVISION_FAILURE_TOTAL).increment(1);
@@ -336,6 +336,33 @@ impl DataUsageCache {
         }
     }
 
+    async fn revision_for_path<S: ScannerObjectIO>(store: Arc<S>, path: &str) -> StorageResult<DataUsageCacheRevision> {
+        match store
+            .get_object_reader(
+                RUSTFS_META_BUCKET,
+                path,
+                None,
+                HeaderMap::new(),
+                &ObjectOptions {
+                    no_lock: true,
+                    ..Default::default()
+                },
+            )
+            .await
+        {
+            Ok(reader) => reader
+                .object_info
+                .etag
+                .filter(|etag| !etag.is_empty())
+                .map(DataUsageCacheRevision::Etag)
+                .ok_or_else(|| StorageError::other(format!("scanner cache object {path} has no ETag"))),
+            Err(Error::FileNotFound | Error::VolumeNotFound | Error::ObjectNotFound(_, _) | Error::BucketNotFound(_)) => {
+                Ok(DataUsageCacheRevision::Missing)
+            }
+            Err(err) => Err(err),
+        }
+    }
+
     pub(super) fn cache_save_timeout() -> Duration {
         crate::runtime_config::scanner_cache_save_timeout()
     }

crates/scanner/src/data_usage_define/tests.rs

@@ -16,7 +16,7 @@ use super::persistence::DataUsageCacheLoadAttempt;
 use super::*;
 use crate::storage_api::scanner_io::{HTTPRangeSpec, ObjectIO};
 use crate::{ScannerGetObjectReader, ScannerPutObjReader};
-use rustfs_data_usage::{ReplicationAllStats, ReplicationTargetUsage};
+use rustfs_data_usage::{ReplicationAllStats, ReplicationStats};
 use serde_json::Value;
 use std::io::Cursor;
 use std::pin::Pin;
@@ -573,6 +573,7 @@ fn size_summary_add_saturates_all_usage_counters() {
             failed_count: usize::MAX,
         },
     );
+
     let mut increment = SizeSummary {
         total_size: 1,
         versions: 1,
@@ -587,24 +588,6 @@ fn size_summary_add_saturates_all_usage_counters() {
         failed_count: 1,
         ..Default::default()
     };
-    summary.tier_stats.insert(
-        UNKNOWN_TIER.to_string(),
-        TierStats {
-            total_size: u64::MAX,
-            num_versions: u64::MAX,
-            num_objects: u64::MAX,
-        },
-    );
-    increment.tier_stats.insert(
-        UNKNOWN_TIER.to_string(),
-        TierStats {
-            total_size: 1,
-            num_versions: 1,
-            num_objects: 1,
-        },
-    );
-    increment.unknown_tier_stats.unknown_bytes = 1;
-    increment.unknown_tier_stats.unknown_physical_bytes = 1;
     increment.repl_target_stats.insert(
         target.clone(),
         ReplTargetSizeSummary {
@@ -641,8 +624,6 @@ fn size_summary_add_saturates_all_usage_counters() {
     assert_eq!(target_summary.failed_size, i64::MAX);
     assert_eq!(target_summary.pending_count, usize::MAX);
     assert_eq!(target_summary.failed_count, usize::MAX);
-    assert_eq!(summary.tier_stats[UNKNOWN_TIER].total_size, u64::MAX);
-    assert_eq!(summary.unknown_tier_stats.unknown_bytes, 1);
 }
 
 #[test]
@@ -692,162 +673,6 @@ fn size_summary_actions_accounting_accumulates_tier_stats() {
     );
 }
 
-#[test]
-fn unknown_tier_is_bounded_and_accounted() {
-    let mut summary = SizeSummary::new();
-    summary.tier_stats.insert("WARM".to_string(), TierStats::default());
-    let object = ObjectInfo {
-        storage_class: Some("retired-tier".to_string()),
-        size: 11,
-        is_latest: true,
-        ..Default::default()
-    };
-
-    summary.actions_accounting(&object, 11, 11);
-
-    assert_eq!(summary.tier_stats.len(), 2);
-    assert_eq!(summary.tier_stats.get(UNKNOWN_TIER).map(|stats| stats.total_size), Some(11));
-    assert_eq!(summary.unknown_tier_stats.unknown_bytes, 11);
-    assert_eq!(summary.unknown_tier_stats.unknown_physical_bytes, 11);
-    assert_eq!(summary.unknown_tier_stats.unknown_objects, 1);
-    assert!(
-        summary
-            .unknown_tier_stats
-            .diagnostics
-            .iter()
-            .all(|entry| !entry.contains("retired"))
-    );
-}
-
-#[test]
-fn unknown_tier_is_accounted_when_no_remote_tier_is_configured() {
-    let mut summary = SizeSummary::new();
-    let object = ObjectInfo {
-        storage_class: Some("retired-tier".to_string()),
-        size: 3,
-        is_latest: true,
-        ..Default::default()
-    };
-
-    summary.actions_accounting(&object, 9, 9);
-
-    assert_eq!(summary.tier_stats.len(), 1);
-    assert_eq!(summary.tier_stats[UNKNOWN_TIER].total_size, 3);
-    assert_eq!(summary.unknown_tier_stats.unknown_bytes, 9);
-    assert_eq!(summary.unknown_tier_stats.unknown_physical_bytes, 3);
-
-    let standard = ObjectInfo {
-        storage_class: Some(storageclass::STANDARD.to_string()),
-        size: 4,
-        is_latest: true,
-        ..Default::default()
-    };
-    summary.actions_accounting(&standard, 4, 4);
-    assert_eq!(summary.tier_stats.len(), 1, "built-ins preserve the no-tier map shape");
-}
-
-#[test]
-fn million_unique_tier_keys_do_not_grow_stats_map() {
-    let mut summary = SizeSummary::new();
-    summary.tier_stats.insert("WARM".to_string(), TierStats::default());
-    for index in 0..1_000_000_u64 {
-        let object = ObjectInfo {
-            storage_class: Some(format!("untrusted-tier-{index}")),
-            size: 1,
-            ..Default::default()
-        };
-        summary.actions_accounting(&object, 1, 1);
-    }
-
-    assert_eq!(summary.tier_stats.len(), 2);
-    assert_eq!(summary.tier_stats[UNKNOWN_TIER].total_size, 1_000_000);
-    assert_eq!(summary.unknown_tier_stats.unknown_bytes, 1_000_000);
-}
-
-#[test]
-fn unknown_tier_never_triggers_transition() {
-    let mut summary = SizeSummary::new();
-    summary.tier_stats.insert("WARM".to_string(), TierStats::default());
-    let mut object = ObjectInfo {
-        storage_class: Some("removed-tier".to_string()),
-        size: 7,
-        ..Default::default()
-    };
-    object.transitioned_object.status = TRANSITION_COMPLETE.to_string();
-    object.transitioned_object.tier = "removed-tier".to_string();
-
-    summary.actions_accounting(&object, 7, 7);
-
-    assert_eq!(summary.tier_stats.get("removed-tier"), None);
-    assert_eq!(summary.tier_stats[UNKNOWN_TIER].total_size, 7);
-}
-
-#[test]
-fn removed_tier_survives_restart_as_unknown() {
-    let mut summary = SizeSummary::new();
-    summary.tier_stats.insert("COLD".to_string(), TierStats::default());
-    let object = ObjectInfo {
-        storage_class: Some("retired-tier".to_string()),
-        size: 5,
-        ..Default::default()
-    };
-    summary.actions_accounting(&object, 5, 5);
-    let mut entry = DataUsageEntry::default();
-    entry.add_tier_sizes(&summary.tier_stats);
-    entry.add_unknown_tier_stats(&summary.unknown_tier_stats);
-    let encoded = rmp_serde::to_vec(&entry).expect("entry should encode");
-    let restored: DataUsageEntry = rmp_serde::from_slice(&encoded).expect("entry should decode");
-
-    assert_eq!(restored.all_tier_stats.expect("tier stats persisted").tiers[UNKNOWN_TIER].total_size, 5);
-    assert_eq!(restored.unknown_tier_stats.expect("unknown stats persisted").unknown_bytes, 5);
-}
-
-#[test]
-fn tier_registry_refresh_does_not_mix_cycle_generations() {
-    let first = crate::TierRegistrySnapshot {
-        generation: 1,
-        names: Arc::from(["WARM".to_string()]),
-        refresh_failed: false,
-    };
-    let second = crate::TierRegistrySnapshot {
-        generation: 2,
-        names: Arc::from(["COLD".to_string()]),
-        refresh_failed: false,
-    };
-    assert_ne!(first.generation, second.generation);
-    assert_eq!(first.names.as_ref(), ["WARM".to_string()]);
-    assert_eq!(second.names.as_ref(), ["COLD".to_string()]);
-    assert!(first.refreshed(Err(())).refresh_failed);
-    assert!(!second.refreshed(Ok(Arc::from(["HOT".to_string()]))).refresh_failed);
-    assert_eq!(first.refreshed(Err(())).generation, first.generation);
-    assert_eq!(first.refreshed(Err(())).names, first.names);
-}
-
-#[test]
-fn unknown_tier_counter_uses_checked_arithmetic() {
-    let max = TierStats {
-        total_size: u64::MAX,
-        num_versions: u64::MAX,
-        num_objects: u64::MAX,
-    };
-    assert!(max.checked_add(&TierStats::default()).is_some());
-    assert!(
-        max.checked_add(&TierStats {
-            total_size: 1,
-            ..Default::default()
-        })
-        .is_none()
-    );
-
-    let mut unknown = UnknownTierStats {
-        unknown_bytes: u64::MAX,
-        ..Default::default()
-    };
-    unknown.record("overflow", 1, 1, 1);
-    assert_eq!(unknown.unknown_bytes, u64::MAX);
-    assert_eq!(unknown.unknown_objects, 1);
-}
-
 #[test]
 fn test_data_usage_entry_merge_sums_failed_objects() {
     let mut left = DataUsageEntry {
@@ -1101,7 +926,7 @@ const USAGE_CACHE_WIRE_FIXTURE: &[u8] = &[
     0xdc, 0x00, 0x20, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
     0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0xb0, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f,
     0x6b, 0x65, 0x79, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x01, 0x81, 0xab, 0x77, 0x69, 0x72, 0x65, 0x2d, 0x62, 0x75, 0x63,
-    0x6b, 0x65, 0x74, 0x8c, 0xa8, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x90, 0xa4, 0x73, 0x69, 0x7a, 0x65, 0xcd, 0x10,
+    0x6b, 0x65, 0x74, 0x8b, 0xa8, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x90, 0xa4, 0x73, 0x69, 0x7a, 0x65, 0xcd, 0x10,
     0x00, 0xa7, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x03, 0xa8, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x05, 0xae,
     0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x01, 0xa9, 0x6f, 0x62, 0x6a, 0x5f, 0x73,
     0x69, 0x7a, 0x65, 0x73, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xac, 0x6f, 0x62, 0x6a, 0x5f,
@@ -1109,8 +934,7 @@ const USAGE_CACHE_WIRE_FIXTURE: &[u8] = &[
     0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0xc0, 0xa9, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63,
     0x74, 0x65, 0x64, 0xc3, 0xae, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x02, 0xae,
     0x61, 0x6c, 0x6c, 0x5f, 0x74, 0x69, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x91, 0x81, 0xa4, 0x57, 0x41, 0x52, 0x4d,
-    0x93, 0xcd, 0x08, 0x00, 0x02, 0x01, 0xb2, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x5f, 0x74, 0x69, 0x65, 0x72, 0x5f, 0x73,
-    0x74, 0x61, 0x74, 0x73, 0xc0,
+    0x93, 0xcd, 0x08, 0x00, 0x02, 0x01,
 ];
 
 #[test]
@@ -1812,7 +1636,7 @@ fn size_recursive_prunes_empty_and_preserves_threshold_replication_stats() {
             replication_stats: Some(ReplicationAllStats {
                 targets: HashMap::from([(
                     "arn:test:threshold".to_string(),
-                    ReplicationTargetUsage {
+                    ReplicationStats {
                         after_threshold_count: 1,
                         ..Default::default()
                     },

crates/scanner/src/lib.rs

@@ -75,10 +75,7 @@ pub use remote_scanner::{
 };
 pub use runtime_config::{apply_scanner_runtime_config, scanner_runtime_config_status, validate_scanner_runtime_config};
 pub use rustfs_common::last_minute;
-pub use scanner::{
-    ScannerCycleRecoveryMarker, ScannerCycleRecoveryStatus, ScannerCycleScheduleStatus, init_data_scanner,
-    reset_scanner_cycle_recovery, scanner_cycle_recovery_status, scanner_cycle_schedule_status, scanner_topology_digest,
-};
+pub use scanner::{ScannerCycleScheduleStatus, init_data_scanner, scanner_cycle_schedule_status, scanner_topology_digest};
 pub use scanner_io::{
     ScannerDirtyUsageAckError, ScannerDirtyUsageState, acknowledge_dirty_usage_generation, clear_dirty_usage_bucket,
     record_dirty_usage_bucket, record_scanner_maintenance_change, scanner_activity_epoch, scanner_dirty_usage_state,
@@ -94,45 +91,6 @@ static SCANNER_RUNTIME_INSTANCES: AtomicU64 = AtomicU64::new(0);
 static SCANNER_FOREGROUND_READ_ACTIVITY: AtomicU64 = AtomicU64::new(0);
 static SCANNER_FOREGROUND_STREAM_READS: AtomicU64 = AtomicU64::new(0);
 
-/// Immutable tier registry captured at the beginning of a folder scan.
-/// Generation makes it possible to prove that a result was classified against
-/// one registry even when the process-wide TTL cache refreshes concurrently.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct TierRegistrySnapshot {
-    pub(crate) generation: u64,
-    pub(crate) names: Arc<[String]>,
-    /// True when the last refresh attempt failed and `names` is therefore a
-    /// retained last-good snapshot rather than a newly read registry.
-    pub(crate) refresh_failed: bool,
-}
-
-impl TierRegistrySnapshot {
-    /// Apply a refresh only when the registry read succeeds. A failed refresh
-    /// retains the prior generation, preventing a transient config failure
-    /// from classifying the remainder of a scan against an empty registry.
-    pub(crate) fn refreshed(&self, names: Result<Arc<[String]>, ()>) -> Self {
-        match names {
-            Ok(names) => Self {
-                generation: self.generation.saturating_add(1),
-                names,
-                refresh_failed: false,
-            },
-            Err(()) => Self {
-                refresh_failed: true,
-                ..self.clone()
-            },
-        }
-    }
-
-    pub(crate) fn initial(names: Arc<[String]>) -> Self {
-        Self {
-            generation: 1,
-            names,
-            refresh_failed: false,
-        }
-    }
-}
-
 pub fn current_scanner_activity() -> u64 {
     SCANNER_ACTIVE_WORK_UNITS.load(Ordering::Relaxed)
 }
@@ -422,48 +380,24 @@ const TIER_NAME_CACHE_TTL: Duration = Duration::from_secs(30);
 /// `TIER_NAME_CACHE_TTL` later; a removed tier can leave an all-zero
 /// `TierStats` seed behind for one cache generation, which merges harmlessly
 /// by key in per-object accounting and disappears on the next refresh.
-static TIER_NAME_CACHE: RwLock<Option<(Instant, TierRegistrySnapshot)>> = RwLock::new(None);
-static TIER_REGISTRY_GENERATION: AtomicU64 = AtomicU64::new(0);
+static TIER_NAME_CACHE: RwLock<Option<(Instant, Arc<[String]>)>> = RwLock::new(None);
 
-/// Return one immutable registry snapshot for a scanner unit of work.
-pub(crate) async fn runtime_tier_registry() -> TierRegistrySnapshot {
+/// Tier names currently registered in the tier configuration, cached for
+/// `TIER_NAME_CACHE_TTL`.
+pub(crate) async fn runtime_tier_names() -> Arc<[String]> {
     {
         let cached = TIER_NAME_CACHE.read().unwrap_or_else(|err| err.into_inner()).clone();
-        if let Some((refreshed_at, snapshot)) = cached
+        if let Some((refreshed_at, names)) = cached
             && refreshed_at.elapsed() < TIER_NAME_CACHE_TTL
         {
-            return snapshot;
+            return names;
         }
     }
 
     let tiers = ecstore_get_global_tier_config_mgr().read().await.list_tiers();
     let names: Arc<[String]> = tiers.iter().map(|tier| tier.name.clone()).collect::<Vec<_>>().into();
-    let previous = TIER_NAME_CACHE
-        .read()
-        .unwrap_or_else(|err| err.into_inner())
-        .as_ref()
-        .map(|(_, snapshot)| snapshot.clone());
-    let snapshot = previous
-        .as_ref()
-        .map(|snapshot| {
-            let refreshed = snapshot.refreshed(Ok(Arc::clone(&names)));
-            TierRegistrySnapshot {
-                generation: TIER_REGISTRY_GENERATION.fetch_add(1, Ordering::Relaxed).saturating_add(1),
-                ..refreshed
-            }
-        })
-        .unwrap_or_else(|| TierRegistrySnapshot {
-            generation: TIER_REGISTRY_GENERATION.fetch_add(1, Ordering::Relaxed).saturating_add(1),
-            ..TierRegistrySnapshot::initial(names)
-        });
-    *TIER_NAME_CACHE.write().unwrap_or_else(|err| err.into_inner()) = Some((Instant::now(), snapshot.clone()));
-    snapshot
-}
-
-/// Tier names currently registered in the tier configuration, cached for
-/// `TIER_NAME_CACHE_TTL`.
-pub(crate) async fn runtime_tier_names() -> Arc<[String]> {
-    runtime_tier_registry().await.names
+    *TIER_NAME_CACHE.write().unwrap_or_else(|err| err.into_inner()) = Some((Instant::now(), Arc::clone(&names)));
+    names
 }
 
 /// Test-only cache reset; the production cache has no invalidation hook

crates/scanner/src/runtime_config.rs

@@ -125,10 +125,7 @@ impl Default for ScannerRuntimeConfig {
             cycle_interval_source: ScannerRuntimeConfigSource::Default,
             bitrot_cycle: Some(Duration::from_secs(DEFAULT_HEAL_BITROT_CYCLE_SECS)),
             bitrot_cycle_source: ScannerRuntimeConfigSource::Default,
-            cycle_budget: ScannerCycleBudgetConfig {
-                max_duration: Some(Duration::from_secs(DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS)),
-                ..Default::default()
-            },
+            cycle_budget: ScannerCycleBudgetConfig::default(),
             cycle_max_duration_source: ScannerRuntimeConfigSource::Default,
             cycle_max_objects_source: ScannerRuntimeConfigSource::Default,
             cycle_max_directories_source: ScannerRuntimeConfigSource::Default,
@@ -377,10 +374,7 @@ fn validate_persisted_scanner_runtime_config(config: &ServerConfig) -> Result<()
     }
     validate_optional_config_u64(scanner_kvs, SCANNER_START_DELAY, "")?;
     validate_optional_config_u64(scanner_kvs, SCANNER_CYCLE, "")?;
-    if let Some(value) = config_value(scanner_kvs, SCANNER_CYCLE_MAX_DURATION, DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS) {
-        let secs = parse_config_u64(SCANNER_CYCLE_MAX_DURATION, value)?;
-        cycle_duration_from_secs(SCANNER_CYCLE_MAX_DURATION, secs)?;
-    }
+    validate_optional_config_u64(scanner_kvs, SCANNER_CYCLE_MAX_DURATION, DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS)?;
     validate_optional_config_u64(scanner_kvs, SCANNER_CYCLE_MAX_OBJECTS, DEFAULT_SCANNER_CYCLE_MAX_OBJECTS)?;
     validate_optional_config_u64(scanner_kvs, SCANNER_CYCLE_MAX_DIRECTORIES, DEFAULT_SCANNER_CYCLE_MAX_DIRECTORIES)?;
     if let Some(value) = config_value(heal_kvs, HEAL_BITROT_CYCLE, DEFAULT_HEAL_BITROT_CYCLE_SECS) {
@@ -442,46 +436,19 @@ fn lookup_max_wait(
     Ok((speed.max_sleep(), speed_source))
 }
 
-fn lookup_cycle_duration(kvs: Option<&KVS>) -> Result<(Option<Duration>, ScannerRuntimeConfigSource), ScannerRuntimeConfigError> {
-    match rustfs_utils::get_env_parse_outcome::<u64>(ENV_SCANNER_CYCLE_MAX_DURATION_SECS) {
-        rustfs_utils::EnvParseOutcome::Parsed(secs) => {
-            return cycle_duration_from_secs(ENV_SCANNER_CYCLE_MAX_DURATION_SECS, secs)
-                .map(|duration| (duration, ScannerRuntimeConfigSource::Env));
-        }
-        rustfs_utils::EnvParseOutcome::Invalid => {
-            // Do not include the raw environment value in the typed error:
-            // deployments occasionally put sensitive material in inherited
-            // environment snapshots. The key still identifies the control.
-            return Err(invalid_value(
-                ENV_SCANNER_CYCLE_MAX_DURATION_SECS,
-                "<invalid>",
-                "expected unsigned integer seconds",
-            ));
-        }
-        rustfs_utils::EnvParseOutcome::Absent => {}
+fn lookup_optional_seconds(
+    kvs: Option<&KVS>,
+    key: &'static str,
+    env_key: &'static str,
+    default: u64,
+) -> Result<(Option<Duration>, ScannerRuntimeConfigSource), ScannerRuntimeConfigError> {
+    if let Some(secs) = rustfs_utils::get_env_opt_u64(env_key) {
+        return Ok((Some(Duration::from_secs(secs)), ScannerRuntimeConfigSource::Env));
     }
-
-    if let Some(value) = config_value(kvs, SCANNER_CYCLE_MAX_DURATION, DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS) {
-        let secs = parse_config_u64(SCANNER_CYCLE_MAX_DURATION, value)?;
-        return cycle_duration_from_secs(SCANNER_CYCLE_MAX_DURATION, secs)
-            .map(|duration| (duration, ScannerRuntimeConfigSource::Config));
+    if let Some(value) = config_value(kvs, key, default) {
+        return parse_config_u64(key, value).map(|secs| (Some(Duration::from_secs(secs)), ScannerRuntimeConfigSource::Config));
     }
-
-    Ok((
-        Some(Duration::from_secs(DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS)),
-        ScannerRuntimeConfigSource::Default,
-    ))
-}
-
-fn cycle_duration_from_secs(key: &'static str, secs: u64) -> Result<Option<Duration>, ScannerRuntimeConfigError> {
-    if secs == 0 {
-        return Ok(None);
-    }
-    let duration = Duration::from_secs(secs);
-    if std::time::Instant::now().checked_add(duration).is_none() {
-        return Err(invalid_value(key, "<overflow>", "duration exceeds the timer range"));
-    }
-    Ok(Some(duration))
+    Ok((None, ScannerRuntimeConfigSource::Default))
 }
 
 fn lookup_start_delay(kvs: Option<&KVS>) -> Result<(Option<Duration>, ScannerRuntimeConfigSource), ScannerRuntimeConfigError> {
@@ -586,7 +553,12 @@ pub(crate) fn lookup_scanner_runtime_config(
         (speed.cycle_interval(), speed_source)
     };
 
-    let (cycle_max_duration, cycle_max_duration_source) = lookup_cycle_duration(scanner_kvs)?;
+    let (cycle_max_duration, cycle_max_duration_source) = lookup_optional_seconds(
+        scanner_kvs,
+        SCANNER_CYCLE_MAX_DURATION,
+        ENV_SCANNER_CYCLE_MAX_DURATION_SECS,
+        DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS,
+    )?;
     let (cycle_max_objects, cycle_max_objects_source) = lookup_count_budget(
         scanner_kvs,
         SCANNER_CYCLE_MAX_OBJECTS,
@@ -891,10 +863,10 @@ mod tests {
     use rustfs_config::server_config::{Config as ServerConfig, KVS};
     use rustfs_config::{
         DEFAULT_DELIMITER, DEFAULT_HEAL_BITROT_CYCLE_SECS, ENV_SCANNER_BITROT_CYCLE_SECS, ENV_SCANNER_CACHE_SAVE_TIMEOUT_SECS,
-        ENV_SCANNER_CYCLE, ENV_SCANNER_CYCLE_MAX_DURATION_SECS, ENV_SCANNER_CYCLE_MAX_OBJECTS, ENV_SCANNER_DELAY,
-        ENV_SCANNER_MAX_WAIT_SECS, ENV_SCANNER_SPEED, HEAL_BITROT_CYCLE, HEAL_SUB_SYS, SCANNER_BITROT_CYCLE,
-        SCANNER_CACHE_SAVE_TIMEOUT, SCANNER_CYCLE, SCANNER_CYCLE_MAX_DIRECTORIES, SCANNER_CYCLE_MAX_DURATION,
-        SCANNER_CYCLE_MAX_OBJECTS, SCANNER_DELAY, SCANNER_IDLE_MODE, SCANNER_SPEED, SCANNER_SUB_SYS, ScannerSpeed,
+        ENV_SCANNER_CYCLE, ENV_SCANNER_CYCLE_MAX_OBJECTS, ENV_SCANNER_DELAY, ENV_SCANNER_MAX_WAIT_SECS, ENV_SCANNER_SPEED,
+        HEAL_BITROT_CYCLE, HEAL_SUB_SYS, SCANNER_BITROT_CYCLE, SCANNER_CACHE_SAVE_TIMEOUT, SCANNER_CYCLE,
+        SCANNER_CYCLE_MAX_DIRECTORIES, SCANNER_CYCLE_MAX_DURATION, SCANNER_CYCLE_MAX_OBJECTS, SCANNER_DELAY, SCANNER_IDLE_MODE,
+        SCANNER_SPEED, SCANNER_SUB_SYS, ScannerSpeed,
     };
     use std::collections::HashMap;
     use std::time::Duration;
@@ -969,50 +941,6 @@ mod tests {
         });
     }
 
-    #[test]
-    fn scanner_unset_budget_uses_safe_default_but_explicit_zero_is_unbounded() {
-        let config = server_config_with_scanner(&[]);
-        with_var_unset(ENV_SCANNER_CYCLE_MAX_DURATION_SECS, || {
-            let resolved = lookup_scanner_runtime_config(Some(&config)).expect("scanner runtime config");
-            assert_eq!(resolved.cycle_budget.max_duration, Some(Duration::from_secs(1800)));
-            assert_eq!(resolved.cycle_max_duration_source, ScannerRuntimeConfigSource::Default);
-        });
-
-        let config = server_config_with_scanner(&[(SCANNER_CYCLE_MAX_DURATION, "0")]);
-        with_var_unset(ENV_SCANNER_CYCLE_MAX_DURATION_SECS, || {
-            let resolved = lookup_scanner_runtime_config(Some(&config)).expect("scanner runtime config");
-            assert_eq!(resolved.cycle_budget.max_duration, None);
-            assert_eq!(resolved.cycle_max_duration_source, ScannerRuntimeConfigSource::Config);
-        });
-    }
-
-    #[test]
-    fn cycle_budget_invalid_or_overflow_config_is_rejected() {
-        with_var(ENV_SCANNER_CYCLE_MAX_DURATION_SECS, Some("invalid"), || {
-            let error = lookup_scanner_runtime_config(None).expect_err("invalid duration env must be rejected");
-            assert!(error.to_string().contains(ENV_SCANNER_CYCLE_MAX_DURATION_SECS));
-            assert!(error.to_string().contains("<invalid>"));
-            assert!(!error.to_string().contains(": invalid ("));
-        });
-        with_var(ENV_SCANNER_CYCLE_MAX_DURATION_SECS, Some("18446744073709551616"), || {
-            assert!(lookup_scanner_runtime_config(None).is_err());
-        });
-        with_var(ENV_SCANNER_CYCLE_MAX_DURATION_SECS, Some("18446744073709551615"), || {
-            assert!(lookup_scanner_runtime_config(None).is_err());
-        });
-        let config = server_config_with_scanner(&[(SCANNER_CYCLE_MAX_DURATION, "not-a-duration")]);
-        assert!(lookup_scanner_runtime_config(Some(&config)).is_err());
-    }
-
-    #[test]
-    fn scanner_runtime_config_validation_rejects_overflow_persisted_duration() {
-        let config = server_config_with_scanner(&[(SCANNER_CYCLE_MAX_DURATION, "18446744073709551615")]);
-
-        let error = validate_scanner_runtime_config(&config)
-            .expect_err("persisted duration that exceeds the timer range must be rejected");
-        assert!(error.to_string().contains(SCANNER_CYCLE_MAX_DURATION));
-    }
-
     #[test]
     fn scanner_runtime_config_normalizes_persisted_default_speed() {
         let config = server_config_with_scanner(&[(SCANNER_SPEED, "default")]);

crates/scanner/src/scanner.rs

@@ -20,7 +20,7 @@ use std::sync::{Arc, LazyLock, RwLock};
 
 use crate::data_usage_define::{
     BACKGROUND_HEAL_INFO_PATH, DATA_USAGE_BLOOM_NAME_PATH, DATA_USAGE_OBJ_NAME_PATH, DATA_USAGE_OBSERVED_OBJ_NAME_PATH,
-    DataUsageCache, DataUsageCacheRevision, LEGACY_DATA_USAGE_OBJ_NAME_PATH, read_config_revision, read_config_with_revision,
+    DataUsageCache, DataUsageCacheRevision, LEGACY_DATA_USAGE_OBJ_NAME_PATH, read_config_with_revision,
 };
 use crate::runtime_config::{
     ScannerRuntimeConfig, ScannerRuntimeConfigSource, refresh_scanner_runtime_config_from_global, scanner_bitrot_cycle,
@@ -52,10 +52,11 @@ use rustfs_config::{
 };
 use rustfs_config::{ENV_SCANNER_CYCLE, ENV_SCANNER_SPEED, ENV_SCANNER_START_DELAY_SECS};
 use rustfs_data_usage::observed_data_usage_is_newer;
-use rustfs_lock::NamespaceLockGuard;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest as _, Sha256};
-use tokio::sync::{Notify, mpsc};
+#[cfg(test)]
+use tokio::sync::Notify;
+use tokio::sync::mpsc;
 use tokio::time::{Duration, Instant};
 use tokio_util::sync::CancellationToken;
 use tokio_util::task::AbortOnDropHandle;
@@ -103,13 +104,6 @@ const CLEAN_IDLE_BACKOFF_FACTOR: u32 = 2;
 /// unavailable peer cannot drive a tight retry loop.
 const SCANNER_RETRY_BASE_INTERVAL: Duration = Duration::from_secs(5);
 const SCANNER_RETRY_MAX_INTERVAL: Duration = Duration::from_secs(30 * 60);
-/// A transient backend outage remains self-healing after the short retry
-/// budget is exhausted, but the probe is intentionally sparse until storage
-/// recovers or an operator reset wakes the scanner.
-const SCANNER_CYCLE_RECOVERY_PAUSED_INTERVAL: Duration = Duration::from_secs(5 * 60);
-/// Permanent recovery states still get a sparse status probe so a reset that
-/// races the wait registration cannot leave the scanner asleep forever.
-const SCANNER_CYCLE_RECOVERY_BLOCKED_PROBE_INTERVAL: Duration = Duration::from_secs(5 * 60);
 const SCANNER_LEADER_LOCK_POLL_INTERVAL: Duration = Duration::from_secs(1);
 #[cfg(not(test))]
 const SCANNER_LOCK_LOSS_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(30);
@@ -131,12 +125,6 @@ type ScannerCycleStatePersistTestHook = (u64, Arc<Notify>);
 static SCANNER_CYCLE_STATE_PERSIST_TEST_HOOK: LazyLock<StdMutex<Option<ScannerCycleStatePersistTestHook>>> =
     LazyLock::new(|| StdMutex::new(None));
 
-static SCANNER_CYCLE_RECOVERY_WAKE: LazyLock<Notify> = LazyLock::new(Notify::new);
-
-pub(super) fn notify_scanner_cycle_recovery_wake() {
-    SCANNER_CYCLE_RECOVERY_WAKE.notify_one();
-}
-
 #[cfg(test)]
 struct ScannerCycleStatePersistTestHookGuard;
 
@@ -588,21 +576,19 @@ pub async fn init_data_scanner(ctx: CancellationToken, storeapi: Arc<ECStore>) {
             tokio::time::sleep(sleep_time).await;
         }
 
-        let mut transient_backoff = ScannerRetryBackoff::default();
-        let mut recovery_retry_count = 0_u32;
         loop {
             if ctx_clone.is_cancelled() {
                 break;
             }
 
-            let run_result = run_data_scanner_with_maintenance_state(
+            if let Err(e) = run_data_scanner_with_maintenance_state(
                 ctx_clone.clone(),
                 storeapi_clone.clone(),
                 startup_features,
                 startup_maintenance_generation,
             )
-            .await;
-            if let Err(e) = &run_result {
+            .await
+            {
                 error!(
                     target: "rustfs::scanner",
                     event = EVENT_SCANNER_CYCLE_STATE,
@@ -613,52 +599,11 @@ pub async fn init_data_scanner(ctx: CancellationToken, storeapi: Arc<ECStore>) {
                     "Scanner runtime iteration failed"
                 );
             }
-            let recovery_status = scanner_cycle_recovery_status();
-            if recovery_status.retryable {
-                recovery_retry_count = recovery_retry_count.saturating_add(1);
-                let _ = record_scanner_cycle_recovery_retry(recovery_retry_count);
-            } else {
-                recovery_retry_count = 0;
-            }
-
-            let recovery_status = scanner_cycle_recovery_status();
-            if recovery_status.state == "paused" {
-                transient_backoff.record_retryable_cycle(false);
-                tokio::select! {
-                    _ = ctx_clone.cancelled() => break,
-                    _ = SCANNER_CYCLE_RECOVERY_WAKE.notified() => {},
-                    _ = tokio::time::sleep(SCANNER_CYCLE_RECOVERY_PAUSED_INTERVAL) => {},
-                }
-                recovery_retry_count = 0;
-                continue;
-            }
-            if !recovery_status.retryable
-                && matches!(recovery_status.state.as_str(), "blocked" | "recovery-required" | "cleanup-pending")
-            {
-                transient_backoff.record_retryable_cycle(false);
-                tokio::select! {
-                    _ = ctx_clone.cancelled() => break,
-                    _ = SCANNER_CYCLE_RECOVERY_WAKE.notified() => {},
-                    _ = tokio::time::sleep(SCANNER_CYCLE_RECOVERY_BLOCKED_PROBE_INTERVAL) => {},
-                }
-                continue;
-            }
-
-            let retry_delay = if recovery_status.retryable || run_result.is_err() {
-                transient_backoff.record_retryable_cycle(true);
-                transient_backoff
-                    .retry_interval(scanner_cycle_interval())
-                    .unwrap_or(SCANNER_RETRY_BASE_INTERVAL)
-            } else {
-                transient_backoff.record_retryable_cycle(false);
-                randomized_cycle_delay()
-            };
             // Backoff before retrying after lock contention or scanner-level failures.
             // Keep this cancellation-aware so shutdown is not delayed by backoff sleep.
             tokio::select! {
                 _ = ctx_clone.cancelled() => break,
-                _ = SCANNER_CYCLE_RECOVERY_WAKE.notified() => {},
-                _ = tokio::time::sleep(retry_delay) => {}
+                _ = tokio::time::sleep(randomized_cycle_delay()) => {}
             }
         }
     });
@@ -1038,116 +983,20 @@ fn data_usage_persist_timeout() -> Duration {
     DataUsageCache::persistence_timeout()
 }
 
-#[cfg(not(test))]
-const SCANNER_CYCLE_EPOCH_FENCE_TIMEOUT: Duration = Duration::from_secs(30);
-#[cfg(test)]
-const SCANNER_CYCLE_EPOCH_FENCE_TIMEOUT: Duration = Duration::from_millis(50);
-
-async fn fence_scanner_epoch_after_cycle_timeout<Store, LockLost>(
-    ctx: &CancellationToken,
-    storeapi: Arc<Store>,
-    cycle_info: &mut CurrentCycle,
-    cycle_revision: &mut DataUsageCacheRevision,
-    leader_epoch: &mut u64,
-    lock_lost: LockLost,
-) -> bool
-where
-    Store: ScannerObjectIO,
-    LockLost: Future<Output = ()>,
-{
-    let fence_ctx = ctx.child_token();
-    let claim = claim_scanner_leadership(&fence_ctx, storeapi, cycle_info, cycle_revision, leader_epoch);
-    tokio::pin!(claim);
-    tokio::pin!(lock_lost);
-    tokio::select! {
-        biased;
-        _ = &mut lock_lost => {
-            fence_ctx.cancel();
-            false
-        }
-        result = tokio::time::timeout(SCANNER_CYCLE_EPOCH_FENCE_TIMEOUT, &mut claim) => {
-            result.unwrap_or(false) && !fence_ctx.is_cancelled()
-        }
-    }
-}
-
-struct ScannerCycleDeadlineState<'a> {
-    cycle_info: &'a mut CurrentCycle,
-    cycle_revision: &'a mut DataUsageCacheRevision,
-    leader_epoch: &'a mut u64,
-    cycle_budget: &'a ScannerCycleBudget,
-}
-
-fn cycle_timeout_requires_recovery(worker_stopped: bool, cycle_state_persisted: bool, generation_fenced: bool) -> bool {
-    !worker_stopped || !cycle_state_persisted || !generation_fenced
-}
-
-async fn handle_scanner_cycle_deadline<Store>(
-    ctx: &CancellationToken,
-    storeapi: Arc<Store>,
-    state: ScannerCycleDeadlineState<'_>,
-    worker_stopped: bool,
-    guard: &mut NamespaceLockGuard,
-) where
-    Store: ScannerObjectIO,
-{
-    let fenced = fence_scanner_epoch_after_cycle_timeout(
-        ctx,
-        storeapi,
-        state.cycle_info,
-        state.cycle_revision,
-        state.leader_epoch,
-        guard.lock_lost_notified(),
-    )
-    .await;
-    let cycle_state_persisted = state.cycle_budget.cycle_state_persisted();
-    let recovery_required = cycle_timeout_requires_recovery(worker_stopped, cycle_state_persisted, fenced);
-    warn!(
-        target: "rustfs::scanner",
-        event = EVENT_SCANNER_CYCLE_STATE,
-        component = LOG_COMPONENT_SCANNER,
-        subsystem = LOG_SUBSYSTEM_RUNTIME,
-        state = "cycle_timeout",
-        worker_stopped,
-        cycle_state_persisted,
-        generation_fenced = fenced,
-        recovery_required,
-        "Scanner cycle deadline expired; durable cursor/generation fencing completed when possible"
-    );
-    global_metrics().record_scanner_cycle_timeout(recovery_required, state.cycle_budget.progress_age());
-    // Stop renewing before releasing the lease. A new leader can then claim the
-    // higher persisted generation instead of inheriting the expired worker.
-    guard.release();
-    global_metrics().set_cycle(None).await;
-}
-
 async fn mark_scan_cycle_idle(cycle_info: &mut CurrentCycle, cycle_metrics_guard: &mut ScannerCycleMetricsGuard) {
     cycle_info.current = 0;
     global_metrics().clear_current_scan_mode();
     cycle_metrics_guard.finish(cycle_info.clone()).await;
 }
 
-#[cfg(test)]
+#[instrument(skip_all)]
+#[hotpath::measure]
 async fn run_data_scanner_cycle(
     ctx: &CancellationToken,
     storeapi: &Arc<ECStore>,
     cycle_info: &mut CurrentCycle,
     cycle_revision: &mut DataUsageCacheRevision,
     leader_epoch: u64,
-) -> ScannerCycleOutcome {
-    let cycle_budget = ScannerCycleBudget::new(ctx, scanner_cycle_budget_config());
-    run_data_scanner_cycle_with_budget(ctx, storeapi, cycle_info, cycle_revision, leader_epoch, cycle_budget).await
-}
-
-#[instrument(skip_all)]
-#[hotpath::measure]
-async fn run_data_scanner_cycle_with_budget(
-    ctx: &CancellationToken,
-    storeapi: &Arc<ECStore>,
-    cycle_info: &mut CurrentCycle,
-    cycle_revision: &mut DataUsageCacheRevision,
-    leader_epoch: u64,
-    cycle_budget: Arc<ScannerCycleBudget>,
 ) -> ScannerCycleOutcome {
     let _activity_guard = ScannerActivityGuard::new();
     if let Err(err) = refresh_scanner_runtime_config_from_global() {
@@ -1163,11 +1012,7 @@ async fn run_data_scanner_cycle_with_budget(
     }
     let configured_cycle_interval = scanner_cycle_interval();
     let configured_bitrot_cycle = scanner_bitrot_cycle();
-    let cycle_budget_config = ScannerCycleBudgetConfig {
-        max_duration: cycle_budget.max_duration(),
-        max_objects: cycle_budget.max_objects(),
-        max_directories: cycle_budget.max_directories(),
-    };
+    let cycle_budget_config = scanner_cycle_budget_config();
     let usage_persist_timeout = data_usage_persist_timeout();
     global_metrics().record_scanner_cycle_config(
         configured_cycle_interval,
@@ -1238,6 +1083,7 @@ async fn run_data_scanner_cycle_with_budget(
     let (sender, receiver) = mpsc::channel::<DataUsageInfo>(1);
 
     let done_cycle = Metrics::time(Metric::ScanCycle);
+    let cycle_budget = ScannerCycleBudget::new(ctx, cycle_budget_config);
     let scan_result = storeapi
         .clone()
         .nsscanner_with_status(
@@ -1377,7 +1223,7 @@ async fn run_data_scanner_cycle_with_budget(
                 "Scanner cycle is recovering to a newer durable cache generation"
             );
             emit_scan_cycle_partial_with_source(cycle_start.elapsed(), ScanCyclePartialReason::Unknown, None);
-            let persisted = persist_required_scanner_cycle_floor(
+            return if persist_required_scanner_cycle_floor(
                 ctx,
                 storeapi.clone(),
                 cycle_info,
@@ -1386,9 +1232,8 @@ async fn run_data_scanner_cycle_with_budget(
                 required_cycle,
                 &mut cycle_metrics_guard,
             )
-            .await;
-            return if persisted {
-                cycle_budget.mark_cycle_state_persisted();
+            .await
+            {
                 ScannerCycleOutcome::Partial
             } else {
                 ScannerCycleOutcome::Failed
@@ -1446,7 +1291,7 @@ async fn run_data_scanner_cycle_with_budget(
             scan_cycle_partial_reason(budget_reason),
             scan_cycle_partial_source(budget_reason),
         );
-        let persisted = finalize_partial_scan_cycle(
+        return if finalize_partial_scan_cycle(
             ctx,
             storeapi.clone(),
             cycle_info,
@@ -1454,9 +1299,8 @@ async fn run_data_scanner_cycle_with_budget(
             leader_epoch,
             &mut cycle_metrics_guard,
         )
-        .await;
-        return if persisted {
-            cycle_budget.mark_cycle_state_persisted();
+        .await
+        {
             ScannerCycleOutcome::Partial
         } else {
             ScannerCycleOutcome::Failed
@@ -1531,7 +1375,7 @@ async fn run_data_scanner_cycle_with_budget(
                 );
             }
             emit_scan_cycle_partial_with_source(cycle_start.elapsed(), ScanCyclePartialReason::Unknown, None);
-            let persisted = finalize_partial_scan_cycle(
+            return if finalize_partial_scan_cycle(
                 ctx,
                 storeapi.clone(),
                 cycle_info,
@@ -1539,9 +1383,8 @@ async fn run_data_scanner_cycle_with_budget(
                 leader_epoch,
                 &mut cycle_metrics_guard,
             )
-            .await;
-            return if persisted {
-                cycle_budget.mark_cycle_state_persisted();
+            .await
+            {
                 ScannerCycleOutcome::Partial
             } else {
                 ScannerCycleOutcome::Failed
@@ -1582,7 +1425,6 @@ async fn run_data_scanner_cycle_with_budget(
             )
             .await
             {
-                cycle_budget.mark_cycle_state_persisted();
                 emit_scan_cycle_superseded(cycle_start.elapsed());
                 return ScannerCycleOutcome::Superseded;
             }
@@ -1615,7 +1457,6 @@ async fn run_data_scanner_cycle_with_budget(
         emit_scan_cycle_complete(false, cycle_start.elapsed());
         return ScannerCycleOutcome::Failed;
     }
-    cycle_budget.mark_cycle_state_persisted();
 
     done_cycle();
     emit_scan_cycle_complete(true, cycle_start.elapsed());
@@ -1680,7 +1521,7 @@ async fn run_data_scanner_with_maintenance_state(
 ) -> Result<(), ScannerError> {
     reset_scanner_cycle_schedule();
     // Acquire leader lock (write lock) to ensure only one scanner runs
-    let mut guard = match storeapi.new_ns_lock(RUSTFS_META_BUCKET, "leader.lock").await {
+    let guard = match storeapi.new_ns_lock(RUSTFS_META_BUCKET, "leader.lock").await {
         Ok(ns_lock) => match ns_lock.get_write_lock_quiet(get_lock_acquire_timeout()).await {
             Ok(guard) => {
                 record_scanner_leader_lock_state("acquired");
@@ -1765,22 +1606,40 @@ async fn run_data_scanner_with_maintenance_state(
         observe_scanner_activity(&storeapi, distributed, &mut scanner_activity_seen).await;
     }
 
-    let (mut cycle_info, mut leader_epoch, mut cycle_revision) =
-        match load_scanner_cycle_state_for_startup(storeapi.clone()).await {
-            ScannerCycleStateStartup::Ready {
-                cycle,
-                leader_epoch,
-                revision,
-            } => (cycle, leader_epoch, revision),
-            ScannerCycleStateStartup::Blocked => {
-                global_metrics().set_cycle(None).await;
-                return Ok(());
-            }
-            ScannerCycleStateStartup::Transient(err) => {
-                global_metrics().set_cycle(None).await;
-                return Err(err);
-            }
-        };
+    let (buf, mut cycle_revision) = match read_config_with_revision(storeapi.clone(), DATA_USAGE_BLOOM_NAME_PATH.as_str()).await {
+        Ok((buf, revision)) => (buf.unwrap_or_default(), revision),
+        Err(err) => {
+            error!(
+                target: "rustfs::scanner",
+                event = EVENT_SCANNER_PERSIST_STATE,
+                component = LOG_COMPONENT_SCANNER,
+                subsystem = LOG_SUBSYSTEM_RUNTIME,
+                path = %&*DATA_USAGE_BLOOM_NAME_PATH,
+                state = "revision_load_failed",
+                error = %err,
+                "Scanner cycle state revision load failed"
+            );
+            global_metrics().set_cycle(None).await;
+            return Ok(());
+        }
+    };
+    let (mut cycle_info, mut leader_epoch) = match decode_scanner_cycle_state_for_startup(&buf) {
+        Ok(state) => state,
+        Err(err) => {
+            error!(
+                target: "rustfs::scanner",
+                event = EVENT_SCANNER_PERSIST_STATE,
+                component = LOG_COMPONENT_SCANNER,
+                subsystem = LOG_SUBSYSTEM_RUNTIME,
+                path = %&*DATA_USAGE_BLOOM_NAME_PATH,
+                state = "cycle_decode_failed",
+                error = %err,
+                "Scanner stopped because persisted cycle state is invalid"
+            );
+            global_metrics().set_cycle(None).await;
+            return Ok(());
+        }
+    };
     let usage_floor = match persisted_usage_floor(storeapi.clone()).await {
         Ok(floor) => floor,
         Err(err) => {
@@ -1845,49 +1704,13 @@ async fn run_data_scanner_with_maintenance_state(
             return Ok(());
         }
         let cycle_ctx = ctx.child_token();
-        let cycle_budget = ScannerCycleBudget::new_with_runtime_progress_tracking(&cycle_ctx, scanner_cycle_budget_config());
-        let initial_outcome = match await_scanner_cycle_with_budget_fence(
+        let initial_outcome = await_scanner_cycle_with_lock_fence(
             &cycle_ctx,
-            &cycle_budget,
-            run_data_scanner_cycle_with_budget(
-                &cycle_ctx,
-                &storeapi,
-                &mut cycle_info,
-                &mut cycle_revision,
-                leader_epoch,
-                cycle_budget.clone(),
-            ),
+            run_data_scanner_cycle(&cycle_ctx, &storeapi, &mut cycle_info, &mut cycle_revision, leader_epoch),
             guard.lock_lost_notified(),
         )
         .await
-        {
-            ScannerCycleWaitOutcome::Completed(outcome) => outcome,
-            ScannerCycleWaitOutcome::LockLost => {
-                record_scanner_leader_lock_lost("Scanner leader lock lost during the initial cycle").await;
-                global_metrics().set_cycle(None).await;
-                return Ok(());
-            }
-            ScannerCycleWaitOutcome::Cancelled => {
-                global_metrics().set_cycle(None).await;
-                return Ok(());
-            }
-            ScannerCycleWaitOutcome::Deadline { worker_stopped } => {
-                handle_scanner_cycle_deadline(
-                    &ctx,
-                    storeapi.clone(),
-                    ScannerCycleDeadlineState {
-                        cycle_info: &mut cycle_info,
-                        cycle_revision: &mut cycle_revision,
-                        leader_epoch: &mut leader_epoch,
-                        cycle_budget: &cycle_budget,
-                    },
-                    worker_stopped,
-                    &mut guard,
-                )
-                .await;
-                return Ok(());
-            }
-        };
+        .unwrap_or(ScannerCycleOutcome::Failed);
         superseded_backoff.record_retryable_cycle(initial_outcome == ScannerCycleOutcome::Superseded);
         deferred_backoff.record_retryable_cycle(matches!(initial_outcome, ScannerCycleOutcome::Deferred(_)));
         dirty_usage_generation_seen = dirty_generation_before_cycle;
@@ -2093,49 +1916,13 @@ async fn run_data_scanner_with_maintenance_state(
         }
         let dirty_generation_before_cycle = dirty_usage_generation();
         let cycle_ctx = ctx.child_token();
-        let cycle_budget = ScannerCycleBudget::new_with_runtime_progress_tracking(&cycle_ctx, scanner_cycle_budget_config());
-        let outcome = match await_scanner_cycle_with_budget_fence(
+        let outcome = await_scanner_cycle_with_lock_fence(
             &cycle_ctx,
-            &cycle_budget,
-            run_data_scanner_cycle_with_budget(
-                &cycle_ctx,
-                &storeapi,
-                &mut cycle_info,
-                &mut cycle_revision,
-                leader_epoch,
-                cycle_budget.clone(),
-            ),
+            run_data_scanner_cycle(&cycle_ctx, &storeapi, &mut cycle_info, &mut cycle_revision, leader_epoch),
             guard.lock_lost_notified(),
         )
         .await
-        {
-            ScannerCycleWaitOutcome::Completed(outcome) => outcome,
-            ScannerCycleWaitOutcome::LockLost => {
-                record_scanner_leader_lock_lost("Scanner leader lock lost during a scanner cycle").await;
-                global_metrics().set_cycle(None).await;
-                return Ok(());
-            }
-            ScannerCycleWaitOutcome::Cancelled => {
-                global_metrics().set_cycle(None).await;
-                return Ok(());
-            }
-            ScannerCycleWaitOutcome::Deadline { worker_stopped } => {
-                handle_scanner_cycle_deadline(
-                    &ctx,
-                    storeapi.clone(),
-                    ScannerCycleDeadlineState {
-                        cycle_info: &mut cycle_info,
-                        cycle_revision: &mut cycle_revision,
-                        leader_epoch: &mut leader_epoch,
-                        cycle_budget: &cycle_budget,
-                    },
-                    worker_stopped,
-                    &mut guard,
-                )
-                .await;
-                return Ok(());
-            }
-        };
+        .unwrap_or(ScannerCycleOutcome::Failed);
         superseded_backoff.record_retryable_cycle(outcome == ScannerCycleOutcome::Superseded);
         deferred_backoff.record_retryable_cycle(matches!(outcome, ScannerCycleOutcome::Deferred(_)));
         dirty_usage_generation_seen = dirty_generation_before_cycle;
@@ -2432,12 +2219,7 @@ pub(crate) use activity::{
 pub(crate) use activity::{ScannerCycleOutcome, scanner_cycle_outcome_with_pending_maintenance};
 #[cfg(test)]
 pub(crate) use cycle_state::encode_scanner_cycle_fence_for_test;
-pub use cycle_state::{
-    ScannerCycleRecoveryMarker, ScannerCycleRecoveryStatus, reset_scanner_cycle_recovery, scanner_cycle_recovery_status,
-};
-pub(crate) use cycle_state::{
-    current_scanner_leader_epoch, decode_persisted_scanner_cycle_fence, load_scanner_cycle_state_for_startup,
-};
+pub(crate) use cycle_state::{current_scanner_leader_epoch, decode_persisted_scanner_cycle_fence};
 pub use heal_info::{BackgroundHealInfo, read_background_heal_info, save_background_heal_info};
 pub use usage_store::store_data_usage_in_backend;
 

crates/scanner/src/scanner/leadership.rs

@@ -196,7 +196,7 @@ pub(super) async fn claim_scanner_leadership(
         if ctx.is_cancelled() {
             return false;
         }
-        let Some(claimed_epoch) = persisted_epoch.checked_add(1).filter(|epoch| *epoch < u64::MAX) else {
+        let Some(claimed_epoch) = persisted_epoch.checked_add(1) else {
             error!(
                 target: "rustfs::scanner",
                 event = EVENT_SCANNER_PERSIST_STATE,

crates/scanner/src/scanner_budget.rs

@@ -14,16 +14,17 @@
 
 use std::sync::{
     Arc,
-    atomic::{AtomicBool, AtomicU8, AtomicU64, Ordering},
+    atomic::{AtomicU8, AtomicU64, Ordering},
 };
-use tokio::time::{Duration, Instant};
+use std::time::Instant;
+
+use tokio::time::Duration;
 use tokio_util::sync::CancellationToken;
 
 const BUDGET_REASON_NONE: u8 = 0;
 const BUDGET_REASON_RUNTIME: u8 = 1;
 const BUDGET_REASON_OBJECTS: u8 = 2;
 const BUDGET_REASON_DIRECTORIES: u8 = 3;
-const PROGRESS_CLOCK_SAMPLE_INTERVAL: u64 = 128;
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub(crate) struct ScannerCycleBudgetConfig {
@@ -62,51 +63,29 @@ pub struct ScannerCycleBudget {
     token: CancellationToken,
     reason: Arc<AtomicU8>,
     started_at: Instant,
-    deadline: Option<Instant>,
     max_duration: Option<Duration>,
     max_objects: Option<u64>,
     max_directories: Option<u64>,
     track_progress: bool,
-    track_unbounded_counts: bool,
     objects_scanned: AtomicU64,
     directories_started: AtomicU64,
     entries_visited: AtomicU64,
-    last_progress_millis: AtomicU64,
-    cycle_state_persisted: AtomicBool,
 }
 
 impl ScannerCycleBudget {
-    #[cfg(test)]
     pub(crate) fn new(parent: &CancellationToken, config: ScannerCycleBudgetConfig) -> Arc<Self> {
-        Self::new_inner(parent, config, false, false)
+        Self::new_inner(parent, config, false)
     }
 
     pub(crate) fn new_with_progress_tracking(parent: &CancellationToken, config: ScannerCycleBudgetConfig) -> Arc<Self> {
-        Self::new_inner(parent, config, true, true)
+        Self::new_inner(parent, config, true)
     }
 
-    pub(crate) fn new_with_runtime_progress_tracking(parent: &CancellationToken, config: ScannerCycleBudgetConfig) -> Arc<Self> {
-        let track_progress = config.max_duration.is_some();
-        Self::new_inner(parent, config, track_progress, false)
-    }
-
-    fn new_inner(
-        parent: &CancellationToken,
-        config: ScannerCycleBudgetConfig,
-        track_progress: bool,
-        track_unbounded_counts: bool,
-    ) -> Arc<Self> {
+    fn new_inner(parent: &CancellationToken, config: ScannerCycleBudgetConfig, track_progress: bool) -> Arc<Self> {
         let token = parent.child_token();
         let reason = Arc::new(AtomicU8::new(BUDGET_REASON_NONE));
-        let started_at = Instant::now();
-        let deadline = config.max_duration.map(|duration| match started_at.checked_add(duration) {
-            Some(deadline) => deadline,
-            // Runtime config rejects this range, but keep programmatic callers
-            // fail-closed instead of panicking or silently disabling the wall clock.
-            None => started_at,
-        });
 
-        if let Some(deadline) = deadline {
+        if let Some(duration) = config.max_duration {
             let parent = parent.clone();
             let token_wait = token.clone();
             let token_cancel = token.clone();
@@ -115,7 +94,7 @@ impl ScannerCycleBudget {
                 tokio::select! {
                     _ = parent.cancelled() => {}
                     _ = token_wait.cancelled() => {}
-                    _ = tokio::time::sleep_until(deadline) => {
+                    _ = tokio::time::sleep(duration) => {
                         Self::cancel_for_reason(&reason, &token_cancel, ScannerCycleBudgetReason::Runtime);
                     }
                 }
@@ -125,18 +104,14 @@ impl ScannerCycleBudget {
         Arc::new(Self {
             token,
             reason,
-            started_at,
-            deadline,
+            started_at: Instant::now(),
             max_duration: config.max_duration,
             max_objects: config.max_objects,
             max_directories: config.max_directories,
             track_progress,
-            track_unbounded_counts,
             objects_scanned: AtomicU64::new(0),
             directories_started: AtomicU64::new(0),
             entries_visited: AtomicU64::new(0),
-            last_progress_millis: AtomicU64::new(0),
-            cycle_state_persisted: AtomicBool::new(false),
         })
     }
 
@@ -156,14 +131,6 @@ impl ScannerCycleBudget {
         self.max_duration
     }
 
-    pub(crate) fn deadline(&self) -> Option<Instant> {
-        self.deadline
-    }
-
-    pub(crate) fn cancel_for_runtime(&self) {
-        self.cancel_for(ScannerCycleBudgetReason::Runtime);
-    }
-
     pub(crate) fn max_objects(&self) -> Option<u64> {
         self.max_objects
     }
@@ -206,43 +173,15 @@ impl ScannerCycleBudget {
         self.entries_visited.load(Ordering::Relaxed)
     }
 
-    pub(crate) fn mark_cycle_state_persisted(&self) {
-        self.cycle_state_persisted.store(true, Ordering::Release);
-    }
-
-    pub(crate) fn cycle_state_persisted(&self) -> bool {
-        self.cycle_state_persisted.load(Ordering::Acquire)
-    }
-
-    pub(crate) fn progress_age(&self) -> Duration {
-        let elapsed_millis = u64::try_from(self.started_at.elapsed().as_millis()).unwrap_or(u64::MAX);
-        let last_progress = self.last_progress_millis.load(Ordering::Relaxed);
-        Duration::from_millis(elapsed_millis.saturating_sub(last_progress))
-    }
-
-    fn record_progress_sample(&self, event: u64) {
-        // Clock reads are sampled at batch/count boundaries; the scanner's
-        // per-object path does not add a second progress atomic.
-        if event == 0 || (event != 1 && !event.is_multiple_of(PROGRESS_CLOCK_SAMPLE_INTERVAL)) {
-            return;
-        }
-        let elapsed_millis = u64::try_from(self.started_at.elapsed().as_millis()).unwrap_or(u64::MAX);
-        self.last_progress_millis.store(elapsed_millis, Ordering::Relaxed);
-    }
-
     pub(crate) fn record_entries_visited(&self, entries_visited: u64) {
         if self.track_progress {
-            let entries = saturating_fetch_add(&self.entries_visited, entries_visited);
-            self.record_progress_sample(entries);
+            saturating_fetch_add(&self.entries_visited, entries_visited);
         }
     }
 
     pub(crate) fn record_remote_progress(&self, objects_scanned: u64, directories_started: u64) {
         if self.track_progress || self.max_objects.is_some() {
             let objects = saturating_fetch_add(&self.objects_scanned, objects_scanned);
-            if self.track_progress {
-                self.record_progress_sample(objects);
-            }
             if self.max_objects.is_some_and(|max_objects| objects >= max_objects) {
                 self.cancel_for(ScannerCycleBudgetReason::Objects);
             }
@@ -250,12 +189,9 @@ impl ScannerCycleBudget {
 
         if self.track_progress || self.max_directories.is_some() {
             let directories = saturating_fetch_add(&self.directories_started, directories_started);
-            if self.track_progress {
-                self.record_progress_sample(directories);
-            }
             if self
                 .max_directories
-                .is_some_and(|max_directories| directory_budget_exhausted(directories, max_directories))
+                .is_some_and(|max_directories| directories > max_directories)
             {
                 self.cancel_for(ScannerCycleBudgetReason::Directories);
             }
@@ -271,17 +207,14 @@ impl ScannerCycleBudget {
     }
 
     pub(crate) fn try_start_directory(&self) -> bool {
-        if self.max_directories.is_none() && !self.track_unbounded_counts {
+        if !self.track_progress && self.max_directories.is_none() {
             return true;
         }
 
         let directories = saturating_fetch_add(&self.directories_started, 1);
-        if self.track_progress {
-            self.record_progress_sample(directories);
-        }
         if self
             .max_directories
-            .is_some_and(|max_directories| directory_budget_exhausted(directories, max_directories))
+            .is_some_and(|max_directories| directories > max_directories)
         {
             self.cancel_for(ScannerCycleBudgetReason::Directories);
             return false;
@@ -291,14 +224,11 @@ impl ScannerCycleBudget {
     }
 
     pub(crate) fn record_object_scanned(&self) {
-        if self.max_objects.is_none() && !self.track_unbounded_counts {
+        if !self.track_progress && self.max_objects.is_none() {
             return;
         }
 
         let objects = saturating_fetch_add(&self.objects_scanned, 1);
-        if self.track_progress {
-            self.record_progress_sample(objects);
-        }
         if self.max_objects.is_some_and(|max_objects| objects >= max_objects) {
             self.cancel_for(ScannerCycleBudgetReason::Objects);
         }
@@ -329,13 +259,6 @@ fn saturating_fetch_add(value: &AtomicU64, delta: u64) -> u64 {
     }
 }
 
-fn directory_budget_exhausted(directories: u64, max_directories: u64) -> bool {
-    // Saturation hides a remote max+1 update when the configured limit is the
-    // largest representable counter. Treat that boundary as exhausted rather
-    // than allowing work to continue indefinitely.
-    directories > max_directories || (directories == u64::MAX && max_directories == u64::MAX)
-}
-
 impl Drop for ScannerCycleBudget {
     fn drop(&mut self) {
         self.token.cancel();
@@ -478,35 +401,6 @@ mod tests {
         assert_eq!(directory_budget.reason(), Some(ScannerCycleBudgetReason::Directories));
     }
 
-    #[test]
-    fn directory_budget_fails_closed_when_progress_saturates() {
-        let parent = CancellationToken::new();
-        let budget = ScannerCycleBudget::new(
-            &parent,
-            ScannerCycleBudgetConfig {
-                max_directories: Some(u64::MAX),
-                ..Default::default()
-            },
-        );
-
-        budget.record_remote_progress(0, u64::MAX);
-
-        assert_eq!(budget.reason(), Some(ScannerCycleBudgetReason::Directories));
-        assert!(budget.token().is_cancelled());
-
-        let local_budget = ScannerCycleBudget::new(
-            &parent,
-            ScannerCycleBudgetConfig {
-                max_directories: Some(u64::MAX),
-                ..Default::default()
-            },
-        );
-        local_budget.record_remote_progress(0, u64::MAX - 1);
-        assert!(!local_budget.budget_elapsed());
-        assert!(!local_budget.try_start_directory());
-        assert_eq!(local_budget.reason(), Some(ScannerCycleBudgetReason::Directories));
-    }
-
     #[test]
     fn explicit_progress_tracking_counts_unbounded_remote_work_without_cancelling() {
         let parent = CancellationToken::new();
@@ -567,29 +461,4 @@ mod tests {
         assert!(object_limited.requires_serial_progress_accounting());
         assert!(directory_limited.requires_serial_progress_accounting());
     }
-
-    #[tokio::test(start_paused = true)]
-    async fn progress_age_uses_virtual_time_and_sampled_progress() {
-        let parent = CancellationToken::new();
-        let budget = ScannerCycleBudget::new_with_runtime_progress_tracking(
-            &parent,
-            ScannerCycleBudgetConfig {
-                max_duration: Some(Duration::from_secs(60)),
-                ..Default::default()
-            },
-        );
-
-        tokio::time::advance(Duration::from_secs(5)).await;
-        assert_eq!(budget.progress_age(), Duration::from_secs(5));
-        budget.record_entries_visited(1);
-        assert_eq!(budget.progress_age(), Duration::ZERO);
-
-        tokio::time::advance(Duration::from_secs(2)).await;
-        for _ in 0..126 {
-            budget.record_entries_visited(1);
-        }
-        assert_eq!(budget.progress_age(), Duration::from_secs(2));
-        budget.record_entries_visited(1);
-        assert_eq!(budget.progress_age(), Duration::ZERO);
-    }
 }

crates/scanner/src/scanner_folder.rs

@@ -43,7 +43,10 @@ use rustfs_common::metrics::{
     UpdateCurrentPathFn, current_path_updater, global_metrics,
 };
 use rustfs_common::trace_bus::{TraceEvent, TraceFunc, TraceKind, trace_emit, trace_subscriber_count};
-use rustfs_filemeta::{MetaCacheEntries, MetaCacheEntry, MetadataResolutionParams};
+use rustfs_filemeta::{
+    MAX_META_CACHE_HEAL_CANDIDATES, MAX_META_CACHE_HEAL_TRUNCATED_OBJECTS, MetaCacheEntries, MetaCacheEntry,
+    MetaCacheHealCandidateKind,
+};
 use rustfs_utils::path::{SLASH_SEPARATOR, path_join_buf};
 use s3s::dto::{BucketLifecycleConfiguration, ObjectLockConfiguration, VersioningConfiguration};
 use time::OffsetDateTime;
@@ -55,9 +58,9 @@ use tracing::{debug, error, warn};
 use crate::{
     Disk, DiskError, DiskInfoOptions, Evaluator, Event, LcEventSrc, ListPathRawOptions, ObjectOpts, ReplicationConfig,
     ReplicationHealObject, ReplicationQueueAdmission, ReplicationStatusType, STORAGE_FORMAT_FILE, ScannerDiskExt as _,
-    ScannerLifecycleConfigExt as _, ScannerVersioningConfigExt as _, StorageError, TierRegistrySnapshot, apply_expiry_rule,
-    apply_transition_rule, enqueue_runtime_newer_noncurrent, is_reserved_or_invalid_bucket, list_path_raw, path2_bucket_object,
-    path2_bucket_object_with_base_path, queue_replication_heal, runtime_tier_registry, scanner_is_erasure,
+    ScannerLifecycleConfigExt as _, ScannerVersioningConfigExt as _, StorageError, apply_expiry_rule, apply_transition_rule,
+    enqueue_runtime_newer_noncurrent, is_reserved_or_invalid_bucket, list_path_raw, path2_bucket_object,
+    path2_bucket_object_with_base_path, queue_replication_heal, scanner_is_erasure,
     scanner_replication_config_for_lifecycle_eval,
 };
 use crate::{ScannerObjectInfo as ObjectInfo, ScannerObjectToDelete as ObjectToDelete};
@@ -96,6 +99,11 @@ const METRIC_SCANNER_EXCESS_OBJECT_VERSION_SIZE_TOTAL: &str = "rustfs_scanner_ex
 const METRIC_SCANNER_EXCESS_FOLDERS_TOTAL: &str = "rustfs_scanner_excess_folders_total";
 const METRIC_SCANNER_PENDING_HEAL_PRUNE_TOTAL: &str = "rustfs_scanner_pending_heal_prune_total";
 const METRIC_SCANNER_PENDING_HEAL_MALFORMED_TOTAL: &str = "rustfs_scanner_pending_heal_malformed_total";
+const METRIC_SCANNER_HEAL_DISCOVERY_CANDIDATES_TOTAL: &str = "rustfs_scanner_heal_discovery_candidates_total";
+const METRIC_SCANNER_HEAL_DISCOVERY_SUB_QUORUM_TOTAL: &str = "rustfs_scanner_heal_discovery_sub_quorum_total";
+const METRIC_SCANNER_HEAL_DISCOVERY_UNVERIFIED_TOTAL: &str = "rustfs_scanner_heal_discovery_unverified_total";
+const METRIC_SCANNER_HEAL_DISCOVERY_QUEUED_TOTAL: &str = "rustfs_scanner_heal_discovery_queued_total";
+const METRIC_SCANNER_HEAL_DISCOVERY_TRUNCATED_TOTAL: &str = "rustfs_scanner_heal_discovery_truncated_total";
 const MAX_PENDING_SCANNER_HEAL_RETRIES_PER_BUCKET: usize = 128;
 
 // --- scanner excess alerts as S3 notification events (rustfs/backlog#1868) --
@@ -626,7 +634,6 @@ fn apply_scanner_size_summary(into: &mut DataUsageEntry, summary: &SizeSummary)
     }
 
     into.add_tier_sizes(&summary.tier_stats);
-    into.add_unknown_tier_stats(&summary.unknown_tier_stats);
 }
 
 fn data_usage_root_has_progress(root: &DataUsageEntry) -> bool {
@@ -671,9 +678,6 @@ pub struct FolderScanner {
     budget: Arc<ScannerCycleBudget>,
     skip_heal: Arc<std::sync::atomic::AtomicBool>,
     local_disk: Arc<Disk>,
-    /// Tier registry frozen for this folder scan. A refresh applies to the
-    /// next scan and cannot mix generations in one aggregate.
-    tier_registry: TierRegistrySnapshot,
     pending_heals_changed: bool,
     #[cfg(test)]
     list_path_raw_options_observer: Option<mpsc::UnboundedSender<ListPathRawTimeoutSnapshot>>,
@@ -887,7 +891,7 @@ impl FolderScanner {
         object: Option<String>,
         version_id: Option<String>,
         request: HealChannelRequest,
-    ) -> Result<(), ScannerError> {
+    ) -> Result<HealAdmissionResult, ScannerError> {
         let candidate_type = pending_scanner_heal_candidate_type(kind);
         let priority = request.priority;
         let scan_mode = request.scan_mode.unwrap_or(self.scan_mode);
@@ -915,7 +919,7 @@ impl FolderScanner {
                     error = %err,
                     "Scanner deferred heal request after channel error"
                 );
-                return Ok(());
+                return Ok(HealAdmissionResult::Full);
             }
         };
         self.update_pending_scanner_heal_after_admission(
@@ -927,7 +931,7 @@ impl FolderScanner {
             result,
         );
         if result.is_admitted() {
-            return Ok(());
+            return Ok(result);
         }
 
         record_high_priority_heal_escalation(candidate_type, priority, result);
@@ -948,7 +952,7 @@ impl FolderScanner {
             state = "high_priority_not_admitted",
             "Scanner high-priority heal admission failed"
         );
-        Ok(())
+        Ok(result)
     }
 
     pub fn set_heal_object_select(&mut self, prob: u32) {
@@ -1333,11 +1337,7 @@ impl FolderScanner {
                     continue;
                 }
 
-                let sz = match self
-                    .local_disk
-                    .get_size_with_tier_names(item.clone(), &self.tier_registry.names)
-                    .await
-                {
+                let sz = match self.local_disk.get_size(item.clone()).await {
                     Ok(sz) => sz,
                     Err(e) => {
                         let failure_action = classify_get_size_failure(&item, &e);
@@ -1744,14 +1744,7 @@ impl FolderScanner {
                 break;
             }
 
-            let mut resolver = MetadataResolutionParams {
-                dir_quorum: self.disks_quorum,
-                obj_quorum: self.disks_quorum,
-                bucket: "".to_string(),
-                strict: false,
-                ..Default::default()
-            };
-
+            let mut previous_bucket = String::new();
             for name in abandoned_children {
                 if !self.should_heal().await {
                     break;
@@ -1759,7 +1752,7 @@ impl FolderScanner {
 
                 let (bucket, prefix) = path2_bucket_object(name.as_str());
 
-                if bucket != resolver.bucket {
+                if bucket != previous_bucket {
                     self.send_required_scanner_heal_request(
                         PendingScannerHealKind::Bucket,
                         bucket.clone(),
@@ -1768,10 +1761,9 @@ impl FolderScanner {
                         build_bucket_heal_request(bucket.clone(), HealChannelPriority::High),
                     )
                     .await?;
+                    previous_bucket = bucket.clone();
                 }
 
-                resolver.bucket = bucket.clone();
-
                 let child_ctx = ctx.child_token();
 
                 let (agreed_tx, mut agreed_rx) = mpsc::channel::<String>(1);
@@ -1888,6 +1880,8 @@ impl FolderScanner {
                 let mut agreed_closed = false;
                 let mut partial_closed = false;
                 let mut finished_closed = false;
+                let mut seen_heal_candidates: HashSet<(String, Option<String>, MetaCacheHealCandidateKind)> = HashSet::new();
+                let mut seen_truncated_objects: HashSet<String> = HashSet::new();
 
                 loop {
                     if agreed_closed && partial_closed && finished_closed {
@@ -1912,65 +1906,117 @@ impl FolderScanner {
                                 break;
                             }
 
-                            let Some(entry) = resolve_object_heal_entry(&entries, resolver.clone()) else {
-                                continue;
-                            };
-
-                            (self.update_current_path)(&entry.name).await;
-
-                            if entry.is_dir() {
-                                continue;
+                            let discovery = entries.discover_heal_candidates(&bucket, MAX_META_CACHE_HEAL_CANDIDATES);
+                            counter!(METRIC_SCANNER_HEAL_DISCOVERY_CANDIDATES_TOTAL)
+                                .increment(u64::try_from(discovery.candidates.len()).unwrap_or(u64::MAX));
+                            counter!(METRIC_SCANNER_HEAL_DISCOVERY_SUB_QUORUM_TOTAL).increment(
+                                u64::try_from(
+                                    discovery
+                                        .candidates
+                                        .iter()
+                                        .filter(|candidate| candidate.replica_count < disks_quorum)
+                                        .count(),
+                                )
+                                .unwrap_or(u64::MAX),
+                            );
+                            counter!(METRIC_SCANNER_HEAL_DISCOVERY_UNVERIFIED_TOTAL).increment(
+                                u64::try_from(discovery.unverified_count).unwrap_or(u64::MAX),
+                            );
+                            if discovery.truncated {
+                                counter!(METRIC_SCANNER_HEAL_DISCOVERY_TRUNCATED_TOTAL).increment(1);
                             }
 
-                            let fivs = match entry.file_info_versions(&bucket) {
-                                Ok(fivs) => fivs,
-                                Err(e) => {
-                                    error!(
-                                        target: "rustfs::scanner::folder",
-                                        event = EVENT_SCANNER_FOLDER_STATE,
-                                        component = LOG_COMPONENT_SCANNER,
-                                        subsystem = LOG_SUBSYSTEM_FOLDER,
-                                        bucket = %bucket,
-                                        entry = %entry.name,
-                                        state = "file_info_versions_failed",
-                                        error = %e,
-                                        "Scanner list_path_raw failed to resolve file versions"
-                                    );
-                                    self.send_required_scanner_heal_request(
-                                        PendingScannerHealKind::Object,
-                                        bucket.clone(),
-                                        Some(entry.name.clone()),
-                                        None,
-                                        build_object_heal_request(
-                                            bucket.clone(),
-                                            entry.name.clone(),
-                                            None,
-                                            self.scan_mode,
-                                            HealChannelPriority::High,
-                                        ),
-                                    )
-                                    .await?;
-                                    found_objects = true;
+                            for candidate in discovery.candidates {
+                                let sub_quorum_candidate = candidate.replica_count < disks_quorum;
+                                let version_id = candidate.validated_version().map(|id| id.to_string());
+                                let identity = (candidate.object.clone(), version_id.clone(), candidate.kind.clone());
+                                if seen_heal_candidates.len() >= MAX_META_CACHE_HEAL_CANDIDATES
+                                    && !seen_heal_candidates.contains(&identity)
+                                {
                                     continue;
                                 }
-                            };
-
-                            for fiv in fivs.versions {
-                                let version_id = fiv.version_id.and_then(|v| if v.is_nil() { None } else { Some(v.to_string()) });
-                                self.send_required_scanner_heal_request(
-                                    PendingScannerHealKind::Object,
-                                    bucket.clone(),
-                                    Some(entry.name.clone()),
-                                    version_id.clone(),
-                                    build_object_heal_request(
+                                if !seen_heal_candidates.insert(identity) {
+                                    continue;
+                                }
+                                let request = if candidate.is_unversioned() {
+                                    build_non_destructive_object_heal_request(
                                         bucket.clone(),
-                                        entry.name.clone(),
-                                        version_id,
+                                        candidate.object.clone(),
                                         self.scan_mode,
                                         HealChannelPriority::High,
-                                    ),
+                                    )
+                                } else {
+                                    build_object_heal_request(
+                                        bucket.clone(),
+                                        candidate.object.clone(),
+                                        version_id.clone(),
+                                        self.scan_mode,
+                                        HealChannelPriority::High,
+                                    )
+                                };
+                                (self.update_current_path)(&candidate.object).await;
+                                let admission = self.send_required_scanner_heal_request(
+                                    PendingScannerHealKind::Object,
+                                    bucket.clone(),
+                                    Some(candidate.object.clone()),
+                                    version_id.clone(),
+                                    request,
                                 )
                                 .await?;
+                                if admission.is_admitted() {
+                                    counter!(METRIC_SCANNER_HEAL_DISCOVERY_QUEUED_TOTAL).increment(1);
+                                } else if sub_quorum_candidate {
+                                    self.mark_pending_scanner_heal_reason(
+                                        PendingScannerHealKind::Object,
+                                        &bucket,
+                                        Some(&candidate.object),
+                                        version_id.as_deref(),
+                                        "sub_quorum_metadata",
+                                    );
+                                }
+                                found_objects = true;
+                            }
+
+                            // A bounded candidate union may overflow for an
+                            // object with a very long version history. Keep
+                            // that overflow explicit and issue one safe,
+                            // versionless inspection request per object so
+                            // the dropped versions are not silently treated
+                            // as absent. This continuation is deliberately
+                            // outside the versioned candidate cap and always
+                            // disables destructive cleanup.
+                            for object in discovery.truncated_objects {
+                                if seen_truncated_objects.len() >= MAX_META_CACHE_HEAL_TRUNCATED_OBJECTS
+                                    && !seen_truncated_objects.contains(&object)
+                                {
+                                    continue;
+                                }
+                                if !seen_truncated_objects.insert(object.clone()) {
+                                    continue;
+                                }
+                                let identity = (object.clone(), None, MetaCacheHealCandidateKind::UnversionedObject);
+                                if !seen_heal_candidates.insert(identity) {
+                                    continue;
+                                }
+                                let request = build_non_destructive_object_heal_request(
+                                    bucket.clone(),
+                                    object.clone(),
+                                    self.scan_mode,
+                                    HealChannelPriority::High,
+                                );
+                                (self.update_current_path)(&object).await;
+                                let admission = self
+                                    .send_required_scanner_heal_request(
+                                        PendingScannerHealKind::Object,
+                                        bucket.clone(),
+                                        Some(object.clone()),
+                                        None,
+                                        request,
+                                    )
+                                    .await?;
+                                if admission.is_admitted() {
+                                    counter!(METRIC_SCANNER_HEAL_DISCOVERY_QUEUED_TOTAL).increment(1);
+                                }
                                 found_objects = true;
                             }
 
@@ -2169,10 +2215,6 @@ pub async fn scan_data_folder(
 
     let failed_object_ttl = rustfs_utils::get_env_u32(ENV_FAILED_OBJECT_TTL_SECS, DEFAULT_FAILED_OBJECT_TTL_SECS) as u64;
     let failed_objects_max = rustfs_utils::get_env_u32(ENV_FAILED_OBJECTS_MAX, DEFAULT_FAILED_OBJECTS_MAX) as usize;
-    let tier_registry = runtime_tier_registry().await;
-    let mut cache = cache;
-    cache.fold_retired_tiers(&tier_registry.names);
-    cache.info.tier_registry_generation = Some(tier_registry.generation);
 
     // Create folder scanner
     let mut scanner = FolderScanner {
@@ -2201,7 +2243,6 @@ pub async fn scan_data_folder(
         budget: budget.clone(),
         skip_heal,
         local_disk,
-        tier_registry,
         pending_heals_changed: false,
         #[cfg(test)]
         list_path_raw_options_observer: None,

crates/scanner/src/scanner_folder/item_actions.rs

@@ -13,6 +13,8 @@
 // limitations under the License.
 /// Per-object scan actions: ScannerItem, the get-size failure policy, and the heal/ILM admission helpers.
 use super::*;
+#[cfg(test)]
+use rustfs_filemeta::MetadataResolutionParams;
 
 /// Cached folder information for scanning
 #[derive(Clone, Debug)]
@@ -88,6 +90,22 @@ pub(super) fn build_object_heal_request(
     }
 }
 
+/// Build the versionless inspection request used when discovery cannot prove
+/// a destructive version identity (for example an unversioned object or a
+/// bounded candidate overflow). The explicit flag is the fail-closed safety
+/// boundary; callers must not reconstruct it with the destructive default.
+pub(super) fn build_non_destructive_object_heal_request(
+    bucket: String,
+    object: String,
+    scan_mode: HealScanMode,
+    priority: HealChannelPriority,
+) -> HealChannelRequest {
+    let mut request = build_object_heal_request(bucket, object, None, scan_mode, priority);
+    request.remove_corrupted = Some(false);
+    request
+}
+
+#[cfg(test)]
 pub(super) fn resolve_object_heal_entry(
     entries: &MetaCacheEntries,
     resolver: MetadataResolutionParams,
@@ -289,42 +307,11 @@ impl ScannerItem {
         item.object_path()
     }
 
-    fn effective_tier(oi: &ObjectInfo) -> &str {
-        if oi.transitioned_object.status == crate::TRANSITION_COMPLETE {
-            oi.transitioned_object.tier.as_str()
-        } else {
-            oi.storage_class.as_deref().unwrap_or(crate::storageclass::STANDARD)
-        }
-    }
-
-    fn tier_is_known(oi: &ObjectInfo, tier_names: &[String]) -> bool {
-        let tier = Self::effective_tier(oi);
-        if tier == crate::data_usage_define::UNKNOWN_TIER {
-            return false;
-        }
-        tier == crate::storageclass::STANDARD || tier == crate::storageclass::RRS || tier_names.iter().any(|name| name == tier)
-    }
-
-    fn action_requires_known_tier(action: IlmAction) -> bool {
-        matches!(
-            action,
-            IlmAction::TransitionAction
-                | IlmAction::TransitionVersionAction
-                | IlmAction::DeleteAction
-                | IlmAction::DeleteVersionAction
-                | IlmAction::DeleteRestoredAction
-                | IlmAction::DeleteRestoredVersionAction
-                | IlmAction::DeleteAllVersionsAction
-                | IlmAction::DelMarkerDeleteAllVersionsAction
-        )
-    }
-
     pub async fn apply_actions(
         &mut self,
         object_infos: Vec<ObjectInfo>,
         lock_retention: Option<Arc<ObjectLockConfiguration>>,
         versioning_config: VersioningConfiguration,
-        tier_names: &[String],
         size_summary: &mut SizeSummary,
     ) {
         let object_path = self.object_path();
@@ -456,18 +443,6 @@ impl ScannerItem {
                 let mut size = actual_size;
                 let mut account_now = true;
 
-                // A retired/unknown source tier may point at a remote object
-                // that cannot be safely deleted or transitioned. Lifecycle
-                // evaluation is still useful for accounting, but all
-                // side-effecting tier actions fail closed until the registry
-                // recognizes the source again.
-                if !Self::tier_is_known(oi, tier_names) && Self::action_requires_known_tier(event.action) {
-                    size = self.heal_actions(oi, actual_size, size_summary).await;
-                    size_summary.actions_accounting(oi, size, actual_size);
-                    cumulative_size += size;
-                    continue;
-                }
-
                 match event.action {
                     IlmAction::DeleteAllVersionsAction | IlmAction::DelMarkerDeleteAllVersionsAction => {
                         debug!(
@@ -972,15 +947,4 @@ mod tests {
         assert_eq!(item.object_name, "object");
         assert_eq!(item.object_path(), "object");
     }
-
-    #[test]
-    fn unknown_tier_never_triggers_transition() {
-        let object = ObjectInfo {
-            storage_class: Some("retired-tier".to_string()),
-            ..Default::default()
-        };
-        assert!(!ScannerItem::tier_is_known(&object, &["WARM".to_string()]));
-        assert!(ScannerItem::action_requires_known_tier(IlmAction::TransitionAction));
-        assert!(ScannerItem::action_requires_known_tier(IlmAction::DeleteVersionAction));
-    }
 }

crates/scanner/src/scanner_folder/ledger.rs

@@ -105,6 +105,29 @@ impl FolderScanner {
         }
     }
 
+    /// Preserve the discovery reason when a candidate could not be admitted
+    /// immediately. The existing string field is intentionally reused so the
+    /// scanner's map-encoded cache schema stays backward compatible.
+    pub(super) fn mark_pending_scanner_heal_reason(
+        &mut self,
+        kind: PendingScannerHealKind,
+        bucket: &str,
+        object: Option<&str>,
+        version_id: Option<&str>,
+        reason: &str,
+    ) {
+        if let Some(entry) = self
+            .new_cache
+            .info
+            .pending_heals
+            .iter_mut()
+            .find(|entry| pending_scanner_heal_matches(entry, kind, bucket, object, version_id))
+        {
+            entry.last_admission_reason = reason.to_string();
+            self.sync_pending_heals();
+        }
+    }
+
     pub(super) fn prune_pending_scanner_heals(&mut self) {
         let now = Self::now_secs();
         let before_expiry = self.new_cache.info.pending_heals.len();
@@ -305,13 +328,22 @@ pub(super) fn build_pending_scanner_heal_request(entry: &PendingScannerHeal) ->
     match entry.kind {
         PendingScannerHealKind::Bucket => Some(build_bucket_heal_request(entry.bucket.clone(), HealChannelPriority::High)),
         PendingScannerHealKind::Object => entry.object.as_ref().map(|object| {
-            build_object_heal_request(
-                entry.bucket.clone(),
-                object.clone(),
-                entry.version_id.clone(),
-                entry.scan_mode,
-                HealChannelPriority::High,
-            )
+            if entry.version_id.is_none() {
+                build_non_destructive_object_heal_request(
+                    entry.bucket.clone(),
+                    object.clone(),
+                    entry.scan_mode,
+                    HealChannelPriority::High,
+                )
+            } else {
+                build_object_heal_request(
+                    entry.bucket.clone(),
+                    object.clone(),
+                    entry.version_id.clone(),
+                    entry.scan_mode,
+                    HealChannelPriority::High,
+                )
+            }
         }),
     }
 }

crates/scanner/src/scanner_folder/tests.rs

@@ -17,7 +17,7 @@ use crate::SCANNER_SLEEPER;
 use super::*;
 use crate::storage_api::VersionPurgeStatusType;
 use crate::{DiskOption, Endpoint, STORAGE_FORMAT_FILE, TierStats, new_disk, storageclass};
-use rustfs_filemeta::{FileInfo, FileMeta};
+use rustfs_filemeta::{FileInfo, FileMeta, MetadataResolutionParams};
 use std::io::Write;
 #[cfg(unix)]
 use std::os::unix::fs::{PermissionsExt, symlink};
@@ -325,11 +325,6 @@ async fn build_test_scanner() -> (FolderScanner, std::path::PathBuf) {
         budget: ScannerCycleBudget::new(&CancellationToken::new(), Default::default()),
         skip_heal: Arc::new(AtomicBool::new(false)),
         local_disk: disk,
-        tier_registry: crate::TierRegistrySnapshot {
-            generation: 0,
-            names: Arc::new([]),
-            refresh_failed: false,
-        },
         pending_heals_changed: false,
         list_path_raw_options_observer: None,
     };
@@ -987,6 +982,21 @@ fn test_build_object_heal_request_omits_nil_version_id() {
     assert_eq!(request.recreate_missing, Some(false));
 }
 
+#[test]
+fn test_build_non_destructive_object_heal_request_disables_removal() {
+    let request = build_non_destructive_object_heal_request(
+        "bucket".to_string(),
+        "path/to/object".to_string(),
+        HealScanMode::Deep,
+        HealChannelPriority::High,
+    );
+
+    assert_eq!(request.object_version_id, None);
+    assert_eq!(request.remove_corrupted, Some(false));
+    assert_eq!(request.recreate_missing, Some(false));
+    assert_eq!(request.source, HealRequestSource::Scanner);
+}
+
 #[test]
 fn test_build_bucket_heal_request_disables_recreate_for_scanner() {
     let request = build_bucket_heal_request("bucket".to_string(), HealChannelPriority::Low);
@@ -1126,6 +1136,42 @@ fn test_pending_heal_reconstructs_object_request_with_version() {
     assert_eq!(request.source, HealRequestSource::Scanner);
 }
 
+#[test]
+fn test_pending_heal_reconstructs_unversioned_request_without_removal() {
+    let pending = pending_heal(PendingScannerHealKind::Object, "bucket", Some("object"), None, 1, 1);
+
+    let request = build_pending_scanner_heal_request(&pending).expect("unversioned object request should rebuild");
+
+    assert!(request.object_version_id.is_none());
+    assert_eq!(request.remove_corrupted, Some(false));
+    assert_eq!(request.recreate_missing, Some(false));
+}
+
+#[tokio::test]
+async fn test_pending_heal_reason_preserves_sub_quorum_discovery() {
+    let (mut scanner, temp_dir) = build_test_scanner().await;
+    let _guard = TestGuard::new(u64::MAX, usize::MAX, &mut scanner, temp_dir);
+
+    scanner.update_pending_scanner_heal_after_admission(
+        PendingScannerHealKind::Object,
+        "bucket",
+        Some("object"),
+        Some("version-a"),
+        HealScanMode::Deep,
+        HealAdmissionResult::Full,
+    );
+    scanner.mark_pending_scanner_heal_reason(
+        PendingScannerHealKind::Object,
+        "bucket",
+        Some("object"),
+        Some("version-a"),
+        "sub_quorum_metadata",
+    );
+
+    assert_eq!(scanner.new_cache.info.pending_heals.len(), 1);
+    assert_eq!(scanner.new_cache.info.pending_heals[0].last_admission_reason, "sub_quorum_metadata");
+}
+
 #[test]
 fn test_pending_heal_retry_candidates_respect_cap_and_order() {
     let pending: Vec<PendingScannerHeal> = (0..(MAX_PENDING_SCANNER_HEAL_RETRIES_PER_BUCKET + 2))
@@ -1328,6 +1374,20 @@ fn metadata_for_object(bucket: &str, object: &str) -> Vec<u8> {
     meta.marshal_msg().expect("test metadata should marshal")
 }
 
+fn metadata_for_object_version(bucket: &str, object: &str, version_id: Option<Uuid>) -> Vec<u8> {
+    let mut file_info = FileInfo::new(object, 4, 2);
+    file_info.volume = bucket.to_string();
+    file_info.name = object.to_string();
+    file_info.version_id = version_id;
+    file_info.versioned = version_id.is_some();
+    file_info.mod_time = Some(OffsetDateTime::now_utc());
+    file_info.size = 1;
+
+    let mut meta = FileMeta::new();
+    meta.add_version(file_info).expect("test metadata version should be accepted");
+    meta.marshal_msg().expect("test metadata should marshal")
+}
+
 async fn write_test_object_metadata(root: &std::path::Path, bucket: &str, object: &str) {
     write_test_object_metadata_bytes(root, bucket, object, &metadata_for_object(bucket, object)).await;
 }
@@ -1731,12 +1791,21 @@ async fn test_scan_folder_exits_when_abandoned_child_listing_finishes() {
     let _guard = TestGuard::new(60, 100, &mut scanner, temp_dir.clone());
     let heal_starts = Arc::new(AtomicUsize::new(0));
     let heal_starts_clone = heal_starts.clone();
+    let healed_versions = Arc::new(Mutex::new(Vec::<Option<String>>::new()));
+    let healed_versions_clone = healed_versions.clone();
     let mut heal_rx =
         rustfs_common::heal_channel::init_heal_channel().expect("heal channel should initialize once for scanner tests");
     let _heal_responder = tokio::spawn(async move {
         while let Some(command) = heal_rx.recv().await {
-            if let rustfs_common::heal_channel::HealChannelCommand::Start { response_tx, .. } = command {
+            if let rustfs_common::heal_channel::HealChannelCommand::Start {
+                request, response_tx, ..
+            } = command
+            {
                 heal_starts_clone.fetch_add(1, Ordering::Relaxed);
+                healed_versions_clone
+                    .lock()
+                    .expect("heal version capture lock should not be poisoned")
+                    .push(request.object_version_id);
                 let _ = response_tx.send(Ok(HealAdmissionResult::Accepted));
             }
         }
@@ -1744,13 +1813,18 @@ async fn test_scan_folder_exits_when_abandoned_child_listing_finishes() {
 
     let bucket = "src-archive";
     let object = "snapshots/37b3f20d941e2f5e6d99114d9bb2f3e67a8a2e5c9c4c5a1b0d6e7f8091a2b3c4";
-    let metadata = metadata_for_object(bucket, object);
-    write_test_object_metadata_bytes(&temp_dir, bucket, object, &metadata).await;
+    let orphan_version = Uuid::from_u128(0x1934);
+    let shared_version = Uuid::from_u128(0x1935);
+    let orphan_metadata = metadata_for_object_version(bucket, object, Some(orphan_version));
+    let shared_metadata = metadata_for_object_version(bucket, object, Some(shared_version));
+    write_test_object_metadata_bytes(&temp_dir, bucket, object, &orphan_metadata).await;
+    let mut expected_metadata = vec![(temp_dir.join(bucket).join(object).join("xl.meta"), orphan_metadata.clone())];
 
     let mut disks = vec![scanner.local_disk.clone()];
     for disk_name in ["disk2", "disk3", "disk4"] {
         let disk_root = temp_dir.join(disk_name);
-        write_test_object_metadata_bytes(&disk_root, bucket, object, &metadata).await;
+        write_test_object_metadata_bytes(&disk_root, bucket, object, &shared_metadata).await;
+        expected_metadata.push((disk_root.join(bucket).join(object).join("xl.meta"), shared_metadata.clone()));
         let endpoint = Endpoint::try_from(disk_root.to_string_lossy().as_ref()).expect("failed to create extra disk endpoint");
         let disk = new_disk(
             &endpoint,
@@ -1799,8 +1873,29 @@ async fn test_scan_folder_exits_when_abandoned_child_listing_finishes() {
         .new_cache
         .checked_flatten(bucket)
         .expect("healed cache must contain canonical child links");
-    assert_eq!(root.objects, 1);
+    // The fixture intentionally exposes two divergent version histories, so
+    // the scanner keeps both logical versions visible while discovering heals.
+    assert_eq!(root.objects, 2);
     assert!(heal_starts.load(Ordering::Relaxed) > 0, "test must execute the heal child-link path");
+    let orphan_version_text = orphan_version.to_string();
+    assert!(
+        healed_versions
+            .lock()
+            .expect("heal version capture lock should not be poisoned")
+            .iter()
+            .any(|version| version.as_deref() == Some(orphan_version_text.as_str())),
+        "sub-quorum orphan version must be submitted as an exact heal candidate"
+    );
+    for (path, expected) in expected_metadata {
+        assert_eq!(
+            tokio::fs::read(&path)
+                .await
+                .expect("scanner discovery must not delete metadata"),
+            expected,
+            "scanner discovery must not modify candidate metadata: {}",
+            path.display()
+        );
+    }
 }
 
 #[tokio::test]

crates/scanner/src/scanner_io.rs

@@ -48,7 +48,6 @@ use time::OffsetDateTime;
 use tokio::sync::{Mutex, Notify, Semaphore, mpsc};
 use tokio::time::Duration;
 use tokio_util::sync::CancellationToken;
-use tokio_util::task::AbortOnDropHandle;
 use tracing::{debug, error, warn};
 
 use crate::ScannerObjectInfo as ObjectInfo;
@@ -498,9 +497,6 @@ pub trait ScannerIODisk: Send + Sync + Debug + 'static {
     ) -> Result<ScannerDiskScanOutcome>;
 
     async fn get_size(&self, item: ScannerItem) -> Result<SizeSummary>;
-
-    /// Read one object using a registry snapshot captured at scan start.
-    async fn get_size_with_tier_names(&self, item: ScannerItem, tier_names: &[String]) -> Result<SizeSummary>;
 }
 
 #[derive(Debug)]

crates/scanner/src/scanner_io/cache.rs

@@ -216,7 +216,6 @@ pub(super) fn completed_data_usage_info(
         delete_markers_total_count: u64::try_from(total.delete_markers).ok()?,
         objects_total_size: u64::try_from(total.size).ok()?,
         tier_stats: total.all_tier_stats.filter(|tiers| !tiers.is_empty()),
-        unknown_tier_stats: total.unknown_tier_stats.filter(|stats| !stats.is_empty()),
         buckets_count: u64::try_from(all_buckets.len()).ok()?,
         bucket_sizes,
         buckets_usage,

crates/scanner/src/scanner_io/io_cache.rs

@@ -314,7 +314,7 @@ impl ScannerIOCache for SetDisks {
         let ctx_clone = ctx.clone();
         let completed_bucket_count = Arc::new(AtomicUsize::new(0));
         let completed_bucket_count_clone = completed_bucket_count.clone();
-        let collect_bucket_results_fut = AbortOnDropHandle::new(tokio::spawn(async move {
+        let collect_bucket_results_fut = tokio::spawn(async move {
             let mut cancelled = false;
 
             loop {
@@ -333,7 +333,7 @@ impl ScannerIOCache for SetDisks {
                     }
                 }
             }
-        }));
+        });
 
         let mut futs = Vec::new();
 
@@ -365,7 +365,7 @@ impl ScannerIOCache for SetDisks {
                 NamespaceScannerWorkerMode::RemoteV4(server_epoch) => Some(server_epoch),
                 NamespaceScannerWorkerMode::Coordinator => None,
             };
-            futs.push(AbortOnDropHandle::new(tokio::spawn(async move {
+            futs.push(tokio::spawn(async move {
                 let remote_session_id = uuid::Uuid::new_v4();
                 let mut remote_session_sequence = 0_u64;
                 loop {
@@ -1038,7 +1038,7 @@ impl ScannerIOCache for SetDisks {
                         );
                     }
                 }
-            })));
+            }));
         }
         drop(bucket_tx);
         drop(bucket_result_tx);

crates/scanner/src/scanner_io/io_cycle.rs

@@ -242,7 +242,7 @@ impl ScannerIOCycle for ECStore {
                         results[results_index_clone] = result;
                     }
                 });
-                wait_futs.push(AbortOnDropHandle::new(receiver_fut));
+                wait_futs.push(receiver_fut);
 
                 let scan_plan = ScannerBucketScanPlan {
                     buckets: set_buckets,
@@ -318,7 +318,7 @@ impl ScannerIOCycle for ECStore {
                         record_set_scan_failure(&mut first_err, e);
                     }
                 });
-                wait_futs.push(AbortOnDropHandle::new(scanner_fut));
+                wait_futs.push(scanner_fut);
             }
         }
 

crates/scanner/src/scanner_io/io_disk.rs

@@ -13,38 +13,29 @@
 // limitations under the License.
 /// ScannerIODisk implementation for Disk: get_size and the per-disk bucket scan.
 use super::*;
-use crate::UNKNOWN_TIER;
 
 ///
 /// Seed [`SizeSummary::tier_stats`] from the cached tier-name list.
 ///
-/// Preserves the original no-tier shape: with no tiers configured the map
-/// stays completely empty (STANDARD/RRS/UNKNOWN are not seeded either).
-/// Otherwise the standard storage classes and one fixed unknown bucket are
-/// seeded alongside every configured tier so per-object accounting never
-/// inserts an untrusted metadata key.
+/// Preserves the original seeding semantics: with no tiers configured the map
+/// stays completely empty (STANDARD/RRS are not seeded either); otherwise the
+/// standard storage classes are seeded alongside every configured tier so
+/// per-object accounting always finds its tier key.
 pub(super) fn tier_stats_template(tier_names: &[String]) -> HashMap<String, TierStats> {
-    let mut tier_stats = HashMap::with_capacity(tier_names.len() + 3);
+    let mut tier_stats = HashMap::with_capacity(tier_names.len() + 2);
     for tier_name in tier_names {
-        if tier_name != UNKNOWN_TIER {
-            tier_stats.insert(tier_name.clone(), TierStats::default());
-        }
+        tier_stats.insert(tier_name.clone(), TierStats::default());
     }
     if !tier_stats.is_empty() {
         tier_stats.insert(storageclass::STANDARD.to_string(), TierStats::default());
         tier_stats.insert(storageclass::RRS.to_string(), TierStats::default());
-        tier_stats.insert(UNKNOWN_TIER.to_string(), TierStats::default());
     }
     tier_stats
 }
 
 #[async_trait::async_trait]
 impl ScannerIODisk for Disk {
-    async fn get_size(&self, item: ScannerItem) -> Result<SizeSummary> {
-        self.get_size_with_tier_names(item, &runtime_tier_names().await).await
-    }
-
-    async fn get_size_with_tier_names(&self, mut item: ScannerItem, tier_names: &[String]) -> Result<SizeSummary> {
+    async fn get_size(&self, mut item: ScannerItem) -> Result<SizeSummary> {
         let done_object = Metrics::time(Metric::ScanObject);
 
         if !is_xl_meta_path(&item.path) {
@@ -116,10 +107,10 @@ impl ScannerIODisk for Disk {
 
         let mut size_summary = SizeSummary::default();
 
-        // The caller supplies one registry snapshot for the whole folder scan;
-        // seeding from it prevents a TTL refresh from mixing generations in a
-        // single result.
-        size_summary.tier_stats = tier_stats_template(tier_names);
+        // Tier names come from the process-wide TTL cache; seeding from them
+        // replaces the per-object clone of every full TierConfig.
+        let tier_names = runtime_tier_names().await;
+        size_summary.tier_stats = tier_stats_template(&tier_names);
 
         let lock_config = object_lock_config_for_scanner_item(&item).await;
 
@@ -129,7 +120,7 @@ impl ScannerIODisk for Disk {
         // `object_infos`.
         global_metrics().record_scanner_versions_scanned(object_infos.len() as u64);
 
-        item.apply_actions(object_infos, lock_config, versioning_config, tier_names, &mut size_summary)
+        item.apply_actions(object_infos, lock_config, versioning_config, &mut size_summary)
             .await;
 
         if !free_version_infos.is_empty() {

crates/scanner/src/scanner_io/publish_gate_tests.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use super::*;
-use rustfs_data_usage::{ReplicationAllStats, ReplicationTargetUsage};
+use rustfs_data_usage::{ReplicationAllStats, ReplicationStats};
 
 const TEST_PLAN_DIGEST: DataUsageScanPlanDigest = DataUsageScanPlanDigest([7; 32]);
 
@@ -271,7 +271,7 @@ fn completed_data_usage_info_flattens_nested_bucket_entries() {
         replication_stats: Some(ReplicationAllStats {
             targets: HashMap::from([(
                 "arn:target".to_string(),
-                ReplicationTargetUsage {
+                ReplicationStats {
                     replicated_size: 2048,
                     replicated_count: 2,
                     ..Default::default()

crates/scanner/src/scanner_io/tests.rs

@@ -23,7 +23,7 @@ use crate::storage_api::owner::{
 use crate::storage_api::scan::{BucketOperations as _, DeleteBucketOptions, MakeBucketOptions, ObjectIO as _};
 use crate::{
     DiskOption, ECStore, Endpoint, EndpointServerPools, Endpoints, InstanceContext, PoolEndpoints, ScannerObjectOptions,
-    ScannerPutObjReader, UNKNOWN_TIER, init_bucket_metadata_sys_for_scanner_tests, init_ecstore_config_for_scanner_tests,
+    ScannerPutObjReader, init_bucket_metadata_sys_for_scanner_tests, init_ecstore_config_for_scanner_tests,
     init_local_disks_with_instance_ctx, new_disk, path2_bucket_object_with_base_path,
 };
 use rustfs_filemeta::FileInfo;
@@ -986,8 +986,8 @@ fn is_xl_meta_path_accepts_forward_separator() {
 fn tier_stats_template_seeds_tiers_and_standard_classes() {
     let template = tier_stats_template(&["WARM".to_string(), "COLD".to_string()]);
 
-    assert_eq!(template.len(), 5);
-    for tier in ["WARM", "COLD", storageclass::STANDARD, storageclass::RRS, UNKNOWN_TIER] {
+    assert_eq!(template.len(), 4);
+    for tier in ["WARM", "COLD", storageclass::STANDARD, storageclass::RRS] {
         assert_eq!(template.get(tier), Some(&TierStats::default()), "missing seed for tier {tier}");
     }
 }

crates/storage-api/src/lib.rs

@@ -76,7 +76,6 @@ pub use bucket::{BucketInfo, BucketOperations, BucketOptions, DeleteBucketOption
 pub use capability::{CapabilitySnapshotError, CapabilityState, CapabilityStatus};
 pub use error::{StorageErrorCode, StorageResult};
 pub use multipart::{CompletePart, ListMultipartsInfo, ListPartsInfo, MultipartInfo, MultipartUploadResult, PartInfo};
-pub use object::DeleteAccounting;
 pub use object::ObjectLockDeleteOptions;
 pub use object::{DeletedObject, ObjectToDelete};
 pub use object::{ExpirationOptions, TransitionedObject};

crates/storage-api/src/object.rs

@@ -218,17 +218,6 @@ pub struct DeletedObject {
     pub force_delete_generation: Option<i64>,
 }
 
-/// Accounting identity returned by the internal commit-time delete path.
-///
-/// This is carried separately from [`DeletedObject`] so adding quota details
-/// does not change the source shape of the public S3 delete result contract.
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub struct DeleteAccounting {
-    pub size: Option<u64>,
-    pub version_id: Option<Uuid>,
-    pub removed_current_object: bool,
-}
-
 impl DeletedObject {
     pub fn version_purge_status(&self) -> VersionPurgeStatusType {
         self.replication_state
@@ -352,19 +341,6 @@ pub trait ObjectOperations: Send + Sync + fmt::Debug {
         objects: Vec<Self::ObjectToDelete>,
         opts: Self::ObjectOptions,
     ) -> (Vec<Self::DeletedObject>, Vec<Option<Self::Error>>);
-    /// Delete objects and optionally return commit-time accounting identities.
-    /// The default preserves the ordinary delete contract for implementations
-    /// that do not expose storage-level accounting details.
-    async fn delete_objects_with_accounting(
-        &self,
-        bucket: &str,
-        objects: Vec<Self::ObjectToDelete>,
-        opts: Self::ObjectOptions,
-    ) -> (Vec<Self::DeletedObject>, Vec<Option<Self::Error>>, Vec<Option<DeleteAccounting>>) {
-        let object_count = objects.len();
-        let (deleted, errors) = self.delete_objects(bucket, objects, opts).await;
-        (deleted, errors, vec![None; object_count])
-    }
     async fn put_object_metadata(
         &self,
         bucket: &str,

crates/utils/src/envs.rs

@@ -268,7 +268,7 @@ where
         .parse::<T>()
         .map_err(|_| {
             log_once(&format!("env_invalid_value:{used_key}"), || {
-                format!("Invalid {} value for {used_key}. Treating as unset.", type_name::<T>())
+                format!("Invalid {} value for {used_key}: {value}. Treating as unset.", type_name::<T>())
             });
         })
         .ok()
@@ -570,7 +570,7 @@ where
         Ok(parsed) => EnvParseOutcome::Parsed(parsed),
         Err(_) => {
             log_once(&format!("env_invalid_value:{used_key}"), || {
-                format!("Invalid {} value for {used_key}. Treating as unset.", type_name::<T>())
+                format!("Invalid {} value for {used_key}: {value}. Treating as unset.", type_name::<T>())
             });
             EnvParseOutcome::Invalid
         }

docs/operations/scanner-runtime-controls.md

@@ -52,7 +52,7 @@ The `/v3/scanner/status` response reports each effective runtime value with a
 | `scanner.max_wait` | `RUSTFS_SCANNER_MAX_WAIT_SECS` | seconds | preset-derived | Caps one scanner sleep. |
 | `scanner.cycle` | `RUSTFS_SCANNER_CYCLE` | seconds | preset-derived | Sets the interval between scanner cycles. |
 | `scanner.start_delay` | `RUSTFS_SCANNER_START_DELAY_SECS` | seconds | unset | Sets startup delay and, for compatibility, the cycle interval when `scanner.cycle` is unset. |
-| `scanner.cycle_max_duration` | `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` | seconds | `1800` | Caps one cycle's runtime. An explicit `0` disables this budget. |
+| `scanner.cycle_max_duration` | `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` | seconds | `0` | Caps one cycle's runtime. `0` disables this budget. |
 | `scanner.cycle_max_objects` | `RUSTFS_SCANNER_CYCLE_MAX_OBJECTS` | objects | `0` | Caps objects processed by one cycle. `0` disables this budget. |
 | `scanner.cycle_max_directories` | `RUSTFS_SCANNER_CYCLE_MAX_DIRECTORIES` | directories | `0` | Caps directories entered by one cycle. `0` disables this budget. |
 | `heal.bitrot_cycle` | `RUSTFS_SCANNER_BITROT_CYCLE_SECS` | seconds | `2592000` | Controls periodic deep bitrot scans. `false`, `off`, `no`, or `disabled` disables periodic deep scans; `0`, `true`, `on`, or `yes` runs deep mode every scanner cycle. |
@@ -70,21 +70,6 @@ sleep multiplier, maximum wait, and cycle interval. Use `scanner.delay`,
 `scanner.max_wait`, and `scanner.cycle` when the preset is close but one axis
 needs a precise override.
 
-When the cycle duration control is unset, RustFS uses a finite 1800-second
-(30-minute) default, matching the scanner benchmark guidance. An explicit `0`
-preserves the compatibility behavior of an unbounded cycle; object and
-directory budgets likewise remain unbounded when explicitly set to `0`. Invalid
-or overflowing duration environment values are configuration errors rather than
-silent fallback values.
-
-When a finite deadline expires, RustFS cancels cooperative scanner work and
-waits only for the existing bounded shutdown window. A non-yielding I/O future
-is dropped after that window. RustFS then attempts a higher leadership epoch so
-late cycle, usage, cache, and remote writes from the old generation fail closed.
-If the worker cannot stop cooperatively, the cycle state was not confirmed
-durable, or that epoch fence cannot be durably persisted, the scanner reports
-`recovery-required`; it does not claim an uncooperative cursor was saved.
-
 An explicit `scanner.cycle` or `RUSTFS_SCANNER_CYCLE` is a minimum inter-cycle
 cadence: dirty-usage notifications do not bypass that configured interval.
 The default adaptive policy continues to use dirty-usage notifications to wake
@@ -159,10 +144,6 @@ metrics.maintenance_control.primary_control
 metrics.source_work
 metrics.replication_repair
 metrics.scan_checkpoint
-metrics.cycle_timeout_total
-metrics.cycle_last_progress_age
-metrics.leader_lease_without_progress
-metrics.cycle_recovery_required_total
 ```
 
 ## Reading Pacing Pressure

rustfs/src/admin/handlers/mod.rs

@@ -126,7 +126,6 @@ mod tests {
         let _list_remote_target_handler = replication::ListRemoteTargetHandler {};
         let _remove_remote_target_handler = replication::RemoveRemoteTargetHandler {};
         let _scanner_status_handler = scanner::ScannerStatusHandler {};
-        let _scanner_cycle_state_reset_handler = scanner::ScannerCycleStateResetHandler {};
         let _ilm_expiry_status_handler = scanner::IlmExpiryStatusHandler {};
         let _manual_transition_handler = ilm_transition::ManualTransitionRunHandler {};
         let _manual_transition_status_handler = ilm_transition::ManualTransitionJobStatusHandler {};

rustfs/src/admin/handlers/replication.rs

@@ -73,8 +73,6 @@ enum TargetUpdateOp {
     /// Connection group: credentials plus endpoint, target bucket, and TLS settings.
     Credentials,
     Sync,
-    /// Per-target read-proxy opt-out (`disableProxy`).
-    Proxy,
     Bandwidth,
     Path,
 }
@@ -83,13 +81,12 @@ fn parse_remote_target_update_ops(queries: &HashMap<String, String>) -> S3Result
     const SUPPORTED_OPS: &[(&str, TargetUpdateOp)] = &[
         ("creds", TargetUpdateOp::Credentials),
         ("sync", TargetUpdateOp::Sync),
-        ("proxy", TargetUpdateOp::Proxy),
         ("bandwidth", TargetUpdateOp::Bandwidth),
         ("path", TargetUpdateOp::Path),
     ];
     // Present in the MinIO wire contract, but they drive target fields this
     // version rejects as unsupported — fail loudly instead of silently ignoring.
-    const UNSUPPORTED_OPS: &[&str] = &["healthcheck", "edge", "edgeSyncBeforeExpiry"];
+    const UNSUPPORTED_OPS: &[&str] = &["proxy", "healthcheck", "edge", "edgeSyncBeforeExpiry"];
 
     for key in UNSUPPORTED_OPS {
         if queries.get(*key).is_some_and(|value| value == "true") {
@@ -315,10 +312,11 @@ impl RemoteTargetRequest {
             ));
         }
 
-        for (unsupported, configured) in REMOTE_TARGET_UNSUPPORTED_FIELDS
-            .iter()
-            .copied()
-            .zip([self.edge, self.edge_sync_before_expiry])
+        for (unsupported, configured) in
+            REMOTE_TARGET_UNSUPPORTED_FIELDS
+                .iter()
+                .copied()
+                .zip([self.disable_proxy, self.edge, self.edge_sync_before_expiry])
         {
             if configured {
                 return Err(s3_error!(
@@ -704,7 +702,6 @@ impl Operation for SetRemoteTargetHandler {
                         target.deployment_id = remote_target.deployment_id.clone();
                     }
                     TargetUpdateOp::Sync => target.replication_sync = remote_target.replication_sync,
-                    TargetUpdateOp::Proxy => target.disable_proxy = remote_target.disable_proxy,
                     TargetUpdateOp::Bandwidth => target.bandwidth_limit = remote_target.bandwidth_limit,
                     TargetUpdateOp::Path => target.path = remote_target.path.clone(),
                 }
@@ -1523,7 +1520,6 @@ mod tests {
             ("update", "true"),
             ("creds", "true"),
             ("sync", "true"),
-            ("proxy", "true"),
             ("bandwidth", "true"),
             ("path", "true"),
         ]))
@@ -1533,7 +1529,6 @@ mod tests {
             vec![
                 TargetUpdateOp::Credentials,
                 TargetUpdateOp::Sync,
-                TargetUpdateOp::Proxy,
                 TargetUpdateOp::Bandwidth,
                 TargetUpdateOp::Path
             ]
@@ -2075,6 +2070,7 @@ mod tests {
             ("credentials.session_token", serde_json::json!("session-token")),
             ("credentials.expiration", serde_json::json!("2026-01-01T00:00:00Z")),
             ("api", serde_json::json!("s3v2")),
+            ("disableProxy", serde_json::json!(true)),
             ("edge", serde_json::json!(true)),
             ("edgeSyncBeforeExpiry", serde_json::json!(true)),
         ] {
@@ -2304,44 +2300,6 @@ mod tests {
         assert!(!REMOTE_TARGET_UNSUPPORTED_FIELDS.contains(&"healthCheckDuration"));
     }
 
-    #[test]
-    fn remote_target_disable_proxy_is_declared_writable_edge_stays_unsupported() {
-        assert!(REMOTE_TARGET_WRITABLE_FIELDS.contains(&"disableProxy"));
-        assert!(!REMOTE_TARGET_UNSUPPORTED_FIELDS.contains(&"disableProxy"));
-        // edge sync has no implementation behind it — it must stay rejected.
-        assert!(REMOTE_TARGET_UNSUPPORTED_FIELDS.contains(&"edge"));
-        assert!(REMOTE_TARGET_UNSUPPORTED_FIELDS.contains(&"edgeSyncBeforeExpiry"));
-    }
-
-    #[test]
-    fn remote_target_create_accepts_disable_proxy() {
-        let mut request = valid_remote_target_request();
-        request["disableProxy"] = serde_json::json!(true);
-
-        let target = serde_json::from_value::<RemoteTargetRequest>(request)
-            .expect("request should deserialize")
-            .into_bucket_target()
-            .expect("disableProxy is a supported per-target read-proxy opt-out");
-
-        assert!(target.disable_proxy);
-    }
-
-    #[test]
-    fn update_body_with_proxy_op_toggles_disable_proxy_without_credentials() {
-        // Mirrors the other partial-update groups: a proxy-only update body may
-        // omit the connection fields entirely.
-        let body = serde_json::json!({
-            "arn": "arn:rustfs:replication:us-east-1:dep:target",
-            "type": "replication",
-            "disableProxy": true
-        });
-        let request: RemoteTargetRequest = serde_json::from_value(body).expect("partial update body should deserialize");
-        let target = request
-            .into_update_bucket_target(&[TargetUpdateOp::Proxy])
-            .expect("proxy-only update must not require credentials");
-        assert!(target.disable_proxy);
-    }
-
     #[test]
     fn remote_target_capability_fields_do_not_overlap() {
         for field in REMOTE_TARGET_UNSUPPORTED_FIELDS {

rustfs/src/admin/handlers/scanner.rs

@@ -13,11 +13,8 @@
 // limitations under the License.
 
 use crate::admin::auth::authorize_admin_request;
-use crate::admin::handlers::supervise_admin_mutation;
 use crate::admin::router::{AdminOperation, Operation, S3Router};
-use crate::admin::runtime_sources::{
-    app_context_from_req, current_object_store_handle_for_context, current_scanner_metrics_report,
-};
+use crate::admin::runtime_sources::current_scanner_metrics_report;
 use crate::module_switches::{ENV_SCANNER_ENABLED, scanner_enabled_from_env};
 use crate::server::ADMIN_PREFIX;
 use chrono::Utc;
@@ -25,13 +22,11 @@ use http::{HeaderMap, HeaderValue};
 use hyper::{Method, StatusCode};
 use matchit::Params;
 use rustfs_common::metrics::{ScannerLifecycleExpirySnapshot, ScannerMaintenanceControlSnapshot, ScannerMetricsReport};
-use rustfs_config::MAX_ADMIN_REQUEST_BODY_SIZE;
 use rustfs_credentials::Credentials;
 use rustfs_policy::policy::action::{Action, AdminAction};
 use s3s::header::CONTENT_TYPE;
 use s3s::{Body, S3Error, S3ErrorCode, S3Request, S3Response, S3Result, s3_error};
-use serde::{Deserialize, Serialize};
-use tokio_util::sync::CancellationToken;
+use serde::Serialize;
 
 const JSON_CONTENT_TYPE: &str = "application/json";
 
@@ -43,13 +38,6 @@ struct ScannerStatusResponse {
     metrics: ScannerMetricsReport,
     cycle_schedule: rustfs_scanner::ScannerCycleScheduleStatus,
     runtime_config: rustfs_scanner::runtime_config::ScannerRuntimeConfigStatus,
-    cycle_recovery: rustfs_scanner::ScannerCycleRecoveryStatus,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-struct ScannerCycleResetRequest {
-    mode: String,
 }
 
 #[derive(Debug, Serialize)]
@@ -129,7 +117,6 @@ fn scanner_status_response(
         metrics,
         cycle_schedule,
         runtime_config,
-        cycle_recovery: rustfs_scanner::scanner::scanner_cycle_recovery_status(),
     }
 }
 
@@ -157,11 +144,6 @@ pub fn register_scanner_route(r: &mut S3Router<AdminOperation>) -> std::io::Resu
         format!("{ADMIN_PREFIX}/v3/scanner/status").as_str(),
         AdminOperation(&ScannerStatusHandler {}),
     )?;
-    r.insert(
-        Method::POST,
-        format!("{ADMIN_PREFIX}/v3/scanner/cycle-state/reset").as_str(),
-        AdminOperation(&ScannerCycleStateResetHandler {}),
-    )?;
     r.insert(
         Method::GET,
         format!("{ADMIN_PREFIX}/v3/ilm/expiry/status").as_str(),
@@ -181,13 +163,6 @@ async fn validate_scanner_status_request(req: &S3Request<Body>) -> S3Result<Cred
     authorize_admin_request(req, vec![Action::AdminAction(AdminAction::ServerInfoAdminAction)]).await
 }
 
-async fn validate_scanner_reset_request(req: &S3Request<Body>) -> S3Result<Credentials> {
-    if req.credentials.is_none() {
-        return Err(s3_error!(InvalidRequest, "missing credentials"));
-    }
-    authorize_admin_request(req, vec![Action::AdminAction(AdminAction::ConfigUpdateAdminAction)]).await
-}
-
 fn json_response(body: Vec<u8>) -> S3Result<S3Response<(StatusCode, Body)>> {
     let mut headers = HeaderMap::new();
     let content_type = HeaderValue::from_str(JSON_CONTENT_TYPE)
@@ -217,37 +192,6 @@ impl Operation for ScannerStatusHandler {
 
 pub struct IlmExpiryStatusHandler {}
 
-pub struct ScannerCycleStateResetHandler {}
-
-#[async_trait::async_trait]
-impl Operation for ScannerCycleStateResetHandler {
-    async fn call(&self, mut req: S3Request<Body>, _params: Params<'_, '_>) -> S3Result<S3Response<(StatusCode, Body)>> {
-        let _cred = validate_scanner_reset_request(&req).await?;
-        let body = req
-            .input
-            .store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE)
-            .await
-            .map_err(|err| S3Error::with_message(S3ErrorCode::InvalidRequest, format!("invalid reset request body: {err}")))?;
-        let reset = serde_json::from_slice::<ScannerCycleResetRequest>(&body)
-            .map_err(|err| S3Error::with_message(S3ErrorCode::InvalidRequest, format!("invalid reset request body: {err}")))?;
-        if reset.mode != "full-rescan" {
-            return Err(S3Error::with_message(S3ErrorCode::InvalidRequest, "reset mode must be full-rescan"));
-        }
-        let context = app_context_from_req(&req)
-            .ok_or_else(|| S3Error::with_message(S3ErrorCode::InternalError, "storage layer not initialized"))?;
-        let store = current_object_store_handle_for_context(Some(context.as_ref()))
-            .ok_or_else(|| S3Error::with_message(S3ErrorCode::InternalError, "storage layer not initialized"))?;
-        supervise_admin_mutation("scanner cycle state reset", async move {
-            rustfs_scanner::scanner::reset_scanner_cycle_recovery(CancellationToken::new(), store)
-                .await
-                .map_err(|err| S3Error::with_message(S3ErrorCode::InternalError, err.to_string()))?;
-            Ok::<_, S3Error>(())
-        })
-        .await?;
-        json_response(br#"{"status":"reset","mode":"full-rescan"}"#.to_vec())
-    }
-}
-
 #[async_trait::async_trait]
 impl Operation for IlmExpiryStatusHandler {
     async fn call(&self, req: S3Request<Body>, _params: Params<'_, '_>) -> S3Result<S3Response<(StatusCode, Body)>> {
@@ -293,38 +237,6 @@ mod tests {
         assert_eq!(err.message(), Some("missing credentials"));
     }
 
-    #[tokio::test]
-    async fn scanner_reset_gate_rejects_missing_credentials() {
-        let req = S3Request {
-            input: Body::from(String::new()),
-            method: Method::POST,
-            uri: http::Uri::from_static("/rustfs/admin/v3/scanner/cycle-state/reset"),
-            headers: HeaderMap::new(),
-            extensions: http::Extensions::new(),
-            credentials: None,
-            region: None,
-            service: None,
-            trailing_headers: None,
-        };
-
-        let err = validate_scanner_reset_request(&req)
-            .await
-            .expect_err("a reset request without credentials must be rejected");
-        assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
-        assert_eq!(err.message(), Some("missing credentials"));
-    }
-
-    #[test]
-    fn admin_reset_requires_full_rescan_or_verified_cursor() {
-        let full_rescan: ScannerCycleResetRequest =
-            serde_json::from_str(r#"{"mode":"full-rescan"}"#).expect("full rescan must be accepted");
-        assert_eq!(full_rescan.mode, "full-rescan");
-        let cursor: ScannerCycleResetRequest =
-            serde_json::from_str(r#"{"mode":"cursor"}"#).expect("mode validation belongs to the handler");
-        assert_ne!(cursor.mode, "full-rescan");
-        assert!(serde_json::from_str::<ScannerCycleResetRequest>(r#"{"mode":"full-rescan","cursor":"untrusted"}"#).is_err());
-    }
-
     #[test]
     fn scanner_disabled_reason_reports_startup_env_key() {
         assert_eq!(scanner_disabled_reason(true), None);
@@ -392,11 +304,6 @@ mod tests {
         assert_eq!(encoded["cycle_schedule"]["effective_interval_seconds"], 0);
         assert_eq!(encoded["cycle_schedule"]["clean_idle_backoff_enabled"], false);
         assert_eq!(encoded["cycle_schedule"]["clean_idle_backoff_multiplier"], 1);
-        assert_eq!(encoded["cycle_recovery"]["state"], "healthy");
-        assert_eq!(
-            encoded["cycle_recovery"]["quarantine_path"],
-            rustfs_scanner::DATA_USAGE_BLOOM_RECOVERY_PATH.as_str()
-        );
     }
 
     #[test]

rustfs/src/admin/handlers/system.rs

@@ -1262,9 +1262,7 @@ mod tests {
         assert_eq!(response.summary.manual_transition_jobs.state, CapabilityState::Supported);
         assert_eq!(response.replication.contract_version, 1);
         assert_eq!(response.replication.bucket_replication.contract_version, 1);
-        // v2: disableProxy moved from unsupported to writable (per-target
-        // read-proxy opt-out reached the admin API).
-        assert_eq!(response.replication.remote_targets.contract_version, 2);
+        assert_eq!(response.replication.remote_targets.contract_version, 1);
         assert_eq!(response.replication.bucket_replication.status.state, CapabilityState::Supported);
         assert_eq!(response.replication.remote_targets.status.state, CapabilityState::Supported);
         assert_eq!(
@@ -1295,15 +1293,7 @@ mod tests {
                 .remote_targets
                 .fields
                 .iter()
-                .any(|field| field.name == "disableProxy" && field.state == super::ReplicationFieldState::Supported)
-        );
-        assert!(
-            response
-                .replication
-                .remote_targets
-                .fields
-                .iter()
-                .any(|field| field.name == "edge" && field.state == super::ReplicationFieldState::Unsupported)
+                .any(|field| field.name == "disableProxy" && field.state == super::ReplicationFieldState::Unsupported)
         );
         assert!(
             response
@@ -1374,7 +1364,7 @@ mod tests {
         assert_eq!(value["summary"]["manual_transition_jobs"]["state"], "supported");
         assert_eq!(value["replication"]["contract_version"], 1);
         assert_eq!(value["replication"]["bucket_replication"]["contract_version"], 1);
-        assert_eq!(value["replication"]["remote_targets"]["contract_version"], 2);
+        assert_eq!(value["replication"]["remote_targets"]["contract_version"], 1);
         assert_eq!(value["replication"]["bucket_replication"]["status"]["state"], "supported");
         assert_eq!(value["replication"]["remote_targets"]["status"]["state"], "supported");
         assert_eq!(
@@ -1393,14 +1383,7 @@ mod tests {
                 .as_array()
                 .expect("remote target fields should be an array")
                 .iter()
-                .any(|field| field["name"] == "disableProxy" && field["state"] == "supported")
-        );
-        assert!(
-            value["replication"]["remote_targets"]["fields"]
-                .as_array()
-                .expect("remote target fields should be an array")
-                .iter()
-                .any(|field| field["name"] == "edge" && field["state"] == "unsupported")
+                .any(|field| field["name"] == "disableProxy" && field["state"] == "unsupported")
         );
         assert!(
             value["replication"]["remote_targets"]["fields"]

rustfs/src/admin/route_policy.rs

@@ -428,12 +428,6 @@ pub const ADMIN_ROUTE_POLICY_SPECS: &[AdminRouteSpec] = &[
     admin(HttpMethod::Get, "/rustfs/admin/v3/config", CONFIG_UPDATE, RouteRiskLevel::High),
     admin(HttpMethod::Put, "/rustfs/admin/v3/config", CONFIG_UPDATE, RouteRiskLevel::High),
     admin(HttpMethod::Get, "/rustfs/admin/v3/scanner/status", SERVER_INFO, RouteRiskLevel::Sensitive),
-    admin(
-        HttpMethod::Post,
-        "/rustfs/admin/v3/scanner/cycle-state/reset",
-        CONFIG_UPDATE,
-        RouteRiskLevel::High,
-    ),
     admin(
         HttpMethod::Get,
         "/rustfs/admin/v3/ilm/expiry/status",
@@ -2026,12 +2020,6 @@ mod tests {
         assert_not_action(HttpMethod::Get, "/rustfs/admin/v3/ilm/expiry/status", SET_TIER);
     }
 
-    #[test]
-    fn route_policy_requires_config_update_for_scanner_cycle_reset() {
-        assert_action(HttpMethod::Post, "/rustfs/admin/v3/scanner/cycle-state/reset", CONFIG_UPDATE);
-        assert_not_action(HttpMethod::Post, "/rustfs/admin/v3/scanner/cycle-state/reset", SERVER_INFO);
-    }
-
     #[test]
     fn route_policy_uses_tier_actions_for_transition_routes() {
         assert_action(HttpMethod::Post, "/rustfs/admin/v3/ilm/transition/run", SET_TIER);

rustfs/src/admin/route_registration_test.rs

@@ -243,7 +243,6 @@ fn expected_admin_route_matrix() -> Vec<RouteMatrixEntry> {
         admin_route(Method::GET, "/v3/config"),
         admin_route(Method::PUT, "/v3/config"),
         admin_route(Method::GET, "/v3/scanner/status"),
-        admin_route(Method::POST, "/v3/scanner/cycle-state/reset"),
         admin_route(Method::GET, "/v3/audit/target/list"),
         admin_route_sample(
             Method::PUT,
@@ -880,7 +879,6 @@ fn test_register_routes_cover_representative_admin_paths() {
     assert_route(&router, Method::GET, &admin_path("/v3/config"));
     assert_route(&router, Method::PUT, &admin_path("/v3/config"));
     assert_route(&router, Method::GET, &admin_path("/v3/scanner/status"));
-    assert_route(&router, Method::POST, &admin_path("/v3/scanner/cycle-state/reset"));
     assert_route(&router, Method::GET, &admin_path("/v3/ilm/expiry/status"));
     assert_route(&router, Method::POST, &admin_path("/v3/ilm/transition/run"));
     assert_route(
@@ -1369,7 +1367,6 @@ fn test_admin_alias_paths_match_existing_admin_routes() {
         (Method::GET, compat_admin_alias_path("/v3/config")),
         (Method::PUT, compat_admin_alias_path("/v3/config")),
         (Method::GET, compat_admin_alias_path("/v3/scanner/status")),
-        (Method::POST, compat_admin_alias_path("/v3/scanner/cycle-state/reset")),
         (Method::GET, compat_admin_alias_path("/v3/ilm/expiry/status")),
     ] {
         assert!(

rustfs/src/app/bucket_usecase.rs

@@ -1021,7 +1021,7 @@ fn build_list_objects_v2_metadata_output(
                 object: Object {
                     key: Some(encode_list_objects_v2_value(&object.name, encoding_type)),
                     last_modified: object.mod_time.map(Timestamp::from),
-                    size: Some(object.get_actual_size_or_physical()),
+                    size: Some(object.get_actual_size().unwrap_or_default()),
                     e_tag: object.etag.clone().map(|etag| to_s3s_etag(&etag)),
                     storage_class: Some(ObjectStorageClass::from(
                         object

rustfs/src/app/object_usecase.rs

@@ -3969,55 +3969,6 @@ fn delete_creates_delete_marker(opts: &ObjectOptions) -> bool {
     opts.version_id.is_none() && opts.versioned && !opts.version_suspended
 }
 
-fn delete_removes_current_object(opts: &ObjectOptions) -> bool {
-    delete_request_targets_current(
-        opts.version_id
-            .as_deref()
-            .and_then(|version_id| Uuid::parse_str(version_id).ok()),
-    )
-}
-
-fn delete_request_targets_current(version_id: Option<Uuid>) -> bool {
-    version_id.is_none() || version_id.is_some_and(|version_id| version_id.is_nil())
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum DeleteMemoryUpdate {
-    DeleteMarker,
-    Object { size: u64, removed_current_object: bool },
-}
-
-fn delete_memory_update(
-    creates_delete_marker: bool,
-    committed_delete_marker: bool,
-    requested_current: bool,
-    accounting_size: Option<u64>,
-    removed_current_object: bool,
-) -> Option<DeleteMemoryUpdate> {
-    if creates_delete_marker || (committed_delete_marker && requested_current) {
-        return Some(DeleteMemoryUpdate::DeleteMarker);
-    }
-
-    (!committed_delete_marker)
-        .then_some(accounting_size)
-        .flatten()
-        .map(|size| DeleteMemoryUpdate::Object {
-            size,
-            removed_current_object,
-        })
-}
-
-async fn apply_delete_memory_update(bucket: &str, update: Option<DeleteMemoryUpdate>) {
-    match update {
-        Some(DeleteMemoryUpdate::DeleteMarker) => record_bucket_delete_marker_memory(bucket).await,
-        Some(DeleteMemoryUpdate::Object {
-            size,
-            removed_current_object,
-        }) => record_bucket_object_delete_memory(bucket, size, removed_current_object).await,
-        None => {}
-    }
-}
-
 /// `DeleteObjects` is idempotent. A raw filesystem `NotFound` can cross the
 /// distributed delete path instead of its usual typed missing-object error.
 fn is_delete_objects_not_found(error: &EcstoreError) -> bool {
@@ -8458,6 +8409,8 @@ impl DefaultObjectUsecase {
             object: ObjectToDelete,
             versioned: bool,
             version_suspended: bool,
+            size: i64,
+            existing: Option<ObjectInfo>,
         }
 
         // Phase 2 (bounded concurrency, backlog#929 / HP-8): collect the
@@ -8475,23 +8428,32 @@ impl DefaultObjectUsecase {
                     skip_stat,
                 } = prepared;
                 let synthetic_version_id = object.version_id.is_none() && is_dir_object(&object.object_name);
-                if !skip_stat {
+                let (goi, source_missing) = if skip_stat {
+                    (ObjectInfo::default(), false)
+                } else {
                     match store_ref.get_object_info(bucket_ref, &object.object_name, &opts).await {
-                        Ok(_) => {}
-                        Err(err) if is_err_object_not_found(&err) || is_err_version_not_found(&err) => {}
+                        Ok(res) => (res, false),
+                        Err(err) if is_err_object_not_found(&err) || is_err_version_not_found(&err) => {
+                            (ObjectInfo::default(), true)
+                        }
                         Err(err) => return Err(ApiError::from(err)),
                     }
-                }
+                };
+
+                let size = goi.size;
 
                 if synthetic_version_id {
                     object.version_id = Some(Uuid::nil());
                 }
 
+                let existing = (!skip_stat && !source_missing).then_some(goi);
                 Ok::<_, ApiError>(AdmittedDelete {
                     idx,
                     object,
                     versioned: opts.versioned,
                     version_suspended: opts.version_suspended,
+                    size,
+                    existing,
                 })
             }))
             .buffered(DELETE_OBJECTS_PRE_STAT_CONCURRENCY)
@@ -8502,11 +8464,15 @@ impl DefaultObjectUsecase {
         // per-key success/failure reporting is unchanged.
         let mut object_to_delete = Vec::new();
         let mut object_to_delete_idx = Vec::new();
+        let mut object_sizes = Vec::new();
+        let mut existing_object_infos = Vec::new();
         let mut object_versioning = Vec::new();
         for admitted in admitted_deletes {
+            object_sizes.push(admitted.size);
             object_to_delete_idx.push(admitted.idx);
             object_versioning.push((admitted.versioned, admitted.version_suspended));
             object_to_delete.push(admitted.object);
+            existing_object_infos.push(admitted.existing);
         }
         let cache_adapter = self.object_data_cache();
         let cache_keys_before_delete = object_to_delete
@@ -8523,8 +8489,8 @@ impl DefaultObjectUsecase {
             ..Default::default()
         };
         apply_bucket_generation_guard(&req, &bucket, &mut storage_delete_opts)?;
-        let (dobjs, errs, accounting) = store
-            .delete_objects_with_tier_delete_journal_and_accounting(&bucket, object_to_delete.clone(), storage_delete_opts)
+        let (dobjs, errs) = store
+            .delete_objects_with_tier_delete_journal(&bucket, object_to_delete.clone(), storage_delete_opts)
             .await;
 
         let _manager = get_concurrency_manager();
@@ -8549,16 +8515,17 @@ impl DefaultObjectUsecase {
                     delete_results[didx].delete_object = Some(deleted_object.clone());
                     let (versioned, version_suspended) = object_versioning[i];
                     let creates_delete_marker = object_to_delete[i].version_id.is_none() && versioned && !version_suspended;
-                    let committed_delete_marker = dobjs[i].delete_marker;
-                    let delete_accounting = accounting.get(i).and_then(Option::as_ref);
-                    let update = delete_memory_update(
-                        creates_delete_marker,
-                        committed_delete_marker,
-                        delete_request_targets_current(object_to_delete[i].version_id),
-                        delete_accounting.and_then(|value| value.size),
-                        delete_accounting.is_some_and(|value| value.removed_current_object),
-                    );
-                    apply_delete_memory_update(&bucket, update).await;
+                    if creates_delete_marker {
+                        record_bucket_delete_marker_memory(&bucket).await;
+                    } else {
+                        let size = object_sizes[i].max(0) as u64;
+                        record_bucket_object_delete_memory(
+                            &bucket,
+                            size,
+                            existing_object_infos[i].is_some() && object_to_delete[i].version_id.is_none(),
+                        )
+                        .await;
+                    }
                 }
                 Err(error) => {
                     delete_results[didx].error = Some(error);
@@ -8836,24 +8803,12 @@ impl DefaultObjectUsecase {
             let _ = invalidate_object_data_cache_after_delete_success(&cache_adapter, &bucket, &key).await;
         }
 
-        // Fast in-memory update for immediate quota and admin usage consistency.
-        // Prefix/force deletes and synthetic directory entries do not carry one
-        // committed object identity; leave their cache delta to reconciliation.
-        let update = if force_delete || obj_info.name.is_empty() || synthetic_version_id {
-            None
+        // Fast in-memory update for immediate quota and admin usage consistency
+        if delete_creates_delete_marker(&opts) {
+            record_bucket_delete_marker_memory(&bucket).await;
         } else {
-            // The storage commit returns this object's metadata while its
-            // generation lock is held. Never fall back to a pre-delete stat:
-            // an overwrite can commit between that stat and this delete.
-            delete_memory_update(
-                delete_creates_delete_marker(&opts),
-                obj_info.delete_marker,
-                opts.version_id.is_none(),
-                quota_object_size(&obj_info).ok(),
-                delete_removes_current_object(&opts),
-            )
-        };
-        apply_delete_memory_update(&bucket, update).await;
+            record_bucket_object_delete_memory(&bucket, obj_info.size.max(0) as u64, opts.version_id.is_none()).await;
+        }
 
         if obj_info.name.is_empty() {
             if let Some((operation_id, target_arns, generation)) = force_delete_intent {
@@ -17906,158 +17861,6 @@ mod tests {
         assert!(!can_skip_delete_objects_pre_stat(false, &delete_marker_creating_opts(), false));
     }
 
-    #[test]
-    fn delete_accounting_recognizes_explicit_null_as_current_object() {
-        let opts = ObjectOptions {
-            version_id: Some(Uuid::nil().to_string()),
-            version_suspended: true,
-            ..Default::default()
-        };
-        assert!(delete_removes_current_object(&opts));
-        assert!(delete_request_targets_current(Some(Uuid::nil())));
-        assert!(!delete_request_targets_current(Some(Uuid::new_v4())));
-        assert!(!delete_removes_current_object(&ObjectOptions {
-            version_id: Some(Uuid::new_v4().to_string()),
-            ..Default::default()
-        }));
-    }
-
-    #[test]
-    fn compressed_object_delete_restores_usage_baseline() {
-        let mut metadata = HashMap::new();
-        insert_str(&mut metadata, SUFFIX_COMPRESSION, "klauspost/compress/s2".to_string());
-        let object = ObjectInfo {
-            size: 400,
-            actual_size: 1000,
-            user_defined: Arc::new(metadata),
-            ..Default::default()
-        };
-        let accounting_size = quota_object_size(&object).expect("logical compressed size should be canonical");
-
-        assert_eq!(
-            delete_memory_update(false, false, true, Some(accounting_size), true),
-            Some(DeleteMemoryUpdate::Object {
-                size: 1000,
-                removed_current_object: true,
-            })
-        );
-    }
-
-    #[test]
-    fn invalid_accounting_metadata_is_reconciled_without_overflow() {
-        assert_eq!(delete_memory_update(false, false, true, None, true), None);
-        assert_eq!(
-            delete_memory_update(false, true, true, None, true),
-            Some(DeleteMemoryUpdate::DeleteMarker)
-        );
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn compressed_delete_requests_restore_usage_baseline() {
-        use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, DeleteBucketOptions, MakeBucketOptions};
-
-        let store = crate::app::gating_test_env::shared_gating_ecstore().await;
-        if current_app_context().is_none() {
-            crate::app::runtime_sources::install_test_app_context(Arc::clone(&store)).await;
-        }
-        let bucket = format!("compressed-delete-request-{}", Uuid::new_v4().simple());
-        store
-            .make_bucket(&bucket, &MakeBucketOptions::default())
-            .await
-            .expect("create compressed delete request bucket");
-
-        // Seed the process-local usage with the canonical logical bytes. The
-        // direct storage PUT below intentionally does not apply an app-layer
-        // usage delta; the two real DELETE requests must remove exactly this
-        // amount through their request-layer wiring.
-        crate::app::storage_api::test::data_usage::seed_bucket_usage_memory_for_test(&bucket, 2_000).await;
-
-        for object in ["single", "batch"] {
-            let mut metadata = HashMap::new();
-            insert_str(&mut metadata, SUFFIX_COMPRESSION, "klauspost/compress/s2".to_string());
-            insert_str(&mut metadata, SUFFIX_ACTUAL_SIZE, "1000".to_string());
-            let reader = HashReader::from_stream(std::io::Cursor::new(vec![0x5a; 400]), 400, 1000, None, None, false)
-                .expect("compressed fixture reader should be valid");
-            let mut reader = PutObjReader::new(reader);
-            store
-                .put_object(
-                    &bucket,
-                    object,
-                    &mut reader,
-                    &ObjectOptions {
-                        user_defined: metadata,
-                        ..Default::default()
-                    },
-                )
-                .await
-                .expect("compressed fixture object should be written");
-        }
-
-        let mut single_req = build_request(
-            DeleteObjectInput::builder()
-                .bucket(bucket.clone())
-                .key("single".to_string())
-                .build()
-                .expect("single delete input should build"),
-            Method::DELETE,
-        );
-        single_req.extensions.insert(crate::storage::access::ReqInfo {
-            cred: Some(rustfs_credentials::Credentials::default()),
-            is_owner: true,
-            ..Default::default()
-        });
-        DefaultObjectUsecase::from_global()
-            .execute_delete_object(single_req)
-            .await
-            .expect("single compressed delete should succeed");
-        assert_eq!(
-            crate::app::storage_api::test::data_usage::get_bucket_usage_memory(&bucket).await,
-            Some(1_000),
-            "single delete must subtract the logical accounting size"
-        );
-
-        let mut batch_req = build_request(
-            DeleteObjectsInput::builder()
-                .bucket(bucket.clone())
-                .delete(Delete {
-                    objects: vec![ObjectIdentifier {
-                        key: "batch".to_string(),
-                        ..Default::default()
-                    }],
-                    quiet: None,
-                })
-                .build()
-                .expect("batch delete input should build"),
-            Method::POST,
-        );
-        batch_req.extensions.insert(crate::storage::access::ReqInfo {
-            cred: Some(rustfs_credentials::Credentials::default()),
-            is_owner: true,
-            ..Default::default()
-        });
-        DefaultObjectUsecase::from_global()
-            .execute_delete_objects(batch_req)
-            .await
-            .expect("batch compressed delete should succeed");
-        assert_eq!(
-            crate::app::storage_api::test::data_usage::get_bucket_usage_memory(&bucket).await,
-            Some(0),
-            "batch delete must subtract the committed logical accounting size"
-        );
-
-        store
-            .delete_bucket(
-                &bucket,
-                &DeleteBucketOptions {
-                    force: true,
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("clean up compressed delete request bucket");
-    }
-
     #[tokio::test]
     async fn execute_get_object_attributes_returns_internal_error_when_store_uninitialized() {
         let input = GetObjectAttributesInput::builder()

rustfs/src/app/storage_api.rs

@@ -72,11 +72,6 @@ pub(crate) mod data_usage {
         compute_bucket_usage, live_bucket_usage_computations, seed_bucket_usage_memory_for_test, store_data_usage_in_backend,
     };
 
-    #[cfg(test)]
-    pub(crate) async fn get_bucket_usage_memory(bucket: &str) -> Option<u64> {
-        crate::storage::storage_api::ecstore_data_usage::get_bucket_usage_memory(bucket).await
-    }
-
     pub(crate) async fn record_bucket_object_delete_memory(bucket: &str, deleted_size: u64, removed_current_object: bool) {
         crate::storage::storage_api::ecstore_data_usage::record_bucket_object_delete_memory(
             bucket,
@@ -1238,10 +1233,7 @@ pub(crate) mod test {
 
     pub(crate) use super::access::ReqInfo;
     pub(crate) use super::options::VERSIONING_CONFIG_LOOKUPS;
-    pub(crate) use super::{bucket, ecfs, object_utils, runtime};
-    pub(crate) mod data_usage {
-        pub(crate) use super::super::data_usage::*;
-    }
+    pub(crate) use super::{bucket, data_usage, ecfs, object_utils, runtime};
     pub(crate) use crate::storage::storage_api::test_consumer::{get_global_bucket_metadata_sys, set_bucket_metadata};
     pub(crate) use crate::storage::storage_api::{
         ECStore, Endpoint, Endpoints, PoolEndpoints, StorageObjectInfo, StorageObjectOptions, StoragePutObjReader,

rustfs/src/storage/s3_api/bucket.rs

@@ -296,10 +296,7 @@ pub(crate) fn build_list_objects_v2_output(
             let mut obj = Object {
                 key: Some(key),
                 last_modified: v.mod_time.map(Timestamp::from),
-                // Compressed legacy objects may retain an unknown (-1)
-                // logical-size sentinel; never expose that internal value in
-                // an S3 response.
-                size: Some(v.get_actual_size_or_physical()),
+                size: Some(v.get_actual_size().unwrap_or_default()),
                 e_tag: v.etag.clone().map(|etag| to_s3s_etag(&etag)),
                 storage_class: v.storage_class.clone().map(ObjectStorageClass::from),
                 ..Default::default()
@@ -659,45 +656,6 @@ mod tests {
         assert_eq!(output.common_prefixes.as_ref().map(std::vec::Vec::len), Some(2));
     }
 
-    #[test]
-    fn list_objects_never_exposes_compressed_unknown_size_sentinel() {
-        let mut metadata = std::collections::HashMap::new();
-        rustfs_utils::http::insert_str(
-            &mut metadata,
-            rustfs_utils::http::SUFFIX_COMPRESSION,
-            "klauspost/compress/s2".to_string(),
-        );
-        let output = build_list_objects_v2_output(
-            ListObjectsV2Info {
-                objects: vec![ObjectInfo {
-                    name: "legacy-compressed".to_string(),
-                    size: 128,
-                    actual_size: -1,
-                    user_defined: std::sync::Arc::new(metadata),
-                    ..Default::default()
-                }],
-                ..Default::default()
-            },
-            false,
-            1000,
-            "bucket".to_string(),
-            String::new(),
-            None,
-            None,
-            None,
-            None,
-        );
-
-        assert_eq!(
-            output
-                .contents
-                .as_ref()
-                .and_then(|objects| objects.first())
-                .and_then(|object| object.size),
-            Some(128)
-        );
-    }
-
     #[test]
     fn list_responses_report_standard_for_legacy_label_only_file_metadata() {
         let version_id = Uuid::parse_str("11111111-2222-3333-4444-555555555555").expect("fixture version ID should be valid");

rustfs/src/storage/storage_api.rs

@@ -429,8 +429,6 @@ pub(crate) mod ecstore_config {
 }
 
 pub(crate) mod ecstore_data_usage {
-    #[cfg(test)]
-    pub(crate) use rustfs_ecstore::api::data_usage::get_bucket_usage_memory;
     pub(crate) use rustfs_ecstore::api::data_usage::{
         apply_bucket_usage_memory_overlay, init_compression_total_memory_from_backend, load_admin_data_usage_from_backend_cached,
         load_data_usage_from_backend, quota_object_size, record_bucket_delete_marker_memory, record_bucket_object_delete_memory,