test(heal): cover privileged mount readiness

Add Linux-only ignored replacement readiness tests for independent mount admission and same-device sibling rejection. Co-Authored-By: heihutu <heihutu@gmail.com>
2026-08-14 00:53:14 +00:00 · 2026-08-10 13:33:39 +08:00
328 changed files with 11964 additions and 52082 deletions
@@ -34,8 +34,7 @@ e2e-vault = { max-threads = 1 }

 # Reliability / fault-injection e2e tests each spawn a single-node 4-disk RustFS
 # server and manipulate its disk directories at runtime (crates/e2e_test:
-# reliability_disk_fault_test, degraded_read_eof_regression_test / dist-13, and
-# replacement_privileged_e2e_test when explicitly run as root on Linux). They
+# reliability_disk_fault_test, degraded_read_eof_regression_test / dist-13). They
 # are correct in isolation but resource-heavy; serialize them under nextest's
 # process boundary (serial_test's #[serial] does not cross it) so several 4-disk
 # servers never run at once. ci-7's nightly picks these up via the e2e suite;
@@ -91,7 +90,7 @@ test-group = 'ecstore-serial-flaky'
 # e2e-reliability test-group note above). The matching ci-profile override is at
 # the end of the file, after [profile.ci] is declared.
 [[profile.default.overrides]]
-filter = 'package(e2e_test) & test(/^(reliability_disk_fault|degraded_read_eof_regression|replacement_privileged_e2e)_test::/)'
+filter = 'package(e2e_test) & test(/^(reliability_disk_fault|degraded_read_eof_regression)_test::/)'
 test-group = 'e2e-reliability'

 [[profile.default.overrides]]
@@ -156,7 +155,7 @@ retries = 2
 # quarantine: no retries, just single-threaded so several 4-disk servers never
 # run concurrently when ci-7's nightly runs the full e2e suite.
 [[profile.ci.overrides]]
-filter = 'package(e2e_test) & test(/^(reliability_disk_fault|degraded_read_eof_regression|replacement_privileged_e2e)_test::/)'
+filter = 'package(e2e_test) & test(/^(reliability_disk_fault|degraded_read_eof_regression)_test::/)'
 test-group = 'e2e-reliability'

 # Serialize the multipart crash-consistency scenarios under the ci profile too
@@ -219,7 +218,7 @@ test-group = 'ecstore-serial-flaky'
 # the nightly profile derives its set as "the replication module MINUS this
 # allowlist", so any new replication test lands in nightly by default (never
 # silently unrun) until it is explicitly blessed as fast here. Keep the two
-# regexes byte-identical. Count invariant: 20 here + 49 nightly = 69 total
+# regexes byte-identical. Count invariant: 20 here + 36 nightly = 56 total
 # (authority: `cargo nextest list`; docs/testing/e2e-suite-inventory.md).
 # HISTORY (2026-07-11): the 20 fast tests were briefly pulled out of this lane
 # (#4724) because they set a loopback (127.0.0.1) replication target that the
@@ -345,7 +344,7 @@ path = "junit.xml"
 #     object_lambda) — too heavy for the merge budget; they run in ci-7's
 #     nightly 4-node lane.
 #   * replication_extension_test — repl-1 already splits it into the PR
-#     `e2e-smoke` (20 fast) and `e2e-repl-nightly` (49 slow) lanes and reserves
+#     `e2e-smoke` (20 fast) and `e2e-repl-nightly` (27 slow) lanes and reserves
 #     it for those, so e2e-full does not double-run it.
 #   * #[ignore]d tests — nextest skips them by default (no --run-ignored); the
 #     manual-localhost:9000 reliant/policy tests are ci-13's migration.
@@ -384,7 +383,7 @@ path = "junit.xml"
 # quarantine: no retries, just single-threaded so several 4-disk servers never
 # run concurrently.
 [[profile.e2e-full.overrides]]
-filter = 'package(e2e_test) & test(/^(reliability_disk_fault|degraded_read_eof_regression|replacement_privileged_e2e)_test::/)'
+filter = 'package(e2e_test) & test(/^(reliability_disk_fault|degraded_read_eof_regression)_test::/)'
 test-group = 'e2e-reliability'

 [[profile.e2e-full.overrides]]
@@ -17,11 +17,9 @@
 # =============================================================================
 #
 # Metric source: the KMS operation-policy choke point in
-# crates/kms/src/policy.rs, except KmsKeyRotationOverdue, which reads the
-# label-less key-lifecycle gauge published by the deletion worker's sweep
-# (crates/kms/src/deletion_worker.rs). All label values are bounded static
-# strings (operation, op_class, outcome, error_class, backend, scope); key
-# identifiers, key material, and tokens never appear in labels.
+# crates/kms/src/policy.rs. All label values are bounded static strings
+# (operation, op_class, outcome, error_class, backend, scope); key identifiers,
+# key material, and tokens never appear in labels.
 #
 # Response procedures: docs/operations/kms-observability-runbook.md
 #
@@ -214,38 +212,3 @@ groups:
            circuit_open until the half-open probe succeeds or returns
            a non-retryable failure.
          runbook_url: "https://github.com/rustfs/rustfs/blob/main/docs/operations/kms-observability-runbook.md#kmsbackendcircuitopen"
-
-      # ------------------------------------------------------------------
-      # 7. KmsKeyRotationOverdue
-      #    The least recently rotated usable key has gone more than 400
-      #    days without a rotation (measured from creation for keys with
-      #    no recorded rotation). Direct gauge state published by the
-      #    deletion worker's sweep, so no traffic guard applies; the
-      #    one-hour hold only bridges scrape gaps. The worker runs only
-      #    on backends with the schedule_deletion capability, so on the
-      #    Static backend the series never exists and this alert cannot
-      #    fire — that backend cannot rotate either; see the rotation
-      #    driver matrix in docs/operations/kms-backend-security.md.
-      #    Threshold: 400 days — conservative default sitting above a
-      #    one-year rotation policy. Align it with the rotation period
-      #    your compliance policy requires, and with
-      #    RUSTFS_KMS_ROTATION_MAX_AGE_SECS so the per-key rotation_due
-      #    verdict and this aggregate alert agree.
-      # ------------------------------------------------------------------
-      - alert: KmsKeyRotationOverdue
-        expr: |
-          rustfs_kms_oldest_key_rotation_age_seconds > (400 * 86400)
-        for: 1h
-        labels:
-          severity: warning
-          component: kms
-        annotations:
-          summary: "Oldest KMS key unrotated for more than 400 days"
-          description: >-
-            The least recently rotated usable KMS key was last rotated
-            {{ $value | humanizeDuration }} ago (measured from creation
-            for keys with no recorded rotation). List keys through the
-            admin API and read rotation_due / rotation_due_reason for
-            the per-key verdict; an "unsupported" reason means the
-            backend cannot rotate at all.
-          runbook_url: "https://github.com/rustfs/rustfs/blob/main/docs/operations/kms-observability-runbook.md#kmskeyrotationoverdue"
@@ -85,7 +85,7 @@ runs:
        repo-token: ${{ github.token }}

    - name: Install flatc
-      uses: Nugine/setup-flatc@698800de72a96bfb22cf60431dc21a2ff9a7e07b # v1
+      uses: Nugine/setup-flatc@e7855e994773ce90094a3f1626d4afc9080c23ae # v1
      with:
        version: "25.12.19"

@@ -55,142 +55,3 @@ jobs:

      - name: Build RustFS
        run: cargo build --release --locked --target x86_64-unknown-linux-gnu -p rustfs --bins
-
-  # Live-Vault lane for the rustfs-kms suite (rustfs/backlog#1774).
-  #
-  # RUSTFS_KMS_VAULT_TOKEN is the single switch that adds the Vault KV2 and
-  # Vault Transit backends to every for_each_backend spec in
-  # crates/kms/tests/behavior_*.rs (see crates/kms/AGENTS.md). rotate and
-  # versioning are advertised only by the Vault backends, so without this lane
-  # no CI run ever asserts the working half of behavior_rotation.rs — a
-  # rotation that silently dropped historical key versions would stay green.
-  # The same lane runs the dev-Vault #[ignore] tests and the two self-hosting
-  # live scripts (AppRole login, three-node Raft leader failover).
-  #
-  # GitHub-hosted ubuntu-latest, deliberately not the self-hosted sm-standard
-  # fleet: the HA failover script needs a working Docker daemon, and the
-  # self-hosted fleet is heterogeneous — a docker-dependent workflow has been
-  # burned by it before (see the banner in e2e-s3tests.yml, rustfs/backlog#1149).
-  kms-vault-lane:
-    name: KMS live Vault lane
-    runs-on: ubuntu-latest
-    timeout-minutes: 90
-    env:
-      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
-      # Root token of the ephemeral loopback dev server. Not a secret: the
-      # server lives only for this job, listens on 127.0.0.1, and holds only
-      # keys the tests create. The literal value matters — the dev-Vault
-      # #[ignore] fixtures in crates/kms/src/backends/vault.rs hardcode it.
-      VAULT_LANE_TOKEN: dev-only-token
-      VAULT_LANE_ADDR: http://127.0.0.1:8200
-      # Keeps a runner-level proxy from swallowing the loopback dev-server
-      # traffic (see crates/kms/AGENTS.md). Actions env keys are
-      # case-insensitive, so only the uppercase form is set; reqwest reads
-      # either casing.
-      NO_PROXY: 127.0.0.1,localhost
-    steps:
-      - name: Checkout main branch
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-          ref: main
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          # Dedicated key: rust-cache cannot tell runner images apart, so
-          # sharing a key with an sm-standard lane would let two different
-          # system images overwrite each other's artifacts (same reasoning as
-          # ci.yml's ci-uring lane). Saved from this nightly job itself so the
-          # next night starts warm.
-          cache-shared-key: kms-vault-lane
-          cache-save-if: 'true'
-          install-build-packaging-tools: 'false'
-          install-test-tools: 'false'
-
-      - name: Install Vault CLI
-        run: |
-          set -euo pipefail
-          wget -qO- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
-          echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list >/dev/null
-          sudo apt-get update -qq
-          sudo apt-get install -y -qq vault
-          vault version
-
-      - name: Start Vault dev server with KV2 and Transit engines
-        run: |
-          set -euo pipefail
-          nohup vault server -dev \
-            -dev-root-token-id="${VAULT_LANE_TOKEN}" \
-            -dev-listen-address=127.0.0.1:8200 >/tmp/vault-dev.log 2>&1 &
-          for _ in $(seq 1 60); do
-            if curl -fsS "${VAULT_LANE_ADDR}/v1/sys/health" >/dev/null 2>&1; then
-              break
-            fi
-            sleep 1
-          done
-          curl -fsS "${VAULT_LANE_ADDR}/v1/sys/health"
-          export VAULT_ADDR="${VAULT_LANE_ADDR}" VAULT_TOKEN="${VAULT_LANE_TOKEN}"
-          # Dev mode mounts KV v2 at secret/ by default; Transit is explicit.
-          # Prove both engines actually work rather than assuming the defaults.
-          vault secrets enable transit
-          vault kv put secret/rustfs-ci-lane-probe value=ok >/dev/null
-          vault kv get secret/rustfs-ci-lane-probe >/dev/null
-          vault write -f transit/keys/rustfs-ci-lane-probe >/dev/null
-
-      - name: Run rustfs-kms suite with the Vault lane on
-        env:
-          RUSTFS_KMS_VAULT_TOKEN: ${{ env.VAULT_LANE_TOKEN }}
-          RUSTFS_KMS_VAULT_ADDR: ${{ env.VAULT_LANE_ADDR }}
-        run: cargo test -p rustfs-kms --locked
-
-      - name: Run dev-Vault ignored tests
-        env:
-          RUSTFS_KMS_VAULT_TOKEN: ${{ env.VAULT_LANE_TOKEN }}
-          RUSTFS_KMS_VAULT_ADDR: ${{ env.VAULT_LANE_ADDR }}
-        # Filters select the dev-Vault-only #[ignore] tests. The AWS #[ignore]
-        # tests (backends::aws, service_manager) stay excluded — they need real
-        # AWS credentials and create billable keys. The AppRole and HA #[ignore]
-        # tests are excluded here because their own scripts below provision the
-        # Vault topology they need.
-        run: |
-          set -euo pipefail
-          cargo test -p rustfs-kms --locked --lib backends::contract_tests -- --ignored
-          cargo test -p rustfs-kms --locked --lib backends::vault -- --ignored
-          cargo test -p rustfs-kms --locked --test vault_fault_injection -- --ignored
-
-      - name: Run AppRole live checks (self-hosting ephemeral Vault)
-        run: bash scripts/test/vault_approle_kms_live.sh
-
-      - name: Show Vault dev server log on failure
-        if: failure()
-        run: tail -n 200 /tmp/vault-dev.log || true
-
-  # Three-node Raft leader failover (crates/kms/tests/vault_ha_failover_live.rs,
-  # first validated by rustfs/rustfs#5653). Its own job so an election-timing
-  # flake cannot mask the main lane's verdict, and vice versa. The script
-  # provisions and tears down its own Docker cluster.
-  kms-vault-ha-failover:
-    name: KMS Vault HA failover lane
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    env:
-      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
-      NO_PROXY: 127.0.0.1,localhost
-    steps:
-      - name: Checkout main branch
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-          ref: main
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          cache-shared-key: kms-vault-lane
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
-          install-test-tools: 'false'
-
-      - name: Run HA leader failover live checks (three-node Raft cluster in Docker)
-        run: bash scripts/test/vault_ha_kms_live.sh
@@ -322,17 +322,6 @@ jobs:
          sudo apt-get update && sudo apt-get install -y ruby ruby-dev build-essential
          sudo gem install fpm

-          # Create config file for fpm (DEB build creates it in its package dir structure,
-          # but fpm needs the file to exist before packaging)
-          mkdir -p ./tmp-pkg/etc/default
-          cat > ./tmp-pkg/etc/default/rustfs << 'ENVEOF'
-          # RustFS Environment Configuration
-          # See https://rustfs.com/docs/ for more information
-          # RUSTFS_VOLUMES=""
-          # RUSTFS_ROOT_USER=""
-          # RUSTFS_ROOT_PASSWORD=""
-          ENVEOF
-
          fpm -s dir -t rpm \
            --name rustfs \
            --version "$VERSION" \
@@ -373,7 +362,6 @@ jobs:
            ) \
            --config-files /etc/default/rustfs \
            ./bin/rustfs=/usr/bin/rustfs \
-            ./tmp-pkg/etc/default/rustfs=/etc/default/rustfs \
            deploy/build/rustfs.service=/lib/systemd/system/rustfs.service \
            LICENSE=/usr/share/doc/rustfs/LICENSE \
            README.md=/usr/share/doc/rustfs/README.md
@@ -1,6 +1,6 @@
 # ARCHITECTURE.md

-> Last updated: 2026-08-12 · Revision: 3
+> Last updated: 2026-07-02 · Revision: 2
 >
 > This document describes the high-level architecture of RustFS.
 > If you want to familiarize yourself with the code base, you are in the right place!
@@ -119,44 +119,19 @@ module split is tracked under `docs/architecture/`.

 3. **Each type has exactly one definition.** Types shared across crates must be defined
   in one crate and re-exported or imported by others.
-   - ⚠️ VIOLATED: `ReplicationStats` names three unrelated types
-     (`crates/data-usage/src/data_usage.rs`,
-     `crates/obs/src/metrics/collectors/replication.rs`,
-     `crates/ecstore/src/bucket/replication/replication_state.rs`) — a naming
-     collision, not copies; renaming is tracked in rustfs/backlog#1847.
-   - `LastMinuteLatency` has two deliberately different implementations: the
-     per-second bucketed accumulator in `crates/common/src/last_minute.rs` and
-     the in-memory endpoint-health sample tracker in
-     `crates/ecstore/src/bucket/bucket_target_sys.rs` (its doc comment explains
-     why it stays local).
-   - ✅ RESOLVED: `BackpressureConfig` and `DataUsageInfo` each have exactly one
-     definition (`crates/io-core/src/backpressure.rs`,
-     `crates/data-usage/src/data_usage.rs`). The zero-consumer
-     `BackpressureSettings` copy that lingered in io-metrics was removed
-     (rustfs/backlog#1833).
+   - ⚠️ VIOLATED: `ReplicationStats` (4 copies), `LastMinuteLatency` (3 copies),
+     `BackpressureConfig` (3 copies), `DataUsageInfo` (2 copies).

 4. **ecstore does not know about HTTP or S3 protocol details.** It operates on
   storage-level abstractions (objects, buckets, disks, pools).
-   - ⚠️ VIOLATED: 58 files under `crates/ecstore/src` reference `s3s`
-     (`rg -l 's3s' crates/ecstore/src | wc -l`), `crates/ecstore/src/client/`
-     is a ~9.4K-line embedded S3 HTTP client, and `crates/ecstore/Cargo.toml`
-     depends on `s3s`, `http`, `hyper`/`hyper-util`/`hyper-rustls`, and
-     `reqwest`. Target state: the engine's need to act as an S3 client
-     (tiering, replication targets) is served by an extracted client crate,
-     and ecstore holds no wire or DTO types.

 5. **The `rustfs` binary crate is the only place that wires everything together.**
   Individual crates should be testable in isolation.

 6. **Error types use `thiserror` with descriptive names** (e.g., `StorageError`,
   not bare `Error`).
-   - ✅ RESOLVED (strategy): `snafu` is gone from source
-     (`rg -l snafu crates/ rustfs/` is empty) and library code no longer uses
-     `anyhow` (remaining hits are test code and the `e2e_test` crate; `heal`
-     uses `thiserror`).
-   - ⚠️ VIOLATED (naming): 6 crates still export a bare `pub enum Error`:
-     `crypto`, `filemeta`, `heal`, `iam`, `policy`, and `replication`
-     (`src/resync.rs`) — all `thiserror`-derived.
+   - ⚠️ VIOLATED: 6 crates use `pub enum Error`; 2 crates use `snafu`;
+      `heal` use `anyhow` in library code.

 ## Known Structural Issues

@@ -165,25 +140,13 @@ module split is tracked under `docs/architecture/`.

 ### Critical

- **scanner/data-usage duplicate `.usage-cache.bin` serialization types.** The
-  original finding ("common/scanner code duplication, ~3K lines") is resolved:
-  `scanner` imports the shared data-usage types from `rustfs-data-usage` (see
-  the `pub use rustfs_data_usage::…` re-exports at the top of
-  `crates/scanner/src/data_usage_define.rs`). What remains: `scanner` and
-  `data-usage` each hold their own serialization types for the scanner cache
-  file (`DataUsageCacheInfo`/`DataUsageEntryInfo` in
-  `crates/scanner/src/data_usage_define.rs` vs
-  `DataUsageCacheInfo`/`DataUsageEntry` in
-  `crates/data-usage/src/data_usage.rs`); convergence is tracked in
-  rustfs/backlog#1828.
+- **common/scanner code duplication (~3K lines).** `scanner` depends on `common`
+  but maintains its own copies of `DataUsageInfo`, `LastMinuteLatency`, and related
+  types instead of importing them.

- **ecstore is a monolith (265 files, ~288K lines — roughly half is inline
-  `#[cfg(test)]` code).** Measured with
-  `find crates/ecstore/src -name '*.rs' | xargs wc -l`. It contains disk
-  management, bucket management, erasure coding, replication, lifecycle, RPC,
-  and configuration — all in one crate. It should be decomposed along its
-  existing subdirectories; the split plan lives in
-  [docs/architecture/ecstore-module-split-plan.md](docs/architecture/ecstore-module-split-plan.md).
+- **ecstore is a monolith (87K lines, 163 files).** It contains disk management,
+  bucket management, erasure coding, replication, lifecycle, RPC, and configuration
+  — all in one crate. It should be decomposed along its existing subdirectories.

 ### High

@@ -191,26 +154,19 @@ module split is tracked under `docs/architecture/`.
  `common → filemeta/madmin` edges must stay removed so leaf/helper crates do
  not regain upward dependencies.

- **Three-layer backpressure/deadlock policy bridging** across io-core,
-  concurrency, and `rustfs/src/storage`. The config types are no longer
-  duplicated (`BackpressureConfig` and `DeadlockDetectorConfig` are each
-  defined once, in io-core). Storage policies expose and consume explicit
-  projections into the concurrency/io-core policy shapes, and workload
+- **Three-layer BackpressureConfig/DeadlockConfig duplication** across io-core,
+  concurrency, and `rustfs/src/storage`. Storage policies now expose and consume
+  explicit projections into the concurrency/io-core policy shapes, and workload
  admission snapshots are composed through provider registries; later work
  should use those bridges before deleting compatibility wrappers.

 ### Medium

- **Bare `Error` naming.** Error-handling strategy has converged on `thiserror`
-  (no `snafu`, no `anyhow` in library code); the remaining inconsistency is the
-  bare `pub enum Error` naming in the 6 crates listed under Invariant 6.
+- **Inconsistent error handling.** Three strategies (thiserror/snafu/anyhow) and
+  mixed naming (bare `Error` vs descriptive names).

- **`common` is mostly parked domain code, not shared utilities.** Of its
-  6,724 lines, ~83% is scanner/heal domain code stranded there to break
-  dependency cycles (`metrics.rs`, ~4,810 lines of scanner-domain metrics;
-  `heal_channel.rs`, ~776 lines of heal-domain channel types). The
-  "common vs utils" naming ambiguity is secondary to moving that code to its
-  domain owners.
+- **Ambiguous common vs utils boundary.** Both described as "utilities and data
+  structures." Need clear ownership rules.

 ## Cross-Cutting Concerns

@@ -276,7 +232,7 @@ The binary (`main.rs`) boots in this order:

 ```
                            ┌─────────┐
-                            │  rustfs │  (binary + lib)
+                            │  rustfs │  (binary + lib, 75K lines)
                            │  main   │
                            └────┬────┘
                                 │
@@ -299,7 +255,7 @@ The binary (`main.rs`) boots in this order:
              │                  │                  │
        ┌─────▼──────┐    ┌──────▼──────┐    ┌──────▼──────┐
        │  ecstore   │    │     rio     │    │   io-core   │
-        │   (core)   │    │  (readers)  │    │ (zero-copy) │
+        │ (87K,core) │    │  (readers)  │    │ (zero-copy) │
        └─────┬──────┘    └─────────────┘    └─────────────┘
              │
     ┌─────┬──┼──┬─────┬──────┐
@@ -104,12 +104,6 @@ dependencies = [
 "memchr",
 ]

-[[package]]
-name = "aliasable"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
-
 [[package]]
 name = "aligned-vec"
 version = "0.6.4"
@@ -272,24 +266,24 @@ checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"

 [[package]]
 name = "apache-avro"
-version = "0.22.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "312c1ea69e5fe9966e0029fb95aca8790100b85aff4f0d3b00a9337c74069a9c"
+checksum = "36fa98bc79671c7981272d91a8753a928ff6a1cd8e4f20a44c45bd5d313840bf"
 dependencies = [
 "bigdecimal",
 "bon",
- "digest 0.11.3",
+ "digest 0.10.7",
 "log",
- "miniz_oxide 0.9.1",
+ "miniz_oxide",
 "num-bigint 0.4.8",
- "ouroboros",
 "quad-rand",
- "rand 0.10.2",
+ "rand 0.9.5",
 "regex-lite",
 "serde",
 "serde_bytes",
 "serde_json",
- "strum",
+ "strum 0.27.2",
+ "strum_macros 0.27.2",
 "thiserror 2.0.20",
 "uuid",
 ]
@@ -1162,9 +1156,9 @@ dependencies = [

 [[package]]
 name = "aws-smithy-eventstream"
-version = "0.61.2"
+version = "0.61.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6de526c7b567420a31bc283657a7921b45c4cafe0827fdf2490713dcc770c28f"
+checksum = "5a9381123ab62d20c13082b151f30f962a3b112b727345394536dfa39a482944"
 dependencies = [
 "aws-smithy-types",
 "bytes",
@@ -1195,9 +1189,9 @@ dependencies = [

 [[package]]
 name = "aws-smithy-http-client"
-version = "1.3.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c1c8a04cb31ba74d0115af5a890bb8c0d48fba64b52812fa13929a6ef0cc83c"
+checksum = "635d23afda0a6ab48d666c4d447c4873e8d1e83518a2be2093122397e50b838e"
 dependencies = [
 "aws-smithy-async",
 "aws-smithy-protocol-test",
@@ -1277,9 +1271,9 @@ dependencies = [

 [[package]]
 name = "aws-smithy-runtime"
-version = "1.13.1"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "483b858ff67522011c4786310c5cd8fd88d0be7ea3d5f1a48328446300c4269e"
+checksum = "07505b34e8f4b3591a4fa69e9792b52289b95488dbbc68c3c0075b7bedb245e1"
 dependencies = [
 "aws-smithy-async",
 "aws-smithy-http",
@@ -1343,9 +1337,9 @@ dependencies = [

 [[package]]
 name = "aws-smithy-types"
-version = "1.6.2"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fce83ce9abbb198d25bc7131e468d0f9fe1257125e58c39f3f9fc9f5098c9647"
+checksum = "d6dc683efb34b9e755675b37fedbe0103141e5b6df7bdc9eb6967756a8c167d8"
 dependencies = [
 "base64-simd",
 "bytes",
@@ -1464,7 +1458,7 @@ dependencies = [
 "addr2line",
 "cfg-if",
 "libc",
- "miniz_oxide 0.8.9",
+ "miniz_oxide",
 "object 0.37.3",
 "rustc-demangle",
 "windows-link",
@@ -1807,15 +1801,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"

-[[package]]
-name = "castaway"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "cbc"
 version = "0.1.2"
@@ -2009,7 +1994,7 @@ version = "4.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061"
 dependencies = [
- "heck 0.5.0",
+ "heck",
 "proc-macro2",
 "quote",
 "syn 3.0.3",
@@ -2078,19 +2063,6 @@ dependencies = [
 "unicode-width 0.2.2",
 ]

-[[package]]
-name = "compact_str"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79fcda08c33bb58b97008b2cdada6622500e949e060f5913361763121abd2416"
-dependencies = [
- "castaway",
- "cfg-if",
- "itoa",
- "static_assertions",
- "zmij",
-]
-
 [[package]]
 name = "compression-codecs"
 version = "0.4.38"
@@ -4190,7 +4162,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
 dependencies = [
 "crc32fast",
- "miniz_oxide 0.8.9",
+ "miniz_oxide",
 "zlib-rs",
 ]

@@ -4254,9 +4226,9 @@ checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"

 [[package]]
 name = "futures"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3"
+checksum = "a88cf1f829d945f548cf8fec32c61b1f202b6d93b45848602fc02af4b12ad218"
 dependencies = [
 "futures-channel",
 "futures-core",
@@ -4269,9 +4241,9 @@ dependencies = [

 [[package]]
 name = "futures-channel"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4"
+checksum = "262590f4fe6afeb0bc83be1daa64e52657fe185690a958af7f3ad0e92085c5ae"
 dependencies = [
 "futures-core",
 "futures-sink",
@@ -4279,15 +4251,15 @@ dependencies = [

 [[package]]
 name = "futures-core"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
+checksum = "2cd50c473c80f6d7c3670a752354b8e569b1a7cbfdc0419ec88e5edad85e0dc7"

 [[package]]
 name = "futures-executor"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432"
+checksum = "6754879cc9f2c66f88c6e5c35344bb0bdb0708b0352b1201815667c7eabc7458"
 dependencies = [
 "futures-core",
 "futures-task",
@@ -4296,9 +4268,9 @@ dependencies = [

 [[package]]
 name = "futures-io"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"
+checksum = "4577ecaa3c4f96589d473f679a71b596316f6641bc350038b962a5daf0085d7a"

 [[package]]
 name = "futures-lite"
@@ -4315,13 +4287,13 @@ dependencies = [

 [[package]]
 name = "futures-macro"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"
+checksum = "2d6d3cde68c518367be28956066ddfef33813991b77a55005a69dae04bf3b10b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 3.0.3",
+ "syn 2.0.119",
 ]

 [[package]]
@@ -4337,21 +4309,21 @@ dependencies = [

 [[package]]
 name = "futures-sink"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"
+checksum = "e34418ac499d6305c2fb5ad0ed2f6ac998c5f8ca209b4510f7f94242c647e307"

 [[package]]
 name = "futures-task"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
+checksum = "b231ed28831efb4a61a08580c4bc233ec56bc009f4cd8f52da2c3cb97df0c109"

 [[package]]
 name = "futures-util"
-version = "0.3.34"
+version = "0.3.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
+checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa"
 dependencies = [
 "futures-channel",
 "futures-core",
@@ -4860,12 +4832,6 @@ dependencies = [
 "stable_deref_trait",
 ]

-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -5025,9 +4991,9 @@ dependencies = [

 [[package]]
 name = "hotpath"
-version = "0.23.2"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62e810bedda5a467ef5c9b5c8a20763fefebc89b63ef36f7ee44a143085204a2"
+checksum = "be80823867e0c9820c9237c38b21f9f4aa1ebb0db1f98ff25ac0b1d2c088a470"
 dependencies = [
 "arc-swap",
 "async-channel",
@@ -5059,9 +5025,9 @@ dependencies = [

 [[package]]
 name = "hotpath-macros"
-version = "0.23.2"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01bdc59bfc1a9984bee2ff5da63b2f6fccbaa57cd9a4119d709524632bddf341"
+checksum = "61d1fb3ee80ae7b4743d29487665766ce5a1442e959521790e86317f89dcd5a3"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -5070,15 +5036,15 @@ dependencies = [

 [[package]]
 name = "hotpath-macros-meta"
-version = "0.23.2"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9216e8a01abe1e1671c376dc8736fb1bf772d7a889538d25f9e1200120ced38"
+checksum = "feede71fa226b0b5d523e58e7b0a1462935c0b8a00584a6669f45d564086209d"

 [[package]]
 name = "hotpath-meta"
-version = "0.23.2"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f22a9d20435fb79511b19dae37b3607224cd98f342a410702d84657cc38fc72f"
+checksum = "424fe0a13105d3731f65237785f5b95c3e4b8bfae4a039d932f56192cd74afc0"
 dependencies = [
 "hotpath-macros-meta",
 ]
@@ -5133,9 +5099,9 @@ dependencies = [

 [[package]]
 name = "http-body-util"
-version = "0.1.5"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c"
+checksum = "e9f41fd6a08e4d4ec69df65976da761afd5ad5e58a9d4acb46bd1c953a9e3ff2"
 dependencies = [
 "bytes",
 "futures-core",
@@ -5454,9 +5420,9 @@ dependencies = [

 [[package]]
 name = "io-uring"
-version = "0.7.14"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d64d8ca234d152948ceaede1f419b6a83983a5ecccaac05fb337a809c96d3aa6"
+checksum = "9080b15e63775b9a2ac7dca720f7050a8b955e092ea0f6020a4a80f69998cdc0"
 dependencies = [
 "bitflags 2.13.1",
 "cfg-if",
@@ -5930,18 +5896,18 @@ dependencies = [

 [[package]]
 name = "liblzma"
-version = "0.4.8"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fe0a34ca854fd4f20c07f696fc8675aec78f87d88d29f5e10257a7490a1b2e1"
+checksum = "45aec2360b3933207e27908049d8e4df4e476b58180afb1e56b2a4fb72efe4ba"
 dependencies = [
 "liblzma-sys",
 ]

 [[package]]
 name = "liblzma-sys"
-version = "0.4.8"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0dad045e4b1b7b170be4b60b54b780cafb4490165461bac7d1cf7b703f61d5f"
+checksum = "a046c7f353ba30f810545151e04f63545833803f5b86ee3ddf1517247fe560a5"
 dependencies = [
 "cc",
 "libc",
@@ -5957,7 +5923,7 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 [[package]]
 name = "libmimalloc-sys"
 version = "0.1.49"
-source = "git+https://github.com/xonatius/mimalloc_rust.git?rev=6d4c41bb10c6d9da1d1b6f07b38c4cc051667f11#6d4c41bb10c6d9da1d1b6f07b38c4cc051667f11"
+source = "git+https://github.com/xonatius/mimalloc_rust.git?rev=ce6338661179c8be22e516b00af7483f151485a7#ce6338661179c8be22e516b00af7483f151485a7"
 dependencies = [
 "cc",
 "cty",
@@ -6259,9 +6225,9 @@ dependencies = [

 [[package]]
 name = "metrique"
-version = "0.1.30"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dedbf06ffeef4c37990c73636fbd993aa34fb1948afd736e6114f239220993db"
+checksum = "d2e394c63e2d1a30aeb3b9392ecf3439d8475d2df810a8f4f6e66d6866754017"
 dependencies = [
 "itoa",
 "jiff",
@@ -6289,9 +6255,9 @@ dependencies = [

 [[package]]
 name = "metrique-macro"
-version = "0.1.21"
+version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4fb1f30185f53f7f6e4c9e46745c1a1350af8e77fda5a88aded44b0637a82e0"
+checksum = "786df1fd0abebd0db685f7e9a353c78756d4b370fb98a52376c2015fa55f141f"
 dependencies = [
 "Inflector",
 "darling 0.23.0",
@@ -6318,9 +6284,9 @@ checksum = "2faca4e4480069ff02b1763b3b79f5cec7e8628e24d9dc5b6073f53d2577a4d9"

 [[package]]
 name = "metrique-writer"
-version = "0.1.26"
+version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20bd17c1a3ca2719e31f19ce77a853948dc2102f35976b92276c42a64fdc5f3f"
+checksum = "82cdde44d241dab7fc8b7a32e0eb5dae6cd28f8de80b59f9a1e9f2f0b05e485e"
 dependencies = [
 "ahash",
 "crossbeam-queue",
@@ -6339,9 +6305,9 @@ dependencies = [

 [[package]]
 name = "metrique-writer-core"
-version = "0.1.20"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1a55b6aae1d85c557c729564c4e2b32a26dc65ba2d90d9647ca01f2bd4854c4"
+checksum = "e57379b7ee2272efaeaaa6de062503563e57333b24aadc7f2255b3d602899e8b"
 dependencies = [
 "derive-where",
 "itertools 0.14.0",
@@ -6366,7 +6332,7 @@ dependencies = [
 [[package]]
 name = "mimalloc"
 version = "0.1.52"
-source = "git+https://github.com/xonatius/mimalloc_rust.git?rev=6d4c41bb10c6d9da1d1b6f07b38c4cc051667f11#6d4c41bb10c6d9da1d1b6f07b38c4cc051667f11"
+source = "git+https://github.com/xonatius/mimalloc_rust.git?rev=ce6338661179c8be22e516b00af7483f151485a7#ce6338661179c8be22e516b00af7483f151485a7"
 dependencies = [
 "libmimalloc-sys",
 ]
@@ -6403,15 +6369,6 @@ dependencies = [
 "simd-adler32",
 ]

-[[package]]
-name = "miniz_oxide"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
-dependencies = [
- "adler2",
-]
-
 [[package]]
 name = "minlz"
 version = "1.2.3"
@@ -6459,9 +6416,9 @@ dependencies = [

 [[package]]
 name = "moka"
-version = "0.12.16"
+version = "0.12.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4293f18e7567a1caf3c584855554377025c65e0aa445344d04171f5ad63d19b9"
+checksum = "957228ad12042ee839f93c8f257b62b4c0ab5eaae1d4fa60de53b27c9d7c5046"
 dependencies = [
 "async-lock",
 "crossbeam-channel",
@@ -6506,7 +6463,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4db8a44120571277accfaa3f3d91e7d3989d601d817c2fc01a9391b86135666"
 dependencies = [
 "darling 0.23.0",
- "heck 0.5.0",
+ "heck",
 "manyhow",
 "num-bigint 0.4.8",
 "proc-macro-crate",
@@ -6790,9 +6747,9 @@ checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"

 [[package]]
 name = "num-integer"
-version = "0.1.47"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
 "num-traits",
 ]
@@ -6882,7 +6839,7 @@ version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51e219e79014df21a225b1860a479e2dcd7cbd9130f4defd4bd0e191ea31d67d"
 dependencies = [
- "base64 0.21.7",
+ "base64 0.22.1",
 "chrono",
 "getrandom 0.2.17",
 "http 1.5.0",
@@ -7211,30 +7168,6 @@ dependencies = [
 "num-traits",
 ]

-[[package]]
-name = "ouroboros"
-version = "0.18.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e0f050db9c44b97a94723127e6be766ac5c340c48f2c4bb3ffa11713744be59"
-dependencies = [
- "aliasable",
- "ouroboros_macro",
- "static_assertions",
-]
-
-[[package]]
-name = "ouroboros_macro"
-version = "0.18.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c7028bdd3d43083f6d8d4d5187680d0d3560d54df4cc9d752005268b41e64d0"
-dependencies = [
- "heck 0.4.1",
- "proc-macro2",
- "proc-macro2-diagnostics",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "outref"
 version = "0.5.2"
@@ -7787,9 +7720,9 @@ dependencies = [

 [[package]]
 name = "portable-atomic"
-version = "1.15.0"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+checksum = "3d20d5497ef88037a52ff98267d066e7f11fcc5e99bbfbd58a42336193aacec3"

 [[package]]
 name = "portable-atomic-util"
@@ -7970,19 +7903,6 @@ dependencies = [
 "unicode-ident",
 ]

-[[package]]
-name = "proc-macro2-diagnostics"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
- "version_check",
- "yansi",
-]
-
 [[package]]
 name = "prometheus"
 version = "0.14.0"
@@ -8042,8 +7962,8 @@ version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf"
 dependencies = [
- "heck 0.5.0",
- "itertools 0.10.5",
+ "heck",
+ "itertools 0.14.0",
 "log",
 "multimap",
 "once_cell",
@@ -8062,8 +7982,8 @@ version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03da047801ff44bb6a4d407d4860c05fd70bb81714e6b2f3812603d5b145b042"
 dependencies = [
- "heck 0.5.0",
- "itertools 0.10.5",
+ "heck",
+ "itertools 0.14.0",
 "log",
 "multimap",
 "petgraph 0.8.3",
@@ -8084,7 +8004,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
 dependencies = [
 "anyhow",
- "itertools 0.10.5",
+ "itertools 0.14.0",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
@@ -8097,7 +8017,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf"
 dependencies = [
 "anyhow",
- "itertools 0.10.5",
+ "itertools 0.14.0",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
@@ -8154,9 +8074,9 @@ dependencies = [

 [[package]]
 name = "pulldown-cmark-to-cmark"
-version = "22.0.1"
+version = "22.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab1ad36992cead65f02aa399a373a42730922f1525d988172634fdefdecb8a60"
+checksum = "50793def1b900256624a709439404384204a5dc3a6ec580281bfaac35e882e90"
 dependencies = [
 "pulldown-cmark",
 ]
@@ -8510,9 +8430,9 @@ dependencies = [

 [[package]]
 name = "rcgen"
-version = "0.14.9"
+version = "0.14.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "091e7a8e7d86e6feb87a27ce8e2cba29d49eff9507afeebefab7eeb2ca667fb4"
+checksum = "57f6d249aad744e274e682777a50283a225a32705394ee6d5fcc01efa25e4055"
 dependencies = [
 "aws-lc-rs",
 "pem",
@@ -8917,9 +8837,9 @@ dependencies = [

 [[package]]
 name = "russh"
-version = "0.62.6"
+version = "0.62.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b41043523e0edcbd4e31d00903e26f12994f63b21bae9904f7405c1ed92752a5"
+checksum = "da7c230e0ed9cbeb92fbad6c8848985d6df2a1464c0dc247a021abd666e9005e"
 dependencies = [
 "aes 0.9.2",
 "aws-lc-rs",
@@ -9201,6 +9121,7 @@ dependencies = [
 "sha2 0.11.0",
 "shadow-rs",
 "socket2",
+ "starshard",
 "subtle",
 "sysinfo",
 "temp-env",
@@ -9344,6 +9265,7 @@ dependencies = [
 name = "rustfs-data-usage"
 version = "1.0.0-rc.1"
 dependencies = [
+ "async-trait",
 "hotpath",
 "rmp-serde",
 "rustfs-filemeta",
@@ -9535,6 +9457,7 @@ dependencies = [
 "futures",
 "hotpath",
 "http 1.5.0",
+ "libc",
 "metrics",
 "rustfs-common",
 "rustfs-concurrency",
@@ -9571,7 +9494,6 @@ dependencies = [
 "moka",
 "openidconnect",
 "pollster",
- "rcgen",
 "reqwest",
 "rustfs-config",
 "rustfs-credentials",
@@ -9583,8 +9505,6 @@ dependencies = [
 "rustfs-storage-api",
 "rustfs-test-utils",
 "rustfs-utils",
- "rustls",
- "rustls-pki-types",
 "serde",
 "serde_json",
 "serial_test",
@@ -9620,7 +9540,9 @@ dependencies = [
 "metrics",
 "metrics-util",
 "num_cpus",
+ "rustfs-common",
 "rustfs-s3-ops",
+ "rustfs-utils",
 "sysinfo",
 "thiserror 2.0.20",
 "tokio",
@@ -9734,7 +9656,6 @@ dependencies = [
 "rustfs-utils",
 "rustify",
 "serde",
- "serde_ignored",
 "serde_json",
 "sha2 0.11.0",
 "subtle",
@@ -9779,7 +9700,6 @@ name = "rustfs-lock"
 version = "1.0.0-rc.1"
 dependencies = [
 "async-trait",
- "compact_str",
 "crossbeam-queue",
 "futures",
 "hotpath",
@@ -9790,6 +9710,7 @@ dependencies = [
 "serde",
 "serde_json",
 "smallvec",
+ "smartstring",
 "thiserror 2.0.20",
 "tokio",
 "tonic",
@@ -9979,7 +9900,7 @@ dependencies = [
 "rustfs-crypto",
 "serde",
 "serde_json",
- "strum",
+ "strum 0.28.0",
 "temp-env",
 "test-case",
 "thiserror 2.0.20",
@@ -10559,9 +10480,9 @@ dependencies = [

 [[package]]
 name = "rustls-connector"
-version = "0.23.8"
+version = "0.23.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1babecfcc65b139b812e74bcc7f9ec7b4e00db659fd42d99567b7e77f0c714c6"
+checksum = "09a5abe04eec18f8b9fbe87885bcaee6426de80bbc579958c0bc064b728ee617"
 dependencies = [
 "futures-io",
 "futures-rustls",
@@ -10623,9 +10544,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"

 [[package]]
 name = "rustls-webpki"
-version = "0.103.14"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0527518605e68109d875e248ea259b6758801cf165e4b2c2733ae3b51f12535a"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
 dependencies = [
 "aws-lc-rs",
 "ring",
@@ -10937,16 +10858,6 @@ dependencies = [
 "syn 3.0.3",
 ]

-[[package]]
-name = "serde_ignored"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "115dffd5f3853e06e746965a20dcbae6ee747ae30b543d91b0e089668bb07798"
-dependencies = [
- "serde",
- "serde_core",
-]
-
 [[package]]
 name = "serde_json"
 version = "1.0.151"
@@ -11015,9 +10926,9 @@ dependencies = [

 [[package]]
 name = "serde_with"
-version = "3.22.0"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee78f1fbe43ac4a0e47aadb3dbd357b69eb0d3793e948624cd03dd2750ab1c0a"
+checksum = "76a5c54c7310e7b8b9577c286d7e399ddd876c3e12b3ed917a8aabc4b96e9e8c"
 dependencies = [
 "base64 0.22.1",
 "bs58",
@@ -11025,7 +10936,6 @@ dependencies = [
 "hex",
 "indexmap 1.9.3",
 "indexmap 2.14.0",
- "jiff",
 "schemars 0.9.0",
 "schemars 1.2.2",
 "serde_core",
@@ -11036,9 +10946,9 @@ dependencies = [

 [[package]]
 name = "serde_with_macros"
-version = "3.22.0"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8705578779c2b6bd90d84d66eb2e206b708b1a4d7b9f17641b293545bf1c7e46"
+checksum = "84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660"
 dependencies = [
 "darling 0.23.0",
 "proc-macro2",
@@ -11332,6 +11242,17 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "smartstring"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fb72c633efbaa2dd666986505016c32c3044395ceaf881518399d2f4127ee29"
+dependencies = [
+ "autocfg",
+ "static_assertions",
+ "version_check",
+]
+
 [[package]]
 name = "snafu"
 version = "0.6.10"
@@ -11578,13 +11499,31 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"

+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+
 [[package]]
 name = "strum"
 version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
 dependencies = [
- "strum_macros",
+ "strum_macros 0.28.0",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]

 [[package]]
@@ -11593,7 +11532,7 @@ version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
 dependencies = [
- "heck 0.5.0",
+ "heck",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
@@ -11800,7 +11739,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
 "fastrand",
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
 "once_cell",
 "rustix",
 "windows-sys 0.61.2",
@@ -12866,9 +12805,9 @@ dependencies = [

 [[package]]
 name = "whoami"
-version = "2.1.3"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "626c4bac6755d76ffc12cb01b2eac751db1996b9e0041de9aa02c8c211ddc82c"
+checksum = "998767ef88740d1f5b0682a9c53c24431453923962269c2db68ee43788c5a40d"
 dependencies = [
 "libc",
 "libredox",
@@ -142,10 +142,10 @@ async-recursion = "1.1.1"
 async-trait = "0.1.92"
 async-nats = { version = "0.50.0", default-features = false }
 axum = "0.8.9"
-futures = "0.3.34"
-futures-core = "0.3.34"
+futures = "0.3.33"
+futures-core = "0.3.33"
 futures-lite = "2.6.1"
-futures-util = "0.3.34"
+futures-util = "0.3.33"
 pollster = "1.0.1"
 pulsar = { default-features = false, version = "6.8.0" }
 lapin = { default-features = false, version = "4.10.0" }
@@ -154,7 +154,7 @@ hyper-rustls = { default-features = false, version = "0.27.9" }
 hyper-util = { version = "0.1.20" }
 http = "1.5.0"
 http-body = "1.1.0"
-http-body-util = "0.1.5"
+http-body-util = "0.1.4"
 minlz = "1.2.3"
 reqwest = "0.13.4"
 rustfs-kafka-async = { version = "1.2.0" }
@@ -171,7 +171,7 @@ tower = { version = "0.5.3" }
 tower-http = { version = "0.7.0" }

 # Serialization and Data Formats
-apache-avro = "0.22.0"
+apache-avro = "0.21.0"
 bytes = { version = "1.12.1" }
 bytesize = "2.7.0"
 byteorder = "1.5.0"
@@ -182,7 +182,6 @@ quick-xml = "0.41.0"
 rmp = { version = "0.8.15" }
 rmp-serde = { version = "1.3.1" }
 serde = { version = "1.0.229" }
-serde_ignored = { version = "0.1" }
 serde_json = { version = "1.0.151" }
 serde_urlencoded = "0.7.1"

@@ -231,9 +230,9 @@ aws-credential-types = { version = "1.3.0" }
 aws-sdk-kms = { default-features = false, version = "1.114.0" }
 aws-sdk-s3 = { default-features = false, version = "1.141.0" }
 aws-sdk-sts = { default-features = false, version = "1.110.0" }
-aws-smithy-http-client = { default-features = false, version = "1.3.0" }
+aws-smithy-http-client = { default-features = false, version = "1.2.0" }
 aws-smithy-runtime-api = { version = "1.14.0" }
-aws-smithy-types = { version = "1.6.2" }
+aws-smithy-types = { version = "1.6.1" }
 base64 = "0.23.1"
 base64-simd = "0.8.0"
 brotli = "8.0.4"
@@ -269,7 +268,7 @@ lz4 = "1.28.1"
 matchit = "0.9.2"
 md-5 = "0.11.0"
 mime_guess = "2.0.5"
-moka = { version = "0.12.16" }
+moka = { version = "0.12.15" }
 netif = "0.1.6"
 num_cpus = { version = "1.17.0" }
 nvml-wrapper = "0.12.1"
@@ -295,7 +294,7 @@ serial_test = "4.0.1"
 shadow-rs = { default-features = false, version = "2.0.0" }
 siphasher = "1.0.3"
 smallvec = { version = "1.15.2" }
-compact_str = "0.10.0"
+smartstring = "1.0.1"
 snap = "1.1.2"
 starshard = { version = "2.2.2" }
 strum = { version = "0.28.0" }
@@ -340,17 +339,17 @@ pyroscope = { version = "2.1.1" }
 libunftp = { version = "0.23.0" }
 unftp-core = "0.1.0"
 suppaftp = { version = "10.0.1" }
-rcgen = { version = "0.14.9", default-features = false, features = ["aws_lc_rs", "crypto", "pem"] }
-russh = { version = "0.62.6" }
+rcgen = { version = "0.14.8", default-features = false, features = ["aws_lc_rs", "crypto", "pem"] }
+russh = { version = "0.62.5" }
 russh-sftp = "2.4.0"

 # WebDAV
 dav-server = "0.11.0"

 # Performance Analysis and Memory Profiling
-mimalloc = { version = "0.1.52", git = "https://github.com/xonatius/mimalloc_rust.git", rev = "6d4c41bb10c6d9da1d1b6f07b38c4cc051667f11" }
-libmimalloc-sys = { version = "0.1.49", git = "https://github.com/xonatius/mimalloc_rust.git", rev = "6d4c41bb10c6d9da1d1b6f07b38c4cc051667f11", features = ["extended"] }
-hotpath = { version = "0.23.2", default-features = false }
+mimalloc = { version = "0.1.52", git = "https://github.com/xonatius/mimalloc_rust.git", rev = "ce6338661179c8be22e516b00af7483f151485a7" }
+libmimalloc-sys = { version = "0.1.49", git = "https://github.com/xonatius/mimalloc_rust.git", rev = "ce6338661179c8be22e516b00af7483f151485a7", features = ["extended"] }
+hotpath = { version = "0.23.1", default-features = false }
 # Snapshot testing for output format regression detection
 insta = { version = "1.48" }

@@ -21,13 +21,6 @@ use crate::{
    Xxhash3, Xxhash64, Xxhash128,
 };

-// DELIBERATE DUPLICATION of the x-amz-checksum-* names that also exist as
-// AMZ_CHECKSUM_* in rustfs-utils' headers module (crates/utils/src/http/
-// headers.rs): this crate is a zero-internal-dependency leaf, so it cannot
-// import them, and it additionally owns the RustFS extension names
-// (sha512/xxhash*) that utils does not carry. Values are pinned by the S3
-// wire protocol; do not merge without a maintainer decision on the leaf
-// boundary (backlog#1833).
 pub const CRC_32_HEADER_NAME: &str = "x-amz-checksum-crc32";
 pub const CRC_32_C_HEADER_NAME: &str = "x-amz-checksum-crc32c";
 pub const SHA_1_HEADER_NAME: &str = "x-amz-checksum-sha1";
@@ -41,14 +41,6 @@ pub const XXHASH_64_NAME: &str = "xxhash64";
 pub const XXHASH_128_NAME: &str = "xxhash128";
 pub const MD5_NAME: &str = "md5";

-/// One of three deliberately separate checksum registries (backlog#1833):
-/// this enum owns the **streaming-hash algorithm registry**, including the
-/// RustFS extensions (sha512, xxhash3/64/128). The on-disk xl.meta bitset
-/// lives in `rustfs_rio::ChecksumType` (crates/rio/src/checksum.rs, varint
-/// bits are append-only), and the MinIO-port client keeps its own
-/// `ChecksumMode` (crates/ecstore/src/client/checksum.rs). When adding an
-/// algorithm, extend all three (or record why not) — they do not derive from
-/// each other.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 #[non_exhaustive]
 pub enum ChecksumAlgorithm {
@@ -0,0 +1,87 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::last_minute::{self};
+use std::collections::HashMap;
+
+pub struct ReplicationLatency {
+    // Delays for single and multipart PUT requests
+    upload_histogram: last_minute::LastMinuteHistogram,
+}
+
+impl ReplicationLatency {
+    // Merge two ReplicationLatency
+    pub fn merge(&mut self, other: &mut ReplicationLatency) -> &ReplicationLatency {
+        self.upload_histogram.merge(&other.upload_histogram);
+        self
+    }
+
+    // Get upload delay (categorized by object size interval)
+    pub fn get_upload_latency(&mut self) -> HashMap<String, u64> {
+        let mut ret = HashMap::new();
+        let avg = self.upload_histogram.get_avg_data();
+        for (i, v) in avg.iter().enumerate() {
+            let avg_duration = v.avg();
+            ret.insert(self.size_tag_to_string(i), avg_duration.as_millis() as u64);
+        }
+        ret
+    }
+    pub fn update(&mut self, size: i64, during: std::time::Duration) {
+        self.upload_histogram.add(size, during);
+    }
+
+    // Simulate the conversion from size tag to string
+    fn size_tag_to_string(&self, tag: usize) -> String {
+        match tag {
+            0 => String::from("Size < 1 KiB"),
+            1 => String::from("Size < 1 MiB"),
+            2 => String::from("Size < 10 MiB"),
+            3 => String::from("Size < 100 MiB"),
+            4 => String::from("Size < 1 GiB"),
+            _ => String::from("Size > 1 GiB"),
+        }
+    }
+}
+
+// #[derive(Debug, Clone, Default)]
+// pub struct ReplicationLastMinute {
+//     pub last_minute: LastMinuteLatency,
+// }
+
+// impl ReplicationLastMinute {
+//     pub fn merge(&mut self, other: ReplicationLastMinute) -> ReplicationLastMinute {
+//         let mut nl = ReplicationLastMinute::default();
+//         nl.last_minute = self.last_minute.merge(&mut other.last_minute);
+//         nl
+//     }
+
+//     pub fn add_size(&mut self, n: i64) {
+//         let t = SystemTime::now()
+//             .duration_since(UNIX_EPOCH)
+//             .expect("Time went backwards")
+//             .as_secs();
+//         self.last_minute.add_all(t - 1, &AccElem { total: t - 1, size: n as u64, n: 1 });
+//     }
+
+//     pub fn get_total(&self) -> AccElem {
+//         self.last_minute.get_total()
+//     }
+// }
+
+// impl fmt::Display for ReplicationLastMinute {
+//     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+//         let t = self.last_minute.get_total();
+//         write!(f, "ReplicationLastMinute sz= {}, n= {}, dur= {}", t.size, t.n, t.total)
+//     }
+// }
@@ -572,3 +572,44 @@ mod tests {
        assert_eq!(total.n, 6);
    }
 }
+
+const SIZE_LAST_ELEM_MARKER: usize = 10; // Assumed marker size is 10, modify according to actual situation
+
+#[allow(dead_code)]
+#[derive(Debug, Default)]
+pub struct LastMinuteHistogram {
+    histogram: Vec<LastMinuteLatency>,
+    size: u32,
+}
+
+impl LastMinuteHistogram {
+    pub fn merge(&mut self, other: &LastMinuteHistogram) {
+        for i in 0..self.histogram.len() {
+            self.histogram[i].merge(&other.histogram[i]);
+        }
+    }
+
+    pub fn add(&mut self, size: i64, t: Duration) {
+        let index = size_to_tag(size);
+        self.histogram[index].add(&t);
+    }
+
+    pub fn get_avg_data(&mut self) -> [AccElem; SIZE_LAST_ELEM_MARKER] {
+        let mut res = [AccElem::default(); SIZE_LAST_ELEM_MARKER];
+        for (i, elem) in self.histogram.iter_mut().enumerate() {
+            res[i] = elem.get_total();
+        }
+        res
+    }
+}
+
+fn size_to_tag(size: i64) -> usize {
+    match size {
+        _ if size < 1024 => 0,               // sizeLessThan1KiB
+        _ if size < 1024 * 1024 => 1,        // sizeLessThan1MiB
+        _ if size < 10 * 1024 * 1024 => 2,   // sizeLessThan10MiB
+        _ if size < 100 * 1024 * 1024 => 3,  // sizeLessThan100MiB
+        _ if size < 1024 * 1024 * 1024 => 4, // sizeLessThan1GiB
+        _ => 5,                              // sizeGreaterThan1GiB
+    }
+}
@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

+pub mod bucket_stats;
 // pub mod error;
 pub mod globals;
 pub mod heal_channel;
 pub mod last_minute;
 pub mod metrics;
 mod readiness;
-pub mod table_catalog;

 pub use globals::*;
 pub use readiness::{GlobalReadiness, SystemStage};
@@ -915,13 +915,11 @@ const SCAN_CYCLE_RESULT_SUCCESS: u8 = 1;
 const SCAN_CYCLE_RESULT_ERROR: u8 = 2;
 const SCAN_CYCLE_RESULT_PARTIAL: u8 = 3;
 const SCAN_CYCLE_RESULT_SUPERSEDED: u8 = 4;
-const SCAN_CYCLE_RESULT_DEFERRED: u8 = 5;
 const SCAN_CYCLE_RESULT_UNKNOWN_LABEL: &str = "unknown";
 const SCAN_CYCLE_RESULT_SUCCESS_LABEL: &str = "success";
 const SCAN_CYCLE_RESULT_ERROR_LABEL: &str = "error";
 const SCAN_CYCLE_RESULT_PARTIAL_LABEL: &str = "partial";
 const SCAN_CYCLE_RESULT_SUPERSEDED_LABEL: &str = "superseded";
-const SCAN_CYCLE_RESULT_DEFERRED_LABEL: &str = "deferred";

 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub enum ScanCyclePartialReason {
@@ -1426,7 +1424,6 @@ fn scan_cycle_result_label(result: u8) -> &'static str {
        SCAN_CYCLE_RESULT_ERROR => SCAN_CYCLE_RESULT_ERROR_LABEL,
        SCAN_CYCLE_RESULT_PARTIAL => SCAN_CYCLE_RESULT_PARTIAL_LABEL,
        SCAN_CYCLE_RESULT_SUPERSEDED => SCAN_CYCLE_RESULT_SUPERSEDED_LABEL,
-        SCAN_CYCLE_RESULT_DEFERRED => SCAN_CYCLE_RESULT_DEFERRED_LABEL,
        _ => SCAN_CYCLE_RESULT_UNKNOWN_LABEL,
    }
 }
@@ -1755,11 +1752,6 @@ pub fn emit_scan_cycle_superseded(duration: Duration) {
    metrics::counter!(OTEL_SCANNER_CYCLES, "result" => SCAN_CYCLE_RESULT_SUPERSEDED_LABEL).increment(1);
 }

-pub fn emit_scan_cycle_deferred(duration: Duration) {
-    global_metrics().record_scan_cycle_deferred(duration);
-    metrics::counter!(OTEL_SCANNER_CYCLES, "result" => SCAN_CYCLE_RESULT_DEFERRED_LABEL).increment(1);
-}
-
 pub fn emit_scan_bucket_drive_complete(success: bool, bucket: &str, disk: &str, duration: Duration) {
    let result = if success { "success" } else { "error" };
    global_metrics().record_scanner_bucket_drive_result(bucket, disk, result);
@@ -2557,17 +2549,6 @@ impl Metrics {
            .store(duration_millis_saturated(duration), Ordering::Relaxed);
    }

-    pub fn record_scan_cycle_deferred(&self, duration: Duration) {
-        self.record_scanner_cycle_end_time();
-        self.last_scan_cycle_result
-            .store(SCAN_CYCLE_RESULT_DEFERRED, Ordering::Relaxed);
-        self.last_scan_cycle_partial_reason
-            .store(ScanCyclePartialReason::Unknown as u8, Ordering::Relaxed);
-        self.last_scan_cycle_partial_source.store(0, Ordering::Relaxed);
-        self.last_scan_cycle_duration_millis
-            .store(duration_millis_saturated(duration), Ordering::Relaxed);
-    }
-
    pub fn record_scan_cycle_partial(&self, duration: Duration, reason: ScanCyclePartialReason) {
        self.record_scan_cycle_partial_with_source(duration, reason, None);
    }
@@ -4283,21 +4264,6 @@ mod tests {
        assert_eq!(report.partial_cycles, 0);
    }

-    #[tokio::test]
-    async fn report_tracks_deferred_cycle_without_failed_increment() {
-        let metrics = Metrics::new();
-        metrics.record_scan_cycle_deferred(Duration::from_millis(250));
-
-        let report = metrics.report().await;
-
-        assert_eq!(report.last_cycle_result, SCAN_CYCLE_RESULT_DEFERRED_LABEL);
-        assert_eq!(report.last_cycle_result_code, u64::from(SCAN_CYCLE_RESULT_DEFERRED));
-        assert_eq!(report.last_cycle_duration_seconds, 0.25);
-        assert_eq!(report.failed_cycles, 0);
-        assert_eq!(report.superseded_cycles, 0);
-        assert_eq!(report.partial_cycles, 0);
-    }
-
    #[tokio::test]
    async fn report_tracks_successful_scan_cycle_without_failed_increment() {
        let metrics = Metrics::new();
@@ -1,17 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/// Cross-crate lock identity used to fence table-bucket publication against
-/// object mutations that bypass the S3 request authorization layer.
-pub const TABLE_BUCKET_PUBLICATION_LOCK_PATH: &str = ".rustfs-table/warehouses/default/publication.lock";
@@ -97,14 +97,6 @@ Current guidance:
  - enables minimal payload mode for GET health responses (`status`, `ready` only).
 - `RUSTFS_HEALTH_READINESS_CACHE_TTL_MS`
  - TTL for readiness cache evaluation.
- `RUSTFS_HEALTH_OBJECT_PROGRESS_ENABLE`
-  - withdraws readiness when bounded object read/write stages stop completing while requests remain active.
-  - default is `true`.
- `RUSTFS_HEALTH_OBJECT_PROGRESS_TIMEOUT_MS`
-  - maximum time without completion in a bounded object stage before readiness is withdrawn.
-  - default is `30000`; `0` uses the default.
-  - the effective value is at least 5 seconds longer than `RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT`.
-  - this readiness SLO is independent of disk read/write failure deadlines and may withdraw traffic before those deadlines expire.
 - `RUSTFS_HEALTH_COMPAT_BUSY_CHECK_ENABLE`
  - enables busy protection behavior for health probes.
  - default is `false`.
@@ -353,11 +353,6 @@ pub const DEFAULT_OBS_TRACES_EXPORT_ENABLED: bool = true;
 /// Environment variable: RUSTFS_OBS_METRICS_EXPORT_ENABLED
 pub const DEFAULT_OBS_METRICS_EXPORT_ENABLED: bool = true;

-/// Default detailed PUT stage metrics enabled
-/// Default value: false
-/// Environment variable: RUSTFS_OBS_PUT_STAGE_METRICS_ENABLED
-pub const DEFAULT_OBS_PUT_STAGE_METRICS_ENABLED: bool = false;
-
 /// Default logs export enabled
 /// It is used to enable or disable exporting logs
 /// Default value: true
@@ -22,19 +22,6 @@ pub const DEFAULT_HEALTH_ENDPOINT_ENABLE: bool = true;
 pub const ENV_HEALTH_READINESS_CACHE_TTL_MS: &str = "RUSTFS_HEALTH_READINESS_CACHE_TTL_MS";
 pub const DEFAULT_HEALTH_READINESS_CACHE_TTL_MS: u64 = 1000;

-/// Enable readiness withdrawal when bounded object read/write stages stop
-/// completing while requests remain active.
-pub const ENV_HEALTH_OBJECT_PROGRESS_ENABLE: &str = "RUSTFS_HEALTH_OBJECT_PROGRESS_ENABLE";
-pub const DEFAULT_HEALTH_OBJECT_PROGRESS_ENABLE: bool = true;
-
-/// Requested time without completion in a bounded object stage before local
-/// readiness is withdrawn (milliseconds). A value of `0` uses the default;
-/// runtime adds a safety floor based on the object-lock acquisition timeout.
-pub const ENV_HEALTH_OBJECT_PROGRESS_TIMEOUT_MS: &str = "RUSTFS_HEALTH_OBJECT_PROGRESS_TIMEOUT_MS";
-pub const DEFAULT_HEALTH_OBJECT_PROGRESS_TIMEOUT_MS: u64 = 30_000;
-/// Additional time beyond the configured object-lock acquisition deadline.
-pub const HEALTH_OBJECT_PROGRESS_LOCK_MARGIN_MS: u64 = 5_000;
-
 /// Timeout for cluster health readiness collectors (milliseconds).
 /// This bounds expensive storage and lock quorum checks used by cluster probes.
 pub const ENV_HEALTH_CLUSTER_TIMEOUT_MS: &str = "RUSTFS_HEALTH_CLUSTER_TIMEOUT_MS";
@@ -137,37 +137,6 @@ pub const DEFAULT_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED: bool = false;
 const _: () = assert!(!DEFAULT_TIER_REMOTE_VERSION_STATE_WRITE);
 const _: () = assert!(!DEFAULT_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED);

-/// Request the object-transaction fencing contract used by storage-owned
-/// cleanup receipts and lock-window optimizations.
-///
-/// This is fail-closed: enabling the writer without a live fleet proof rejects
-/// the commit rather than silently using a legacy-safe path.
-pub const ENV_OBJECT_TRANSACTION_FENCING_WRITE: &str = "RUSTFS_OBJECT_TRANSACTION_FENCING_WRITE";
-pub const DEFAULT_OBJECT_TRANSACTION_FENCING_WRITE: bool = false;
-
-/// Operator-attested confirmation that every serving node understands the
-/// object transaction fencing contract.
-pub const ENV_OBJECT_TRANSACTION_FENCING_FLEET_CONFIRMED: &str = "RUSTFS_OBJECT_TRANSACTION_FENCING_FLEET_CONFIRMED";
-pub const DEFAULT_OBJECT_TRANSACTION_FENCING_FLEET_CONFIRMED: bool = false;
-
-const _: () = assert!(!DEFAULT_OBJECT_TRANSACTION_FENCING_WRITE);
-const _: () = assert!(!DEFAULT_OBJECT_TRANSACTION_FENCING_FLEET_CONFIRMED);
-
-/// Request preserving legacy per-part checksum metadata during data movement.
-///
-/// This remains ineffective until
-/// [`ENV_DATA_MOVEMENT_PART_CHECKSUMS_FLEET_CONFIRMED`] is also enabled.
-pub const ENV_DATA_MOVEMENT_PART_CHECKSUMS_WRITE: &str = "RUSTFS_DATA_MOVEMENT_PART_CHECKSUMS_WRITE";
-pub const DEFAULT_DATA_MOVEMENT_PART_CHECKSUMS_WRITE: bool = false;
-
-/// Operator-attested confirmation that every serving node understands the
-/// data-movement per-part checksum sidecar.
-pub const ENV_DATA_MOVEMENT_PART_CHECKSUMS_FLEET_CONFIRMED: &str = "RUSTFS_DATA_MOVEMENT_PART_CHECKSUMS_FLEET_CONFIRMED";
-pub const DEFAULT_DATA_MOVEMENT_PART_CHECKSUMS_FLEET_CONFIRMED: bool = false;
-
-const _: () = assert!(!DEFAULT_DATA_MOVEMENT_PART_CHECKSUMS_WRITE);
-const _: () = assert!(!DEFAULT_DATA_MOVEMENT_PART_CHECKSUMS_FLEET_CONFIRMED);
-
 // =============================================================================
 // Concurrent Request Fix - Timeout and Backpressure Configuration
 // =============================================================================
@@ -680,22 +649,4 @@ mod remote_version_state_tests {
            "RUSTFS_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED"
        );
    }
-
-    #[test]
-    fn data_movement_part_checksum_gate_uses_stable_environment_names() {
-        assert_eq!(super::ENV_DATA_MOVEMENT_PART_CHECKSUMS_WRITE, "RUSTFS_DATA_MOVEMENT_PART_CHECKSUMS_WRITE");
-        assert_eq!(
-            super::ENV_DATA_MOVEMENT_PART_CHECKSUMS_FLEET_CONFIRMED,
-            "RUSTFS_DATA_MOVEMENT_PART_CHECKSUMS_FLEET_CONFIRMED"
-        );
-    }
-
-    #[test]
-    fn object_transaction_fencing_gate_uses_stable_environment_names() {
-        assert_eq!(super::ENV_OBJECT_TRANSACTION_FENCING_WRITE, "RUSTFS_OBJECT_TRANSACTION_FENCING_WRITE");
-        assert_eq!(
-            super::ENV_OBJECT_TRANSACTION_FENCING_FLEET_CONFIRMED,
-            "RUSTFS_OBJECT_TRANSACTION_FENCING_FLEET_CONFIRMED"
-        );
-    }
 }
@@ -81,9 +81,6 @@ pub const ENV_TEST_IAM_FAIL_INIT_ATTEMPTS: &str = "RUSTFS_TEST_IAM_FAIL_INIT_ATT
 pub const ENV_TEST_IAM_RETRY_INTERVAL_MS: &str = "RUSTFS_TEST_IAM_RETRY_INTERVAL_MS";
 /// Runtime env var controlling the transition worker count.
 pub const ENV_TRANSITION_WORKERS: &str = "RUSTFS_MAX_TRANSITION_WORKERS";
-/// Runtime env var controlling the ILM expiry worker count. A set, parsable,
-/// non-zero value wins; anything else falls back to `min(cpus, 16)`.
-pub const ENV_MAX_EXPIRY_WORKERS: &str = "RUSTFS_MAX_EXPIRY_WORKERS";
 /// Runtime env var controlling the absolute maximum transition workers.
 pub const ENV_TRANSITION_WORKERS_ABSOLUTE_MAX: &str = "RUSTFS_ABSOLUTE_MAX_WORKERS";
 /// Runtime env var controlling the transition queue capacity.
@@ -36,11 +36,6 @@ pub const ENV_TRUST_SYSTEM_CA: &str = "RUSTFS_TRUST_SYSTEM_CA";
 /// To change this behavior, set the environment variable RUSTFS_TRUST_SYSTEM_CA=1
 pub const DEFAULT_TRUST_SYSTEM_CA: bool = false;

-/// Environment variable for an extra outbound root CA certificate bundle.
-/// Use this to trust an internal CA for outbound HTTPS clients without replacing
-/// the default operating-system/web PKI roots via SSL_CERT_FILE.
-pub const ENV_RUSTFS_EXTRA_CA_CERT: &str = "RUSTFS_EXTRA_CA_CERT";
-
 /// Environment variable to trust leaf certificates as CA
 /// When set to "1", RustFS will treat leaf certificates as CA certificates for trust validation.
 /// By default, this is disabled.
@@ -44,10 +44,6 @@ pub const ENV_OBS_METRICS_EXPORT_ENABLED: &str = "RUSTFS_OBS_METRICS_EXPORT_ENAB
 pub const ENV_OBS_LOGS_EXPORT_ENABLED: &str = "RUSTFS_OBS_LOGS_EXPORT_ENABLED";
 pub const ENV_OBS_PROFILING_EXPORT_ENABLED: &str = "RUSTFS_OBS_PROFILING_EXPORT_ENABLED";

-/// Enables detailed per-stage PUT metrics. Disabled by default because each
-/// PUT records multiple timers and histograms when attribution is active.
-pub const ENV_OBS_PUT_STAGE_METRICS_ENABLED: &str = "RUSTFS_OBS_PUT_STAGE_METRICS_ENABLED";
-
 pub const ENV_OBS_LOGGER_LEVEL: &str = "RUSTFS_OBS_LOGGER_LEVEL";
 pub const ENV_OBS_LOG_STDOUT_ENABLED: &str = "RUSTFS_OBS_LOG_STDOUT_ENABLED";
 pub const ENV_OBS_LOG_DIRECTORY: &str = "RUSTFS_OBS_LOG_DIRECTORY";
@@ -145,7 +141,6 @@ mod tests {
        assert_eq!(ENV_OBS_METRICS_EXPORT_ENABLED, "RUSTFS_OBS_METRICS_EXPORT_ENABLED");
        assert_eq!(ENV_OBS_LOGS_EXPORT_ENABLED, "RUSTFS_OBS_LOGS_EXPORT_ENABLED");
        assert_eq!(ENV_OBS_PROFILING_EXPORT_ENABLED, "RUSTFS_OBS_PROFILING_EXPORT_ENABLED");
-        assert_eq!(ENV_OBS_PUT_STAGE_METRICS_ENABLED, "RUSTFS_OBS_PUT_STAGE_METRICS_ENABLED");
        // Test log cleanup related env keys
        assert_eq!(ENV_OBS_LOG_MAX_TOTAL_SIZE_BYTES, "RUSTFS_OBS_LOG_MAX_TOTAL_SIZE_BYTES");
        assert_eq!(ENV_OBS_LOG_MAX_SINGLE_FILE_SIZE_BYTES, "RUSTFS_OBS_LOG_MAX_SINGLE_FILE_SIZE_BYTES");
@@ -37,6 +37,7 @@ hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-filemeta/hotpath-cpu"]
 hotpath.workspace = true
 serde = { workspace = true, features = ["derive"] }
 rmp-serde = { workspace = true }
+async-trait = { workspace = true }
 rustfs-filemeta = { workspace = true }

 [lib]
@@ -846,15 +846,8 @@ impl DataUsageEntry {
    }
 }

-/// Read-only projection of the scanner's `.usage-cache.bin` info block.
-///
-/// The canonical wire format is written by the hand-written map-encoded
-/// `Serialize` on the scanner-side `DataUsageCacheInfo`
-/// (`crates/scanner/src/data_usage_define.rs`), which carries 16 fields.
-/// This type decodes only the shared subset and is deliberately not
-/// `Serialize`: a derived (array) encoding of this 6-field subset would
-/// corrupt the cache for scanner readers, so no write path may exist here.
-#[derive(Clone, Debug, Default, Deserialize)]
+/// Data usage cache info
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct DataUsageCacheInfo {
    pub name: String,
    pub next_cycle: u64,
@@ -870,12 +863,8 @@ pub struct DataUsageCacheInfo {
    pub snapshot_complete: bool,
 }

-/// Read-only projection of a scanner-written `.usage-cache.bin` file.
-///
-/// The scanner-side `DataUsageCache` (`crates/scanner/src/data_usage_define.rs`)
-/// owns the persisted format; this type only decodes it (see
-/// [`DataUsageCacheInfo`]) and must never grow a serialization path.
-#[derive(Clone, Debug, Default, Deserialize)]
+/// Data usage cache
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct DataUsageCache {
    pub info: DataUsageCacheInfo,
    pub cache: HashMap<String, DataUsageEntry>,
@@ -1197,10 +1186,31 @@ impl DataUsageCache {
        }
    }

+    pub fn marshal_msg(&self) -> Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>> {
+        let mut buf = Vec::new();
+        self.serialize(&mut rmp_serde::Serializer::new(&mut buf))?;
+        Ok(buf)
+    }
+
    pub fn unmarshal(buf: &[u8]) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
        let t: Self = rmp_serde::from_slice(buf)?;
        Ok(t)
    }
+
+    // Note: load and save methods are storage-specific and should be implemented
+    // in the ecstore crate where storage access is available
+}
+
+/// Trait for storage-specific operations on DataUsageCache
+#[async_trait::async_trait]
+pub trait DataUsageCacheStorage {
+    /// Load data usage cache from backend storage
+    async fn load(store: &dyn std::any::Any, name: &str) -> Result<Self, Box<dyn std::error::Error + Send + Sync>>
+    where
+        Self: Sized;
+
+    /// Save data usage cache to backend storage
+    async fn save(&self, name: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>>;
 }

 // Helper structs and functions for cache operations
@@ -1822,82 +1832,6 @@ mod tests {
        assert!(decoded.all_tier_stats.is_none());
    }

-    /// Scanner-written `.usage-cache.bin` bytes: a 2-element array of the
-    /// canonical 16-field map-encoded info block and one map-encoded entry.
-    /// Captured from the canonical writer's `marshal_msg` — see
-    /// `usage_cache_wire_format_is_pinned` in
-    /// `crates/scanner/src/data_usage_define.rs`, which pins these exact
-    /// bytes and documents regeneration. Hardcoded here because a
-    /// dev-dependency on rustfs-scanner would pull the whole ecstore tree
-    /// into this crate's test build, and a fixture generated at test runtime
-    /// could not detect writer drift anyway.
-    const SCANNER_USAGE_CACHE_WIRE_FIXTURE: &[u8] = &[
-        0x92, 0xde, 0x00, 0x10, 0xa4, 0x6e, 0x61, 0x6d, 0x65, 0xab, 0x77, 0x69, 0x72, 0x65, 0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65,
-        0x74, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x07, 0xac, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72,
-        0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x09, 0xab, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x92,
-        0xce, 0x65, 0x53, 0xf1, 0x00, 0x00, 0xac, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x68, 0x65, 0x61, 0x6c, 0x69, 0x6e, 0x67, 0xc3,
-        0xa9, 0x6c, 0x69, 0x66, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0xc0, 0xab, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
-        0x69, 0x6f, 0x6e, 0xc0, 0xae, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x81,
-        0xb0, 0x77, 0x69, 0x72, 0x65, 0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x6c, 0x6f, 0x73, 0x74, 0x0b, 0xb1, 0x73,
-        0x63, 0x61, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0xb2, 0x77, 0x69, 0x72,
-        0x65, 0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x72, 0x65, 0x73, 0x75, 0x6d, 0x65, 0xaf, 0x73, 0x63, 0x61, 0x6e,
-        0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0xc0, 0xad, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67,
-        0x5f, 0x68, 0x65, 0x61, 0x6c, 0x73, 0x91, 0x9a, 0xa6, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0xab, 0x77, 0x69, 0x72, 0x65,
-        0x2d, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74, 0xa6, 0x62, 0x72, 0x6f, 0x6b, 0x65, 0x6e, 0xc0, 0x01, 0x64, 0xcc, 0xc8, 0x03,
-        0xa8, 0x64, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0xa6, 0x62, 0x75, 0x64, 0x67, 0x65, 0x74, 0xab, 0x6f, 0x62, 0x6a,
-        0x65, 0x63, 0x74, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0xc0, 0xa6, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x92, 0x01, 0x02, 0xb1,
-        0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0xc3, 0xb0, 0x73,
-        0x63, 0x61, 0x6e, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x5f, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 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, 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, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x97, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x72,
-        0x65, 0x70, 0x6c, 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,
-    ];
-
-    #[test]
-    fn thin_usage_cache_decodes_scanner_wire_fixture() {
-        let decoded =
-            DataUsageCache::unmarshal(SCANNER_USAGE_CACHE_WIRE_FIXTURE).expect("thin projection decodes a scanner-written cache");
-
-        // The six fields shared with the scanner's 16-field info block; the
-        // remaining ten (lifecycle, replication, checkpoint, heals, ...) must
-        // be skipped, not error.
-        assert_eq!(decoded.info.name, "wire-bucket");
-        assert_eq!(decoded.info.next_cycle, 7);
-        assert_eq!(
-            decoded.info.last_update,
-            Some(SystemTime::UNIX_EPOCH + Duration::from_secs(1_700_000_000))
-        );
-        assert!(decoded.info.skip_healing);
-        assert_eq!(decoded.info.failed_objects.get("wire-bucket/lost"), Some(&11));
-        assert!(decoded.info.snapshot_complete);
-
-        // Entries use the shared canonical map-encoded type end to end.
-        let entry = decoded.cache.get("wire-bucket").expect("fixture entry decodes");
-        assert_eq!(entry.size, 4096);
-        assert_eq!(entry.objects, 3);
-        assert_eq!(entry.versions, 5);
-        assert_eq!(entry.delete_markers, 1);
-        assert!(entry.compacted);
-        assert_eq!(entry.failed_objects, 2);
-        assert_eq!(
-            entry.all_tier_stats.as_ref().and_then(|tiers| tiers.tiers.get("WARM")),
-            Some(&TierStats {
-                total_size: 2048,
-                num_versions: 2,
-                num_objects: 1,
-            })
-        );
-    }
-
    #[test]
    fn hash_path_uses_portable_slash_semantics() {
        for (input, expected) in [
@@ -40,8 +40,7 @@ use http::header::{CONTENT_TYPE, HOST};
 use rustfs_signer::constants::UNSIGNED_PAYLOAD;
 use rustfs_signer::sign_v4;
 use s3s::Body;
-use sha2::{Digest, Sha256};
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeSet;
 use std::error::Error;
 use std::path::{Path, PathBuf};
 use tracing::info;
@@ -60,26 +59,13 @@ pub(crate) struct VersionShardCensus {
    pub version_id: Option<String>,
    pub has_xl_meta: bool,
    pub data_dir: Option<String>,
-    pub erasure_index: Option<usize>,
    pub expected_part_numbers: BTreeSet<usize>,
-    pub present_part_fingerprints: BTreeMap<usize, PartShardFingerprint>,
-    pub inline_data_fingerprint: Option<PartShardFingerprint>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub(crate) struct PartShardFingerprint {
-    pub size: u64,
-    pub sha256: String,
+    pub present_part_numbers: BTreeSet<usize>,
 }

 impl VersionShardCensus {
    pub(crate) fn is_complete(&self) -> bool {
-        self.has_xl_meta
-            && self.expected_part_numbers.len() == self.present_part_fingerprints.len()
-            && self
-                .expected_part_numbers
-                .iter()
-                .all(|part_number| self.present_part_fingerprints.contains_key(part_number))
+        self.has_xl_meta && self.expected_part_numbers == self.present_part_numbers
    }

    pub(crate) fn matches_manifest(&self, manifest: &Self) -> bool {
@@ -87,25 +73,10 @@ impl VersionShardCensus {
            && self.is_complete()
            && manifest.is_complete()
            && self.data_dir == manifest.data_dir
-            && self.erasure_index == manifest.erasure_index
            && self.expected_part_numbers == manifest.expected_part_numbers
-            && self.present_part_fingerprints == manifest.present_part_fingerprints
-            && self.inline_data_fingerprint == manifest.inline_data_fingerprint
    }
 }

-fn sha256_hex(data: &[u8]) -> String {
-    let digest = Sha256::digest(data);
-    digest.iter().map(|byte| format!("{byte:02x}")).collect()
-}
-
-fn shard_fingerprint(data: &[u8]) -> ChaosResult<PartShardFingerprint> {
-    Ok(PartShardFingerprint {
-        size: u64::try_from(data.len())?,
-        sha256: sha256_hex(data),
-    })
-}
-
 /// Single-node RustFS server with `disk_count` local volume directories that
 /// can be faulted individually while the server is running.
 pub struct DiskFaultHarness {
@@ -312,10 +283,8 @@ pub(crate) fn census_object_version_on_disk(
            version_id,
            has_xl_meta: false,
            data_dir: None,
-            erasure_index: None,
            expected_part_numbers: BTreeSet::new(),
-            present_part_fingerprints: BTreeMap::new(),
-            inline_data_fingerprint: None,
+            present_part_numbers: BTreeSet::new(),
        });
    }

@@ -327,31 +296,20 @@ pub(crate) fn census_object_version_on_disk(
        file_info.parts.iter().map(|part| part.number).collect()
    };
    let data_dir = file_info.data_dir.map(|id| id.to_string());
-    let erasure_index = Some(file_info.erasure.index);
-    let inline_data_fingerprint = file_info.data.as_deref().map(shard_fingerprint).transpose()?;
    let part_dir = data_dir.as_ref().map_or_else(|| object_dir.clone(), |id| object_dir.join(id));
-    let present_part_fingerprints = match std::fs::read_dir(&part_dir) {
-        Ok(entries) => {
-            let mut fingerprints = BTreeMap::new();
-            for entry in entries {
-                let entry = entry?;
-                if !entry.file_type()?.is_file() {
-                    continue;
-                }
-                let file_name = entry.file_name();
-                let Some(part_number) = file_name
-                    .to_str()
-                    .and_then(|name| name.strip_prefix("part."))
-                    .and_then(|number| number.parse::<usize>().ok())
-                else {
-                    continue;
-                };
-                let data = std::fs::read(entry.path())?;
-                fingerprints.insert(part_number, shard_fingerprint(&data)?);
-            }
-            fingerprints
-        }
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => BTreeMap::new(),
+    let present_part_numbers = match std::fs::read_dir(&part_dir) {
+        Ok(entries) => entries
+            .filter_map(Result::ok)
+            .filter_map(|entry| {
+                entry
+                    .file_type()
+                    .ok()
+                    .filter(|kind| kind.is_file())
+                    .and_then(|_| entry.file_name().to_str().map(str::to_owned))
+            })
+            .filter_map(|name| name.strip_prefix("part.").and_then(|number| number.parse::<usize>().ok()))
+            .collect(),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => BTreeSet::new(),
        Err(error) => return Err(error.into()),
    };

@@ -359,10 +317,8 @@ pub(crate) fn census_object_version_on_disk(
        version_id,
        has_xl_meta: true,
        data_dir,
-        erasure_index,
        expected_part_numbers,
-        present_part_fingerprints,
-        inline_data_fingerprint,
+        present_part_numbers,
    })
 }

@@ -402,43 +358,3 @@ pub async fn signed_admin_post(url: &str, body: Option<&str>, access_key: &str,

    Ok(body)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn complete_census() -> VersionShardCensus {
-        VersionShardCensus {
-            version_id: Some("version".to_string()),
-            has_xl_meta: true,
-            data_dir: Some("data-dir".to_string()),
-            erasure_index: Some(3),
-            expected_part_numbers: BTreeSet::from([1]),
-            present_part_fingerprints: BTreeMap::from([(1, shard_fingerprint(b"part").unwrap())]),
-            inline_data_fingerprint: None,
-        }
-    }
-
-    #[test]
-    fn shard_fingerprint_uses_physical_length_and_sha256() {
-        assert_eq!(
-            shard_fingerprint(b"abc").unwrap(),
-            PartShardFingerprint {
-                size: 3,
-                sha256: "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad".to_string(),
-            }
-        );
-    }
-
-    #[test]
-    fn manifest_requires_matching_inline_payload() {
-        let mut expected = complete_census();
-        expected.expected_part_numbers.clear();
-        expected.present_part_fingerprints.clear();
-        expected.inline_data_fingerprint = Some(shard_fingerprint(b"expected").unwrap());
-        let mut changed = expected.clone();
-        changed.inline_data_fingerprint = Some(shard_fingerprint(b"changed").unwrap());
-        assert!(expected.matches_manifest(&expected));
-        assert!(!changed.matches_manifest(&expected));
-    }
-}
@@ -67,16 +67,6 @@ fn configured_capture_log_path(temp_dir: &str) -> Option<String> {
    capture_log_path(Path::new(&log_dir), temp_dir).map(|path| path.to_string_lossy().into_owned())
 }

-fn capture_command_logs(command: &mut Command, log_path: Option<&str>) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let Some(log_path) = log_path else {
-        return Ok(());
-    };
-    let file = stdfs::OpenOptions::new().create(true).append(true).open(log_path)?;
-    let stderr_file = file.try_clone()?;
-    command.stdout(Stdio::from(file)).stderr(Stdio::from(stderr_file));
-    Ok(())
-}
-
 pub(crate) fn build_test_s3_config(
    endpoint_url: &str,
    access_key: &str,
@@ -567,7 +557,13 @@ impl RustFSTestEnvironment {
        for (key, value) in extra_env {
            command.env(key, value);
        }
-        capture_command_logs(&mut command, self.capture_log_path.as_deref())?;
+        // Optionally capture the child's stdout+stderr to a file so the test can
+        // grep server logs (e.g. to confirm which GET reader path was taken).
+        if let Some(log_path) = &self.capture_log_path {
+            let file = stdfs::OpenOptions::new().create(true).append(true).open(log_path)?;
+            let stderr_file = file.try_clone()?;
+            command.stdout(Stdio::from(file)).stderr(Stdio::from(stderr_file));
+        }
        let process = command.args(&args).spawn()?;

        self.process = Some(process);
@@ -1055,7 +1051,6 @@ pub struct RustFSTestClusterEnvironment {
    pub secret_key: String,
    pub extra_env: Vec<(String, String)>,
    pub node_extra_env: Vec<Vec<(String, String)>>,
-    pub node_capture_log_paths: Vec<Option<String>>,
    pub topology: ClusterTopology,
 }

@@ -1155,7 +1150,6 @@ impl RustFSTestClusterEnvironment {
            secret_key: "rustfs-cluster-test-secret".to_string(),
            extra_env,
            node_extra_env: vec![Vec::new(); topology.node_count],
-            node_capture_log_paths: vec![None; topology.node_count],
            topology,
        })
    }
@@ -1185,20 +1179,6 @@ impl RustFSTestClusterEnvironment {
        Ok(())
    }

-    /// Capture stdout+stderr for a single cluster node process.
-    pub fn set_node_capture_log_path<P>(
-        &mut self,
-        node_idx: usize,
-        path: P,
-    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
-    where
-        P: Into<String>,
-    {
-        self.ensure_node_index(node_idx)?;
-        self.node_capture_log_paths[node_idx] = Some(path.into());
-        Ok(())
-    }
-
    fn ensure_node_index(&self, node_idx: usize) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        if node_idx >= self.nodes.len() {
            return Err(format!("node_idx {node_idx} is invalid").into());
@@ -1288,7 +1268,6 @@ impl RustFSTestClusterEnvironment {
            for (key, value) in &self.node_extra_env[i] {
                command.env(key, value);
            }
-            capture_command_logs(&mut command, self.node_capture_log_paths[i].as_deref())?;

            let process = command.current_dir(&node.data_dir).spawn()?;

@@ -1315,7 +1294,6 @@ impl RustFSTestClusterEnvironment {

        let binary_path = rustfs_binary_path();
        let volumes_arg = self.build_volumes_arg();
-        let log_path = self.node_capture_log_paths[node_idx].clone();
        let node = &mut self.nodes[node_idx];
        info!("Starting cluster node {} on {}", node_idx, node.address);

@@ -1334,7 +1312,6 @@ impl RustFSTestClusterEnvironment {
        for (key, value) in &self.node_extra_env[node_idx] {
            command.env(key, value);
        }
-        capture_command_logs(&mut command, log_path.as_deref())?;

        let process = command.current_dir(&node.data_dir).spawn()?;
        node.process = Some(process);
@@ -1586,7 +1563,6 @@ mod tests {
            secret_key: DEFAULT_SECRET_KEY.to_string(),
            extra_env: Vec::new(),
            node_extra_env: vec![Vec::new(); topology.node_count],
-            node_capture_log_paths: vec![None; topology.node_count],
            topology,
        }
    }
@@ -1682,16 +1658,6 @@ mod tests {
        );
    }

-    #[test]
-    fn cluster_node_log_capture_supports_per_node_paths() {
-        let mut env = fake_cluster(ClusterTopology::single_pool(3));
-        env.set_node_capture_log_path(1, "/tmp/node1.log").unwrap();
-        assert_eq!(env.node_capture_log_paths[0], None);
-        assert_eq!(env.node_capture_log_paths[1], Some("/tmp/node1.log".to_string()));
-        assert_eq!(env.node_capture_log_paths[2], None);
-        assert!(env.set_node_capture_log_path(3, "/tmp/invalid.log").is_err());
-    }
-
    #[test]
    fn cluster_node_env_rejects_invalid_index() {
        let mut env = fake_cluster(ClusterTopology::single_pool(4));
@@ -30,10 +30,10 @@ use s3s::access::{S3Access, S3AccessContext};
 use s3s::auth::SimpleAuth;
 use s3s::dto::{
    AbortMultipartUploadInput, AbortMultipartUploadOutput, CompleteMultipartUploadInput, CompleteMultipartUploadOutput,
-    CreateMultipartUploadInput, CreateMultipartUploadOutput, DeleteMarkerEntry, DeleteObjectInput, DeleteObjectOutput, ETag,
+    CreateMultipartUploadInput, CreateMultipartUploadOutput, DeleteObjectInput, DeleteObjectOutput, ETag,
    GetBucketVersioningInput, GetBucketVersioningOutput, GetObjectInput, GetObjectOutput, HeadBucketInput, HeadBucketOutput,
-    HeadObjectInput, HeadObjectOutput, ListObjectVersionsInput, ListObjectVersionsOutput, ObjectVersionId, PutObjectInput,
-    PutObjectOutput, StreamingBlob, Timestamp, TimestampFormat, UploadPartInput, UploadPartOutput,
+    HeadObjectInput, HeadObjectOutput, PutObjectInput, PutObjectOutput, StreamingBlob, Timestamp, TimestampFormat,
+    UploadPartInput, UploadPartOutput,
 };
 use s3s::service::{S3Service, S3ServiceBuilder};
 use s3s::validation::{AwsNameValidation, NameValidation};
@@ -91,7 +91,6 @@ pub enum Operation {
    GetObject,
    HeadObject,
    DeleteObject,
-    ListObjectVersions,
    CreateMultipartUpload,
    UploadPart,
    CompleteMultipartUpload,
@@ -110,8 +109,6 @@ pub enum FaultAction {
    /// already have buffered the rest of the current frame; the journal reports
    /// the threshold, and the backend never receives or stores the request.
    DisconnectAfterBytes(usize),
-    /// Apply the request, then close the connection before returning its response.
-    DisconnectAfterResponse,
    /// Drain a request body in fixed-size slices, sleeping after every slice.
    SlowDrain { chunk_bytes: usize, delay: Duration },
    /// Store the request normally but replace the response ETag.
@@ -144,8 +141,6 @@ struct ControlState {

 #[derive(Default)]
 struct StoreState {
-    assign_own_version_ids: bool,
-    assign_own_multipart_version_ids: bool,
    buckets: HashMap<String, BucketState>,
    uploads: HashMap<String, MultipartState>,
    total_bytes: usize,
@@ -388,22 +383,6 @@ impl FakeS3Target {
            .is_some_and(|version| !version.delete_marker)
    }

-    /// Make the target mint its own version ids instead of mirroring the
-    /// forwarded source version id — models a generic S3 service.
-    pub fn assign_own_version_ids(&self, enabled: bool) {
-        lock(&self.backend.store).assign_own_version_ids = enabled;
-    }
-
-    /// Mint own version ids for the multipart path only — models a target
-    /// that adopts PutObject version ids but not CreateMultipartUpload ones.
-    pub fn assign_own_multipart_version_ids(&self, enabled: bool) {
-        lock(&self.backend.store).assign_own_multipart_version_ids = enabled;
-    }
-
-    pub fn active_multipart_upload_count(&self) -> usize {
-        lock(&self.backend.store).uploads.len()
-    }
-
    /// Queue `times` copies of a fault for one operation.
    pub fn inject(&self, operation: Operation, action: FaultAction, times: usize) {
        if times == 0 {
@@ -454,25 +433,6 @@ impl FakeS3Target {
        lock(&self.control).requests.drain(..).collect()
    }

-    /// Stored versions for one key as `(version_id, is_delete_marker)`, oldest
-    /// first. Empty when the bucket or key does not exist. Lets purge tests
-    /// assert on the target's actual state instead of inferring it from the
-    /// request journal (a versioned DELETE is a silent no-op for missing ids).
-    pub fn stored_versions(&self, bucket: &str, key: &str) -> Vec<(String, bool)> {
-        let state = lock(&self.backend.store);
-        state
-            .buckets
-            .get(bucket)
-            .and_then(|bucket_state| bucket_state.objects.get(key))
-            .map(|versions| {
-                versions
-                    .iter()
-                    .map(|version| (version.version_id.clone(), version.delete_marker))
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
    pub async fn shutdown(mut self) {
        let _ = self.shutdown.send(true);
        if let Some(task) = self.task.take() {
@@ -673,7 +633,6 @@ fn parse_request(method: &Method, uri: &Uri) -> ParsedRequest {
    let operation = match (method, key.is_some()) {
        (&Method::HEAD, false) => Operation::HeadBucket,
        (&Method::GET, false) if query.contains_key("versioning") => Operation::GetBucketVersioning,
-        (&Method::GET, false) if query.contains_key("versions") => Operation::ListObjectVersions,
        (&Method::PUT, true) if upload_id.is_some() && part_number.is_some() => Operation::UploadPart,
        (&Method::PUT, true) if upload_id.is_some() || query.contains_key("partNumber") => Operation::Unknown,
        (&Method::POST, true) if query.contains_key("uploads") => Operation::CreateMultipartUpload,
@@ -730,17 +689,10 @@ fn validate_retained_identifier(value: String, field: &str) -> S3Result<String>
    }
 }

-/// `assign_own` models a target that mints its own version ids (a generic S3
-/// service): the forwarded source-version-id header is validated but NOT
-/// mirrored into the stored version.
-fn new_version_id(headers: &HeaderMap, assign_own: bool) -> S3Result<String> {
+fn new_version_id(headers: &HeaderMap) -> S3Result<String> {
    let Some(value) = header_value(headers, &SOURCE_VERSION_ID_HEADERS) else {
        return Ok(Uuid::new_v4().to_string());
    };
-    if assign_own {
-        validate_retained_identifier(value.trim().to_owned(), "source version ID")?;
-        return Ok(Uuid::new_v4().to_string());
-    }
    let value = validate_retained_identifier(value.trim().to_owned(), "source version ID")?;
    let version_id = Uuid::parse_str(&value).map_err(|_| s3s::s3_error!(InvalidArgument, "source version ID must be a UUID"))?;
    Ok(version_id.to_string())
@@ -825,10 +777,7 @@ async fn apply_non_body_fault(fault: Option<&RequestFault>, control: &Mutex<Cont
            update_consumed(control, fault.expect("matched fault").sequence, 0);
            Err(scripted_disconnect_error())
        }
-        Some(FaultAction::SlowDrain { .. })
-        | Some(FaultAction::WrongEtag)
-        | Some(FaultAction::DisconnectAfterResponse)
-        | None => Ok(()),
+        Some(FaultAction::SlowDrain { .. }) | Some(FaultAction::WrongEtag) | None => Ok(()),
    }
 }

@@ -869,7 +818,7 @@ async fn collect_stream(
            Some(FaultAction::SlowDrain { chunk_bytes, delay }) => {
                return collect_stream_slow(body, capacity, *chunk_bytes, *delay).await;
            }
-            Some(FaultAction::WrongEtag) | Some(FaultAction::DisconnectAfterResponse) | None => {}
+            Some(FaultAction::WrongEtag) | None => {}
        }

        let mut output = BytesMut::with_capacity(capacity);
@@ -931,9 +880,6 @@ fn apply_response_fault<T>(mut response: S3Response<T>, fault: Option<&RequestFa
    if fault.is_some_and(|fault| fault.action == FaultAction::WrongEtag) {
        response.headers.insert(ETAG, HeaderValue::from_static(WRONG_ETAG));
    }
-    if fault.is_some_and(|fault| fault.action == FaultAction::DisconnectAfterResponse) {
-        response.headers.insert(DISCONNECT_HEADER, HeaderValue::from_static("true"));
-    }
    response
 }

@@ -1122,63 +1068,6 @@ impl S3 for FakeBackend {
        ))
    }

-    /// Prefix + max-keys subset only — enough for the replication-check probe
-    /// key allocation. No pagination markers or delimiter folding.
-    async fn list_object_versions(
-        &self,
-        req: S3Request<ListObjectVersionsInput>,
-    ) -> S3Result<S3Response<ListObjectVersionsOutput>> {
-        let fault = request_fault(&req);
-        apply_non_body_fault(fault.as_ref(), &self.control).await?;
-        let state = lock(&self.store);
-        let Some(bucket_state) = state.buckets.get(&req.input.bucket) else {
-            return Err(s3s::s3_error!(NoSuchBucket, "bucket does not exist"));
-        };
-        let prefix = req.input.prefix.as_deref().unwrap_or_default();
-        let max_keys = req.input.max_keys.unwrap_or(1000).max(0) as usize;
-
-        let mut keys: Vec<&String> = bucket_state.objects.keys().filter(|key| key.starts_with(prefix)).collect();
-        keys.sort();
-
-        let mut versions = Vec::new();
-        let mut delete_markers = Vec::new();
-        'keys: for key in keys {
-            for version in bucket_state.objects[key].iter().rev() {
-                if versions.len() + delete_markers.len() >= max_keys {
-                    break 'keys;
-                }
-                if version.delete_marker {
-                    delete_markers.push(DeleteMarkerEntry {
-                        key: Some(key.clone()),
-                        version_id: Some(ObjectVersionId::from(version.version_id.clone())),
-                        last_modified: Some(version.last_modified.clone()),
-                        ..Default::default()
-                    });
-                } else {
-                    versions.push(s3s::dto::ObjectVersion {
-                        key: Some(key.clone()),
-                        version_id: Some(ObjectVersionId::from(version.version_id.clone())),
-                        last_modified: Some(version.last_modified.clone()),
-                        e_tag: Some(ETag::Strong(version.e_tag.clone())),
-                        size: Some(version.body.len() as i64),
-                        ..Default::default()
-                    });
-                }
-            }
-        }
-        drop(state);
-
-        Ok(apply_response_fault(
-            S3Response::new(ListObjectVersionsOutput {
-                name: Some(req.input.bucket),
-                versions: Some(versions),
-                delete_markers: Some(delete_markers),
-                ..Default::default()
-            }),
-            fault.as_ref(),
-        ))
-    }
-
    async fn put_object(&self, req: S3Request<PutObjectInput>) -> S3Result<S3Response<PutObjectOutput>> {
        let fault = request_fault(&req);
        let _body_permit = timeout(MAX_FAULT_DURATION, Arc::clone(&self.body_limit).acquire_owned())
@@ -1189,8 +1078,7 @@ impl S3 for FakeBackend {
        let input = req.input;
        let body = collect_stream(input.body, input.content_length, fault.as_ref(), &self.control).await?;
        validate_stored_metadata(&input.content_type, &input.metadata)?;
-        let assign_own = lock(&self.store).assign_own_version_ids;
-        let version_id = new_version_id(&headers, assign_own)?;
+        let version_id = new_version_id(&headers)?;
        let e_tag = match source_etag(&headers)? {
            Some(value) => value,
            None => {
@@ -1233,7 +1121,7 @@ impl S3 for FakeBackend {
                content_type: version.content_type,
                metadata: version.metadata,
                e_tag: Some(ETag::Strong(version.e_tag)),
-                last_modified: Some(version.last_modified.clone()),
+                last_modified: Some(version.last_modified),
                version_id: Some(version.version_id),
                ..Default::default()
            }),
@@ -1255,7 +1143,7 @@ impl S3 for FakeBackend {
                content_type: version.content_type,
                metadata: version.metadata,
                e_tag: Some(ETag::Strong(version.e_tag)),
-                last_modified: Some(version.last_modified.clone()),
+                last_modified: Some(version.last_modified),
                version_id: Some(version.version_id),
                ..Default::default()
            }),
@@ -1324,9 +1212,7 @@ impl S3 for FakeBackend {
            ));
        }

-        // `state` is the live store guard: read the flag from it. Re-locking
-        // would self-deadlock (the store mutex is not reentrant).
-        let version_id = new_version_id(&headers, state.assign_own_version_ids)?;
+        let version_id = new_version_id(&headers)?;
        upsert_version(
            &mut state,
            &input.bucket,
@@ -1366,16 +1252,12 @@ impl S3 for FakeBackend {
        ensure_upload_budget(&state)?;
        validate_stored_metadata(&input.content_type, &input.metadata)?;
        let upload_id = Uuid::new_v4().to_string();
-        // Read the flag before the mutable borrow of `state.uploads` below
-        // (and never re-lock the store: the mutex is not reentrant).
-        let mint_own = state.assign_own_version_ids || state.assign_own_multipart_version_ids;
-        let version_id = new_version_id(&headers, mint_own)?;
        state.uploads.insert(
            upload_id.clone(),
            MultipartState {
                bucket: input.bucket.clone(),
                key: input.key.clone(),
-                version_id,
+                version_id: new_version_id(&headers)?,
                content_type: input.content_type,
                metadata: input.metadata,
                parts: BTreeMap::new(),
@@ -189,6 +189,8 @@ mod tests {
            ("RUSTFS_GET_CODEC_STREAMING_ROLLOUT_PCT", "100"),
            ("RUSTFS_GET_CODEC_STREAMING_BODY_COMPAT_CONFIRMED", "true"),
            ("RUSTFS_GET_CODEC_STREAMING_HEADER_COMPAT_CONFIRMED", "true"),
+            // Lower the min-size floor so every non-inline object below is eligible.
+            ("RUSTFS_GET_CODEC_STREAMING_MIN_SIZE", "4096"),
            // Route multipart objects through per-part codec streaming too.
            ("RUSTFS_GET_CODEC_STREAMING_MULTIPART_ENABLE", "true"),
            // Lock optimization is on by default, but pin it so the gate's
@@ -313,13 +315,6 @@ mod tests {
                },
                payload(64 * 1024, 2),
            ),
-            (
-                Shape {
-                    key: "small-non-inline-256kib-plus",
-                    expect_large: true,
-                },
-                payload(256 * 1024 + 1, 6),
-            ),
            (
                Shape {
                    key: "mid-1_5mib",
@@ -14,7 +14,7 @@

 //! E2E tests for group management (fixes #2028).

-use crate::common::{RustFSTestEnvironment, admin_request, awscurl_delete, awscurl_get, awscurl_put, init_logging};
+use crate::common::{RustFSTestEnvironment, awscurl_delete, awscurl_get, awscurl_put, init_logging};
 use aws_sdk_s3::config::{Credentials, Region};
 use aws_sdk_s3::{Client, Config};
 use serial_test::serial;
@@ -32,56 +32,6 @@ fn create_user_s3_client(env: &RustFSTestEnvironment, access_key: &str, secret_k
    Client::from_conf(config)
 }

-#[tokio::test(flavor = "multi_thread")]
-async fn update_group_members_rejects_invalid_new_group_names() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    init_logging();
-
-    let mut env = RustFSTestEnvironment::new().await?;
-    env.start_rustfs_server(vec![]).await?;
-
-    let invalid_groups = [
-        ("test group", "group name contains whitespace"),
-        ("test=group", "group name contains reserved characters =,"),
-        ("test,group", "group name contains reserved characters =,"),
-    ];
-
-    for (group, expected_message) in invalid_groups {
-        let body = serde_json::json!({
-            "group": group,
-            "members": [],
-            "isRemove": false,
-            "groupStatus": "enabled"
-        })
-        .to_string();
-        let (status, response_body) = admin_request(
-            &env.url,
-            http::Method::PUT,
-            "/rustfs/admin/v3/update-group-members",
-            Some(body),
-            &env.access_key,
-            &env.secret_key,
-        )
-        .await?;
-
-        assert_eq!(
-            status,
-            reqwest::StatusCode::BAD_REQUEST,
-            "invalid group {group:?} must return HTTP 400, body: {response_body}"
-        );
-        assert!(
-            response_body.contains("<Code>InvalidArgument</Code>"),
-            "invalid group {group:?} must return InvalidArgument, body: {response_body}"
-        );
-        assert!(
-            response_body.contains(&format!("<Message>{expected_message}</Message>")),
-            "invalid group {group:?} returned an unexpected message: {response_body}"
-        );
-    }
-
-    env.stop_server();
-    Ok(())
-}
-
 /// Test that deleting a group with members fails, and deleting an empty group succeeds.
 #[tokio::test(flavor = "multi_thread")]
 #[serial]
@@ -1,612 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! ILM on SSE-KMS buckets while per-key SSE authorization is enforced (backlog#1582).
-//!
-//! Per-key KMS authorization (`RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY=true`) scopes the
-//! SSE-KMS data path to the requesting principal's `kms:GenerateDataKey` /
-//! `kms:Decrypt` grants. Internal callers — the lifecycle scanner's expiry deletes
-//! and the tier transition worker's reads — carry no request principal, and
-//! `authorize_sse_kms_key` (rustfs/src/storage/sse.rs) exempts a `None` principal
-//! so background maintenance keeps working on encrypted buckets.
-//!
-//! These tests pin that exemption end to end. If enforcement ever starts applying
-//! to the scanner's internal operations, expiry stops happening on SSE-KMS buckets
-//! and [`ilm_expiration_on_sse_kms_bucket_under_enforcement`] times out; if it
-//! starts applying to the transition worker or the read-through path,
-//! [`ilm_transition_on_sse_kms_bucket_under_enforcement_reads_back`] fails at the
-//! transition wait or the plaintext round-trip.
-//!
-//! The replication half of the same acceptance item lives in
-//! `crates/e2e_test/src/replication_extension_test.rs`
-//! (`test_bucket_replication_sse_kms_failure_contract`); ILM had no coverage
-//! before this file.
-//!
-//! Deployment constraint pinned by the transition test's setup: the RustFS warm
-//! backend forwards the object's stored `x-amz-server-side-encryption*` metadata
-//! as raw headers on the tier data PUT (`build_transition_put_options` +
-//! `api_put_object.rs` header mapping), so a RustFS tier target must itself have
-//! KMS enabled and hold the named key or it rejects every transition upload with
-//! 400 InvalidRequest. That rejection is independent of the enforcement switch;
-//! the cold server here therefore runs its own Local KMS with the same key id.
-
-use super::common::{LocalKMSTestEnvironment, create_key_with_specific_id};
-use crate::common::{RustFSTestEnvironment, admin_request, init_logging};
-use aws_sdk_s3::Client;
-use aws_sdk_s3::primitives::ByteStream;
-use aws_sdk_s3::types::{
-    BucketLifecycleConfiguration, ExpirationStatus, LifecycleExpiration, LifecycleRule, LifecycleRuleFilter, RestoreRequest,
-    ServerSideEncryption, ServerSideEncryptionByDefault, ServerSideEncryptionConfiguration, ServerSideEncryptionRule, Transition,
-    TransitionStorageClass,
-};
-use serde::Deserialize;
-use serial_test::serial;
-use std::time::{Duration as StdDuration, Instant};
-use tracing::info;
-
-type TestResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;
-
-const SSE_KEY: &str = "kms-ilm-sse-key";
-const PAYLOAD: &[u8] = b"kms ilm sse payload: survives enforcement, expires and transitions on schedule";
-
-const EXPIRY_BUCKET: &str = "kms-ilm-expiry";
-const EXPIRE_KEY: &str = "expire/object.bin";
-const SURVIVOR_KEY: &str = "keep/object.bin";
-
-const TIER_NAME: &str = "KMSCOLD";
-const TIER_BUCKET: &str = "kms-ilm-cold-tier";
-const TIER_PREFIX: &str = "tiered";
-const TRANSITION_BUCKET: &str = "kms-ilm-transition";
-const TRANSITION_KEY: &str = "tier/object.bin";
-
-/// Generous CI safety net; with a 1s scanner cycle and 2s lifecycle days the
-/// terminal state normally lands within a few seconds.
-const ILM_DEADLINE: StdDuration = StdDuration::from_secs(90);
-
-/// Start a Local-KMS server with per-key SSE authorization enforced and the
-/// lifecycle clock accelerated.
-///
-/// KMS wiring matches `kms_authorization_negative_matrix_test.rs` (local backend,
-/// `--kms-default-key-id`, insecure dev defaults). The lifecycle env matches
-/// `reliant/lifecycle.rs::fast_lifecycle_env` plus `RUSTFS_ILM_DEBUG_DAY_SECS=2`,
-/// so a `Days=1` rule is due about two seconds after the write.
-async fn start_enforcing_ilm_server(env: &mut LocalKMSTestEnvironment) -> TestResult {
-    create_key_with_specific_id(&env.kms_keys_dir, SSE_KEY).await?;
-
-    let key_dir = env.kms_keys_dir.clone();
-    let args = vec![
-        "--kms-enable",
-        "--kms-backend",
-        "local",
-        "--kms-key-dir",
-        key_dir.as_str(),
-        "--kms-default-key-id",
-        SSE_KEY,
-    ];
-
-    let envs = [
-        ("RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS", "true"),
-        ("RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY", "false"),
-        ("RUSTFS_SCANNER_CYCLE", "1"),
-        ("RUSTFS_ILM_PROCESS_TIME", "1"),
-        ("RUSTFS_ILM_DEBUG_DAY_SECS", "2"),
-    ];
-
-    env.base_env.start_rustfs_server_with_env(args, &envs).await?;
-    Ok(())
-}
-
-/// Set the bucket's default encryption to SSE-KMS under [`SSE_KEY`], so plain
-/// PUTs (and internal rewrites) are encrypted without per-request SSE headers.
-async fn set_bucket_default_sse_kms(client: &Client, bucket: &str) -> TestResult {
-    let encryption_config = ServerSideEncryptionConfiguration::builder()
-        .rules(
-            ServerSideEncryptionRule::builder()
-                .apply_server_side_encryption_by_default(
-                    ServerSideEncryptionByDefault::builder()
-                        .sse_algorithm(ServerSideEncryption::AwsKms)
-                        .kms_master_key_id(SSE_KEY)
-                        .build()?,
-                )
-                .build(),
-        )
-        .build()?;
-    client
-        .put_bucket_encryption()
-        .bucket(bucket)
-        .server_side_encryption_configuration(encryption_config)
-        .send()
-        .await?;
-    Ok(())
-}
-
-/// Assert via `HeadObject` that the stored object is SSE-KMS encrypted under
-/// [`SSE_KEY`]. Without this, a bucket-default misconfiguration would let the
-/// tests pass on an unencrypted object and prove nothing about KMS.
-async fn assert_head_sse_kms(client: &Client, bucket: &str, key: &str) -> TestResult {
-    let head = client.head_object().bucket(bucket).key(key).send().await?;
-    assert_eq!(
-        head.server_side_encryption(),
-        Some(&ServerSideEncryption::AwsKms),
-        "{bucket}/{key} must be SSE-KMS encrypted via the bucket default"
-    );
-    assert_eq!(
-        head.ssekms_key_id(),
-        Some(SSE_KEY),
-        "{bucket}/{key} must be wrapped under the configured KMS key"
-    );
-    Ok(())
-}
-
-/// Returns `true` once `GET bucket/key` fails with `NoSuchKey`, `false` while it
-/// still succeeds. Any other error is surfaced. (Copied from
-/// `reliant/lifecycle.rs`; that helper is private to the reliant module.)
-async fn object_is_gone(client: &Client, bucket: &str, key: &str) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
-    match client.get_object().bucket(bucket).key(key).send().await {
-        Ok(output) => {
-            output.body.collect().await?;
-            Ok(false)
-        }
-        Err(e) => {
-            if let Some(service_error) = e.as_service_error() {
-                if service_error.is_no_such_key() {
-                    return Ok(true);
-                }
-                return Err(format!("expected NoSuchKey, got: {e:?}").into());
-            }
-            Err(format!("expected a service error, got: {e:?}").into())
-        }
-    }
-}
-
-/// Poll until `GET bucket/key` returns `NoSuchKey`, or fail after `deadline`.
-async fn wait_for_object_expired(client: &Client, bucket: &str, key: &str, deadline: StdDuration) -> TestResult {
-    let start = Instant::now();
-    loop {
-        if object_is_gone(client, bucket, key).await? {
-            return Ok(());
-        }
-        if start.elapsed() >= deadline {
-            return Err(format!(
-                "object {bucket}/{key} was not expired by the lifecycle scanner within {}s; \
-                 SSE key-policy enforcement may have started blocking the scanner's internal deletes",
-                deadline.as_secs()
-            )
-            .into());
-        }
-        tokio::time::sleep(StdDuration::from_millis(500)).await;
-    }
-}
-
-/// Install a prefix-scoped `Days`-based expiration rule.
-async fn put_expiration_rule(client: &Client, bucket: &str, id: &str, prefix: &str, days: i32) -> TestResult {
-    let rule = LifecycleRule::builder()
-        .id(id)
-        .filter(LifecycleRuleFilter::builder().prefix(prefix).build())
-        .expiration(LifecycleExpiration::builder().days(days).build())
-        .status(ExpirationStatus::Enabled)
-        .build()?;
-    let lifecycle = BucketLifecycleConfiguration::builder().rules(rule).build()?;
-    client
-        .put_bucket_lifecycle_configuration()
-        .bucket(bucket)
-        .lifecycle_configuration(lifecycle)
-        .send()
-        .await?;
-    Ok(())
-}
-
-/// Install a prefix-scoped `Days`-based transition rule targeting [`TIER_NAME`].
-async fn put_transition_rule(client: &Client, bucket: &str, id: &str, prefix: &str, days: i32) -> TestResult {
-    let rule = LifecycleRule::builder()
-        .id(id)
-        .filter(LifecycleRuleFilter::builder().prefix(prefix).build())
-        .transitions(
-            Transition::builder()
-                .days(days)
-                .storage_class(TransitionStorageClass::from(TIER_NAME))
-                .build(),
-        )
-        .status(ExpirationStatus::Enabled)
-        .build()?;
-    let lifecycle = BucketLifecycleConfiguration::builder().rules(rule).build()?;
-    client
-        .put_bucket_lifecycle_configuration()
-        .bucket(bucket)
-        .lifecycle_configuration(lifecycle)
-        .send()
-        .await?;
-    Ok(())
-}
-
-/// Start a plain Local-KMS server (no enforcement, no lifecycle acceleration)
-/// holding [`SSE_KEY`], to serve as the cold tier target.
-///
-/// The RustFS warm backend forwards the stored SSE-KMS headers on the tier data
-/// PUT, so the target re-applies managed SSE-KMS under the named key and must
-/// be able to resolve it; without KMS it answers 400 InvalidRequest and the
-/// transition can never complete. Enforcement stays off here: the tier writes
-/// arrive under `cold`'s root credentials, and one enforcing side is enough to
-/// pin the exemption.
-async fn start_cold_tier_kms_server(env: &mut LocalKMSTestEnvironment) -> TestResult {
-    create_key_with_specific_id(&env.kms_keys_dir, SSE_KEY).await?;
-
-    let key_dir = env.kms_keys_dir.clone();
-    let args = vec![
-        "--kms-enable",
-        "--kms-backend",
-        "local",
-        "--kms-key-dir",
-        key_dir.as_str(),
-        "--kms-default-key-id",
-        SSE_KEY,
-    ];
-
-    env.base_env
-        .start_rustfs_server_with_env(args, &[("RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS", "true")])
-        .await?;
-    Ok(())
-}
-
-/// The subset of the manual transition run report these tests assert on.
-///
-/// Unknown fields are ignored, so this stays compatible with report growth; the
-/// full shape is pinned by `reliant/tiering.rs`.
-#[derive(Debug, Deserialize)]
-struct ManualTransitionRunReport {
-    #[serde(default)]
-    scanned: u64,
-    #[serde(default)]
-    enqueued: u64,
-    #[serde(default)]
-    skipped_already_in_flight: u64,
-    #[serde(default)]
-    skipped_tier: u64,
-}
-
-#[derive(Debug, Deserialize)]
-struct ManualTransitionRunResponse {
-    state: String,
-    report: ManualTransitionRunReport,
-}
-
-/// One synchronous (enqueue-only) manual transition run over `bucket/prefix`,
-/// via the same admin endpoint `reliant/tiering.rs` drives.
-async fn manual_transition_run(
-    hot: &RustFSTestEnvironment,
-    bucket: &str,
-    prefix: &str,
-) -> Result<ManualTransitionRunResponse, Box<dyn std::error::Error + Send + Sync>> {
-    let bucket = urlencoding::encode(bucket);
-    let prefix = urlencoding::encode(prefix);
-    let tier = urlencoding::encode(TIER_NAME);
-    let path =
-        format!("/rustfs/admin/v3/ilm/transition/run?bucket={bucket}&prefix={prefix}&tier={tier}&dryRun=false&maxObjects=10");
-    let (status, body) = admin_request(&hot.url, http::Method::POST, &path, None, &hot.access_key, &hot.secret_key).await?;
-    if !status.is_success() {
-        return Err(format!("manual transition run failed: status={status}, body={body}").into());
-    }
-    Ok(serde_json::from_str(&body)?)
-}
-
-/// Drive manual transition runs until one reports the object as processed.
-///
-/// The `Days=1` rule becomes due about two seconds after the write
-/// (`RUSTFS_ILM_DEBUG_DAY_SECS=2`), so early runs may legitimately report the
-/// object as not yet eligible; the loop keeps running the endpoint until it
-/// either enqueues the transition, sees it already in flight (the 1s scanner
-/// backstop got there first), or finds it already on the tier.
-async fn run_manual_transition_until_processed(
-    hot: &RustFSTestEnvironment,
-    bucket: &str,
-    prefix: &str,
-    deadline: StdDuration,
-) -> TestResult {
-    let start = Instant::now();
-    loop {
-        let run = manual_transition_run(hot, bucket, prefix).await?;
-        assert_eq!(run.report.scanned, 1, "manual transition run must scan the object: {run:#?}");
-        if run.report.enqueued + run.report.skipped_already_in_flight + run.report.skipped_tier >= 1 {
-            info!(state = %run.state, report = ?run.report, "manual transition run processed the SSE-KMS object");
-            return Ok(());
-        }
-        if start.elapsed() >= deadline {
-            return Err(format!(
-                "manual transition runs never processed {bucket}/{prefix} within {}s; last report: {run:#?}",
-                deadline.as_secs()
-            )
-            .into());
-        }
-        tokio::time::sleep(StdDuration::from_millis(500)).await;
-    }
-}
-
-/// Wire `hot` -> `cold` as a `TierType::RustFS` remote tier via `AddTier`.
-///
-/// No `force`, so the server runs the real connectivity probe against `cold`
-/// (the tier bucket must already exist there). Mirrors
-/// `reliant/tiering.rs::add_rustfs_tier`, which is private to that module.
-async fn add_rustfs_tier(hot: &RustFSTestEnvironment, cold: &RustFSTestEnvironment) -> TestResult {
-    let body = serde_json::json!({
-        "type": "rustfs",
-        "rustfs": {
-            "name": TIER_NAME,
-            "endpoint": cold.url.as_str(),
-            "accessKey": cold.access_key.as_str(),
-            "secretKey": cold.secret_key.as_str(),
-            "bucket": TIER_BUCKET,
-            "prefix": TIER_PREFIX,
-            "region": "us-east-1",
-            "storageClass": ""
-        }
-    })
-    .to_string();
-
-    let (status, resp) = admin_request(
-        &hot.url,
-        http::Method::PUT,
-        "/rustfs/admin/v3/tier",
-        Some(body),
-        &hot.access_key,
-        &hot.secret_key,
-    )
-    .await?;
-    if !status.is_success() {
-        return Err(format!("AddTier(RustFS) failed: status={status}, body={resp}").into());
-    }
-    Ok(())
-}
-
-/// Poll `HEAD` until the object's storage class is the tier name (transition
-/// complete), or fail after `deadline`. (From `reliant/tiering.rs`.)
-async fn wait_for_transition(client: &Client, bucket: &str, key: &str, deadline: StdDuration) -> TestResult {
-    let start = Instant::now();
-    loop {
-        let head = client.head_object().bucket(bucket).key(key).send().await?;
-        if head.storage_class().map(|sc| sc.as_str()) == Some(TIER_NAME) {
-            return Ok(());
-        }
-        if start.elapsed() >= deadline {
-            return Err(format!(
-                "object {bucket}/{key} was not transitioned to {TIER_NAME} within {}s (storage_class={:?}); \
-                 SSE key-policy enforcement may have started blocking the transition worker's internal reads",
-                deadline.as_secs(),
-                head.storage_class()
-            )
-            .into());
-        }
-        tokio::time::sleep(StdDuration::from_millis(500)).await;
-    }
-}
-
-/// Poll `HEAD` until `x-amz-restore` reports a finished restore
-/// (`ongoing-request="false"`), or fail after `deadline`.
-async fn wait_for_restore_complete(client: &Client, bucket: &str, key: &str, deadline: StdDuration) -> TestResult {
-    let start = Instant::now();
-    loop {
-        let head = client.head_object().bucket(bucket).key(key).send().await?;
-        if head.restore().is_some_and(|r| r.contains("ongoing-request=\"false\"")) {
-            return Ok(());
-        }
-        if start.elapsed() >= deadline {
-            return Err(format!(
-                "object {bucket}/{key} restore did not complete within {}s (restore={:?}); \
-                 SSE key-policy enforcement may have started blocking the restore copy-back's internal reads",
-                deadline.as_secs(),
-                head.restore()
-            )
-            .into());
-        }
-        tokio::time::sleep(StdDuration::from_millis(500)).await;
-    }
-}
-
-/// ILM expiration keeps working on an SSE-KMS bucket while per-key SSE
-/// authorization is enforced.
-///
-/// The lifecycle scanner deletes expired objects with an internal (no-principal)
-/// identity that holds no `kms` grant. If enforcement ever starts applying to
-/// those internal deletes (or to the scanner's metadata reads) on encrypted
-/// buckets, expiry stops happening and this test times out.
-///
-/// A survivor object under a non-matching prefix isolates the rule's prefix
-/// filter as the cause of the deletion and proves the encrypted bucket stays
-/// readable end to end after the scanner has run.
-#[tokio::test]
-#[serial]
-async fn ilm_expiration_on_sse_kms_bucket_under_enforcement() -> TestResult {
-    init_logging();
-
-    let mut env = LocalKMSTestEnvironment::new().await?;
-    start_enforcing_ilm_server(&mut env).await?;
-    env.base_env.create_test_bucket(EXPIRY_BUCKET).await?;
-
-    let client = env.base_env.create_s3_client();
-    set_bucket_default_sse_kms(&client, EXPIRY_BUCKET).await?;
-
-    for key in [EXPIRE_KEY, SURVIVOR_KEY] {
-        client
-            .put_object()
-            .bucket(EXPIRY_BUCKET)
-            .key(key)
-            .body(ByteStream::from_static(PAYLOAD))
-            .send()
-            .await?;
-        assert_head_sse_kms(&client, EXPIRY_BUCKET, key).await?;
-    }
-    info!("both objects stored SSE-KMS encrypted under enforcement");
-
-    put_expiration_rule(&client, EXPIRY_BUCKET, "kms-ilm-expire", "expire/", 1).await?;
-
-    // The regression this pins: the scanner's internal delete must stay exempt
-    // from per-key SSE authorization, so the encrypted object actually expires.
-    wait_for_object_expired(&client, EXPIRY_BUCKET, EXPIRE_KEY, ILM_DEADLINE).await?;
-    info!("SSE-KMS object expired by the lifecycle scanner under enforcement");
-
-    // Negative control: same bucket, same encryption, non-matching prefix. It
-    // must survive the scanner and still decrypt for the requesting principal.
-    assert!(
-        !object_is_gone(&client, EXPIRY_BUCKET, SURVIVOR_KEY).await?,
-        "non-matching-prefix object must not be expired by a prefix-scoped rule"
-    );
-    let survivor = client.get_object().bucket(EXPIRY_BUCKET).key(SURVIVOR_KEY).send().await?;
-    assert_eq!(
-        survivor.body.collect().await?.into_bytes().as_ref(),
-        PAYLOAD,
-        "surviving SSE-KMS object must still decrypt after the scanner has run"
-    );
-
-    Ok(())
-}
-
-/// ILM transition to a remote tier keeps working on an SSE-KMS bucket while
-/// per-key SSE authorization is enforced, and the transitioned object reads
-/// back as plaintext.
-///
-/// The transition worker moves the stored (encrypted) bytes to the cold tier
-/// with an internal (no-principal) identity; the read-through `GET` then
-/// decrypts the envelope for the requesting principal. If enforcement ever
-/// starts applying to the worker's internal reads, the transition wait times
-/// out; if the stored envelope is mishandled across the tier round trip, the
-/// plaintext comparison fails.
-///
-/// The transition is driven through the manual transition-run admin endpoint
-/// (the mechanism `reliant/tiering.rs` established), so the test does not
-/// depend on scanner scheduling; the 1s scanner cycle stays on as a backstop.
-#[tokio::test]
-#[serial]
-#[ignore = "pins rustfs/rustfs#6025: GET on a transitioned managed-SSE object silently returns corrupt bytes (fails with enforcement on AND off, so it is not an authorization regression); un-ignore with the fix"]
-async fn ilm_transition_on_sse_kms_bucket_under_enforcement_reads_back() -> TestResult {
-    init_logging();
-
-    // Cold-tier server: independent credentials, its own Local KMS holding the
-    // same key id (see the module docs for why the tier target needs KMS).
-    // Started first; each server's startup cleanup only matches its own unique
-    // address and temp dir, so the two instances coexist.
-    let mut cold = LocalKMSTestEnvironment::new().await?;
-    cold.base_env.access_key = "kmscoldtieradmin".to_string();
-    cold.base_env.secret_key = "kmscoldtiersecret".to_string();
-    start_cold_tier_kms_server(&mut cold).await?;
-    let cold_client = cold.base_env.create_s3_client();
-    cold_client.create_bucket().bucket(TIER_BUCKET).send().await?;
-
-    // Hot server: Local KMS + enforcement + accelerated lifecycle clock.
-    let mut env = LocalKMSTestEnvironment::new().await?;
-    start_enforcing_ilm_server(&mut env).await?;
-    let hot_client = env.base_env.create_s3_client();
-
-    add_rustfs_tier(&env.base_env, &cold.base_env).await?;
-
-    env.base_env.create_test_bucket(TRANSITION_BUCKET).await?;
-    set_bucket_default_sse_kms(&hot_client, TRANSITION_BUCKET).await?;
-
-    hot_client
-        .put_object()
-        .bucket(TRANSITION_BUCKET)
-        .key(TRANSITION_KEY)
-        .body(ByteStream::from_static(PAYLOAD))
-        .send()
-        .await?;
-    assert_head_sse_kms(&hot_client, TRANSITION_BUCKET, TRANSITION_KEY).await?;
-    info!("object stored SSE-KMS encrypted under enforcement");
-
-    // Days=1 is due ~2s after the write with RUSTFS_ILM_DEBUG_DAY_SECS=2.
-    put_transition_rule(&hot_client, TRANSITION_BUCKET, "kms-ilm-transition", "tier/", 1).await?;
-
-    // Drive the transition deterministically via the manual run endpoint, then
-    // wait for HEAD to report the tier as the object's storage class.
-    run_manual_transition_until_processed(&env.base_env, TRANSITION_BUCKET, "tier/", ILM_DEADLINE).await?;
-    wait_for_transition(&hot_client, TRANSITION_BUCKET, TRANSITION_KEY, ILM_DEADLINE).await?;
-    info!("SSE-KMS object transitioned to the remote tier under enforcement");
-
-    let head = hot_client
-        .head_object()
-        .bucket(TRANSITION_BUCKET)
-        .key(TRANSITION_KEY)
-        .send()
-        .await?;
-    assert!(
-        head.restore().is_none(),
-        "a freshly transitioned object must not advertise x-amz-restore, got {:?}",
-        head.restore()
-    );
-
-    // The remote copy exists on the cold tier. The payload the tier holds is the
-    // hot server's stored ciphertext, wrapped once more under the cold server's
-    // own managed SSE-KMS layer (the forwarded headers re-request encryption).
-    let remote = cold_client.list_objects_v2().bucket(TIER_BUCKET).send().await?;
-    assert!(!remote.contents().is_empty(), "cold-tier bucket must hold the transitioned object's data");
-
-    // Read-through GET under enforcement must succeed (not AccessDenied) and
-    // keep advertising SSE-KMS. Its BODY is deliberately not compared here:
-    // the transitioned read path skips managed-SSE decryption — a product gap
-    // unrelated to enforcement — so a direct GET streams the stored ciphertext
-    // (`new_getobjectreader` in crates/ecstore/src/client/object_api_utils.rs
-    // hardcodes `is_encrypted = false` and never applies the
-    // `ReadTransform::Encrypted` wrapping the hot-read path builds in
-    // crates/ecstore/src/object_api/readers.rs). Plaintext recovery is pinned
-    // through restore semantics below; when the read-through gap is fixed, a
-    // byte assertion can be added here too.
-    let read_through = hot_client
-        .get_object()
-        .bucket(TRANSITION_BUCKET)
-        .key(TRANSITION_KEY)
-        .send()
-        .await?;
-    assert_eq!(
-        read_through.server_side_encryption(),
-        Some(&ServerSideEncryption::AwsKms),
-        "transitioned object must still report SSE-KMS on read-through"
-    );
-    let read_through_body = read_through.body.collect().await?.into_bytes();
-    assert_eq!(
-        read_through_body.len(),
-        PAYLOAD.len(),
-        "read-through GET must stream the object's full logical size under enforcement"
-    );
-
-    // RestoreObject copies the ciphertext back from the tier under the original
-    // envelope metadata; the restored copy is then served by the normal
-    // decrypting read path. The copy-back runs with an internal (no-principal)
-    // identity, so this also pins the exemption on the restore path. Days=300
-    // because RUSTFS_ILM_DEBUG_DAY_SECS=2 accelerates the restored copy's
-    // expiry as well (300 accelerated days == 600s of validity).
-    hot_client
-        .restore_object()
-        .bucket(TRANSITION_BUCKET)
-        .key(TRANSITION_KEY)
-        .restore_request(RestoreRequest::builder().days(300).build())
-        .send()
-        .await?;
-    wait_for_restore_complete(&hot_client, TRANSITION_BUCKET, TRANSITION_KEY, ILM_DEADLINE).await?;
-    info!("SSE-KMS object restored from the remote tier under enforcement");
-
-    // The KMS-relevant half: the restored envelope decrypts back to the exact
-    // plaintext for the requesting principal.
-    let restored = hot_client
-        .get_object()
-        .bucket(TRANSITION_BUCKET)
-        .key(TRANSITION_KEY)
-        .send()
-        .await?;
-    assert_eq!(
-        restored.server_side_encryption(),
-        Some(&ServerSideEncryption::AwsKms),
-        "restored object must still report SSE-KMS"
-    );
-    let body = restored.body.collect().await?.into_bytes();
-    assert_eq!(body.as_ref(), PAYLOAD, "restored SSE-KMS object must round-trip byte-identical plaintext");
-
-    Ok(())
-}
@@ -59,6 +59,3 @@ mod configured_roundtrip_test;

 #[cfg(test)]
 mod kms_authorization_negative_matrix_test;
-
-#[cfg(test)]
-mod kms_ilm_sse_kms_test;
@@ -39,10 +39,6 @@ pub mod fault_proxy;
 #[cfg(test)]
 mod reliability_disk_fault_test;

-// Privileged Linux-only 3x4 replacement rebuild proof for rustfs#5869/#1791.
-#[cfg(all(test, target_os = "linux"))]
-mod replacement_privileged_e2e_test;
-
 // dist-13 (backlog#1150/#1155): e2e regression net proving a large-object
 // degraded EC read never returns a silently truncated body (rustfs#4594/#4560/#4585).
 #[cfg(test)]
@@ -2854,7 +2854,7 @@ pub(crate) mod cmptst_30 {
        result
    }

-    #[ignore = "timing-sensitive backend-pressure latency probe; run explicitly with --ignored"]
+    #[ignore]
    #[tokio::test]
    async fn regression() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        crate::common::init_logging();
@@ -252,7 +252,6 @@ impl QuotaTestEnv {
 #[cfg(test)]
 mod integration_tests {
    use super::*;
-    use aws_sdk_s3::error::ProvideErrorMetadata;

    #[tokio::test]
    #[serial]
@@ -964,27 +963,9 @@ mod integration_tests {
            .send()
            .await;

-        let complete_error = complete_result.expect_err("multipart completion above quota must be rejected");
-        assert_eq!(complete_error.as_service_error().and_then(|error| error.code()), Some("InvalidRequest"));
+        assert!(complete_result.is_err());
        assert!(!env.object_exists("over_quota.txt").await?);

-        let staged_parts = env
-            .client
-            .list_parts()
-            .bucket(&env.bucket_name)
-            .key("over_quota.txt")
-            .upload_id(upload_id2)
-            .send()
-            .await?;
-        assert_eq!(staged_parts.parts().len(), 2, "quota rejection must preserve the multipart upload");
-        env.client
-            .abort_multipart_upload()
-            .bucket(&env.bucket_name)
-            .key("over_quota.txt")
-            .upload_id(upload_id2)
-            .send()
-            .await?;
-
        env.cleanup_bucket().await?;

        Ok(())
@@ -349,32 +349,11 @@ mod tests {
            .send()
            .await?;

-        let first_inline = client
-            .put_object()
-            .bucket(bucket)
-            .key("versions/inline.bin")
-            .body(ByteStream::from(payload(8 * 1024, 40)))
-            .send()
-            .await?;
-        let first_inline_version = first_inline
-            .version_id()
-            .ok_or("first inline PUT did not return a version ID")?;
-        let second_inline = client
-            .put_object()
-            .bucket(bucket)
-            .key("versions/inline.bin")
-            .body(ByteStream::from(payload(8 * 1024, 41)))
-            .send()
-            .await?;
-        let second_inline_version = second_inline
-            .version_id()
-            .ok_or("second inline PUT did not return a version ID")?;
-
        let first = client
            .put_object()
            .bucket(bucket)
            .key(key)
-            .body(ByteStream::from(payload(128 * 1024, 41)))
+            .body(ByteStream::from(payload(256 * 1024, 41)))
            .send()
            .await?;
        let first_version = first.version_id().ok_or("first PUT did not return a version ID")?;
@@ -382,36 +361,16 @@ mod tests {
            .put_object()
            .bucket(bucket)
            .key(key)
-            .body(ByteStream::from(payload(3 * 1024 * 1024, 42)))
+            .body(ByteStream::from(payload(256 * 1024, 42)))
            .send()
            .await?;
        let second_version = second.version_id().ok_or("second PUT did not return a version ID")?;
        let delete = client.delete_object().bucket(bucket).key(key).send().await?;
        let delete_version = delete.version_id().ok_or("delete marker did not return a version ID")?;

-        let first_inline_census = harness.census_object_version(0, bucket, "versions/inline.bin", Some(first_inline_version))?;
-        let second_inline_census =
-            harness.census_object_version(0, bucket, "versions/inline.bin", Some(second_inline_version))?;
        let first_census = harness.census_object_version(0, bucket, key, Some(first_version))?;
-        let first_other_disk_census = harness.census_object_version(1, bucket, key, Some(first_version))?;
        let second_census = harness.census_object_version(0, bucket, key, Some(second_version))?;
        let delete_census = harness.census_object_version(0, bucket, key, Some(delete_version))?;
-        assert!(
-            first_inline_census.is_complete() && second_inline_census.is_complete(),
-            "inline version physical census is incomplete: first={first_inline_census:?} second={second_inline_census:?}"
-        );
-        assert!(
-            first_inline_census.present_part_fingerprints.is_empty() && second_inline_census.present_part_fingerprints.is_empty(),
-            "inline versions must not select external shard files: first={first_inline_census:?} second={second_inline_census:?}"
-        );
-        assert!(
-            first_inline_census.inline_data_fingerprint.is_some() && second_inline_census.inline_data_fingerprint.is_some(),
-            "inline versions must fingerprint payload bytes stored in xl.meta"
-        );
-        assert_ne!(
-            first_inline_census.inline_data_fingerprint, second_inline_census.inline_data_fingerprint,
-            "same-size inline versions with different payloads must retain distinct xl.meta fingerprints"
-        );
        assert!(
            first_census.is_complete(),
            "first version physical census is incomplete: {first_census:?}"
@@ -420,14 +379,6 @@ mod tests {
            second_census.is_complete(),
            "second version physical census is incomplete: {second_census:?}"
        );
-        assert!(
-            first_other_disk_census.is_complete(),
-            "first version physical census on the second disk is incomplete: {first_other_disk_census:?}"
-        );
-        assert_ne!(
-            first_census.erasure_index, first_other_disk_census.erasure_index,
-            "physical census must preserve each disk's erasure index"
-        );
        assert_ne!(
            first_census.data_dir, second_census.data_dir,
            "distinct object versions must select distinct physical data directories"
@@ -436,24 +387,6 @@ mod tests {
            first_census.expected_part_numbers, second_census.expected_part_numbers,
            "same single-part shape should expose the same part numbers"
        );
-        let first_part = first_census
-            .present_part_fingerprints
-            .values()
-            .next()
-            .ok_or("first version did not expose a physical part fingerprint")?;
-        let second_part = second_census
-            .present_part_fingerprints
-            .values()
-            .next()
-            .ok_or("second version did not expose a physical part fingerprint")?;
-        assert_ne!(
-            first_part.size, second_part.size,
-            "different shard lengths must retain their physical sizes"
-        );
-        assert_ne!(
-            first_part.sha256, second_part.sha256,
-            "different shard contents must retain their physical hashes"
-        );
        assert!(
            delete_census.is_complete(),
            "delete marker physical census is incomplete: {delete_census:?}"
@@ -463,7 +396,7 @@ mod tests {
            "delete marker must not declare object shards: {delete_census:?}"
        );
        assert!(
-            delete_census.present_part_fingerprints.is_empty(),
+            delete_census.present_part_numbers.is_empty(),
            "delete marker must not select stale object shards: {delete_census:?}"
        );
        Ok(())
@@ -32,11 +32,6 @@ workspace = true

 [features]
 default = []
-# Compiles the controlled list-objects namespace-journal chaos injector into a
-# production binary (it is always available to tests). Off by default so the
-# RUSTFS_LIST_OBJECTS_NAMESPACE_JOURNAL_CHAOS_* env vars cannot rewrite journal
-# state in a stock build (backlog#1832).
-list-chaos = []
 rio-v2 = ["dep:rustfs-rio-v2"]
 hotpath = [
    "hotpath/hotpath",
@@ -69,7 +69,6 @@ fn build_non_inline_writers(config: &BenchConfig) -> Vec<Option<BitrotWriterWrap
 fn bench_single_block_non_inline_fast_path(c: &mut Criterion) {
    let configs = vec![
        BenchConfig::new(4 * 1024, 4, 2, 128 * 1024),
-        BenchConfig::new(16 * 1024, 4, 2, 128 * 1024),
        BenchConfig::new(64 * 1024, 4, 2, 128 * 1024),
        BenchConfig::new(128 * 1024, 4, 2, 128 * 1024),
    ];
@@ -113,12 +112,7 @@ fn bench_single_block_non_inline_fast_path(c: &mut Criterion) {
                rt.block_on(async {
                    erasure
                        .clone()
-                        .encode_single_block_non_inline_with_size_hint(
-                            reader,
-                            &mut writers,
-                            config.data_shards,
-                            config.payload_size,
-                        )
+                        .encode_single_block_non_inline(reader, &mut writers, config.data_shards)
                        .await
                        .expect("single block candidate benchmark");
                });
@@ -32,7 +32,7 @@ pub mod bucket {
    pub mod bucket_target_sys {
        pub use crate::bucket::bucket_target_sys::{
            AdvancedPutOptions, BucketTargetError, BucketTargetSys, PutObjectOptions, RemoveObjectOptions, S3ClientError,
-            TargetClient, append_version_id_query,
+            TargetClient,
        };
    }

@@ -61,11 +61,9 @@ pub mod bucket {
                delete_manual_transition_scope_admission_if_current, load_manual_transition_job_record,
                load_manual_transition_job_record_with_etag, load_manual_transition_scope_admission,
                manual_transition_job_lease_expired, manual_transition_scope_admission_lease_expired,
-                manual_transition_scope_key, persist_manual_transition_job_progress,
-                persist_manual_transition_job_progress_if_owned, renew_manual_transition_job_lease,
-                renew_manual_transition_job_lease_if_owned, request_manual_transition_job_cancel,
-                save_manual_transition_job_record, save_manual_transition_job_record_if_current,
-                save_manual_transition_scope_admission_if_absent, update_manual_transition_job_record,
+                manual_transition_scope_key, persist_manual_transition_job_progress, renew_manual_transition_job_lease,
+                request_manual_transition_job_cancel, save_manual_transition_job_record,
+                save_manual_transition_job_record_if_current, save_manual_transition_scope_admission_if_absent,
            };
        }

@@ -283,7 +281,7 @@ pub mod config {
    pub mod com {
        pub use crate::config::com::{
            COMMA_SEPARATED_LISTS, CONFIG_PREFIX, ENV_CONFIG_RECOVER_ON_CORRUPTION, STORAGE_CLASS_SUB_SYS,
-            ServerConfigCorruptError, ServerConfigSaveResult, ServerConfigSnapshot, delete_config, delete_config_no_lock,
+            ServerConfigCorruptError, ServerConfigSaveResult, ServerConfigSnapshot, delete_config,
            is_server_config_corrupt_error, lookup_configs, read_config, read_config_no_lock, read_config_with_metadata,
            read_config_without_migrate, read_config_without_migrate_no_lock, read_existing_server_config_no_lock,
            read_server_config_snapshot, save_config, save_config_no_lock, save_config_with_opts, save_server_config,
@@ -310,8 +308,6 @@ 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,
@@ -346,7 +342,7 @@ pub mod disk {
    }

    pub mod error {
-        pub use crate::disk::error::{DiskError, Error, FileAccessDeniedWithContext, Result};
+        pub use crate::disk::error::{BitrotErrorType, DiskError, Error, FileAccessDeniedWithContext, Result};
    }

    pub mod error_reduce {
@@ -413,10 +409,10 @@ pub mod object {
    pub use crate::object_api::{
        BLOCK_SIZE_V2, ERASURE_ALGORITHM, EncryptionResolutionError, EncryptionResolutionErrorKind, GetObjectBodyCacheHook,
        GetObjectBodyCacheHookLookup, GetObjectBodySource, GetObjectReader, NamespaceLockFence, ObjectEncryptionResolver,
-        ObjectInfo, ObjectLockConfigSnapshot, ObjectMutationHook, ObjectOptions, PutObjReader, QuotaAdmission,
-        RangedDecompressReader, ReadEncryptionMaterial, ReadEncryptionMode, ReadEncryptionRequest, StreamConsumer,
-        get_object_body_cache_plaintext_len, lookup_get_object_body_cache_hook, register_get_object_body_cache_hook,
-        register_object_mutation_hook, unregister_get_object_body_cache_hook, unregister_object_mutation_hook,
+        ObjectInfo, ObjectLockConfigSnapshot, ObjectMutationHook, ObjectOptions, PutObjReader, RangedDecompressReader,
+        ReadEncryptionMaterial, ReadEncryptionMode, ReadEncryptionRequest, StreamConsumer, get_object_body_cache_plaintext_len,
+        lookup_get_object_body_cache_hook, register_get_object_body_cache_hook, register_object_mutation_hook,
+        unregister_get_object_body_cache_hook, unregister_object_mutation_hook,
    };
    pub use crate::store::{
        PrepareSelectObjectSnapshotError, PreparedGetObjectReader, SelectObjectSnapshot, SelectObjectSnapshotReadError,
@@ -1450,7 +1450,7 @@ fn resolve_put_api_version_id(source_version_id: &str) -> Option<&str> {
 /// member, so the query is spliced in via `map_request`, which runs at
 /// `modify_before_signing`: the parameter becomes part of the SigV4 canonical
 /// request.
-pub fn append_version_id_query(uri: &str, version_id: &str) -> String {
+fn append_version_id_query(uri: &str, version_id: &str) -> String {
    let separator = if uri.contains('?') { '&' } else { '?' };
    format!("{uri}{separator}versionId={}", urlencoding::encode(version_id))
 }
@@ -1861,9 +1861,6 @@ impl TargetClient {
        }
    }

-    /// On success returns the version id the target assigned (from
-    /// `x-amz-version-id`), letting callers audit the version-identity
-    /// contract — a target that adopts the source version echoes it back.
    pub async fn put_object(
        &self,
        bucket: &str,
@@ -1871,7 +1868,7 @@ impl TargetClient {
        size: i64,
        body: ByteStream,
        opts: &PutObjectOptions,
-    ) -> Result<Option<String>, S3ClientError> {
+    ) -> Result<(), S3ClientError> {
        let mut headers = opts.header();

        let builder = self.client.put_object();
@@ -1906,7 +1903,7 @@ impl TargetClient {
            .send()
            .await
        {
-            Ok(output) => Ok(output.version_id().map(ToOwned::to_owned)),
+            Ok(_) => Ok(()),
            Err(e) => match e {
                SdkError::ServiceError(service_err) => {
                    let err = service_err.into_err();
@@ -64,41 +64,10 @@ impl BucketDurabilityConfig {
    }
 }

-/// Default durability tier seeded into a newly created bucket's metadata
-/// (rustfs/backlog#1811). `relaxed` aligns new buckets with MinIO's default
-/// posture: object data is still fdatasynced, while xl.meta and directory-entry
-/// fsyncs follow the relaxed durability gate.
-pub const ENV_NEW_BUCKET_DURABILITY_MODE: &str = "RUSTFS_NEW_BUCKET_DURABILITY_MODE";
-pub const DEFAULT_NEW_BUCKET_DURABILITY_MODE: &str = BUCKET_DURABILITY_MODE_RELAXED;
-
-/// The `durability.json` bytes to seed into a freshly created bucket's metadata.
-/// Empty means "no override" (the bucket then follows the global
-/// `RUSTFS_DURABILITY_MODE`); otherwise the serialized chosen tier. Operators
-/// can set `inherit` to disable the new-bucket override. Invalid values also
-/// fail closed to inherit the global mode instead of seeding a surprising tier.
-pub fn new_bucket_durability_config_json() -> Vec<u8> {
-    let raw = std::env::var(ENV_NEW_BUCKET_DURABILITY_MODE).unwrap_or_else(|_| DEFAULT_NEW_BUCKET_DURABILITY_MODE.to_string());
-    let mode = raw.trim();
-    if mode.eq_ignore_ascii_case("inherit") || mode.is_empty() || !BucketDurabilityConfig::is_valid_mode(mode) {
-        return Vec::new();
-    }
-    serde_json::to_vec(&BucketDurabilityConfig::new(mode)).expect("BucketDurabilityConfig serialization cannot fail")
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;

-    fn new_bucket_seeded_mode() -> Option<String> {
-        let json = new_bucket_durability_config_json();
-        if json.is_empty() {
-            return None;
-        }
-        serde_json::from_slice::<BucketDurabilityConfig>(&json)
-            .expect("new-bucket durability config must serialize")
-            .normalized_mode()
-    }
-
    #[test]
    fn valid_modes_are_recognized() {
        assert!(BucketDurabilityConfig::is_valid_mode("strict"));
@@ -130,33 +99,4 @@ mod tests {
        let empty: BucketDurabilityConfig = serde_json::from_slice(b"{}").expect("deserialize empty");
        assert_eq!(empty.normalized_mode(), None);
    }
-
-    #[test]
-    fn new_bucket_default_seeds_relaxed_when_unset() {
-        temp_env::with_var_unset(ENV_NEW_BUCKET_DURABILITY_MODE, || {
-            assert_eq!(new_bucket_seeded_mode().as_deref(), Some(BUCKET_DURABILITY_MODE_RELAXED));
-        });
-    }
-
-    #[test]
-    fn new_bucket_default_honors_explicit_tiers() {
-        for mode in [
-            BUCKET_DURABILITY_MODE_STRICT,
-            BUCKET_DURABILITY_MODE_RELAXED,
-            BUCKET_DURABILITY_MODE_NONE,
-        ] {
-            temp_env::with_var(ENV_NEW_BUCKET_DURABILITY_MODE, Some(mode), || {
-                assert_eq!(new_bucket_seeded_mode().as_deref(), Some(mode));
-            });
-        }
-    }
-
-    #[test]
-    fn new_bucket_default_can_inherit_global_mode() {
-        for mode in ["inherit", "", "bogus"] {
-            temp_env::with_var(ENV_NEW_BUCKET_DURABILITY_MODE, Some(mode), || {
-                assert_eq!(new_bucket_seeded_mode(), None);
-            });
-        }
-    }
 }
@@ -86,21 +86,6 @@ where
    com::save_config_with_opts(api, file, data, opts).await
 }

-pub(crate) async fn save_config_with_opts_quiet<S>(api: Arc<S>, file: &str, data: Vec<u8>, opts: &ObjectOptions) -> Result<()>
-where
-    S: ObjectIO<
-            Error = Error,
-            RangeSpec = HTTPRangeSpec,
-            HeaderMap = HeaderMap,
-            ObjectOptions = ObjectOptions,
-            ObjectInfo = ObjectInfo,
-            GetObjectReader = GetObjectReader,
-            PutObjectReader = PutObjReader,
-        >,
-{
-    com::save_config_with_opts_quiet(api, file, data, opts).await
-}
-
 pub(crate) async fn delete_config<S>(api: Arc<S>, file: &str) -> Result<()>
 where
    S: ObjectOperations<
@@ -45,104 +45,6 @@ const MANUAL_TRANSITION_JOB_LEASE_SECONDS: i128 = 60;
 const MANUAL_TRANSITION_LEGACY_SCOPE_SCAN_LIMIT: i32 = 1000;
 const MANUAL_TRANSITION_TASK_SCAN_LIMIT: i32 = 1000;
 const MANUAL_TRANSITION_WORKER_RESULT_SCAN_LIMIT: i32 = 1000;
-const MANUAL_TRANSITION_JOB_CAS_RETRIES: usize = 4;
-
-#[cfg(test)]
-struct ManualTransitionJobCasBarrierState {
-    job_id: Uuid,
-    paused: std::sync::atomic::AtomicBool,
-    arrived: tokio::sync::Notify,
-    release: tokio::sync::Semaphore,
-}
-
-#[cfg(test)]
-pub(crate) struct ManualTransitionJobCasBarrier {
-    state: Arc<ManualTransitionJobCasBarrierState>,
-}
-
-#[cfg(test)]
-static MANUAL_TRANSITION_JOB_CAS_BARRIER: std::sync::OnceLock<std::sync::Mutex<Option<Arc<ManualTransitionJobCasBarrierState>>>> =
-    std::sync::OnceLock::new();
-
-#[cfg(test)]
-impl ManualTransitionJobCasBarrier {
-    pub(crate) fn install(job_id: Uuid) -> Self {
-        let state = Arc::new(ManualTransitionJobCasBarrierState {
-            job_id,
-            paused: std::sync::atomic::AtomicBool::new(false),
-            arrived: tokio::sync::Notify::new(),
-            release: tokio::sync::Semaphore::new(0),
-        });
-        let mut slot = MANUAL_TRANSITION_JOB_CAS_BARRIER
-            .get_or_init(|| std::sync::Mutex::new(None))
-            .lock()
-            .expect("manual transition progress CAS barrier mutex should not poison");
-        assert!(
-            slot.is_none(),
-            "manual transition job CAS barrier must be installed by one test at a time"
-        );
-        *slot = Some(Arc::clone(&state));
-        drop(slot);
-        Self { state }
-    }
-
-    pub(crate) async fn wait_until_paused(&self) {
-        tokio::time::timeout(std::time::Duration::from_secs(30), async {
-            loop {
-                let arrived = self.state.arrived.notified();
-                if self.state.paused.load(std::sync::atomic::Ordering::Acquire) {
-                    return;
-                }
-                arrived.await;
-            }
-        })
-        .await
-        .expect("manual transition job update should reach the deterministic CAS barrier");
-    }
-
-    pub(crate) fn release(&self) {
-        self.state.release.add_permits(1);
-    }
-}
-
-#[cfg(test)]
-impl Drop for ManualTransitionJobCasBarrier {
-    fn drop(&mut self) {
-        self.release();
-        let mut slot = MANUAL_TRANSITION_JOB_CAS_BARRIER
-            .get_or_init(|| std::sync::Mutex::new(None))
-            .lock()
-            .expect("manual transition progress CAS barrier mutex should not poison");
-        if slot.as_ref().is_some_and(|state| Arc::ptr_eq(state, &self.state)) {
-            *slot = None;
-        }
-    }
-}
-
-#[cfg(test)]
-async fn pause_manual_transition_job_before_first_cas(job_id: Uuid) {
-    let barrier = MANUAL_TRANSITION_JOB_CAS_BARRIER
-        .get_or_init(|| std::sync::Mutex::new(None))
-        .lock()
-        .expect("manual transition progress CAS barrier mutex should not poison")
-        .as_ref()
-        .filter(|barrier| barrier.job_id == job_id)
-        .cloned();
-    if let Some(barrier) = barrier
-        && barrier
-            .paused
-            .compare_exchange(false, true, std::sync::atomic::Ordering::AcqRel, std::sync::atomic::Ordering::Acquire)
-            .is_ok()
-    {
-        barrier.arrived.notify_one();
-        barrier
-            .release
-            .acquire()
-            .await
-            .expect("manual transition job CAS barrier should remain open")
-            .forget();
-    }
-}

 fn is_false(value: &bool) -> bool {
    !*value
@@ -246,6 +148,7 @@ impl ManualTransitionJobRecord {

    pub fn fail(&mut self, error: impl Into<String>) {
        self.state = ManualTransitionJobState::Failed;
+        self.report.tier_failure = self.report.tier_failure.saturating_add(1);
        self.error = Some(error.into());
        self.mark_updated_terminal();
    }
@@ -1137,7 +1040,7 @@ pub async fn save_manual_transition_job_record_if_current(
    }
    let object = manual_transition_job_record_object_name(job.job_id).map_err(manual_transition_job_store_error)?;
    let data = job.encode().map_err(manual_transition_job_store_error)?;
-    config_boundary::save_config_with_opts_quiet(
+    config_boundary::save_config_with_opts(
        api,
        &object,
        data,
@@ -1153,54 +1056,6 @@ pub async fn save_manual_transition_job_record_if_current(
    .await
 }

-/// Applies a job-record mutation with optimistic concurrency control.
-///
-/// The mutation returns whether the record needs to be persisted. When a lease
-/// is supplied, ownership is checked again after every conflicting write.
-pub async fn update_manual_transition_job_record<F>(
-    api: Arc<ECStore>,
-    job_id: Uuid,
-    expected_lease_id: Option<Uuid>,
-    update: F,
-) -> EcstoreResult<ManualTransitionJobRecord>
-where
-    F: FnMut(&mut ManualTransitionJobRecord) -> bool,
-{
-    update_manual_transition_job_record_from(api, job_id, expected_lease_id, None, update).await
-}
-
-async fn update_manual_transition_job_record_from<F>(
-    api: Arc<ECStore>,
-    job_id: Uuid,
-    expected_lease_id: Option<Uuid>,
-    mut current: Option<(ManualTransitionJobRecord, String)>,
-    mut update: F,
-) -> EcstoreResult<ManualTransitionJobRecord>
-where
-    F: FnMut(&mut ManualTransitionJobRecord) -> bool,
-{
-    for _ in 0..MANUAL_TRANSITION_JOB_CAS_RETRIES {
-        let (mut record, etag) = match current.take() {
-            Some(current) => current,
-            None => load_manual_transition_job_record_with_etag(api.clone(), job_id).await?,
-        };
-        if expected_lease_id.is_some_and(|lease_id| record.lease_id != lease_id) {
-            return Err(Error::PreconditionFailed);
-        }
-        if !update(&mut record) {
-            return Ok(record);
-        }
-        #[cfg(test)]
-        pause_manual_transition_job_before_first_cas(job_id).await;
-        match save_manual_transition_job_record_if_current(api.clone(), &record, &etag).await {
-            Ok(()) => return Ok(record),
-            Err(Error::PreconditionFailed) => continue,
-            Err(err) => return Err(err),
-        }
-    }
-    Err(Error::PreconditionFailed)
-}
-
 pub(crate) async fn save_manual_transition_worker_result_if_absent(
    api: Arc<ECStore>,
    record: &ManualTransitionWorkerResultRecord,
@@ -1459,113 +1314,99 @@ pub async fn reconcile_manual_transition_worker_results(
    api: Arc<ECStore>,
    job_id: Uuid,
    queue_snapshot: ManualTransitionQueueSnapshot,
-) -> EcstoreResult<ManualTransitionJobRecord> {
-    reconcile_manual_transition_worker_results_inner(api, job_id, None, queue_snapshot, false).await
-}
-
-pub(crate) async fn reconcile_manual_transition_worker_results_if_owned(
-    api: Arc<ECStore>,
-    job_id: Uuid,
-    expected_lease_id: Uuid,
-    queue_snapshot: ManualTransitionQueueSnapshot,
-) -> EcstoreResult<ManualTransitionJobRecord> {
-    reconcile_manual_transition_worker_results_inner(api, job_id, Some(expected_lease_id), queue_snapshot, false).await
-}
-
-async fn reconcile_manual_transition_worker_results_inner(
-    api: Arc<ECStore>,
-    job_id: Uuid,
-    expected_lease_id: Option<Uuid>,
-    queue_snapshot: ManualTransitionQueueSnapshot,
-    mark_missing_results_unknown: bool,
 ) -> EcstoreResult<ManualTransitionJobRecord> {
    let task_stats = match scan_manual_transition_task_journal(api.clone(), job_id).await? {
        ManualTransitionTaskJournal::Stats(stats) => stats,
        ManualTransitionTaskJournal::Corrupt(error) => {
-            return mark_manual_transition_job_unknown_for_task_journal_error(
-                api,
-                job_id,
-                expected_lease_id,
-                error,
-                queue_snapshot,
-            )
-            .await;
+            return mark_manual_transition_job_unknown_for_task_journal_error(api, job_id, error, queue_snapshot).await;
        }
    };
    let stats = match scan_manual_transition_worker_result_journal(api.clone(), job_id).await? {
        ManualTransitionWorkerResultJournal::Stats(stats) => stats,
        ManualTransitionWorkerResultJournal::Corrupt(error) => {
-            return mark_manual_transition_job_unknown_for_worker_result_journal_error(
-                api,
-                job_id,
-                expected_lease_id,
-                error,
-                queue_snapshot,
-            )
-            .await;
+            return mark_manual_transition_job_unknown_for_worker_result_journal_error(api, job_id, error, queue_snapshot).await;
        }
    };
-    let mut changed = false;
-    let record = update_manual_transition_job_record(api.clone(), job_id, expected_lease_id, |record| {
-        let counts_changed = record.apply_worker_result_counts(
+    for _ in 0..4 {
+        let (mut record, etag) = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
+        let changed = record.apply_worker_result_counts(
            stats.stats.completed,
            stats.stats.failed,
            &stats.stats.tier_failure_by_reason,
            task_stats.queued,
            queue_snapshot,
        );
-        let became_unknown = mark_missing_results_unknown && record.mark_unknown_if_worker_results_lost(queue_snapshot);
-        changed = counts_changed || became_unknown;
-        changed
-    })
-    .await?;
-    if !changed {
-        return Ok(record);
+        if !changed {
+            return Ok(record);
+        }
+        match save_manual_transition_job_record_if_current(api.clone(), &record, &etag).await {
+            Ok(()) => {
+                if record.is_terminal() {
+                    delete_manual_transition_scope_admission_if_current(
+                        api.clone(),
+                        &record.scope_key,
+                        record.job_id,
+                        record.lease_id,
+                    )
+                    .await?;
+                } else {
+                    renew_manual_transition_scope_admission_from_job(api, &record).await?;
+                }
+                return Ok(record);
+            }
+            Err(Error::PreconditionFailed) => continue,
+            Err(err) => return Err(err),
+        }
    }
-    if record.is_terminal() {
-        delete_manual_transition_scope_admission_if_current(api, &record.scope_key, record.job_id, record.lease_id).await?;
-    } else {
-        renew_manual_transition_scope_admission_from_job(api, &record).await?;
-    }
-    Ok(record)
+    Err(Error::PreconditionFailed)
 }

 async fn mark_manual_transition_job_unknown_for_task_journal_error(
    api: Arc<ECStore>,
    job_id: Uuid,
-    expected_lease_id: Option<Uuid>,
    error: String,
    queue_snapshot: ManualTransitionQueueSnapshot,
 ) -> EcstoreResult<ManualTransitionJobRecord> {
-    let mut changed = false;
-    let record = update_manual_transition_job_record(api.clone(), job_id, expected_lease_id, |record| {
-        changed = record.mark_unknown_for_task_journal_error(error.clone(), queue_snapshot);
-        changed
-    })
-    .await?;
-    if changed && record.is_terminal() {
-        delete_manual_transition_scope_admission_if_current(api, &record.scope_key, record.job_id, record.lease_id).await?;
+    for _ in 0..4 {
+        let (mut record, etag) = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
+        if !record.mark_unknown_for_task_journal_error(error.clone(), queue_snapshot) {
+            return Ok(record);
+        }
+        match save_manual_transition_job_record_if_current(api.clone(), &record, &etag).await {
+            Ok(()) => {
+                delete_manual_transition_scope_admission_if_current(api, &record.scope_key, record.job_id, record.lease_id)
+                    .await?;
+                return Ok(record);
+            }
+            Err(Error::PreconditionFailed) => continue,
+            Err(err) => return Err(err),
+        }
    }
-    Ok(record)
+    Err(Error::PreconditionFailed)
 }

 async fn mark_manual_transition_job_unknown_for_worker_result_journal_error(
    api: Arc<ECStore>,
    job_id: Uuid,
-    expected_lease_id: Option<Uuid>,
    error: String,
    queue_snapshot: ManualTransitionQueueSnapshot,
 ) -> EcstoreResult<ManualTransitionJobRecord> {
-    let mut changed = false;
-    let record = update_manual_transition_job_record(api.clone(), job_id, expected_lease_id, |record| {
-        changed = record.mark_unknown_for_worker_result_journal_error(error.clone(), queue_snapshot);
-        changed
-    })
-    .await?;
-    if changed && record.is_terminal() {
-        delete_manual_transition_scope_admission_if_current(api, &record.scope_key, record.job_id, record.lease_id).await?;
+    for _ in 0..4 {
+        let (mut record, etag) = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
+        if !record.mark_unknown_for_worker_result_journal_error(error.clone(), queue_snapshot) {
+            return Ok(record);
+        }
+        match save_manual_transition_job_record_if_current(api.clone(), &record, &etag).await {
+            Ok(()) => {
+                delete_manual_transition_scope_admission_if_current(api, &record.scope_key, record.job_id, record.lease_id)
+                    .await?;
+                return Ok(record);
+            }
+            Err(Error::PreconditionFailed) => continue,
+            Err(err) => return Err(err),
+        }
    }
-    Ok(record)
+    Err(Error::PreconditionFailed)
 }

 pub async fn save_manual_transition_scope_admission_if_absent(
@@ -1762,14 +1603,19 @@ async fn find_active_legacy_manual_transition_scope_conflict(
 }

 pub async fn request_manual_transition_job_cancel(api: Arc<ECStore>, job_id: Uuid) -> EcstoreResult<ManualTransitionJobRecord> {
-    update_manual_transition_job_record(api, job_id, None, |record| {
+    for _ in 0..4 {
+        let (mut record, etag) = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
        if record.is_terminal() || record.cancel_requested {
-            return false;
+            return Ok(record);
        }
        record.mark_cancel_requested();
-        true
-    })
-    .await
+        match save_manual_transition_job_record_if_current(api.clone(), &record, &etag).await {
+            Ok(()) => return Ok(record),
+            Err(Error::PreconditionFailed) => continue,
+            Err(err) => return Err(err),
+        }
+    }
+    Err(Error::PreconditionFailed)
 }

 pub async fn persist_manual_transition_job_progress(
@@ -1778,39 +1624,10 @@ pub async fn persist_manual_transition_job_progress(
    report: &ManualTransitionRunReport,
    queue_snapshot: ManualTransitionQueueSnapshot,
 ) -> EcstoreResult<ManualTransitionJobRecord> {
-    let current = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
-    persist_manual_transition_job_progress_inner(api, job_id, current.0.lease_id, Some(current), report, queue_snapshot).await
-}
-
-pub async fn persist_manual_transition_job_progress_if_owned(
-    api: Arc<ECStore>,
-    job_id: Uuid,
-    expected_lease_id: Uuid,
-    report: &ManualTransitionRunReport,
-    queue_snapshot: ManualTransitionQueueSnapshot,
-) -> EcstoreResult<ManualTransitionJobRecord> {
-    persist_manual_transition_job_progress_inner(api, job_id, expected_lease_id, None, report, queue_snapshot).await
-}
-
-async fn persist_manual_transition_job_progress_inner(
-    api: Arc<ECStore>,
-    job_id: Uuid,
-    expected_lease_id: Uuid,
-    current: Option<(ManualTransitionJobRecord, String)>,
-    report: &ManualTransitionRunReport,
-    queue_snapshot: ManualTransitionQueueSnapshot,
-) -> EcstoreResult<ManualTransitionJobRecord> {
-    let record = update_manual_transition_job_record_from(api.clone(), job_id, Some(expected_lease_id), current, |record| {
-        if record.state != ManualTransitionJobState::Running {
-            return false;
-        }
-        record.update_running_progress(report.clone(), queue_snapshot);
-        true
-    })
-    .await?;
-    if record.state == ManualTransitionJobState::Running {
-        renew_manual_transition_scope_admission_from_job(api, &record).await?;
-    }
+    let (mut record, etag) = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
+    record.update_running_progress(report.clone(), queue_snapshot);
+    save_manual_transition_job_record_if_current(api.clone(), &record, &etag).await?;
+    renew_manual_transition_scope_admission_from_job(api, &record).await?;
    Ok(record)
 }

@@ -1844,58 +1661,25 @@ pub async fn renew_manual_transition_job_lease(
    job_id: Uuid,
    queue_snapshot: ManualTransitionQueueSnapshot,
 ) -> EcstoreResult<ManualTransitionJobRecord> {
-    let current = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
-    renew_manual_transition_job_lease_inner(api, job_id, current.0.lease_id, Some(current), queue_snapshot).await
-}
-
-pub async fn renew_manual_transition_job_lease_if_owned(
-    api: Arc<ECStore>,
-    job_id: Uuid,
-    expected_lease_id: Uuid,
-    queue_snapshot: ManualTransitionQueueSnapshot,
-) -> EcstoreResult<ManualTransitionJobRecord> {
-    renew_manual_transition_job_lease_inner(api, job_id, expected_lease_id, None, queue_snapshot).await
-}
-
-async fn renew_manual_transition_job_lease_inner(
-    api: Arc<ECStore>,
-    job_id: Uuid,
-    expected_lease_id: Uuid,
-    current: Option<(ManualTransitionJobRecord, String)>,
-    queue_snapshot: ManualTransitionQueueSnapshot,
-) -> EcstoreResult<ManualTransitionJobRecord> {
-    let (current, current_etag) = match current {
-        Some(current) => current,
-        None => load_manual_transition_job_record_with_etag(api.clone(), job_id).await?,
-    };
-    if current.lease_id != expected_lease_id {
-        return Err(Error::PreconditionFailed);
-    }
-    if current.state != ManualTransitionJobState::Running {
-        return Ok(current);
-    }
-    if current.scan_completed && queue_snapshot.queued == 0 && queue_snapshot.active == 0 {
-        return reconcile_manual_transition_worker_results_inner(api, job_id, Some(expected_lease_id), queue_snapshot, true)
-            .await;
-    }
-    let record = update_manual_transition_job_record_from(
-        api.clone(),
-        job_id,
-        Some(expected_lease_id),
-        Some((current, current_etag)),
-        |record| {
-            if record.state != ManualTransitionJobState::Running {
-                return false;
+    let (mut record, mut etag) = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
+    if record.state == ManualTransitionJobState::Running {
+        if record.scan_completed && queue_snapshot.queued == 0 && queue_snapshot.active == 0 {
+            record = reconcile_manual_transition_worker_results(api.clone(), job_id, queue_snapshot).await?;
+            if record.is_terminal() || !record.report.worker_transition_pending() {
+                return Ok(record);
            }
+            (record, etag) = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
+        }
+        let became_terminal = record.mark_unknown_if_worker_results_lost(queue_snapshot);
+        if !became_terminal {
            record.renew_lease(queue_snapshot);
-            true
-        },
-    )
-    .await?;
-    if record.is_terminal() {
-        delete_manual_transition_scope_admission_if_current(api, &record.scope_key, record.job_id, record.lease_id).await?;
-    } else if record.state == ManualTransitionJobState::Running {
-        renew_manual_transition_scope_admission_from_job(api, &record).await?;
+        }
+        save_manual_transition_job_record_if_current(api.clone(), &record, &etag).await?;
+        if became_terminal {
+            delete_manual_transition_scope_admission_if_current(api, &record.scope_key, record.job_id, record.lease_id).await?;
+        } else {
+            renew_manual_transition_scope_admission_from_job(api, &record).await?;
+        }
    }
    Ok(record)
 }
@@ -1904,31 +1688,15 @@ async fn renew_manual_transition_scope_admission_from_job(
    api: Arc<ECStore>,
    record: &ManualTransitionJobRecord,
 ) -> EcstoreResult<()> {
-    for _ in 0..MANUAL_TRANSITION_JOB_CAS_RETRIES {
-        let (admission, admission_etag) =
-            match load_manual_transition_scope_admission_with_etag(api.clone(), &record.scope_key).await {
-                Ok(admission) => admission,
-                Err(Error::ConfigNotFound) => return Ok(()),
-                Err(err) => return Err(err),
-            };
-        if admission.job_id != record.job_id || admission.lease_id != record.lease_id {
-            return Err(Error::PreconditionFailed);
-        }
-        let mut renewed_admission = ManualTransitionScopeAdmission::from_job(record);
-        renewed_admission.lease_expires_at_unix_nanos = renewed_admission
-            .lease_expires_at_unix_nanos
-            .max(admission.lease_expires_at_unix_nanos);
-        renewed_admission.updated_at_unix_nanos = renewed_admission.updated_at_unix_nanos.max(admission.updated_at_unix_nanos);
-        if renewed_admission == admission {
-            return Ok(());
-        }
-        match save_manual_transition_scope_admission_if_current(api.clone(), &renewed_admission, &admission_etag).await {
-            Ok(()) => return Ok(()),
-            Err(Error::PreconditionFailed) => continue,
-            Err(err) => return Err(err),
-        }
+    if let Ok((admission, admission_etag)) =
+        load_manual_transition_scope_admission_with_etag(api.clone(), &record.scope_key).await
+        && admission.job_id == record.job_id
+        && admission.lease_id == record.lease_id
+    {
+        let renewed_admission = ManualTransitionScopeAdmission::from_job(record);
+        save_manual_transition_scope_admission_if_current(api, &renewed_admission, &admission_etag).await?;
    }
-    Err(Error::PreconditionFailed)
+    Ok(())
 }

 pub async fn delete_manual_transition_scope_admission_if_current(
@@ -2618,14 +2386,14 @@ mod tests {
    }

    #[test]
-    fn manual_transition_job_record_control_plane_failure_does_not_count_tier_failure() {
+    fn manual_transition_job_record_failure_counts_tier_failure() {
        let options = ManualTransitionRunOptions::default();
        let mut record = ManualTransitionJobRecord::new(Uuid::new_v4(), "bucket", &options, TEST_OWNER);

        record.fail("missing tier");

        assert_eq!(record.state, ManualTransitionJobState::Failed);
-        assert_eq!(record.report.tier_failure, 0);
+        assert_eq!(record.report.tier_failure, 1);
        assert_eq!(record.error.as_deref(), Some("missing tier"));
    }

@@ -18,7 +18,6 @@ use s3s::dto::{BucketLifecycleConfiguration, ObjectLockConfiguration};
 use time::OffsetDateTime;
 use uuid::Uuid;

-use crate::bucket::metadata::BucketMetadata;
 use crate::bucket::metadata_sys::{self, ObjectLockConfigState};
 use crate::error::{Error, Result};

@@ -27,37 +26,16 @@ pub(crate) struct LifecycleExpiryConfigs {
    pub(crate) lifecycle: Option<Arc<BucketLifecycleConfiguration>>,
    pub(crate) object_lock: Option<Arc<ObjectLockConfiguration>>,
    pub(crate) bucket_incarnation_id: Uuid,
-    pub(crate) table_bucket_enabled: bool,
 }

-async fn get_authoritative_metadata(
-    api: &crate::store::ECStore,
-    bucket: &str,
-    bucket_incarnation_id: Uuid,
-) -> Result<Arc<BucketMetadata>> {
+pub(crate) async fn get_expiry_configs(api: &crate::store::ECStore, bucket: &str) -> Result<LifecycleExpiryConfigs> {
+    let bucket_incarnation_id = api.bucket_incarnation_id_from_disk(bucket).await?;
    let sys = metadata_sys::bucket_metadata_sys_of(&api.ctx)?;
    let sys = sys.read().await.clone();
    let metadata = sys.get_authoritative_metadata(bucket).await?;
    if !metadata.bucket_incarnation_sidecar || metadata.bucket_incarnation_id != bucket_incarnation_id {
        return Err(Error::other(format!("bucket lifecycle metadata is not authoritative: {bucket}")));
    }
-    Ok(metadata)
-}
-
-pub(crate) async fn lifecycle_expiry_allowed(
-    api: &crate::store::ECStore,
-    bucket: &str,
-    bucket_incarnation_id: Uuid,
-) -> Result<bool> {
-    Ok(!get_authoritative_metadata(api, bucket, bucket_incarnation_id)
-        .await?
-        .table_bucket_enabled())
-}
-
-pub(crate) async fn get_expiry_configs(api: &crate::store::ECStore, bucket: &str) -> Result<LifecycleExpiryConfigs> {
-    let bucket_incarnation_id = api.bucket_incarnation_id_from_disk(bucket).await?;
-    let metadata = get_authoritative_metadata(api, bucket, bucket_incarnation_id).await?;
-    let table_bucket_enabled = metadata.table_bucket_enabled();

    let lifecycle = if metadata.lifecycle_config.is_none() && !metadata.lifecycle_config_xml.is_empty() {
        return Err(Error::other("persisted bucket lifecycle configuration is invalid"));
@@ -73,7 +51,6 @@ pub(crate) async fn get_expiry_configs(api: &crate::store::ECStore, bucket: &str
            lifecycle: None,
            object_lock: None,
            bucket_incarnation_id,
-            table_bucket_enabled,
        });
    }
    let object_lock = match metadata_sys::object_lock_config_state_from_authoritative_metadata(&metadata)? {
@@ -88,7 +65,6 @@ pub(crate) async fn get_expiry_configs(api: &crate::store::ECStore, bucket: &str
        lifecycle,
        object_lock,
        bucket_incarnation_id,
-        table_bucket_enabled,
    })
 }

@@ -149,7 +125,6 @@ mod tests {
        let lifecycle = lifecycle_config();
        metadata.lifecycle_config_xml = crate::bucket::utils::serialize(&lifecycle).unwrap();
        metadata.lifecycle_config = Some(lifecycle);
-        metadata.table_bucket_config_json = br#"{"enabled":true}"#.to_vec();
        metadata_sys::set_new_bucket_metadata_in(&store_a.ctx, metadata)
            .await
            .unwrap();
@@ -157,14 +132,7 @@ mod tests {
            .await
            .unwrap();

-        let configs = get_expiry_configs(&store_a, bucket).await.unwrap();
-        assert!(configs.lifecycle.is_some());
-        assert!(configs.table_bucket_enabled);
-        assert!(
-            !lifecycle_expiry_allowed(&store_a, bucket, configs.bucket_incarnation_id)
-                .await
-                .unwrap()
-        );
+        assert!(get_expiry_configs(&store_a, bucket).await.unwrap().lifecycle.is_some());
        assert!(get_expiry_configs(&store_b, bucket).await.unwrap().lifecycle.is_none());
    }
 }
@@ -425,15 +425,6 @@ impl BucketMetadata {
        }
    }

-    /// Metadata for a physically new user bucket. Existing or fabricated legacy
-    /// metadata must use [`Self::new`] so upgrades do not rewrite their
-    /// durability posture.
-    pub fn new_with_default_durability(name: &str) -> Self {
-        let mut metadata = Self::new(name);
-        metadata.durability_config_json = super::durability::new_bucket_durability_config_json();
-        metadata
-    }
-
    pub fn save_file_path(&self) -> String {
        format!("{}/{}/{}", BUCKET_META_PREFIX, self.name.as_str(), BUCKET_METADATA_FILE)
    }
@@ -1311,7 +1302,7 @@ mod test {
        assert!(bm.object_locking(), "object lock active via parsed config");
    }

-    /// backlog#580: KNOWN GAP (flagged 2026-03-06: "inline_data 前缀不同"). RustFS's
+    /// backlog#580: KNOWN GAP (weisd 2026-03-06 "inline_data 前缀不同"). RustFS's
    /// inline-data extraction does not yet recover the object body from a
    /// MinIO-written bucket-metadata object: `into_fileinfo(read_data=true).data`
    /// returns bytes that are not the `.metadata.bin` blob (no `format|version`
@@ -1319,7 +1310,7 @@ mod test {
    /// inline-data framing is handled on the read path.
    /// backlog#580: prove RustFS reads a MinIO-written **inlined** bucket-metadata
    /// object end-to-end. MinIO stores inline data as `[bitrot hash][object body]`
-    /// (the "`inline_data` 前缀不同" gap flagged on 2026-03-06 is that
+    /// (the "`inline_data` 前缀不同" that weisd flagged on 2026-03-06 is that
    /// bitrot prefix, not a format incompatibility). Running the raw inline shard
    /// through RustFS's `BitrotReader` with the default `HighwayHash256S` must
    /// verify the checksum and yield the exact `.metadata.bin` blob.
@@ -1387,43 +1378,6 @@ mod test {
        assert_ne!(old.bucket_incarnation_id, new.bucket_incarnation_id);
    }

-    #[test]
-    fn regular_bucket_metadata_constructor_does_not_seed_durability() {
-        temp_env::with_var_unset(crate::bucket::durability::ENV_NEW_BUCKET_DURABILITY_MODE, || {
-            let metadata = BucketMetadata::new("legacy-or-fabricated");
-            assert!(metadata.durability_config_json.is_empty());
-            assert!(metadata.durability_config().is_none());
-        });
-    }
-
-    #[test]
-    fn new_bucket_metadata_constructor_seeds_default_durability() {
-        temp_env::with_var_unset(crate::bucket::durability::ENV_NEW_BUCKET_DURABILITY_MODE, || {
-            let metadata = BucketMetadata::new_with_default_durability("new-user-bucket");
-            assert_eq!(
-                metadata.durability_config().and_then(|cfg| cfg.normalized_mode()).as_deref(),
-                Some(crate::bucket::durability::BUCKET_DURABILITY_MODE_RELAXED)
-            );
-
-            let encoded = metadata.marshal_msg().expect("marshal metadata");
-            let decoded = BucketMetadata::unmarshal(&encoded).expect("unmarshal metadata");
-            assert_eq!(decoded.durability_config_json, metadata.durability_config_json);
-            assert_eq!(
-                decoded.durability_config().and_then(|cfg| cfg.normalized_mode()).as_deref(),
-                Some(crate::bucket::durability::BUCKET_DURABILITY_MODE_RELAXED)
-            );
-        });
-    }
-
-    #[test]
-    fn new_bucket_metadata_constructor_can_inherit_global_durability() {
-        temp_env::with_var(crate::bucket::durability::ENV_NEW_BUCKET_DURABILITY_MODE, Some("inherit"), || {
-            let metadata = BucketMetadata::new_with_default_durability("strict-fleet-new-bucket");
-            assert!(metadata.durability_config_json.is_empty());
-            assert!(metadata.durability_config().is_none());
-        });
-    }
-
    #[test]
    fn site_replication_config_updates_cannot_replace_bucket_incarnation() {
        let mut metadata = BucketMetadata::new("site-replication-update");
@@ -288,13 +288,6 @@ pub(crate) fn bucket_metadata_sys_of(ctx: &crate::runtime::instance::InstanceCon
    get_bucket_metadata_sys()
 }

-pub(crate) fn require_bucket_metadata_sys_in(
-    ctx: &crate::runtime::instance::InstanceContext,
-) -> Result<Arc<RwLock<BucketMetadataSys>>> {
-    ctx.bucket_metadata_sys()
-        .ok_or_else(|| Error::other("bucket metadata sys not initialized for this instance"))
-}
-
 pub(crate) async fn object_store_in(ctx: &crate::runtime::instance::InstanceContext) -> Result<Arc<ECStore>> {
    let sys = bucket_metadata_sys_of(ctx)?;
    Ok(sys.read().await.api.clone())
@@ -383,15 +376,6 @@ pub async fn update(bucket: &str, config_file: &str, data: Vec<u8>) -> Result<Of
    Box::pin(update_with_sys(get_bucket_metadata_sys()?, bucket, config_file, data)).await
 }

-pub(crate) async fn update_in(
-    ctx: &crate::runtime::instance::InstanceContext,
-    bucket: &str,
-    config_file: &str,
-    data: Vec<u8>,
-) -> Result<OffsetDateTime> {
-    Box::pin(update_with_sys(require_bucket_metadata_sys_in(ctx)?, bucket, config_file, data)).await
-}
-
 pub async fn delete(bucket: &str, config_file: &str) -> Result<OffsetDateTime> {
    delete_with_sys(get_bucket_metadata_sys()?, bucket, config_file).await
 }
@@ -14,7 +14,6 @@

 use super::metadata_sys::get_bucket_metadata_sys;
 use crate::error::{Result, StorageError};
-use crate::store::ECStore;
 use rustfs_policy::policy::{BucketPolicy, BucketPolicyArgs};

 pub struct PolicySys {}
@@ -28,10 +27,6 @@ impl PolicySys {
        Self::is_allowed_with_policy(args, Self::get(args.bucket).await).await
    }

-    pub async fn try_is_allowed_for_store(store: &ECStore, args: &BucketPolicyArgs<'_>) -> Result<bool> {
-        Self::is_allowed_with_policy(args, store.get_bucket_policy(args.bucket).await.map(|(policy, _)| policy)).await
-    }
-
    async fn is_allowed_with_policy(args: &BucketPolicyArgs<'_>, policy: Result<BucketPolicy>) -> Result<bool> {
        match policy {
            Ok(policy) => Ok(policy.is_allowed(args).await),
@@ -2567,12 +2567,6 @@ pub trait ReplicationPoolTrait: std::fmt::Debug {
    async fn queue_replica_task(&self, ri: ReplicateObjectInfo) -> ReplicationQueueAdmission;
    async fn queue_replica_delete_task(&self, ri: DeletedObjectReplicationInfo) -> ReplicationQueueAdmission;
    async fn queue_replica_delete_batch(&self, deletes: &[DeletedObjectReplicationInfo]) -> ReplicationBatchAdmission;
-    /// Persist one entry straight to the durable MRF journal, bypassing the
-    /// live worker queues. For failures whose source state is already gone —
-    /// e.g. exhausted delete-marker purges — where only a startup replay can
-    /// retry, and live re-dispatch would loop unboundedly against a down
-    /// target.
-    async fn persist_mrf_entry(&self, entry: MrfReplicateEntry) -> ReplicationQueueAdmission;
    async fn resize(&self, priority: ReplicationPriority, max_workers: usize, max_l_workers: usize);
    async fn get_bucket_resync_status(&self, bucket: &str) -> Result<BucketReplicationResyncStatus, EcstoreError>;
    async fn cancel_bucket_resync(&self, opts: ResyncOpts) -> Result<(), EcstoreError>;
@@ -2613,10 +2607,6 @@ impl<S: ReplicationStorage> ReplicationPoolTrait for ReplicationPool<S> {
        self.queue_replica_delete_batch(deletes).await
    }

-    async fn persist_mrf_entry(&self, entry: MrfReplicateEntry) -> ReplicationQueueAdmission {
-        self.queue_mrf_save_admission(entry, "delete_marker_purge").await
-    }
-
    async fn resize(&self, priority: ReplicationPriority, max_workers: usize, max_l_workers: usize) {
        self.resize(priority, max_workers, max_l_workers).await;
    }
@@ -18,10 +18,9 @@ use super::replication_config_store::ReplicationConfigStore;
 use super::replication_error_boundary::{Result, is_err_object_not_found, is_err_version_not_found};
 use super::replication_event_sink::{EventArgs, send_event, send_local_event};
 use super::replication_filemeta_boundary::{
-    MrfReplicateEntry, NULL_VERSION_ID, REPLICATE_EXISTING, REPLICATE_EXISTING_DELETE, ReplicateDecision, ReplicateObjectInfo,
-    ReplicatedInfos, ReplicatedTargetInfo, ReplicationAction, ReplicationState, ReplicationStatusType, ReplicationType,
-    ReplicationWorkerOperation, VersionPurgeStatusType, get_replication_state, parse_replicate_decision,
-    replication_statuses_map, target_reset_header, version_purge_statuses_map,
+    NULL_VERSION_ID, REPLICATE_EXISTING, REPLICATE_EXISTING_DELETE, ReplicateDecision, ReplicateObjectInfo, ReplicatedInfos,
+    ReplicatedTargetInfo, ReplicationAction, ReplicationState, ReplicationStatusType, ReplicationType, VersionPurgeStatusType,
+    get_replication_state, parse_replicate_decision, replication_statuses_map, target_reset_header, version_purge_statuses_map,
 };
 use super::replication_lock_boundary::ReplicationLockTiming;
 use super::replication_logging::{EVENT_RESYNC_CONFIG_LOOKUP_SKIPPED, LOG_COMPONENT_ECSTORE, LOG_SUBSYSTEM_REPLICATION_RESYNC};
@@ -34,7 +33,7 @@ use super::replication_object_decision_boundary::{
    is_retryable_delete_replication_head_error, is_version_delete_replication, replication_etags_match,
    replication_multipart_complete_actual_size, replication_multipart_part_plan, should_retry_delete_marker_purge,
 };
-use super::replication_queue_boundary::{DeletedObjectReplicationInfo, ReplicationQueueAdmission};
+use super::replication_queue_boundary::DeletedObjectReplicationInfo;
 use super::replication_resync_boundary::ResyncStatusType;
 use super::replication_resync_boundary::{
    BucketReplicationResyncStatus, ResyncOpts, TargetReplicationResyncStatus, encode_resync_file, is_version_id_mismatch,
@@ -64,7 +63,6 @@ use futures::stream::StreamExt;
 use http::HeaderMap;
 use http_body::Frame;
 use http_body_util::StreamBody;
-use metrics::counter;
 #[cfg(test)]
 use rmp_serde;
 use rustfs_s3_types::EventName;
@@ -74,10 +72,10 @@ use rustfs_utils::http::{
 use rustfs_utils::{DEFAULT_SIP_HASH_KEY, get_env_usize, sip_hash};
 #[cfg(test)]
 use s3s::dto::ReplicationConfiguration;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::fmt::Display;
+use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, LazyLock, Mutex as StdMutex};
 use time::OffsetDateTime;
 use time::format_description::well_known::Rfc3339;
 use tokio::io::AsyncRead;
@@ -102,10 +100,6 @@ const EVENT_REPLICATION_FORCE_DELETE_SKIPPED: &str = "replication_force_delete_s
 const EVENT_RESYNC_TASK_FAILED: &str = "replication_resync_task_failed";
 const EVENT_RESYNC_TARGET_OPERATION_FAILED: &str = "replication_resync_target_operation_failed";
 const EVENT_RESYNC_RUNTIME_CHANNEL_FAILED: &str = "replication_resync_runtime_channel_failed";
-const EVENT_DELETE_MARKER_PURGE_FAILED: &str = "replication_delete_marker_purge_failed";
-const EVENT_DELETE_MARKER_PURGE_MRF: &str = "replication_delete_marker_purge_mrf";
-const METRIC_DELETE_MARKER_PURGE_TOTAL: &str = "rustfs_replication_delete_marker_purge_total";
-const EVENT_REPLICATION_VERSION_IDENTITY_DRIFT: &str = "replication_version_identity_drift";
 const REPLICATION_TARGET_OFFLINE_ERROR_MARKERS: &[&str] = &[
    "dispatch failure",
    "timeouterror",
@@ -187,57 +181,6 @@ fn is_head_proxy_failure(err: &SdkError<HeadObjectError>) -> bool {
    should_count_head_proxy_failure(is_not_found, code, raw_status)
 }

-const METRIC_VERSION_IDENTITY_DRIFT_TOTAL: &str = "rustfs_replication_version_identity_drift_total";
-
-/// Targets that already produced a version-identity-drift warning this
-/// process lifetime, by ARN. Deduping is advisory only (the metric still
-/// counts every drifting PUT), so a reconfigured target re-warning only
-/// after a restart is acceptable.
-static VERSION_IDENTITY_WARNED_ARNS: LazyLock<StdMutex<HashSet<String>>> = LazyLock::new(|| StdMutex::new(HashSet::new()));
-
-/// Runtime half of the P1-19 version-identity contract (the explicit probe
-/// lives in replication-check's VersionFidelity phase): every replication PUT
-/// response reveals whether the target adopted the source version id. A
-/// target minting its own ids silently breaks version-addressed deletes and
-/// heal, so surface it — once per target — instead of letting the divergence
-/// accumulate unseen.
-/// Pure drift judgment: the contract only applies when the source addressed a
-/// real (non-nil) version uuid, and drift means the target answered with
-/// anything else — including nothing at all.
-fn version_identity_drifted(source_version_id: &str, assigned_version_id: Option<&str>) -> bool {
-    if source_version_id.is_empty() {
-        return false;
-    }
-    // A nil source uuid travels as the literal "null" (unversioned-source
-    // semantics); no identity contract applies to it.
-    if Uuid::parse_str(source_version_id).map(|uuid| uuid.is_nil()).unwrap_or(true) {
-        return false;
-    }
-    assigned_version_id != Some(source_version_id)
-}
-
-fn audit_target_version_identity(tgt_client: &TargetClient, source_version_id: &str, assigned_version_id: Option<&str>) {
-    if !version_identity_drifted(source_version_id, assigned_version_id) {
-        return;
-    }
-    counter!(METRIC_VERSION_IDENTITY_DRIFT_TOTAL).increment(1);
-    let mut warned = VERSION_IDENTITY_WARNED_ARNS
-        .lock()
-        .unwrap_or_else(|poisoned| poisoned.into_inner());
-    if warned.insert(tgt_client.arn.clone()) {
-        warn!(
-            event = EVENT_REPLICATION_VERSION_IDENTITY_DRIFT,
-            component = LOG_COMPONENT_ECSTORE,
-            subsystem = LOG_SUBSYSTEM_REPLICATION_RESYNC,
-            arn = %tgt_client.arn,
-            endpoint = %tgt_client.endpoint,
-            sent_version_id = %source_version_id,
-            assigned_version_id = assigned_version_id.unwrap_or("<none>"),
-            "Replication target does not adopt source version ids; version-addressed replication cannot converge (run ?replication-check for details)"
-        );
-    }
-}
-
 async fn record_proxy_request(bucket: &str, api: &str, is_err: bool) {
    if let Some(stats) = runtime_sources::replication_stats() {
        stats.inc_proxy(bucket, api, is_err).await;
@@ -1328,12 +1271,7 @@ pub(crate) async fn replicate_delete_with_outcome<S: ReplicationStorage>(
                    reason = "source_version_missing",
                    "Skipping stale delete-marker replication"
                );
-                // The marker is gone at the source, but a replica of it may
-                // already exist on the targets (a live race, or an MRF
-                // purge-intent replay landing here on purpose). Purge instead
-                // of just skipping; the result decides whether an MRF replay
-                // may acknowledge the entry.
-                return purge_stale_delete_marker_targets(&bucket, &dobj).await;
+                return true;
            }
            Err(err) => {
                source_state_verified = false;
@@ -1547,6 +1485,29 @@ pub(crate) async fn replicate_delete_with_outcome<S: ReplicationStorage>(
    let is_version_purge = is_version_delete_replication(&dobj.delete_object);

    let requires_delayed_purge = should_retry_delete_marker_purge(&dobj.delete_object);
+    if requires_delayed_purge {
+        let bucket_clone = bucket.clone();
+        let dobj_clone = dobj.clone();
+        let dsc_clone = dsc.clone();
+        let storage_clone = storage.clone();
+        tokio::spawn(async move {
+            for _ in 0..5 {
+                if let Some(delete_marker_version_id) = dobj_clone.delete_object.delete_marker_version_id
+                    && source_delete_marker_missing(
+                        &*storage_clone,
+                        &bucket_clone,
+                        &dobj_clone.delete_object.object_name,
+                        delete_marker_version_id,
+                    )
+                    .await
+                {
+                    replicate_delete_marker_purge_to_targets(&bucket_clone, &dobj_clone, &dsc_clone).await;
+                    break;
+                }
+                tokio::time::sleep(TokioDuration::from_secs(1)).await;
+            }
+        });
+    }

    let (replication_status, prev_status) = if !is_version_purge {
        (
@@ -1589,24 +1550,6 @@ pub(crate) async fn replicate_delete_with_outcome<S: ReplicationStorage>(
        drs.replication_timestamp = Some(OffsetDateTime::now_utc());
    }

-    if requires_delayed_purge {
-        // Hand the watcher the MERGED replication state: `drs` folds this
-        // round's per-target results into the previous state, including the
-        // version ids the targets assigned to the markers they just created.
-        // Spawning with the pre-merge `dobj` made the purge fall back to a
-        // source-derived id, which a target that mints its own ids answers
-        // with an idempotent 204 — the intent was then dropped while the
-        // real marker stayed behind.
-        let bucket_clone = bucket.clone();
-        let mut dobj_clone = dobj.clone();
-        dobj_clone.delete_object.replication_state = Some(drs.clone());
-        let dsc_clone = dsc.clone();
-        let storage_clone = storage.clone();
-        tokio::spawn(async move {
-            watch_and_purge_source_delete_marker(bucket_clone, dobj_clone, dsc_clone, storage_clone).await;
-        });
-    }
-
    let event_name = if replication_status == ReplicationStatusType::Completed {
        EventName::ObjectReplicationComplete.to_string()
    } else {
@@ -1665,36 +1608,12 @@ pub(crate) async fn replicate_delete_with_outcome<S: ReplicationStorage>(
        }
    };

-    replicate_delete_outcome(
-        expected_targets,
-        rinfos.targets.len(),
-        state_persisted,
-        source_state_verified,
-        &replication_status,
-    )
-}
-
-/// Whether a delete replication fully succeeded — the MRF replay acknowledges
-/// (drops) an entry exactly when this returns true.
-///
-/// The delayed purge is deliberately NOT an input: holding the outcome hostage
-/// to it (`&& !requires_delayed_purge`) forced `false` for every delete-marker
-/// entry and retained them all in the durable MRF journal forever. Purge
-/// failures persist their own purge-intent entry instead
-/// (`watch_and_purge_source_delete_marker`), and replays of those entries
-/// report purge success through `purge_stale_delete_marker_targets`.
-fn replicate_delete_outcome(
-    expected_targets: usize,
-    replicated_targets: usize,
-    state_persisted: bool,
-    source_state_verified: bool,
-    replication_status: &ReplicationStatusType,
-) -> bool {
    expected_targets > 0
-        && replicated_targets == expected_targets
+        && rinfos.targets.len() == expected_targets
        && state_persisted
        && source_state_verified
-        && *replication_status == ReplicationStatusType::Completed
+        && !requires_delayed_purge
+        && replication_status == ReplicationStatusType::Completed
 }

 async fn source_delete_marker_missing<S: EcstoreObjectOperations>(
@@ -1744,286 +1663,48 @@ fn delete_marker_purge_version_id(
    })
 }

-/// One purge pass over the eligible targets. Returns the ARNs that must be
-/// retried: the remote DELETE failed, or the target client was unavailable
-/// (e.g. a runtime cache miss). Inconsistent recorded version mappings are a
-/// deliberate refusal — retrying cannot make guessing a version id safe — so
-/// they are logged and excluded from the retry set.
-async fn replicate_delete_marker_purge_to_targets(
-    bucket: &str,
-    dobj: &DeletedObjectReplicationInfo,
-    dsc: &ReplicateDecision,
-    retry_arns: Option<&[String]>,
-) -> Vec<String> {
+async fn replicate_delete_marker_purge_to_targets(bucket: &str, dobj: &DeletedObjectReplicationInfo, dsc: &ReplicateDecision) {
    let Some(delete_marker_version_id) = dobj.delete_object.delete_marker_version_id else {
-        return Vec::new();
+        return;
    };

-    let target_arns = dobj.admitted_target_arns();
-    let mut failed_arns = Vec::new();
    for tgt_entry in dsc.targets_map.values() {
        if !tgt_entry.replicate {
            continue;
        }
+        let target_arns = dobj.admitted_target_arns();
        if !target_arns.is_empty() && !target_arns.iter().any(|arn| arn == &tgt_entry.arn) {
            continue;
        }
-        if let Some(retry_arns) = retry_arns
-            && !retry_arns.iter().any(|arn| arn == &tgt_entry.arn)
-        {
+        let Some(tgt_client) = ReplicationTargetStore::remote_target_client(bucket, &tgt_entry.arn).await else {
            continue;
-        }
-        // Decide the version first: refusing to guess is a per-target
-        // FAILURE, not a silent skip. Reporting it as success would let the
-        // watcher and the MRF replay drop the purge intent while the marker
-        // is still on the target — the leak stays visible instead (the
-        // entry is retained and keeps warning) until an operator repairs
-        // the metadata.
+        };
+
        let Some(purge_version_id) = delete_marker_purge_version_id(
            dobj.delete_object.replication_state.as_ref(),
            &tgt_entry.arn,
            delete_marker_version_id,
        ) else {
            warn!(
-                event = EVENT_DELETE_MARKER_PURGE_FAILED,
                component = LOG_COMPONENT_ECSTORE,
                subsystem = LOG_SUBSYSTEM_REPLICATION_RESYNC,
                bucket,
                object = dobj.delete_object.object_name,
                arn = tgt_entry.arn,
-                reason = "recorded_target_version_inconsistent",
-                "Delete-marker purge refused: recorded target version metadata is inconsistent"
+                "Skipping delete-marker purge: recorded target version metadata is inconsistent"
            );
-            counter!(METRIC_DELETE_MARKER_PURGE_TOTAL, "state" => "refused").increment(1);
-            failed_arns.push(tgt_entry.arn.clone());
            continue;
        };

-        let Some(tgt_client) = ReplicationTargetStore::remote_target_client(bucket, &tgt_entry.arn).await else {
-            warn!(
-                event = EVENT_DELETE_MARKER_PURGE_FAILED,
-                component = LOG_COMPONENT_ECSTORE,
-                subsystem = LOG_SUBSYSTEM_REPLICATION_RESYNC,
-                bucket,
-                object = dobj.delete_object.object_name,
-                arn = tgt_entry.arn,
-                reason = "target_client_missing",
-                "Delete-marker purge attempt failed"
-            );
-            counter!(METRIC_DELETE_MARKER_PURGE_TOTAL, "state" => "failed").increment(1);
-            failed_arns.push(tgt_entry.arn.clone());
-            continue;
-        };
-
-        match tgt_client
+        let _ = tgt_client
            .remove_object(
                &tgt_client.bucket,
                &dobj.delete_object.object_name,
                purge_version_id,
                replication_delete_marker_purge_remove_options(dobj.delete_object.delete_marker_mtime),
            )
-            .await
-        {
-            Ok(_) => {
-                counter!(METRIC_DELETE_MARKER_PURGE_TOTAL, "state" => "purged").increment(1);
-            }
-            // The marker version is already gone on the target: the purge goal
-            // is met. Strict S3 targets 404 here (RustFS/MinIO answer 204);
-            // treating it as a failure would retain the intent entry forever.
-            Err(error) if matches!(error.code.as_deref(), Some("NoSuchKey" | "NoSuchVersion")) => {
-                counter!(METRIC_DELETE_MARKER_PURGE_TOTAL, "state" => "purged").increment(1);
-            }
-            Err(error) => {
-                warn!(
-                    event = EVENT_DELETE_MARKER_PURGE_FAILED,
-                    component = LOG_COMPONENT_ECSTORE,
-                    subsystem = LOG_SUBSYSTEM_REPLICATION_RESYNC,
-                    bucket,
-                    object = dobj.delete_object.object_name,
-                    arn = tgt_entry.arn,
-                    error = %error,
-                    reason = "target_delete_failed",
-                    "Delete-marker purge attempt failed"
-                );
-                counter!(METRIC_DELETE_MARKER_PURGE_TOTAL, "state" => "failed").increment(1);
-                mark_replication_target_offline_if_needed(&tgt_client, &error).await;
-                failed_arns.push(tgt_entry.arn.clone());
-            }
-        }
+            .await;
    }
-    failed_arns
-}
-
-const DELETE_MARKER_PURGE_WATCH_ROUNDS: usize = 5;
-const DELETE_MARKER_PURGE_WATCH_INTERVAL: TokioDuration = TokioDuration::from_secs(1);
-
-/// Watch the source delete marker for a short window after its replication.
-///
-/// KNOWN NON-DURABLE WINDOW: this task is detached, so a process exit inside
-/// the watch window loses an intent that has not been persisted yet. The
-/// window predates this code (the previous implementation had no durable
-/// channel at all, and no replay half either), so nothing regresses — closing
-/// it needs a write-ahead intent recorded before the parent delete is
-/// acknowledged, which is tracked as follow-up rather than done here: every
-/// delete-marker replication would pay a journal write for a purge that
-/// almost never happens.
-///
-/// If the marker disappears (deleted before or while the replica landed),
-/// purge the replicated marker from the targets, retrying failed targets on
-/// later rounds. When the window drains with targets still dirty, persist the
-/// purge intent as a durable MRF entry so the next startup replays it through
-/// `purge_stale_delete_marker_targets`.
-async fn watch_and_purge_source_delete_marker<S: ReplicationStorage>(
-    bucket: String,
-    dobj: DeletedObjectReplicationInfo,
-    dsc: ReplicateDecision,
-    storage: Arc<S>,
-) {
-    let Some(delete_marker_version_id) = dobj.delete_object.delete_marker_version_id else {
-        return;
-    };
-
-    // `pending` is None until the source marker is observed missing; after the
-    // first purge pass it holds the targets that still need a successful purge.
-    let mut pending: Option<Vec<String>> = None;
-    for round in 0..DELETE_MARKER_PURGE_WATCH_ROUNDS {
-        pending = match pending.take() {
-            None => {
-                if source_delete_marker_missing(&*storage, &bucket, &dobj.delete_object.object_name, delete_marker_version_id)
-                    .await
-                {
-                    Some(replicate_delete_marker_purge_to_targets(&bucket, &dobj, &dsc, None).await)
-                } else {
-                    None
-                }
-            }
-            Some(failed_arns) => Some(replicate_delete_marker_purge_to_targets(&bucket, &dobj, &dsc, Some(&failed_arns)).await),
-        };
-        if matches!(pending.as_deref(), Some([])) {
-            return;
-        }
-        if round + 1 < DELETE_MARKER_PURGE_WATCH_ROUNDS {
-            tokio::time::sleep(DELETE_MARKER_PURGE_WATCH_INTERVAL).await;
-        }
-    }
-    if let Some(failed_arns) = pending.filter(|failed_arns| !failed_arns.is_empty()) {
-        enqueue_delete_marker_purge_mrf(&dobj, failed_arns).await;
-    }
-}
-
-/// Shape an exhausted purge intent as a marker-creation delete entry. Replay
-/// reconstructs it with `delete_marker: true`, finds the source marker gone,
-/// and funnels into the stale-marker branch of `replicate_delete_with_outcome`
-/// — which re-runs the purge without touching source state and reports purge
-/// success as the replay outcome.
-fn delete_marker_purge_mrf_entry(dobj: &DeletedObjectReplicationInfo, failed_arns: Vec<String>) -> MrfReplicateEntry {
-    let mut entry = dobj.to_mrf_entry();
-    entry.delete_marker = true;
-    entry.version_id = None;
-    entry.retry_count = 0;
-    entry.target_arns = failed_arns;
-    entry
-}
-
-async fn enqueue_delete_marker_purge_mrf(dobj: &DeletedObjectReplicationInfo, failed_arns: Vec<String>) {
-    let arns = failed_arns.join(",");
-    let miss_reason = match runtime_sources::replication_pool() {
-        None => Some("replication_pool_unavailable"),
-        Some(pool) => match pool.persist_mrf_entry(delete_marker_purge_mrf_entry(dobj, failed_arns)).await {
-            ReplicationQueueAdmission::Queued => None,
-            _ => Some("mrf_save_unavailable"),
-        },
-    };
-    match miss_reason {
-        None => {
-            warn!(
-                event = EVENT_DELETE_MARKER_PURGE_MRF,
-                component = LOG_COMPONENT_ECSTORE,
-                subsystem = LOG_SUBSYSTEM_REPLICATION_RESYNC,
-                bucket = dobj.bucket,
-                object = dobj.delete_object.object_name,
-                arns,
-                state = "queued",
-                "Delete-marker purge exhausted its watch window; intent persisted to the MRF journal"
-            );
-            counter!(METRIC_DELETE_MARKER_PURGE_TOTAL, "state" => "mrf_queued").increment(1);
-        }
-        Some(reason) => {
-            warn!(
-                event = EVENT_DELETE_MARKER_PURGE_MRF,
-                component = LOG_COMPONENT_ECSTORE,
-                subsystem = LOG_SUBSYSTEM_REPLICATION_RESYNC,
-                bucket = dobj.bucket,
-                object = dobj.delete_object.object_name,
-                arns,
-                state = "missed",
-                reason,
-                "Delete-marker purge intent could not be persisted for retry"
-            );
-            counter!(METRIC_DELETE_MARKER_PURGE_TOTAL, "state" => "mrf_missed").increment(1);
-        }
-    }
-}
-
-/// The marker vanished at the source while its replication was still pending
-/// (a live race), or this is an MRF purge-intent replay. Any marker already
-/// replicated to a target must still be purged; run bounded retry passes and
-/// report the result so an MRF replay only acknowledges the entry once every
-/// target is clean. Live callers persist a fresh purge intent on failure;
-/// replay callers (`ReplicationType::Heal`) rely on Missed retention instead,
-/// so the journal does not accumulate duplicate entries.
-///
-/// Heal callers retry for the full watch window because the startup MRF
-/// processor runs before bucket metadata (and thus target clients) finishes
-/// initializing — the first pass can see `target_client_missing` and a later
-/// round resolves the client; the replay loop is serial and startup-only, so
-/// blocking it for up to the window per dirty entry is acceptable. Live
-/// callers run on replication workers where a down target would pin a worker
-/// for the whole window, so they attempt once and lean on the durable intent
-/// entry instead.
-async fn purge_stale_delete_marker_targets(bucket: &str, dobj: &DeletedObjectReplicationInfo) -> bool {
-    let decision_str = dobj
-        .delete_object
-        .replication_state
-        .as_ref()
-        .map(|state| state.replicate_decision_str.clone())
-        .unwrap_or_default();
-    let dsc = match parse_replicate_decision(bucket, &decision_str) {
-        Ok(dsc) => dsc,
-        Err(error) => {
-            warn!(
-                event = EVENT_DELETE_MARKER_PURGE_FAILED,
-                component = LOG_COMPONENT_ECSTORE,
-                subsystem = LOG_SUBSYSTEM_REPLICATION_RESYNC,
-                bucket,
-                object = dobj.delete_object.object_name,
-                error = %error,
-                reason = "replicate_decision_parse_failed",
-                "Delete-marker purge attempt failed"
-            );
-            return false;
-        }
-    };
-    let rounds = if dobj.op_type == ReplicationType::Heal {
-        DELETE_MARKER_PURGE_WATCH_ROUNDS
-    } else {
-        1
-    };
-    let mut failed_arns = replicate_delete_marker_purge_to_targets(bucket, dobj, &dsc, None).await;
-    for _ in 1..rounds {
-        if failed_arns.is_empty() {
-            break;
-        }
-        tokio::time::sleep(DELETE_MARKER_PURGE_WATCH_INTERVAL).await;
-        failed_arns = replicate_delete_marker_purge_to_targets(bucket, dobj, &dsc, Some(&failed_arns)).await;
-    }
-    if failed_arns.is_empty() {
-        return true;
-    }
-    if dobj.op_type != ReplicationType::Heal {
-        enqueue_delete_marker_purge_mrf(dobj, failed_arns).await;
-    }
-    false
 }

 async fn replicate_force_delete_to_targets<S: ReplicationStorage>(dobj: &DeletedObjectReplicationInfo, storage: Arc<S>) -> bool {
@@ -2924,13 +2605,6 @@ impl ReplicateObjectInfoExt for ReplicateObjectInfo {
            let result = tgt_client
                .put_object(&tgt_client.bucket, &object, transfer_size, byte_stream, &put_opts)
                .await
-                .map(|assigned_version_id| {
-                    audit_target_version_identity(
-                        &tgt_client,
-                        &put_opts.internal.source_version_id,
-                        assigned_version_id.as_deref(),
-                    )
-                })
                .map_err(|e| std::io::Error::other(e.to_string()));
            record_proxy_request(&bucket, "PutObject", result.is_err()).await;
            if has_tagging_replication {
@@ -3338,13 +3012,6 @@ impl ReplicateObjectInfoExt for ReplicateObjectInfo {
            let result = tgt_client
                .put_object(&tgt_client.bucket, &object, transfer_size, byte_stream, &put_opts)
                .await
-                .map(|assigned_version_id| {
-                    audit_target_version_identity(
-                        &tgt_client,
-                        &put_opts.internal.source_version_id,
-                        assigned_version_id.as_deref(),
-                    )
-                })
                .map_err(|e| std::io::Error::other(e.to_string()));
            record_proxy_request(&bucket, "PutObject", result.is_err()).await;
            if has_tagging_replication {
@@ -3536,34 +3203,21 @@ async fn replicate_object_with_multipart<S: ReplicationObjectIO>(ctx: MultipartR

    let actual_size = replication_multipart_complete_actual_size(&object_info.user_defined);

-    let completed = cli
-        .complete_multipart_upload(
-            dst_bucket,
-            object,
-            &upload_id,
-            uploaded_parts,
-            &replication_complete_multipart_options(
-                actual_size,
-                object_info.etag.clone().unwrap_or_default(),
-                object_info.mod_time,
-            ),
-        )
-        .await
-        .map_err(|e| std::io::Error::other(e.to_string()))?;
-
-    // Multipart decides the target version at initiate time and only reveals
-    // it on completion, so this is where the identity contract is observable
-    // for this path. A target can mirror PutObject version ids and still mint
-    // its own here, which would leave multipart deletes and heals addressing
-    // a version that never existed.
-    audit_target_version_identity(&cli, &put_opts.internal.source_version_id, completed.version_id());
+    cli.complete_multipart_upload(
+        dst_bucket,
+        object,
+        &upload_id,
+        uploaded_parts,
+        &replication_complete_multipart_options(actual_size, object_info.etag.clone().unwrap_or_default(), object_info.mod_time),
+    )
+    .await
+    .map_err(|e| std::io::Error::other(e.to_string()))?;

    Ok(())
 }

 #[cfg(test)]
 mod tests {
-    use super::super::replication_filemeta_boundary::ReplicateTargetDecision;
    use super::super::replication_target_boundary::{BucketTarget, BucketTargets};
    use super::*;
    use s3s::dto::{
@@ -3603,27 +3257,6 @@ mod tests {
        ReplicationTargetStore::register_test_target(target).await;
    }

-    /// P1-19 runtime spot-check exemption matrix: drift only applies when the
-    /// source addressed a real version uuid.
-    #[test]
-    fn test_version_identity_drift_judgment() {
-        let source = "6fa459ea-ee8a-3ca4-894e-db77e160355e";
-        for (sent, got, expected) in [
-            (source, Some(source), false),
-            (source, Some("0e304ce5-33e9-4b8a-9b12-9e40a53e6ded"), true),
-            (source, None, true),
-            ("", None, false),
-            ("null", Some("anything"), false),
-            ("00000000-0000-0000-0000-000000000000", Some("anything"), false),
-        ] {
-            assert_eq!(
-                version_identity_drifted(sent, got),
-                expected,
-                "sent {sent:?} got {got:?} must judge drift = {expected}"
-            );
-        }
-    }
-
    #[test]
    fn resync_admission_configuration_is_bounded() {
        assert_eq!(ENV_REPL_RESYNC_MAX_JOBS, "RUSTFS_REPL_RESYNC_MAX_JOBS");
@@ -3948,101 +3581,6 @@ mod tests {
        );
    }

-    /// P1-21 regression guard for the outcome formula. A fully successful
-    /// delete-marker replication must acknowledge its MRF entry: the formula
-    /// once carried `&& !requires_delayed_purge`, which pinned every
-    /// delete-marker entry to Missed and retained the whole backlog forever.
-    /// (Deterministically staging a marker-creation entry in the durable
-    /// journal from e2e would require saturating the worker queues, so the
-    /// formula is pinned here instead; the purge-intent replay half is pinned
-    /// by the delayed-purge e2e pair.)
-    #[test]
-    fn test_replicate_delete_outcome_is_not_held_hostage_by_the_delayed_purge() {
-        assert!(
-            replicate_delete_outcome(1, 1, true, true, &ReplicationStatusType::Completed),
-            "a completed delete-marker replication must be acknowledgeable even though a delayed purge watch is pending"
-        );
-        assert!(!replicate_delete_outcome(0, 0, true, true, &ReplicationStatusType::Completed));
-        assert!(!replicate_delete_outcome(2, 1, true, true, &ReplicationStatusType::Completed));
-        assert!(!replicate_delete_outcome(1, 1, false, true, &ReplicationStatusType::Completed));
-        assert!(!replicate_delete_outcome(1, 1, true, false, &ReplicationStatusType::Completed));
-        assert!(!replicate_delete_outcome(1, 1, true, true, &ReplicationStatusType::Failed));
-    }
-
-    /// P1-21 review follow-up: a target whose recorded marker version is
-    /// inconsistent must be reported as a per-target FAILURE. Treating the
-    /// refusal as success let the watcher and the MRF replay drop the purge
-    /// intent while the marker was still on the target.
-    #[tokio::test]
-    async fn test_delete_marker_purge_reports_corrupt_recorded_version_as_failure() {
-        let arn = format!("arn:rustfs:replication:us-east-1:corrupt:{}", Uuid::new_v4());
-        let mut dsc = ReplicateDecision::new();
-        dsc.set(ReplicateTargetDecision::new(arn.clone(), true, false));
-
-        let mut state = ReplicationState {
-            target_delete_marker_version_ids_corrupt: true,
-            ..Default::default()
-        };
-        state.targets.insert(arn.clone(), ReplicationStatusType::Completed);
-
-        let dobj = DeletedObjectReplicationInfo {
-            delete_object: ReplicationDeletedObject {
-                object_name: "doc.txt".to_string(),
-                delete_marker: true,
-                delete_marker_version_id: Some(Uuid::new_v4()),
-                replication_state: Some(state),
-                ..Default::default()
-            },
-            bucket: "bucket-a".to_string(),
-            ..Default::default()
-        };
-
-        // No target client is registered: the refusal must be decided from
-        // the recorded metadata alone, before any remote call is attempted.
-        let failed = replicate_delete_marker_purge_to_targets("bucket-a", &dobj, &dsc, None).await;
-
-        assert_eq!(
-            failed,
-            vec![arn],
-            "a refused purge must stay in the failed set so the intent is never acknowledged"
-        );
-    }
-
-    #[test]
-    fn test_delete_marker_purge_mrf_entry_replays_through_the_stale_marker_branch() {
-        let delete_marker_version_id = Uuid::new_v4();
-        let dobj = DeletedObjectReplicationInfo {
-            delete_object: ReplicationDeletedObject {
-                object_name: "doc.txt".to_string(),
-                // A version-purge flavored source event: the entry must still
-                // be reshaped as a marker-creation delete so replay funnels
-                // into the stale-marker branch instead of re-running the full
-                // delete replication (whose source-state stamping would fail
-                // against the already-purged version).
-                delete_marker: false,
-                version_id: Some(Uuid::new_v4()),
-                delete_marker_version_id: Some(delete_marker_version_id),
-                ..Default::default()
-            },
-            bucket: "bucket-a".to_string(),
-            ..Default::default()
-        };
-
-        let entry = delete_marker_purge_mrf_entry(&dobj, vec!["arn:a".to_string()]);
-
-        assert!(entry.delete_marker, "purge intents must replay as marker-creation deletes");
-        assert_eq!(entry.version_id, None, "the purged data version must not leak into the replay");
-        assert_eq!(entry.delete_marker_version_id, Some(delete_marker_version_id));
-        assert_eq!(
-            entry.target_arns,
-            vec!["arn:a".to_string()],
-            "only the targets whose purge failed may be retried"
-        );
-        assert_eq!(entry.retry_count, 0);
-        assert_eq!(entry.bucket, "bucket-a");
-        assert_eq!(entry.object, "doc.txt");
-    }
-
    #[test]
    fn test_is_retryable_delete_replication_head_error_allows_delete_marker_head_responses() {
        assert!(
@@ -0,0 +1,171 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use http::{HeaderMap, StatusCode};
+use http_body_util::BodyExt;
+use hyper::body::Body;
+use hyper::body::Bytes;
+use std::collections::HashMap;
+
+use crate::client::{
+    api_error_response::http_resp_to_error_response,
+    transition_api::{ReaderImpl, RequestMetadata, TransitionClient},
+};
+use rustfs_utils::hash::EMPTY_STRING_SHA256_HASH;
+
+impl TransitionClient {
+    pub async fn set_bucket_policy(&self, bucket_name: &str, policy: &str) -> Result<(), std::io::Error> {
+        if policy == "" {
+            return self.remove_bucket_policy(bucket_name).await;
+        }
+
+        self.put_bucket_policy(bucket_name, policy).await
+    }
+
+    pub async fn put_bucket_policy(&self, bucket_name: &str, policy: &str) -> Result<(), std::io::Error> {
+        let mut url_values = HashMap::new();
+        url_values.insert("policy".to_string(), "".to_string());
+
+        let mut req_metadata = RequestMetadata {
+            bucket_name: bucket_name.to_string(),
+            query_values: url_values,
+            content_body: ReaderImpl::Body(Bytes::from(policy.as_bytes().to_vec())),
+            content_length: policy.len() as i64,
+            object_name: "".to_string(),
+            custom_header: HeaderMap::new(),
+            content_md5_base64: "".to_string(),
+            content_sha256_hex: "".to_string(),
+            stream_sha256: false,
+            trailer: HeaderMap::new(),
+            pre_sign_url: Default::default(),
+            add_crc: Default::default(),
+            extra_pre_sign_header: Default::default(),
+            bucket_location: Default::default(),
+            expires: Default::default(),
+        };
+
+        let resp = self.execute_method(http::Method::PUT, &mut req_metadata).await?;
+        //defer closeResponse(resp)
+
+        let resp_status = resp.status();
+        let h = resp.headers().clone();
+
+        //if resp != nil {
+        if resp_status != StatusCode::NO_CONTENT && resp.status() != StatusCode::OK {
+            return Err(std::io::Error::other(http_resp_to_error_response(
+                resp_status,
+                &h,
+                vec![],
+                bucket_name,
+                "",
+            )));
+        }
+        //}
+        Ok(())
+    }
+
+    pub async fn remove_bucket_policy(&self, bucket_name: &str) -> Result<(), std::io::Error> {
+        let mut url_values = HashMap::new();
+        url_values.insert("policy".to_string(), "".to_string());
+
+        let resp = self
+            .execute_method(
+                http::Method::DELETE,
+                &mut RequestMetadata {
+                    bucket_name: bucket_name.to_string(),
+                    query_values: url_values,
+                    content_sha256_hex: EMPTY_STRING_SHA256_HASH.to_string(),
+                    object_name: "".to_string(),
+                    custom_header: HeaderMap::new(),
+                    content_body: ReaderImpl::Body(Bytes::new()),
+                    content_length: 0,
+                    content_md5_base64: "".to_string(),
+                    stream_sha256: false,
+                    trailer: HeaderMap::new(),
+                    pre_sign_url: Default::default(),
+                    add_crc: Default::default(),
+                    extra_pre_sign_header: Default::default(),
+                    bucket_location: Default::default(),
+                    expires: Default::default(),
+                },
+            )
+            .await?;
+        //defer closeResponse(resp)
+
+        let resp_status = resp.status();
+        let h = resp.headers().clone();
+
+        if resp_status != StatusCode::NO_CONTENT {
+            return Err(std::io::Error::other(http_resp_to_error_response(
+                resp_status,
+                &h,
+                vec![],
+                bucket_name,
+                "",
+            )));
+        }
+
+        Ok(())
+    }
+
+    pub async fn get_bucket_policy(&self, bucket_name: &str) -> Result<String, std::io::Error> {
+        let bucket_policy = self.get_bucket_policy_inner(bucket_name).await?;
+        Ok(bucket_policy)
+    }
+
+    pub async fn get_bucket_policy_inner(&self, bucket_name: &str) -> Result<String, std::io::Error> {
+        let mut url_values = HashMap::new();
+        url_values.insert("policy".to_string(), "".to_string());
+
+        let resp = self
+            .execute_method(
+                http::Method::GET,
+                &mut RequestMetadata {
+                    bucket_name: bucket_name.to_string(),
+                    query_values: url_values,
+                    content_sha256_hex: EMPTY_STRING_SHA256_HASH.to_string(),
+                    object_name: "".to_string(),
+                    custom_header: HeaderMap::new(),
+                    content_body: ReaderImpl::Body(Bytes::new()),
+                    content_length: 0,
+                    content_md5_base64: "".to_string(),
+                    stream_sha256: false,
+                    trailer: HeaderMap::new(),
+                    pre_sign_url: Default::default(),
+                    add_crc: Default::default(),
+                    extra_pre_sign_header: Default::default(),
+                    bucket_location: Default::default(),
+                    expires: Default::default(),
+                },
+            )
+            .await?;
+
+        let mut body_vec = Vec::new();
+        let mut body = resp.into_body();
+        while let Some(frame) = body.frame().await {
+            let frame = frame.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+            if let Some(data) = frame.data_ref() {
+                body_vec.extend_from_slice(data);
+            }
+        }
+        let policy = String::from_utf8_lossy(&body_vec).to_string();
+        Ok(policy)
+    }
+}
@@ -0,0 +1,199 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use crate::client::{
+    api_error_response::http_resp_to_error_response,
+    api_get_options::GetObjectOptions,
+    transition_api::{ObjectInfo, ReaderImpl, RequestMetadata, TransitionClient},
+};
+use bytes::Bytes;
+use http::{HeaderMap, HeaderValue};
+use http_body_util::BodyExt;
+use rustfs_config::MAX_S3_CLIENT_RESPONSE_SIZE;
+use rustfs_utils::EMPTY_STRING_SHA256_HASH;
+use s3s::dto::Owner;
+use std::collections::HashMap;
+
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
+pub struct Grantee {
+    pub id: String,
+    pub display_name: String,
+    pub uri: String,
+}
+
+#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
+pub struct Grant {
+    pub grantee: Grantee,
+    pub permission: String,
+}
+
+#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+pub struct AccessControlList {
+    pub grant: Vec<Grant>,
+    pub permission: String,
+}
+
+#[derive(Debug, Default, serde::Deserialize)]
+pub struct AccessControlPolicy {
+    #[serde(skip)]
+    owner: Owner,
+    pub access_control_list: AccessControlList,
+}
+
+impl TransitionClient {
+    pub async fn get_object_acl(&self, bucket_name: &str, object_name: &str) -> Result<ObjectInfo, std::io::Error> {
+        let mut url_values = HashMap::new();
+        url_values.insert("acl".to_string(), "".to_string());
+        let mut resp = self
+            .execute_method(
+                http::Method::GET,
+                &mut RequestMetadata {
+                    bucket_name: bucket_name.to_string(),
+                    object_name: object_name.to_string(),
+                    query_values: url_values,
+                    custom_header: HeaderMap::new(),
+                    content_sha256_hex: EMPTY_STRING_SHA256_HASH.to_string(),
+                    content_body: ReaderImpl::Body(Bytes::new()),
+                    content_length: 0,
+                    content_md5_base64: "".to_string(),
+                    stream_sha256: false,
+                    trailer: HeaderMap::new(),
+                    pre_sign_url: Default::default(),
+                    add_crc: Default::default(),
+                    extra_pre_sign_header: Default::default(),
+                    bucket_location: Default::default(),
+                    expires: Default::default(),
+                },
+            )
+            .await?;
+
+        let resp_status = resp.status();
+        let h = resp.headers().clone();
+
+        let mut body_vec = Vec::new();
+        let mut body = resp.into_body();
+        while let Some(frame) = body.frame().await {
+            let frame = frame.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+            if let Some(data) = frame.data_ref() {
+                body_vec.extend_from_slice(data);
+            }
+        }
+
+        if resp_status != http::StatusCode::OK {
+            return Err(std::io::Error::other(http_resp_to_error_response(
+                resp_status,
+                &h,
+                body_vec,
+                bucket_name,
+                object_name,
+            )));
+        }
+
+        let mut res = match quick_xml::de::from_str::<AccessControlPolicy>(&String::from_utf8(body_vec).unwrap()) {
+            Ok(result) => result,
+            Err(err) => {
+                return Err(std::io::Error::other(err.to_string()));
+            }
+        };
+
+        let mut obj_info = self
+            .stat_object(bucket_name, object_name, &GetObjectOptions::default())
+            .await?;
+
+        obj_info.owner.display_name = res.owner.display_name.clone();
+        obj_info.owner.id = res.owner.id.clone();
+
+        //obj_info.grant.extend(res.access_control_list.grant);
+
+        let canned_acl = get_canned_acl(&res);
+        if canned_acl != "" {
+            obj_info
+                .metadata
+                .insert("X-Amz-Acl", HeaderValue::from_str(&canned_acl).unwrap());
+            return Ok(obj_info);
+        }
+
+        let grant_acl = get_amz_grant_acl(&res);
+        /*for (k, v) in grant_acl {
+            obj_info.metadata.insert(HeaderName::from_bytes(k.as_bytes()).unwrap(), HeaderValue::from_str(&v.to_string()).unwrap());
+        }*/
+
+        Ok(obj_info)
+    }
+}
+
+fn get_canned_acl(ac_policy: &AccessControlPolicy) -> String {
+    let grants = ac_policy.access_control_list.grant.clone();
+
+    if grants.len() == 1 {
+        if grants[0].grantee.uri == "" && grants[0].permission == "FULL_CONTROL" {
+            return "private".to_string();
+        }
+    } else if grants.len() == 2 {
+        for g in grants {
+            if g.grantee.uri == "http://acs.amazonaws.com/groups/global/AuthenticatedUsers" && &g.permission == "READ" {
+                return "authenticated-read".to_string();
+            }
+            if g.grantee.uri == "http://acs.amazonaws.com/groups/global/AllUsers" && &g.permission == "READ" {
+                return "public-read".to_string();
+            }
+            if g.permission == "READ" && g.grantee.id == ac_policy.owner.id.clone().unwrap() {
+                return "bucket-owner-read".to_string();
+            }
+        }
+    } else if grants.len() == 3 {
+        for g in grants {
+            if g.grantee.uri == "http://acs.amazonaws.com/groups/global/AllUsers" && g.permission == "WRITE" {
+                return "public-read-write".to_string();
+            }
+        }
+    }
+    "".to_string()
+}
+
+pub fn get_amz_grant_acl(ac_policy: &AccessControlPolicy) -> HashMap<String, Vec<String>> {
+    let grants = ac_policy.access_control_list.grant.clone();
+    let mut res = HashMap::<String, Vec<String>>::new();
+
+    for g in grants {
+        let mut id = "id=".to_string();
+        id.push_str(&g.grantee.id);
+        let permission: &str = &g.permission;
+        match permission {
+            "READ" => {
+                res.entry("X-Amz-Grant-Read".to_string()).or_insert(vec![]).push(id);
+            }
+            "WRITE" => {
+                res.entry("X-Amz-Grant-Write".to_string()).or_insert(vec![]).push(id);
+            }
+            "READ_ACP" => {
+                res.entry("X-Amz-Grant-Read-Acp".to_string()).or_insert(vec![]).push(id);
+            }
+            "WRITE_ACP" => {
+                res.entry("X-Amz-Grant-Write-Acp".to_string()).or_insert(vec![]).push(id);
+            }
+            "FULL_CONTROL" => {
+                res.entry("X-Amz-Grant-Full-Control".to_string()).or_insert(vec![]).push(id);
+            }
+            _ => (),
+        }
+    }
+    res
+}
@@ -0,0 +1,266 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use http::{HeaderMap, HeaderValue};
+use std::collections::HashMap;
+use time::OffsetDateTime;
+
+use crate::client::constants::{GET_OBJECT_ATTRIBUTES_MAX_PARTS, GET_OBJECT_ATTRIBUTES_TAGS, ISO8601_DATEFORMAT};
+use crate::client::{
+    api_get_object_acl::AccessControlPolicy,
+    transition_api::{ReaderImpl, RequestMetadata, TransitionClient},
+};
+use http_body_util::BodyExt;
+use hyper::body::Body;
+use hyper::body::Bytes;
+use hyper::body::Incoming;
+use rustfs_config::MAX_S3_CLIENT_RESPONSE_SIZE;
+use rustfs_utils::EMPTY_STRING_SHA256_HASH;
+use s3s::header::{X_AMZ_MAX_PARTS, X_AMZ_OBJECT_ATTRIBUTES, X_AMZ_PART_NUMBER_MARKER, X_AMZ_VERSION_ID};
+
+pub struct ObjectAttributesOptions {
+    pub max_parts: i64,
+    pub version_id: String,
+    pub part_number_marker: i64,
+    //server_side_encryption: encrypt::ServerSide,
+}
+
+pub struct ObjectAttributes {
+    pub version_id: String,
+    pub last_modified: OffsetDateTime,
+    pub object_attributes_response: ObjectAttributesResponse,
+}
+
+impl ObjectAttributes {
+    fn new() -> Self {
+        Self {
+            version_id: "".to_string(),
+            last_modified: OffsetDateTime::now_utc(),
+            object_attributes_response: ObjectAttributesResponse::new(),
+        }
+    }
+}
+
+#[derive(Debug, Default, serde::Deserialize)]
+pub struct Checksum {
+    checksum_crc32: String,
+    checksum_crc32c: String,
+    checksum_sha1: String,
+    checksum_sha256: String,
+}
+
+impl Checksum {
+    fn new() -> Self {
+        Self {
+            checksum_crc32: "".to_string(),
+            checksum_crc32c: "".to_string(),
+            checksum_sha1: "".to_string(),
+            checksum_sha256: "".to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Default, serde::Deserialize)]
+pub struct ObjectParts {
+    pub parts_count: i64,
+    pub part_number_marker: i64,
+    pub next_part_number_marker: i64,
+    pub max_parts: i64,
+    is_truncated: bool,
+    parts: Vec<ObjectAttributePart>,
+}
+
+impl ObjectParts {
+    fn new() -> Self {
+        Self {
+            parts_count: 0,
+            part_number_marker: 0,
+            next_part_number_marker: 0,
+            max_parts: 0,
+            is_truncated: false,
+            parts: Vec::new(),
+        }
+    }
+}
+
+#[derive(Debug, Default, serde::Deserialize)]
+pub struct ObjectAttributesResponse {
+    pub etag: String,
+    pub storage_class: String,
+    pub object_size: i64,
+    pub checksum: Checksum,
+    pub object_parts: ObjectParts,
+}
+
+impl ObjectAttributesResponse {
+    fn new() -> Self {
+        Self {
+            etag: "".to_string(),
+            storage_class: "".to_string(),
+            object_size: 0,
+            checksum: Checksum::new(),
+            object_parts: ObjectParts::new(),
+        }
+    }
+}
+
+#[derive(Debug, Default, serde::Deserialize)]
+struct ObjectAttributePart {
+    checksum_crc32: String,
+    checksum_crc32c: String,
+    checksum_sha1: String,
+    checksum_sha256: String,
+    part_number: i64,
+    size: i64,
+}
+
+impl ObjectAttributes {
+    pub async fn parse_response(&mut self, h: &HeaderMap, body_vec: Vec<u8>) -> Result<(), std::io::Error> {
+        let last_modified = h
+            .get("Last-Modified")
+            .ok_or_else(|| std::io::Error::other("missing Last-Modified header"))?
+            .to_str()
+            .map_err(|e| std::io::Error::other(format!("invalid Last-Modified header: {e}")))?;
+        let mod_time = OffsetDateTime::parse(last_modified, ISO8601_DATEFORMAT)
+            .map_err(|e| std::io::Error::other(format!("invalid Last-Modified date: {e}")))?;
+        self.last_modified = mod_time;
+
+        let version_id = h
+            .get(X_AMZ_VERSION_ID)
+            .ok_or_else(|| std::io::Error::other("missing version ID header"))?
+            .to_str()
+            .map_err(|e| std::io::Error::other(format!("invalid version ID header: {e}")))?;
+        self.version_id = version_id.to_string();
+
+        let body_str = String::from_utf8(body_vec).map_err(|e| std::io::Error::other(format!("invalid UTF-8 body: {e}")))?;
+        let mut response = match quick_xml::de::from_str::<ObjectAttributesResponse>(&body_str) {
+            Ok(result) => result,
+            Err(err) => {
+                return Err(std::io::Error::other(err.to_string()));
+            }
+        };
+        self.object_attributes_response = response;
+
+        Ok(())
+    }
+}
+
+impl TransitionClient {
+    pub async fn get_object_attributes(
+        &self,
+        bucket_name: &str,
+        object_name: &str,
+        opts: ObjectAttributesOptions,
+    ) -> Result<ObjectAttributes, std::io::Error> {
+        let mut url_values = HashMap::new();
+        url_values.insert("attributes".to_string(), "".to_string());
+        if opts.version_id != "" {
+            url_values.insert("versionId".to_string(), opts.version_id);
+        }
+
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            X_AMZ_OBJECT_ATTRIBUTES,
+            HeaderValue::from_str(GET_OBJECT_ATTRIBUTES_TAGS).expect("valid header value"),
+        );
+
+        if opts.part_number_marker > 0 {
+            headers.insert(
+                X_AMZ_PART_NUMBER_MARKER,
+                HeaderValue::from_str(&opts.part_number_marker.to_string()).expect("valid header value"),
+            );
+        }
+
+        if opts.max_parts > 0 {
+            headers.insert(
+                X_AMZ_MAX_PARTS,
+                HeaderValue::from_str(&opts.max_parts.to_string()).expect("valid header value"),
+            );
+        } else {
+            headers.insert(
+                X_AMZ_MAX_PARTS,
+                HeaderValue::from_str(&GET_OBJECT_ATTRIBUTES_MAX_PARTS.to_string()).expect("valid header value"),
+            );
+        }
+
+        /*if opts.server_side_encryption.is_some() {
+            opts.server_side_encryption.Marshal(headers);
+        }*/
+
+        let mut resp = self
+            .execute_method(
+                http::Method::HEAD,
+                &mut RequestMetadata {
+                    bucket_name: bucket_name.to_string(),
+                    object_name: object_name.to_string(),
+                    query_values: url_values,
+                    custom_header: headers,
+                    content_sha256_hex: EMPTY_STRING_SHA256_HASH.to_string(),
+                    content_md5_base64: "".to_string(),
+                    content_body: ReaderImpl::Body(Bytes::new()),
+                    content_length: 0,
+                    stream_sha256: false,
+                    trailer: HeaderMap::new(),
+                    pre_sign_url: Default::default(),
+                    add_crc: Default::default(),
+                    extra_pre_sign_header: Default::default(),
+                    bucket_location: Default::default(),
+                    expires: Default::default(),
+                },
+            )
+            .await?;
+
+        let resp_status = resp.status();
+        let h = resp.headers().clone();
+        let has_etag = h.get("ETag").and_then(|v| v.to_str().ok()).unwrap_or("");
+        if !has_etag.is_empty() {
+            return Err(std::io::Error::other(
+                "get_object_attributes is not supported by the current endpoint version",
+            ));
+        }
+
+        let mut body_vec = Vec::new();
+        let mut body = resp.into_body();
+        while let Some(frame) = body.frame().await {
+            let frame = frame.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+            if let Some(data) = frame.data_ref() {
+                body_vec.extend_from_slice(data);
+            }
+        }
+
+        if resp_status != http::StatusCode::OK {
+            let err_body =
+                String::from_utf8(body_vec).map_err(|e| std::io::Error::other(format!("invalid UTF-8 error body: {e}")))?;
+            let mut er = match quick_xml::de::from_str::<AccessControlPolicy>(&err_body) {
+                Ok(result) => result,
+                Err(err) => {
+                    return Err(std::io::Error::other(err.to_string()));
+                }
+            };
+
+            return Err(std::io::Error::other(er.access_control_list.permission));
+        }
+
+        let mut oa = ObjectAttributes::new();
+        oa.parse_response(&h, body_vec).await?;
+
+        Ok(oa)
+    }
+}
@@ -0,0 +1,159 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::io;
+use std::path::{Path, PathBuf};
+
+#[cfg(not(windows))]
+use std::os::unix::fs::PermissionsExt;
+
+use tokio::fs::{self, OpenOptions};
+use tokio::io::{AsyncSeekExt, AsyncWriteExt, SeekFrom};
+
+use crate::client::{
+    api_error_response::err_invalid_argument, api_get_options::GetObjectOptions, transition_api::TransitionClient,
+};
+
+async fn prepare_download_target(file_path: &Path) -> io::Result<()> {
+    match fs::metadata(file_path).await {
+        Ok(metadata) if metadata.is_dir() => {
+            return Err(io::Error::other(err_invalid_argument("filename is a directory.")));
+        }
+        Ok(_) => {}
+        Err(err) if err.kind() == io::ErrorKind::NotFound => {}
+        Err(err) => return Err(err),
+    }
+
+    if let Some(parent) = file_path.parent()
+        && !parent.as_os_str().is_empty()
+    {
+        fs::create_dir_all(parent).await?;
+
+        #[cfg(not(windows))]
+        {
+            let mut permissions = fs::metadata(parent).await?.permissions();
+            permissions.set_mode(0o700);
+            fs::set_permissions(parent, permissions).await?;
+        }
+    }
+
+    Ok(())
+}
+
+fn build_part_path(file_path: &Path) -> PathBuf {
+    PathBuf::from(format!("{}.part.rustfs", file_path.display()))
+}
+
+async fn open_download_part_file(file_part_path: &Path) -> io::Result<tokio::fs::File> {
+    let mut options = OpenOptions::new();
+    options.create(true).truncate(false).read(true).write(true);
+
+    #[cfg(not(windows))]
+    options.mode(0o600);
+
+    options.open(file_part_path).await
+}
+
+async fn cleanup_part_file(file_part_path: &Path) {
+    let _ = fs::remove_file(file_part_path).await;
+}
+
+impl TransitionClient {
+    pub async fn fget_object(
+        &self,
+        bucket_name: &str,
+        object_name: &str,
+        file_path: &str,
+        mut opts: GetObjectOptions,
+    ) -> Result<(), io::Error> {
+        let file_path = Path::new(file_path);
+        prepare_download_target(file_path).await?;
+
+        let file_part_path = build_part_path(file_path);
+        let mut file_part = open_download_part_file(&file_part_path).await?;
+        let existing_len = file_part.metadata().await?.len();
+        if existing_len > 0 {
+            opts.set_range(existing_len as i64, 0)?;
+            file_part.seek(SeekFrom::Start(existing_len)).await?;
+        }
+
+        let (_object_info, _headers, mut object_reader) = self.get_object_inner(bucket_name, object_name, &opts).await?;
+        if let Err(err) = tokio::io::copy(&mut object_reader, &mut file_part).await {
+            cleanup_part_file(&file_part_path).await;
+            return Err(err);
+        }
+
+        if let Err(err) = file_part.flush().await {
+            cleanup_part_file(&file_part_path).await;
+            return Err(err);
+        }
+        drop(file_part);
+
+        if let Err(err) = fs::rename(&file_part_path, file_path).await {
+            cleanup_part_file(&file_part_path).await;
+            return Err(err);
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn prepare_download_target_allows_missing_file_and_creates_parent_dirs() {
+        let dir = tempdir().expect("temp dir");
+        let target = dir.path().join("nested").join("object.bin");
+
+        prepare_download_target(&target)
+            .await
+            .expect("missing target should be accepted");
+
+        assert!(target.parent().expect("parent").exists(), "parent directory should be created");
+        assert!(
+            fs::metadata(&target).await.is_err(),
+            "preparing the target should not create the final file eagerly"
+        );
+    }
+
+    #[tokio::test]
+    async fn prepare_download_target_rejects_directory_paths() {
+        let dir = tempdir().expect("temp dir");
+        let target_dir = dir.path().join("download-dir");
+        fs::create_dir_all(&target_dir).await.expect("target dir");
+
+        let err = prepare_download_target(&target_dir)
+            .await
+            .expect_err("directory targets must be rejected");
+
+        assert!(err.to_string().contains("directory"), "unexpected error for directory target: {err}");
+    }
+
+    #[tokio::test]
+    async fn open_download_part_file_creates_part_file() {
+        let dir = tempdir().expect("temp dir");
+        let target = dir.path().join("object.bin");
+        let part_path = build_part_path(&target);
+
+        let file = open_download_part_file(&part_path)
+            .await
+            .expect("part file should be created");
+        drop(file);
+
+        assert!(part_path.exists(), "part file should exist after creation");
+    }
+}
@@ -0,0 +1,134 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+#![allow(unused_assignments)]
+#![allow(unused_must_use)]
+#![allow(clippy::all)]
+
+use crate::client::{
+    api_error_response::{err_invalid_argument, http_resp_to_error_response},
+    api_get_object_acl::AccessControlList,
+    api_get_options::GetObjectOptions,
+    transition_api::{ObjectInfo, ReadCloser, ReaderImpl, RequestMetadata, TransitionClient, to_object_info},
+};
+use http::HeaderMap;
+use http_body_util::BodyExt;
+use hyper::body::Body;
+use hyper::body::Bytes;
+use s3s::dto::RestoreRequest;
+use std::collections::HashMap;
+use std::io::Cursor;
+use tokio::io::BufReader;
+
+const TIER_STANDARD: &str = "Standard";
+const TIER_BULK: &str = "Bulk";
+const TIER_EXPEDITED: &str = "Expedited";
+
+#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+pub struct Encryption {
+    pub encryption_type: String,
+    pub kms_context: String,
+    pub kms_key_id: String,
+}
+
+#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+pub struct MetadataEntry {
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(Debug, Default, serde::Serialize)]
+pub struct S3 {
+    pub access_control_list: AccessControlList,
+    pub bucket_name: String,
+    pub prefix: String,
+    pub canned_acl: String,
+    pub encryption: Encryption,
+    pub storage_class: String,
+    //tagging:            Tags,
+    pub user_metadata: MetadataEntry,
+}
+
+impl TransitionClient {
+    pub async fn restore_object(
+        &self,
+        bucket_name: &str,
+        object_name: &str,
+        version_id: &str,
+        restore_req: &RestoreRequest,
+    ) -> Result<(), std::io::Error> {
+        /*let restore_request = match quick_xml::se::to_string(restore_req) {
+            Ok(buf) => buf,
+            Err(e) => {
+                return Err(std::io::Error::other(e));
+            }
+        };*/
+        let restore_request = "".to_string();
+        let restore_request_bytes = restore_request.as_bytes().to_vec();
+
+        let mut url_values = HashMap::new();
+        url_values.insert("restore".to_string(), "".to_string());
+        if version_id != "" {
+            url_values.insert("versionId".to_string(), version_id.to_string());
+        }
+
+        let restore_request_buffer = Bytes::from(restore_request_bytes.clone());
+        let resp = self
+            .execute_method(
+                http::Method::HEAD,
+                &mut RequestMetadata {
+                    bucket_name: bucket_name.to_string(),
+                    object_name: object_name.to_string(),
+                    query_values: url_values,
+                    custom_header: HeaderMap::new(),
+                    content_sha256_hex: "".to_string(), //sum_sha256_hex(&restore_request_bytes),
+                    content_md5_base64: "".to_string(), //sum_md5_base64(&restore_request_bytes),
+                    content_body: ReaderImpl::Body(restore_request_buffer),
+                    content_length: restore_request_bytes.len() as i64,
+                    stream_sha256: false,
+                    trailer: HeaderMap::new(),
+                    pre_sign_url: Default::default(),
+                    add_crc: Default::default(),
+                    extra_pre_sign_header: Default::default(),
+                    bucket_location: Default::default(),
+                    expires: Default::default(),
+                },
+            )
+            .await?;
+
+        let resp_status = resp.status();
+        let h = resp.headers().clone();
+
+        let mut body_vec = Vec::new();
+        let mut body = resp.into_body();
+        while let Some(frame) = body.frame().await {
+            let frame = frame.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+            if let Some(data) = frame.data_ref() {
+                body_vec.extend_from_slice(data);
+            }
+        }
+        if resp_status != http::StatusCode::ACCEPTED && resp_status != http::StatusCode::OK {
+            return Err(std::io::Error::other(http_resp_to_error_response(
+                resp_status,
+                &h,
+                body_vec,
+                bucket_name,
+                "",
+            )));
+        }
+        Ok(())
+    }
+}
@@ -27,24 +27,12 @@ use crate::client::utils::base64_decode;
 use crate::client::utils::base64_encode;
 use crate::client::{api_put_object::PutObjectOptions, api_s3_datatypes::ObjectPart};
 use crate::{disk::DiskAPI, object_api::GetObjectReader};
-// s3s::header has no CRC64NVME constant yet; the canonical RustFS copy lives
-// in rustfs-utils' headers module.
-use rustfs_utils::http::headers::AMZ_CHECKSUM_CRC64NVME;
 use s3s::header::{
    X_AMZ_CHECKSUM_ALGORITHM, X_AMZ_CHECKSUM_CRC32, X_AMZ_CHECKSUM_CRC32C, X_AMZ_CHECKSUM_SHA1, X_AMZ_CHECKSUM_SHA256,
 };

 use enumset::{EnumSet, EnumSetType, enum_set};

-/// One of three deliberately separate checksum registries (backlog#1833):
-/// this enum is the MinIO-port client's wire vocabulary and stops at the
-/// standard S3 set (CRC64NVME is its newest member; the RustFS extensions do
-/// not exist on this client path). The streaming-hash registry lives in
-/// `rustfs_checksums::ChecksumAlgorithm` (crates/checksums/src/lib.rs) and
-/// the on-disk xl.meta bitset in `rustfs_rio::ChecksumType`
-/// (crates/rio/src/checksum.rs, varint bits are append-only). When adding an
-/// algorithm, extend all three (or record why not) — they do not derive from
-/// each other.
 #[derive(Debug, EnumSetType, Default)]
 #[enumset(repr = "u8")]
 pub enum ChecksumMode {
@@ -69,6 +57,8 @@ lazy_static! {
    static ref C_ChecksumFullObjectCRC32C: EnumSet<ChecksumMode> =
        enum_set!(ChecksumMode::ChecksumCRC32C | ChecksumMode::ChecksumFullObject);
 }
+const AMZ_CHECKSUM_CRC64NVME: &str = "x-amz-checksum-crc64nvme";
+
 impl ChecksumMode {
    //pub const CRC64_NVME_POLYNOMIAL: i64 = 0xad93d23594c93659;

@@ -37,3 +37,6 @@ pub const TOTAL_WORKERS: i64 = 4;
 pub const SIGN_V4_ALGORITHM: &str = "AWS4-HMAC-SHA256";
 pub const ISO8601_DATEFORMAT: &[FormatItem<'_>] =
    format_description!("[year]-[month]-[day]T[hour]:[minute]:[second].[subsecond]Z");
+
+pub const GET_OBJECT_ATTRIBUTES_TAGS: &str = "ETag,Checksum,StorageClass,ObjectSize,ObjectParts";
+pub const GET_OBJECT_ATTRIBUTES_MAX_PARTS: i64 = 1000;
@@ -16,8 +16,12 @@
 #![allow(dead_code)]

 pub mod admin_handler_utils;
+pub mod api_bucket_policy;
 pub mod api_error_response;
 pub mod api_get_object;
+pub mod api_get_object_acl;
+pub mod api_get_object_attributes;
+pub mod api_get_object_file;
 pub mod api_get_options;
 pub mod api_list;
 pub mod api_put_object;
@@ -25,6 +29,7 @@ pub mod api_put_object_common;
 pub mod api_put_object_multipart;
 pub mod api_put_object_streaming;
 pub mod api_remove;
+pub mod api_restore;
 pub mod api_s3_datatypes;
 pub mod api_stat;
 pub mod bucket_cache;
@@ -1006,6 +1006,16 @@ impl TransitionCore {
        client.abort_multipart_upload(bucket_name, object, upload_id).await
    }

+    pub async fn get_bucket_policy(&self, bucket_name: &str) -> Result<String, std::io::Error> {
+        let client = self.0.clone();
+        client.get_bucket_policy(bucket_name).await
+    }
+
+    pub async fn put_bucket_policy(&self, bucket_name: &str, bucket_policy: &str) -> Result<(), std::io::Error> {
+        let client = self.0.clone();
+        client.put_bucket_policy(bucket_name, bucket_policy).await
+    }
+
    pub async fn get_object(
        &self,
        bucket_name: &str,
@@ -15,12 +15,12 @@
 #[cfg(test)]
 use crate::cluster::rpc::http_auth::RPC_REPLAY_SCOPE_VERSION_HEADER;
 use crate::cluster::rpc::http_auth::{
-    AuthenticatedPeerReplayCapabilities, RPC_AUTH_VERSION_HEADER, RPC_AUTH_VERSION_V2, RPC_BOOT_EPOCH_CHALLENGE_HEADER,
-    RPC_CONTENT_SHA256_HEADER, RPC_REPLAY_CACHE_CAPABILITY_HEADER, RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER,
-    RollingMutationBodyDigest, TIMESTAMP_HEADER, internode_rpc_body_digest_strict,
-    verify_tonic_peer_replay_capabilities_response,
+    RPC_AUTH_VERSION_HEADER, RPC_AUTH_VERSION_V2, RPC_BOOT_EPOCH_CHALLENGE_HEADER, RPC_BOOT_EPOCH_HEADER,
+    RPC_BOOT_EPOCH_PROOF_HEADER, RPC_CONTENT_SHA256_HEADER, TIMESTAMP_HEADER,
+};
+use crate::cluster::rpc::{
+    gen_tonic_replay_scope_headers, gen_tonic_signature_headers, normalize_tonic_rpc_audience, verify_tonic_boot_epoch_response,
 };
-use crate::cluster::rpc::{gen_tonic_replay_scope_headers, gen_tonic_signature_headers, normalize_tonic_rpc_audience};
 #[cfg(test)]
 use crate::cluster::rpc::{tonic_boot_epoch_challenge, tonic_boot_epoch_response_headers};
 use crate::disk::error::{DiskError, Error as DiskErrorType, RpcStatusError};
@@ -233,22 +233,7 @@ pub struct ReplayScopeChannel<S> {
 /// The channel type used by internode clients after v2 authentication and replay-scope handling.
 pub type AuthenticatedChannel = ReplayScopeChannel<Channel>;

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum PeerReplayCapability {
-    Capable { boot_epoch: Uuid },
-    Revoked,
-}
-
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-struct PeerReplayState {
-    boot_epoch: Option<Uuid>,
-    cache_capability: Option<PeerReplayCapability>,
-}
-
-#[derive(Clone, Copy, Debug)]
-struct PeerReplayStateSnapshot(PeerReplayState);
-
-static PEER_REPLAY_STATES: LazyLock<Mutex<HashMap<String, PeerReplayState>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
+static PEER_BOOT_EPOCHS: LazyLock<Mutex<HashMap<String, Uuid>>> = LazyLock::new(|| Mutex::new(HashMap::new()));

 impl<S> ReplayScopeChannel<S> {
    fn new(inner: S, audience: Option<String>) -> Self {
@@ -256,67 +241,13 @@ impl<S> ReplayScopeChannel<S> {
    }
 }

-fn peer_replay_state(audience: &str) -> PeerReplayState {
-    PEER_REPLAY_STATES
-        .lock()
-        .ok()
-        .and_then(|states| states.get(audience).copied())
-        .unwrap_or_default()
+fn cached_peer_boot_epoch(audience: &str) -> Option<Uuid> {
+    PEER_BOOT_EPOCHS.lock().ok().and_then(|epochs| epochs.get(audience).copied())
 }

-fn apply_peer_replay_response(
-    audience: String,
-    sent_state: PeerReplayState,
-    response: std::io::Result<AuthenticatedPeerReplayCapabilities>,
-) {
-    if let Ok(mut states) = PEER_REPLAY_STATES.lock() {
-        let current_state = states.get(&audience).copied().unwrap_or_default();
-        let mut next_state = current_state;
-        if let Ok(response) = &response
-            && sent_state.boot_epoch == current_state.boot_epoch
-        {
-            next_state.boot_epoch = Some(response.boot_epoch);
-        }
-
-        if sent_state.boot_epoch == current_state.boot_epoch {
-            let response_capability = response
-                .as_ref()
-                .ok()
-                .filter(|response| response.dynamic_replay_cache)
-                .map(|response| response.boot_epoch);
-            match (sent_state.cache_capability, current_state.cache_capability, response_capability) {
-                (None, None, Some(boot_epoch))
-                | (Some(PeerReplayCapability::Revoked), Some(PeerReplayCapability::Revoked), Some(boot_epoch)) => {
-                    next_state.cache_capability = Some(PeerReplayCapability::Capable { boot_epoch });
-                }
-                (
-                    Some(PeerReplayCapability::Capable {
-                        boot_epoch: sent_boot_epoch,
-                    }),
-                    Some(PeerReplayCapability::Capable {
-                        boot_epoch: current_boot_epoch,
-                    }),
-                    Some(response_boot_epoch),
-                ) if sent_boot_epoch == current_boot_epoch => {
-                    next_state.cache_capability = Some(PeerReplayCapability::Capable {
-                        boot_epoch: response_boot_epoch,
-                    });
-                }
-                (
-                    Some(PeerReplayCapability::Capable {
-                        boot_epoch: sent_boot_epoch,
-                    }),
-                    Some(PeerReplayCapability::Capable {
-                        boot_epoch: current_boot_epoch,
-                    }),
-                    None,
-                ) if sent_boot_epoch == current_boot_epoch => {
-                    next_state.cache_capability = Some(PeerReplayCapability::Revoked);
-                }
-                _ => {}
-            }
-        }
-        states.insert(audience, next_state);
+fn remember_peer_boot_epoch(audience: String, epoch: Uuid) {
+    if let Ok(mut epochs) = PEER_BOOT_EPOCHS.lock() {
+        epochs.insert(audience, epoch);
    }
 }

@@ -345,11 +276,6 @@ where
                == Some(RPC_AUTH_VERSION_V2)
        });
        let challenge = authenticated.then(Uuid::new_v4);
-        let sent_state = request
-            .extensions()
-            .get::<PeerReplayStateSnapshot>()
-            .map(|snapshot| snapshot.0)
-            .unwrap_or_default();
        if let (Some(audience), Some(challenge)) = (self.audience.as_deref(), challenge) {
            // The challenge is independently HMAC-authenticated by the response proof. It is not
            // part of v2 so old peers ignore it, while a new peer can safely advertise its epoch.
@@ -358,7 +284,7 @@ where
                challenge.to_string().parse().expect("UUID must be a valid header value"),
            );
            if let (Some(boot_epoch), Some(timestamp), Some(content_sha256)) = (
-                sent_state.boot_epoch,
+                cached_peer_boot_epoch(audience),
                request.headers().get(TIMESTAMP_HEADER).and_then(|value| value.to_str().ok()),
                request
                    .headers()
@@ -377,21 +303,16 @@ where
        Box::pin(async move {
            let response = future.await?;
            if let (Some(audience), Some(challenge)) = (audience, challenge) {
-                let response_state = verify_tonic_peer_replay_capabilities_response(&audience, challenge, response.headers());
-                if let Err(error) = &response_state
-                    && (response.headers().contains_key(RPC_REPLAY_CACHE_CAPABILITY_HEADER)
-                        || response.headers().contains_key(RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER))
-                {
-                    debug!(
-                        event = "internode_rpc_capability_proof_rejected",
-                        component = "ecstore",
-                        subsystem = "rpc_client",
-                        result = "rejected",
-                        error = %error,
-                        "internode RPC capability proof rejected"
-                    )
+                match verify_tonic_boot_epoch_response(&audience, challenge, response.headers()) {
+                    Ok(epoch) => remember_peer_boot_epoch(audience, epoch),
+                    Err(error)
+                        if response.headers().contains_key(RPC_BOOT_EPOCH_HEADER)
+                            || response.headers().contains_key(RPC_BOOT_EPOCH_PROOF_HEADER) =>
+                    {
+                        debug!(error = %error, "peer boot epoch response proof was rejected")
+                    }
+                    Err(_) => {}
                }
-                apply_peer_replay_response(audience, sent_state, response_state);
            }
            Ok(response)
        })
@@ -400,7 +321,6 @@ where

 pub struct TonicSignatureInterceptor {
    audience: Option<String>,
-    body_digest_strict: bool,
 }

 impl tonic::service::Interceptor for TonicSignatureInterceptor {
@@ -417,31 +337,9 @@ impl tonic::service::Interceptor for TonicSignatureInterceptor {
            .metadata()
            .get(RPC_CONTENT_SHA256_HEADER)
            .and_then(|value| value.to_str().ok());
-        // RUSTFS_COMPAT_TODO(disk-mutation-body-digest): use cache-free v2 for peers without an authenticated boot epoch. Remove after every supported peer advertises the authenticated dynamic replay-cache capability and body-digest strict mode is the default.
-        // beta.11 verifies v2 body digests but stores their nonces in a fixed-size cache.
-        let rolling_mutation = req.extensions().get::<RollingMutationBodyDigest>().is_some();
-        let peer_state = PEER_REPLAY_STATES
-            .lock()
-            .map_err(|_| tonic::Status::unauthenticated("RPC peer capability state unavailable"))?
-            .get(audience)
-            .copied()
-            .unwrap_or_default();
-        let content_sha256 = if content_sha256.is_some() {
-            if peer_state.cache_capability == Some(PeerReplayCapability::Revoked) {
-                return Err(tonic::Status::unauthenticated("RPC peer replay capability changed"));
-            }
-            if rolling_mutation && !self.body_digest_strict && peer_state.boot_epoch.is_none() {
-                None
-            } else {
-                content_sha256
-            }
-        } else {
-            content_sha256
-        };
        let headers = gen_tonic_signature_headers(audience, method.service(), method.method(), content_sha256)
            .map_err(|_| tonic::Status::unauthenticated("No valid auth token"))?;
        req.metadata_mut().as_mut().extend(headers);
-        req.extensions_mut().insert(PeerReplayStateSnapshot(peer_state));
        inject_trace_context_into_metadata(req.metadata_mut());
        inject_request_id_into_metadata(req.metadata_mut());
        Ok(req)
@@ -449,10 +347,7 @@ impl tonic::service::Interceptor for TonicSignatureInterceptor {
 }

 pub fn gen_tonic_signature_interceptor() -> TonicSignatureInterceptor {
-    TonicSignatureInterceptor {
-        audience: None,
-        body_digest_strict: internode_rpc_body_digest_strict(),
-    }
+    TonicSignatureInterceptor { audience: None }
 }

 pub struct NoOpInterceptor;
@@ -514,7 +409,6 @@ mod tests {
    #[derive(Clone)]
    struct EpochProofService {
        audience: String,
-        include_capability: bool,
        seen_headers: std::sync::Arc<Mutex<Vec<http::HeaderMap>>>,
    }

@@ -536,97 +430,29 @@ mod tests {
                .expect("client challenge must be syntactically valid")
                .expect("authenticated client request must carry a boot epoch challenge");
            let mut response = HttpResponse::new(());
-            let mut headers = tonic_boot_epoch_response_headers(&self.audience, challenge)
-                .expect("test server must be able to sign an epoch proof");
-            if !self.include_capability {
-                headers.remove(RPC_REPLAY_CACHE_CAPABILITY_HEADER);
-                headers.remove(RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER);
-            }
-            response.headers_mut().extend(headers);
+            response.headers_mut().extend(
+                tonic_boot_epoch_response_headers(&self.audience, challenge)
+                    .expect("test server must be able to sign an epoch proof"),
+            );
            std::future::ready(Ok(response))
        }
    }

-    #[derive(Clone)]
-    struct MissingProofService;
-
-    impl Service<HttpRequest<()>> for MissingProofService {
-        type Response = HttpResponse<()>;
-        type Error = std::convert::Infallible;
-        type Future = std::future::Ready<Result<Self::Response, Self::Error>>;
-
-        fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn call(&mut self, _request: HttpRequest<()>) -> Self::Future {
-            std::future::ready(Ok(HttpResponse::new(())))
-        }
-    }
-
    fn ensure_test_rpc_secret() {
        runtime_sources::ensure_test_rpc_secret();
    }

    fn test_request() -> tonic::Request<()> {
-        test_request_for("Ping")
-    }
-
-    fn test_request_for(method: &'static str) -> tonic::Request<()> {
        let mut request = tonic::Request::new(());
        request
            .extensions_mut()
-            .insert(tonic::GrpcMethod::new("node_service.NodeService", method));
+            .insert(tonic::GrpcMethod::new("node_service.NodeService", "Ping"));
        request
    }

    fn test_interceptor() -> TonicSignatureInterceptor {
-        test_interceptor_for("node-a:9000", false)
-    }
-
-    fn test_interceptor_for(audience: &str, body_digest_strict: bool) -> TonicSignatureInterceptor {
        TonicSignatureInterceptor {
-            audience: Some(audience.to_string()),
-            body_digest_strict,
-        }
-    }
-
-    fn clear_peer_capability(audience: &str) {
-        PEER_REPLAY_STATES
-            .lock()
-            .expect("peer capability cache lock must not be poisoned")
-            .remove(audience);
-    }
-
-    fn rolling_mutation_request(method: &'static str) -> tonic::Request<()> {
-        let mut request = tonic::Request::new(rustfs_protos::proto_gen::node_service::GenerallyLockRequest {
-            args: "canonical mutation request".to_string(),
-        });
-        request
-            .extensions_mut()
-            .insert(tonic::GrpcMethod::new("node_service.NodeService", method));
-        crate::cluster::rpc::set_tonic_rolling_mutation_body_digest(&mut request).expect("test mutation digest must be attached");
-        request.map(|_| ())
-    }
-
-    fn replay_scope_request(audience: &str, method: &'static str) -> HttpRequest<()> {
-        let mut request = HttpRequest::builder()
-            .uri(format!("/node_service.NodeService/{method}"))
-            .body(())
-            .expect("test RPC request must build");
-        request.headers_mut().extend(
-            gen_tonic_signature_headers(audience, "node_service.NodeService", method, None).expect("v2 test headers must mint"),
-        );
-        request
-            .extensions_mut()
-            .insert(PeerReplayStateSnapshot(peer_replay_state(audience)));
-        request
-    }
-
-    fn authenticated_peer_response(boot_epoch: Uuid, dynamic_replay_cache: bool) -> AuthenticatedPeerReplayCapabilities {
-        AuthenticatedPeerReplayCapabilities {
-            boot_epoch,
-            dynamic_replay_cache,
+            audience: Some("node-a:9000".to_string()),
        }
    }

@@ -741,431 +567,6 @@ mod tests {
        );
    }

-    #[test]
-    fn unknown_peer_mutations_use_cache_free_unsigned_v2() {
-        ensure_test_rpc_secret();
-        let audience = "legacy-body-digest-client-test:9000";
-        clear_peer_capability(audience);
-        let mut interceptor = test_interceptor_for(audience, false);
-        for method in ["Lock", "WriteAll"] {
-            let request = interceptor
-                .call(rolling_mutation_request(method))
-                .expect("interceptor call should succeed");
-
-            assert_eq!(
-                request
-                    .metadata()
-                    .get("x-rustfs-content-sha256")
-                    .and_then(|value| value.to_str().ok()),
-                Some("UNSIGNED-PAYLOAD")
-            );
-            assert_eq!(
-                request
-                    .metadata()
-                    .get("x-rustfs-rpc-nonce")
-                    .and_then(|value| value.to_str().ok()),
-                Some("unsigned")
-            );
-            assert!(
-                crate::cluster::rpc::verify_tonic_rpc_signature(
-                    audience,
-                    &format!("/node_service.NodeService/{method}"),
-                    request.metadata().as_ref(),
-                )
-                .is_ok(),
-                "the cache-free request must retain valid audience- and method-bound v2 authentication"
-            );
-        }
-    }
-
-    #[test]
-    fn unknown_peer_exact_body_contract_remains_body_bound() {
-        ensure_test_rpc_secret();
-        let audience = "exact-body-contract-client-test:9000";
-        clear_peer_capability(audience);
-        let mut interceptor = test_interceptor_for(audience, false);
-        let mut request = test_request_for("ScannerActivity");
-        crate::cluster::rpc::set_tonic_canonical_body_digest(&mut request, b"exact scanner activity body")
-            .expect("test exact body digest must be attached");
-        let expected_digest = request
-            .metadata()
-            .get("x-rustfs-content-sha256")
-            .and_then(|value| value.to_str().ok())
-            .expect("test request must carry its digest")
-            .to_string();
-
-        let request = interceptor.call(request).expect("interceptor call should succeed");
-
-        assert_eq!(
-            request
-                .metadata()
-                .get("x-rustfs-content-sha256")
-                .and_then(|value| value.to_str().ok()),
-            Some(expected_digest.as_str())
-        );
-        assert!(
-            crate::cluster::rpc::verify_tonic_rpc_signature(
-                audience,
-                "/node_service.NodeService/ScannerActivity",
-                request.metadata().as_ref(),
-            )
-            .is_ok()
-        );
-    }
-
-    #[test]
-    fn unknown_peer_iam_mutation_helper_remains_body_bound() {
-        ensure_test_rpc_secret();
-        let audience = "exact-iam-mutation-client-test:9000";
-        clear_peer_capability(audience);
-        let mut interceptor = test_interceptor_for(audience, false);
-        let mut request = tonic::Request::new(rustfs_protos::proto_gen::node_service::DeleteUserRequest {
-            access_key: "target-access-key".to_string(),
-        });
-        request
-            .extensions_mut()
-            .insert(tonic::GrpcMethod::new("node_service.NodeService", "DeleteUser"));
-        crate::cluster::rpc::set_tonic_mutation_body_digest(&mut request).expect("test IAM mutation digest must be attached");
-        let request = request.map(|_| ());
-        let expected_digest = request
-            .metadata()
-            .get("x-rustfs-content-sha256")
-            .and_then(|value| value.to_str().ok())
-            .expect("test IAM mutation must carry its digest")
-            .to_string();
-
-        let request = interceptor.call(request).expect("interceptor call should succeed");
-
-        assert_eq!(
-            request
-                .metadata()
-                .get("x-rustfs-content-sha256")
-                .and_then(|value| value.to_str().ok()),
-            Some(expected_digest.as_str())
-        );
-        assert!(
-            crate::cluster::rpc::verify_tonic_rpc_signature(
-                audience,
-                "/node_service.NodeService/DeleteUser",
-                request.metadata().as_ref(),
-            )
-            .is_ok(),
-            "IAM mutations must remain body-bound before capability discovery"
-        );
-    }
-
-    #[test]
-    fn authenticated_replay_cache_capability_enables_body_binding() {
-        ensure_test_rpc_secret();
-        let audience = "body-digest-capable-client-test:9000";
-        clear_peer_capability(audience);
-        let seen_headers = std::sync::Arc::new(Mutex::new(Vec::new()));
-        let service = EpochProofService {
-            audience: audience.to_string(),
-            include_capability: true,
-            seen_headers,
-        };
-        let mut channel = ReplayScopeChannel::new(service, Some(audience.to_string()));
-        futures::executor::block_on(channel.call(replay_scope_request(audience, "Ping")))
-            .expect("authenticated capability probe must complete");
-
-        let mut interceptor = test_interceptor_for(audience, false);
-        let request = rolling_mutation_request("Lock");
-        let expected_digest = request
-            .metadata()
-            .get("x-rustfs-content-sha256")
-            .and_then(|value| value.to_str().ok())
-            .expect("test mutation must carry its digest")
-            .to_string();
-
-        let request = interceptor.call(request).expect("interceptor call should succeed");
-
-        assert_eq!(
-            request
-                .metadata()
-                .get("x-rustfs-content-sha256")
-                .and_then(|value| value.to_str().ok()),
-            Some(expected_digest.as_str())
-        );
-        let nonce = request
-            .metadata()
-            .get("x-rustfs-rpc-nonce")
-            .and_then(|value| value.to_str().ok())
-            .and_then(|value| Uuid::parse_str(value).ok())
-            .expect("capable peer body-bound mutation must carry a UUID nonce");
-        assert!(!nonce.is_nil());
-        assert!(
-            crate::cluster::rpc::verify_tonic_rpc_signature(
-                audience,
-                "/node_service.NodeService/Lock",
-                request.metadata().as_ref(),
-            )
-            .is_ok(),
-            "the body-bound request must retain valid audience- and method-bound v2 authentication"
-        );
-        clear_peer_capability(audience);
-    }
-
-    #[test]
-    fn invalid_capability_proof_does_not_enable_body_binding() {
-        ensure_test_rpc_secret();
-        let audience = "invalid-capability-client-test:9000";
-        clear_peer_capability(audience);
-        let service = EpochProofService {
-            audience: "wrong-capability-audience:9000".to_string(),
-            include_capability: true,
-            seen_headers: std::sync::Arc::new(Mutex::new(Vec::new())),
-        };
-        let mut channel = ReplayScopeChannel::new(service, Some(audience.to_string()));
-        futures::executor::block_on(channel.call(replay_scope_request(audience, "Ping")))
-            .expect("invalid capability response must still complete");
-
-        let mut interceptor = test_interceptor_for(audience, false);
-        let request = interceptor
-            .call(rolling_mutation_request("Lock"))
-            .expect("legacy-compatible mutation must still be signed");
-
-        assert_eq!(
-            request
-                .metadata()
-                .get("x-rustfs-content-sha256")
-                .and_then(|value| value.to_str().ok()),
-            Some("UNSIGNED-PAYLOAD")
-        );
-    }
-
-    #[test]
-    fn legacy_boot_proof_keeps_mutations_body_bound_and_enables_non_ping_v3() {
-        ensure_test_rpc_secret();
-        let audience = "legacy-boot-proof-client-test:9000";
-        clear_peer_capability(audience);
-        let seen_headers = std::sync::Arc::new(Mutex::new(Vec::new()));
-        let service = EpochProofService {
-            audience: audience.to_string(),
-            include_capability: false,
-            seen_headers: seen_headers.clone(),
-        };
-        let mut channel = ReplayScopeChannel::new(service, Some(audience.to_string()));
-        futures::executor::block_on(channel.call(replay_scope_request(audience, "Ping")))
-            .expect("legacy boot proof response must complete");
-
-        let state = peer_replay_state(audience);
-        assert!(state.boot_epoch.is_some(), "authenticated legacy proof must enable replay-scoped v3");
-        assert_eq!(state.cache_capability, None);
-
-        let mut interceptor = test_interceptor_for(audience, false);
-        let request = rolling_mutation_request("Lock");
-        let expected_digest = request
-            .metadata()
-            .get("x-rustfs-content-sha256")
-            .and_then(|value| value.to_str().ok())
-            .expect("test mutation must carry its digest")
-            .to_string();
-        let request = interceptor.call(request).expect("legacy-compatible mutation must be signed");
-        assert_eq!(
-            request
-                .metadata()
-                .get("x-rustfs-content-sha256")
-                .and_then(|value| value.to_str().ok()),
-            Some(expected_digest.as_str())
-        );
-        let (metadata, extensions, body) = request.into_parts();
-        let mut request = HttpRequest::new(body);
-        *request.uri_mut() = "/node_service.NodeService/Lock".parse().expect("test RPC URI must parse");
-        *request.headers_mut() = metadata.into_headers();
-        *request.extensions_mut() = extensions;
-        futures::executor::block_on(channel.call(request)).expect("legacy strict-compatible lock request must complete");
-
-        let headers = seen_headers.lock().expect("test header capture lock must not be poisoned");
-        assert!(
-            headers[1].contains_key(RPC_REPLAY_SCOPE_VERSION_HEADER),
-            "authenticated legacy boot proof must enable v3 on a non-Ping request"
-        );
-    }
-
-    #[test]
-    fn reordered_capability_responses_cannot_undo_newer_state() {
-        let audience = "reordered-capability-client-test:9000";
-        let epoch_one = Uuid::new_v4();
-        let epoch_two = Uuid::new_v4();
-        clear_peer_capability(audience);
-
-        let unknown = PeerReplayState::default();
-        apply_peer_replay_response(audience.to_string(), unknown, Ok(authenticated_peer_response(epoch_one, true)));
-        apply_peer_replay_response(audience.to_string(), unknown, Err(std::io::Error::other("delayed legacy response")));
-        let epoch_one_state = PeerReplayState {
-            boot_epoch: Some(epoch_one),
-            cache_capability: Some(PeerReplayCapability::Capable { boot_epoch: epoch_one }),
-        };
-        assert_eq!(peer_replay_state(audience), epoch_one_state);
-
-        apply_peer_replay_response(audience.to_string(), epoch_one_state, Err(std::io::Error::other("rollback response")));
-        apply_peer_replay_response(audience.to_string(), epoch_one_state, Ok(authenticated_peer_response(epoch_one, true)));
-        assert_eq!(
-            peer_replay_state(audience),
-            PeerReplayState {
-                boot_epoch: Some(epoch_one),
-                cache_capability: Some(PeerReplayCapability::Revoked),
-            }
-        );
-
-        let revoked = peer_replay_state(audience);
-        apply_peer_replay_response(audience.to_string(), revoked, Ok(authenticated_peer_response(epoch_two, true)));
-        apply_peer_replay_response(audience.to_string(), epoch_one_state, Ok(authenticated_peer_response(epoch_one, true)));
-        assert_eq!(
-            peer_replay_state(audience),
-            PeerReplayState {
-                boot_epoch: Some(epoch_two),
-                cache_capability: Some(PeerReplayCapability::Capable { boot_epoch: epoch_two }),
-            }
-        );
-        clear_peer_capability(audience);
-    }
-
-    #[test]
-    fn stale_capability_response_cannot_cross_a_new_boot_epoch() {
-        let audience = "cross-epoch-capability-client-test:9000";
-        let epoch_one = Uuid::new_v4();
-        let epoch_two = Uuid::new_v4();
-        let epoch_three = Uuid::new_v4();
-        clear_peer_capability(audience);
-
-        let revoked_epoch_one = PeerReplayState {
-            boot_epoch: Some(epoch_one),
-            cache_capability: Some(PeerReplayCapability::Revoked),
-        };
-        PEER_REPLAY_STATES
-            .lock()
-            .expect("peer replay state lock must not be poisoned")
-            .insert(audience.to_string(), revoked_epoch_one);
-
-        apply_peer_replay_response(
-            audience.to_string(),
-            revoked_epoch_one,
-            Ok(authenticated_peer_response(epoch_three, false)),
-        );
-        apply_peer_replay_response(audience.to_string(), revoked_epoch_one, Ok(authenticated_peer_response(epoch_two, true)));
-
-        assert_eq!(
-            peer_replay_state(audience),
-            PeerReplayState {
-                boot_epoch: Some(epoch_three),
-                cache_capability: Some(PeerReplayCapability::Revoked),
-            },
-            "a stale dynamic-cache proof must not cross a newer authenticated boot epoch"
-        );
-        clear_peer_capability(audience);
-    }
-
-    #[test]
-    fn interceptor_snapshot_prevents_delayed_legacy_response_from_revoking_capability() {
-        ensure_test_rpc_secret();
-        let audience = "capability-snapshot-client-test:9000";
-        clear_peer_capability(audience);
-        let boot_epoch = Uuid::new_v4();
-        let mut interceptor = test_interceptor_for(audience, false);
-        let request = interceptor
-            .call(rolling_mutation_request("Lock"))
-            .expect("legacy-compatible request must pass the interceptor");
-        assert_eq!(
-            request
-                .extensions()
-                .get::<PeerReplayStateSnapshot>()
-                .map(|snapshot| snapshot.0),
-            Some(PeerReplayState::default()),
-            "interceptor must preserve its unknown-state admission snapshot"
-        );
-
-        let capable_state = PeerReplayState {
-            boot_epoch: Some(boot_epoch),
-            cache_capability: Some(PeerReplayCapability::Capable { boot_epoch }),
-        };
-        PEER_REPLAY_STATES
-            .lock()
-            .expect("peer capability cache lock must not be poisoned")
-            .insert(audience.to_string(), capable_state);
-        let (metadata, extensions, body) = request.into_parts();
-        let mut request = HttpRequest::new(body);
-        *request.uri_mut() = "/node_service.NodeService/Lock".parse().expect("test RPC URI must parse");
-        *request.headers_mut() = metadata.into_headers();
-        *request.extensions_mut() = extensions;
-        let mut channel = ReplayScopeChannel::new(MissingProofService, Some(audience.to_string()));
-
-        futures::executor::block_on(channel.call(request)).expect("in-flight request response must complete");
-
-        assert_eq!(peer_replay_state(audience), capable_state);
-        clear_peer_capability(audience);
-    }
-
-    #[test]
-    fn strict_mode_keeps_unknown_peer_mutations_body_bound() {
-        ensure_test_rpc_secret();
-        let audience = "strict-body-digest-client-test:9000";
-        clear_peer_capability(audience);
-        let mut interceptor = test_interceptor_for(audience, true);
-        let request = rolling_mutation_request("WriteAll");
-        let expected_digest = request
-            .metadata()
-            .get("x-rustfs-content-sha256")
-            .and_then(|value| value.to_str().ok())
-            .expect("test mutation must carry its digest")
-            .to_string();
-
-        let request = interceptor.call(request).expect("interceptor call should succeed");
-
-        assert_eq!(
-            request
-                .metadata()
-                .get("x-rustfs-content-sha256")
-                .and_then(|value| value.to_str().ok()),
-            Some(expected_digest.as_str())
-        );
-        let nonce = request
-            .metadata()
-            .get("x-rustfs-rpc-nonce")
-            .and_then(|value| value.to_str().ok())
-            .and_then(|value| Uuid::parse_str(value).ok())
-            .expect("strict body-bound mutation must carry a UUID nonce");
-        assert!(!nonce.is_nil());
-        assert!(
-            crate::cluster::rpc::verify_tonic_rpc_signature(
-                audience,
-                "/node_service.NodeService/WriteAll",
-                request.metadata().as_ref(),
-            )
-            .is_ok()
-        );
-    }
-
-    #[test]
-    fn missing_capability_after_pin_fails_closed() {
-        ensure_test_rpc_secret();
-        let audience = "revoked-capability-client-test:9000";
-        let boot_epoch = Uuid::new_v4();
-        PEER_REPLAY_STATES
-            .lock()
-            .expect("peer capability cache lock must not be poisoned")
-            .insert(
-                audience.to_string(),
-                PeerReplayState {
-                    boot_epoch: Some(boot_epoch),
-                    cache_capability: Some(PeerReplayCapability::Capable { boot_epoch }),
-                },
-            );
-        let mut channel = ReplayScopeChannel::new(MissingProofService, Some(audience.to_string()));
-        futures::executor::block_on(channel.call(replay_scope_request(audience, "Ping")))
-            .expect("legacy response must complete before capability rejection");
-
-        let mut interceptor = test_interceptor_for(audience, false);
-        let error = interceptor
-            .call(rolling_mutation_request("Lock"))
-            .expect_err("a peer that loses its pinned capability must fail closed");
-
-        assert_eq!(error.code(), tonic::Code::Unauthenticated);
-        assert_eq!(error.message(), "RPC peer replay capability changed");
-        clear_peer_capability(audience);
-    }
-
    #[test]
    fn test_signature_interceptor_binds_audience_from_peer_uri() {
        let interceptor = TonicInterceptor::Signature(gen_tonic_signature_interceptor())
@@ -1182,15 +583,27 @@ mod tests {
    fn replay_scope_channel_uses_epoch_proof_before_sending_v3() {
        ensure_test_rpc_secret();
        let audience = "replay-scope-client-test:9000";
-        clear_peer_capability(audience);
+        PEER_BOOT_EPOCHS
+            .lock()
+            .expect("peer epoch cache lock must not be poisoned")
+            .remove(audience);
        let seen_headers = std::sync::Arc::new(Mutex::new(Vec::new()));
        let service = EpochProofService {
            audience: audience.to_string(),
-            include_capability: true,
            seen_headers: seen_headers.clone(),
        };
        let mut channel = ReplayScopeChannel::new(service, Some(audience.to_string()));
-        let make_request = || replay_scope_request(audience, "Ping");
+        let make_request = || {
+            let mut request = HttpRequest::builder()
+                .uri("/node_service.NodeService/Ping")
+                .body(())
+                .expect("test RPC request must build");
+            request.headers_mut().extend(
+                gen_tonic_signature_headers(audience, "node_service.NodeService", "Ping", None)
+                    .expect("v2 test headers must mint"),
+            );
+            request
+        };

        futures::executor::block_on(channel.call(make_request())).expect("first request must complete");
        futures::executor::block_on(channel.call(make_request())).expect("second request must complete");
@@ -1206,7 +619,10 @@ mod tests {
            headers[1].contains_key(RPC_REPLAY_SCOPE_VERSION_HEADER),
            "the second request must carry the replay-scoped v3 signature"
        );
-        clear_peer_capability(audience);
+        PEER_BOOT_EPOCHS
+            .lock()
+            .expect("peer epoch cache lock must not be poisoned")
+            .remove(audience);
    }

    #[test]
@@ -40,11 +40,8 @@ use http::{HeaderMap, HeaderValue, Method, Uri};
 use rustfs_credentials::{DEFAULT_SECRET_KEY, RPC_SECRET_REQUIRED_MESSAGE};
 use rustfs_credentials::{RPC_SECRET_REQUIRED_OPERATOR_MESSAGE, try_get_rpc_token};
 use rustfs_io_metrics::internode_metrics::{
-    INTERNODE_OPERATION_GRPC_BATCH_READ_VERSION, INTERNODE_OPERATION_GRPC_FORCE_UNLOCK, INTERNODE_OPERATION_GRPC_LOCK,
-    INTERNODE_OPERATION_GRPC_LOCK_BATCH, INTERNODE_OPERATION_GRPC_OTHER, INTERNODE_OPERATION_GRPC_READ_ALL,
-    INTERNODE_OPERATION_GRPC_READ_MULTIPLE, INTERNODE_OPERATION_GRPC_READ_VERSION, INTERNODE_OPERATION_GRPC_REFRESH,
-    INTERNODE_OPERATION_GRPC_UNLOCK, INTERNODE_OPERATION_GRPC_UNLOCK_BATCH, INTERNODE_OPERATION_GRPC_WRITE_ALL,
-    INTERNODE_TRANSPORT_BACKEND_GRPC, global_internode_metrics,
+    INTERNODE_OPERATION_GRPC_OTHER, INTERNODE_OPERATION_GRPC_READ_ALL, INTERNODE_OPERATION_GRPC_READ_MULTIPLE,
+    INTERNODE_OPERATION_GRPC_WRITE_ALL, INTERNODE_TRANSPORT_BACKEND_GRPC, global_internode_metrics,
 };
 use rustfs_object_data_cache::{MemoryBasis, resolve_effective_memory};
 use rustfs_utils::get_env_bool;
@@ -73,14 +70,10 @@ pub const RPC_REPLAY_SCOPE_NONCE_HEADER: &str = "x-rustfs-rpc-replay-nonce";
 pub const RPC_BOOT_EPOCH_HEADER: &str = "x-rustfs-rpc-boot-epoch";
 pub const RPC_BOOT_EPOCH_CHALLENGE_HEADER: &str = "x-rustfs-rpc-boot-epoch-challenge";
 pub const RPC_BOOT_EPOCH_PROOF_HEADER: &str = "x-rustfs-rpc-boot-epoch-proof";
-pub(crate) const RPC_REPLAY_CACHE_CAPABILITY_HEADER: &str = "x-rustfs-rpc-replay-cache-capability";
-pub(crate) const RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER: &str = "x-rustfs-rpc-replay-cache-capability-proof";
 const RPC_REPLAY_SCOPE_VERSION_V3: &str = "3";
 const RPC_RESPONSE_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-response-proof-v1\0";
 const RPC_REPLAY_SCOPE_DOMAIN: &[u8] = b"rustfs-rpc-replay-scope-v3\0";
 const RPC_BOOT_EPOCH_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-boot-epoch-proof-v1\0";
-const RPC_REPLAY_CACHE_CAPABILITY_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-replay-cache-capability-proof-v1\0";
-const RPC_REPLAY_CACHE_CAPABILITY_V1: &str = "dynamic-replay-cache-v1";
 const HTTP_PUT_FILE_AUTH_DOMAIN: &[u8] = b"rustfs-http-put-file-auth-v1\0";
 const HTTP_PUT_FILE_CAPABILITY_AUTH_DOMAIN: &[u8] = b"rustfs-http-put-file-capability-v1\0";
 const UNSIGNED_PAYLOAD: &str = "UNSIGNED-PAYLOAD";
@@ -89,9 +82,8 @@ const SIGNATURE_VALID_DURATION: i64 = 300; // 5 minutes
 const REPLAY_CACHE_RETENTION: Duration = Duration::from_secs(601);
 const REPLAY_CACHE_RETENTION_SECS: usize = 601;
 const REPLAY_CACHE_ENTRY_BYTES_ESTIMATE: u64 = 128;
-// Keep 16 CPU / 32 GiB field nodes at the 32M cap without requiring an env override.
-const REPLAY_CACHE_AUTO_MEMORY_PERCENT: u64 = 13;
-const REPLAY_CACHE_AUTO_RPC_RPS_PER_CPU: usize = 4096;
+const REPLAY_CACHE_AUTO_MEMORY_PERCENT: u64 = 8;
+const REPLAY_CACHE_AUTO_RPC_RPS_PER_CPU: usize = 2048;
 const REPLAY_CACHE_AUTO_MAX_CAPACITY: usize = 33_554_432;
 const NS_SCANNER_CAPABILITY_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-capability-v3";
 pub const TONIC_RPC_PREFIX: &str = "/node_service.NodeService";
@@ -107,10 +99,6 @@ static INTERNODE_RPC_BODY_DIGEST_STRICT: LazyLock<bool> = LazyLock::new(|| {
        rustfs_config::DEFAULT_INTERNODE_RPC_BODY_DIGEST_STRICT,
    )
 });
-
-pub(crate) fn internode_rpc_body_digest_strict() -> bool {
-    *INTERNODE_RPC_BODY_DIGEST_STRICT
-}
 static INTERNODE_RPC_REPLAY_SCOPE_STRICT: LazyLock<bool> = LazyLock::new(|| {
    get_env_bool(
        rustfs_config::ENV_INTERNODE_RPC_REPLAY_SCOPE_STRICT,
@@ -352,7 +340,6 @@ struct RpcNonceCacheMetrics<'a> {
    expired: usize,
    entries: usize,
    capacity: usize,
-    record_scope: Option<RpcReplayCacheMetricScope<'a>>,
    overflow_scope: Option<RpcReplayCacheMetricScope<'a>>,
 }

@@ -363,13 +350,6 @@ fn publish_nonce_cache_metrics(metrics: Option<RpcNonceCacheMetrics<'_>>) {
    let internode_metrics = global_internode_metrics();
    internode_metrics.record_replay_cache_evictions("expired", metrics.expired);
    internode_metrics.record_replay_cache_state(metrics.entries, metrics.capacity);
-    if let Some(scope) = metrics.record_scope {
-        internode_metrics.record_replay_cache_record_for_operation_and_backend_path(
-            scope.operation,
-            scope.backend,
-            scope.rpc_path,
-        );
-    }
    if let Some(scope) = metrics.overflow_scope {
        internode_metrics.record_replay_cache_overflow_for_operation_and_backend_path(
            scope.operation,
@@ -405,7 +385,6 @@ impl RpcNonceCache {
            expired,
            entries: self.nonces.len(),
            capacity: record.capacity,
-            record_scope: None,
            overflow_scope: None,
        };
        if self.nonces.contains(&record.nonce) {
@@ -430,7 +409,6 @@ impl RpcNonceCache {
            Ok(()),
            Some(RpcNonceCacheMetrics {
                entries: self.nonces.len(),
-                record_scope: Some(record.metric_scope),
                ..metrics
            }),
        )
@@ -798,50 +776,6 @@ fn verify_boot_epoch_proof(secret: &str, audience: &str, challenge: Uuid, boot_e
        .map_err(|_| std::io::Error::new(std::io::ErrorKind::PermissionDenied, "Invalid RPC boot epoch proof"))
 }

-fn update_replay_cache_capability_proof(mac: &mut HmacSha256, audience: &str, challenge: Uuid, boot_epoch: Uuid) {
-    mac.update(RPC_REPLAY_CACHE_CAPABILITY_PROOF_DOMAIN);
-    for part in [
-        audience.as_bytes(),
-        b"|",
-        challenge.as_bytes(),
-        b"|",
-        boot_epoch.as_bytes(),
-        b"|",
-        RPC_REPLAY_CACHE_CAPABILITY_V1.as_bytes(),
-    ] {
-        mac.update(part);
-    }
-}
-
-fn generate_replay_cache_capability_proof(
-    secret: &str,
-    audience: &str,
-    challenge: Uuid,
-    boot_epoch: Uuid,
-) -> std::io::Result<String> {
-    let mut mac =
-        <HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
-    update_replay_cache_capability_proof(&mut mac, audience, challenge, boot_epoch);
-    Ok(general_purpose::STANDARD.encode(mac.finalize().into_bytes()))
-}
-
-fn verify_replay_cache_capability_proof(
-    secret: &str,
-    audience: &str,
-    challenge: Uuid,
-    boot_epoch: Uuid,
-    proof: &str,
-) -> std::io::Result<()> {
-    let proof = general_purpose::STANDARD
-        .decode(proof)
-        .map_err(|_| std::io::Error::other("Invalid RPC replay cache capability proof"))?;
-    let mut mac =
-        <HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
-    update_replay_cache_capability_proof(&mut mac, audience, challenge, boot_epoch);
-    mac.verify_slice(&proof)
-        .map_err(|_| std::io::Error::new(std::io::ErrorKind::PermissionDenied, "Invalid RPC replay cache capability proof"))
-}
-
 fn non_nil_uuid(value: &str, name: &str) -> std::io::Result<Uuid> {
    let value = Uuid::parse_str(value).map_err(|_| std::io::Error::other(format!("Invalid {name}")))?;
    (!value.is_nil())
@@ -924,34 +858,15 @@ pub fn tonic_boot_epoch_challenge(headers: &HeaderMap) -> std::io::Result<Option
 /// Build the authenticated response headers for a client boot-epoch challenge.
 pub fn tonic_boot_epoch_response_headers(audience: &str, challenge: Uuid) -> std::io::Result<HeaderMap> {
    let boot_epoch = tonic_rpc_boot_epoch();
-    let secret = get_shared_secret()?;
-    let proof = generate_boot_epoch_proof(&secret, audience, challenge, boot_epoch)?;
-    let capability_proof = generate_replay_cache_capability_proof(&secret, audience, challenge, boot_epoch)?;
+    let proof = generate_boot_epoch_proof(&get_shared_secret()?, audience, challenge, boot_epoch)?;
    let mut headers = HeaderMap::new();
    headers.insert(RPC_BOOT_EPOCH_HEADER, header_value(&boot_epoch.to_string(), RPC_BOOT_EPOCH_HEADER)?);
    headers.insert(RPC_BOOT_EPOCH_PROOF_HEADER, header_value(&proof, RPC_BOOT_EPOCH_PROOF_HEADER)?);
-    headers.insert(
-        RPC_REPLAY_CACHE_CAPABILITY_HEADER,
-        HeaderValue::from_static(RPC_REPLAY_CACHE_CAPABILITY_V1),
-    );
-    headers.insert(
-        RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER,
-        header_value(&capability_proof, RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER)?,
-    );
    Ok(headers)
 }

 /// Verify the server boot-epoch response for a challenge generated by this client.
 pub fn verify_tonic_boot_epoch_response(audience: &str, challenge: Uuid, headers: &HeaderMap) -> std::io::Result<Uuid> {
-    verify_tonic_boot_epoch_response_with_secret(&get_shared_secret()?, audience, challenge, headers)
-}
-
-fn verify_tonic_boot_epoch_response_with_secret(
-    secret: &str,
-    audience: &str,
-    challenge: Uuid,
-    headers: &HeaderMap,
-) -> std::io::Result<Uuid> {
    let boot_epoch = headers
        .get(RPC_BOOT_EPOCH_HEADER)
        .and_then(|value| value.to_str().ok())
@@ -961,47 +876,10 @@ fn verify_tonic_boot_epoch_response_with_secret(
        .get(RPC_BOOT_EPOCH_PROOF_HEADER)
        .and_then(|value| value.to_str().ok())
        .ok_or_else(|| std::io::Error::other("Missing RPC boot epoch proof"))?;
-    verify_boot_epoch_proof(secret, audience, challenge, boot_epoch, proof)?;
+    verify_boot_epoch_proof(&get_shared_secret()?, audience, challenge, boot_epoch, proof)?;
    Ok(boot_epoch)
 }

-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) struct AuthenticatedPeerReplayCapabilities {
-    pub(crate) boot_epoch: Uuid,
-    pub(crate) dynamic_replay_cache: bool,
-}
-
-pub(crate) fn verify_tonic_peer_replay_capabilities_response(
-    audience: &str,
-    challenge: Uuid,
-    headers: &HeaderMap,
-) -> std::io::Result<AuthenticatedPeerReplayCapabilities> {
-    let secret = get_shared_secret()?;
-    let boot_epoch = verify_tonic_boot_epoch_response_with_secret(&secret, audience, challenge, headers)?;
-    let capability = headers.get(RPC_REPLAY_CACHE_CAPABILITY_HEADER);
-    let proof = headers.get(RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER);
-    if capability.is_none() && proof.is_none() {
-        return Ok(AuthenticatedPeerReplayCapabilities {
-            boot_epoch,
-            dynamic_replay_cache: false,
-        });
-    }
-    let capability = capability
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC replay cache capability"))?;
-    if capability != RPC_REPLAY_CACHE_CAPABILITY_V1 {
-        return Err(std::io::Error::other("Unsupported RPC replay cache capability"));
-    }
-    let proof = proof
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC replay cache capability proof"))?;
-    verify_replay_cache_capability_proof(&secret, audience, challenge, boot_epoch, proof)?;
-    Ok(AuthenticatedPeerReplayCapabilities {
-        boot_epoch,
-        dynamic_replay_cache: true,
-    })
-}
-
 fn valid_content_sha256(value: &str) -> bool {
    value == UNSIGNED_PAYLOAD
        || (value.len() == 64
@@ -1035,15 +913,7 @@ fn tonic_rpc_metric_operation(path: &str) -> &'static str {
    match parse_tonic_rpc_path(path).ok().map(|(_, rpc_method)| rpc_method) {
        Some("ReadAll") => INTERNODE_OPERATION_GRPC_READ_ALL,
        Some("ReadMultiple") => INTERNODE_OPERATION_GRPC_READ_MULTIPLE,
-        Some("ReadVersion") => INTERNODE_OPERATION_GRPC_READ_VERSION,
-        Some("BatchReadVersion") => INTERNODE_OPERATION_GRPC_BATCH_READ_VERSION,
        Some("WriteAll") => INTERNODE_OPERATION_GRPC_WRITE_ALL,
-        Some("Lock") => INTERNODE_OPERATION_GRPC_LOCK,
-        Some("UnLock") => INTERNODE_OPERATION_GRPC_UNLOCK,
-        Some("LockBatch") => INTERNODE_OPERATION_GRPC_LOCK_BATCH,
-        Some("UnLockBatch") => INTERNODE_OPERATION_GRPC_UNLOCK_BATCH,
-        Some("Refresh") => INTERNODE_OPERATION_GRPC_REFRESH,
-        Some("ForceUnLock") => INTERNODE_OPERATION_GRPC_FORCE_UNLOCK,
        _ => INTERNODE_OPERATION_GRPC_OTHER,
    }
 }
@@ -1212,23 +1082,6 @@ pub fn set_tonic_mutation_body_digest<T: rustfs_protos::CanonicalMutationBody>(
    set_tonic_canonical_body_digest(request, &canonical_body)
 }

-pub fn set_tonic_rolling_mutation_body_digest<T: rustfs_protos::CanonicalMutationBody>(
-    request: &mut tonic::Request<T>,
-) -> std::io::Result<()> {
-    set_tonic_mutation_body_digest(request)?;
-    request.extensions_mut().insert(RollingMutationBodyDigest);
-    Ok(())
-}
-
-pub fn set_tonic_rolling_canonical_body_digest<T>(request: &mut tonic::Request<T>, canonical_body: &[u8]) -> std::io::Result<()> {
-    set_tonic_canonical_body_digest(request, canonical_body)?;
-    request.extensions_mut().insert(RollingMutationBodyDigest);
-    Ok(())
-}
-
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct RollingMutationBodyDigest;
-
 pub fn verify_tonic_canonical_body_digest<T>(request: &tonic::Request<T>, canonical_body: &[u8]) -> std::io::Result<()> {
    let version = request
        .metadata()
@@ -1265,7 +1118,7 @@ pub fn verify_tonic_canonical_body_digest<T>(request: &tonic::Request<T>, canoni
 /// including v1-downgraded ones. It converges independently of the signature-strict switch
 /// (<https://github.com/rustfs/backlog/issues/1327>).
 pub fn verify_tonic_mutation_body_digest<T>(request: &tonic::Request<T>, canonical_body: &[u8]) -> std::io::Result<()> {
-    verify_tonic_mutation_body_digest_with_strictness(request, canonical_body, internode_rpc_body_digest_strict())
+    verify_tonic_mutation_body_digest_with_strictness(request, canonical_body, *INTERNODE_RPC_BODY_DIGEST_STRICT)
 }

 /// [`verify_tonic_mutation_body_digest`] with the strict gate injected as a parameter, so both
@@ -2318,23 +2171,6 @@ mod tests {
        assert!(verify_tonic_boot_epoch_response("node-a:9000", Uuid::new_v4(), &headers).is_err());
    }

-    #[test]
-    fn replay_cache_capability_proof_binds_audience_challenge_epoch_and_value() {
-        ensure_test_rpc_secret();
-        let challenge = Uuid::new_v4();
-        let headers = tonic_boot_epoch_response_headers("node-a:9000", challenge).expect("capability headers should build");
-        let capabilities = verify_tonic_peer_replay_capabilities_response("node-a:9000", challenge, &headers)
-            .expect("matching capability proof should verify");
-        assert_eq!(capabilities.boot_epoch, tonic_rpc_boot_epoch());
-        assert!(capabilities.dynamic_replay_cache);
-        assert!(verify_tonic_peer_replay_capabilities_response("node-b:9000", challenge, &headers).is_err());
-        assert!(verify_tonic_peer_replay_capabilities_response("node-a:9000", Uuid::new_v4(), &headers).is_err());
-
-        let mut changed_capability = headers;
-        changed_capability.insert(RPC_REPLAY_CACHE_CAPABILITY_HEADER, HeaderValue::from_static("dynamic-replay-cache-v2"));
-        assert!(verify_tonic_peer_replay_capabilities_response("node-a:9000", challenge, &changed_capability).is_err());
-    }
-
    #[test]
    fn tonic_rpc_auth_failure_reason_maps_security_relevant_errors() {
        for (message, reason) in [
@@ -2621,42 +2457,10 @@ mod tests {
            tonic_rpc_metric_operation("/node_service.NodeService/ReadMultiple"),
            INTERNODE_OPERATION_GRPC_READ_MULTIPLE
        );
-        assert_eq!(
-            tonic_rpc_metric_operation("/node_service.NodeService/ReadVersion"),
-            INTERNODE_OPERATION_GRPC_READ_VERSION
-        );
-        assert_eq!(
-            tonic_rpc_metric_operation("/node_service.NodeService/BatchReadVersion"),
-            INTERNODE_OPERATION_GRPC_BATCH_READ_VERSION
-        );
        assert_eq!(
            tonic_rpc_metric_operation("/node_service.NodeService/WriteAll"),
            INTERNODE_OPERATION_GRPC_WRITE_ALL
        );
-        assert_eq!(
-            tonic_rpc_metric_operation("/node_service.NodeService/Lock"),
-            INTERNODE_OPERATION_GRPC_LOCK
-        );
-        assert_eq!(
-            tonic_rpc_metric_operation("/node_service.NodeService/UnLock"),
-            INTERNODE_OPERATION_GRPC_UNLOCK
-        );
-        assert_eq!(
-            tonic_rpc_metric_operation("/node_service.NodeService/LockBatch"),
-            INTERNODE_OPERATION_GRPC_LOCK_BATCH
-        );
-        assert_eq!(
-            tonic_rpc_metric_operation("/node_service.NodeService/UnLockBatch"),
-            INTERNODE_OPERATION_GRPC_UNLOCK_BATCH
-        );
-        assert_eq!(
-            tonic_rpc_metric_operation("/node_service.NodeService/Refresh"),
-            INTERNODE_OPERATION_GRPC_REFRESH
-        );
-        assert_eq!(
-            tonic_rpc_metric_operation("/node_service.NodeService/ForceUnLock"),
-            INTERNODE_OPERATION_GRPC_FORCE_UNLOCK
-        );
        assert_eq!(
            tonic_rpc_metric_operation("/node_service.NodeService/SignalService"),
            INTERNODE_OPERATION_GRPC_OTHER
@@ -2695,27 +2499,21 @@ mod tests {

        assert_eq!(decision.source, ReplayCacheCapacitySource::Auto);
        assert_eq!(decision.memory_basis, Some(MemoryBasis::Host));
-        assert_eq!(decision.memory_based_capacity, 17_448_304);
-        assert_eq!(decision.cpu_based_capacity, 19_693_568);
-        assert_eq!(decision.capacity, 17_448_304);
+        assert_eq!(decision.memory_based_capacity, 10_737_418);
+        assert_eq!(decision.cpu_based_capacity, 9_846_784);
+        assert_eq!(decision.capacity, 9_846_784);
    }

    #[test]
-    fn replay_cache_capacity_auto_uses_32m_on_field_sized_nodes() {
+    fn replay_cache_capacity_auto_uses_resource_model_on_larger_nodes() {
        let gib = 1024_u64 * 1024 * 1024;
        let decision =
            replay_cache_capacity_decision(rustfs_utils::EnvParseOutcome::Absent, 16, Some(32 * gib), Some(MemoryBasis::Host));

        assert_eq!(decision.source, ReplayCacheCapacitySource::Auto);
-        assert_eq!(decision.memory_based_capacity, 34_896_609);
-        assert_eq!(decision.cpu_based_capacity, 39_387_136);
-        assert_eq!(decision.capacity, REPLAY_CACHE_AUTO_MAX_CAPACITY);
-
-        let observed_field_node =
-            replay_cache_capacity_decision(rustfs_utils::EnvParseOutcome::Absent, 16, Some(31 * gib), Some(MemoryBasis::Host));
-        assert_eq!(observed_field_node.memory_based_capacity, 33_806_090);
-        assert_eq!(observed_field_node.cpu_based_capacity, 39_387_136);
-        assert_eq!(observed_field_node.capacity, REPLAY_CACHE_AUTO_MAX_CAPACITY);
+        assert_eq!(decision.memory_based_capacity, 21_474_836);
+        assert_eq!(decision.cpu_based_capacity, 19_693_568);
+        assert_eq!(decision.capacity, 19_693_568);
    }

    #[test]
@@ -2747,7 +2545,7 @@ mod tests {
        let decision = replay_cache_capacity_decision(rustfs_utils::EnvParseOutcome::Invalid, 8, None, None);

        assert_eq!(decision.source, ReplayCacheCapacitySource::AutoInvalidEnv);
-        assert_eq!(decision.capacity, 19_693_568);
+        assert_eq!(decision.capacity, 9_846_784);
    }

    fn check_test_nonce_record(cache: &mut RpcNonceCache, record: RpcNonceRecord<'_>) -> std::io::Result<()> {
@@ -2756,13 +2554,6 @@ mod tests {
        result
    }

-    fn check_test_nonce_record_with_metrics<'a>(
-        cache: &mut RpcNonceCache,
-        record: RpcNonceRecord<'a>,
-    ) -> (std::io::Result<()>, Option<RpcNonceCacheMetrics<'a>>) {
-        cache.check_and_record(record)
-    }
-
    fn test_nonce_record(
        nonce: Uuid,
        signed_at: i64,
@@ -2806,48 +2597,6 @@ mod tests {
        assert!(cache.nonces.contains(&nonce_b));
    }

-    #[test]
-    fn nonce_cache_metrics_mark_successful_records_only() {
-        let now = Instant::now();
-        let expiry = now.checked_add(REPLAY_CACHE_RETENTION).expect("test expiry should fit");
-        let nonce_a = Uuid::new_v4();
-        let nonce_b = Uuid::new_v4();
-        let mut cache = RpcNonceCache::default();
-
-        let (recorded, metrics) =
-            check_test_nonce_record_with_metrics(&mut cache, test_nonce_record(nonce_a, 100, now, 100, expiry, 1));
-        recorded.expect("first nonce should be recorded");
-        let metrics = metrics.expect("successful nonce should publish metrics");
-        let record_scope = metrics.record_scope.expect("successful nonce should carry record scope");
-        assert_eq!(record_scope.operation, INTERNODE_OPERATION_GRPC_READ_ALL);
-        assert_eq!(record_scope.backend, INTERNODE_TRANSPORT_BACKEND_GRPC);
-        assert_eq!(record_scope.rpc_path, "/node_service.NodeService/ReadAll");
-        assert!(metrics.overflow_scope.is_none());
-
-        let (replay, metrics) =
-            check_test_nonce_record_with_metrics(&mut cache, test_nonce_record(nonce_a, 100, now, 100, expiry, 1));
-        assert_eq!(
-            replay.expect_err("duplicate nonce must fail closed").to_string(),
-            "RPC request replay detected"
-        );
-        let metrics = metrics.expect("replay rejection should still publish cache state");
-        assert!(metrics.record_scope.is_none());
-        assert!(metrics.overflow_scope.is_none());
-
-        let (overflow, metrics) =
-            check_test_nonce_record_with_metrics(&mut cache, test_nonce_record(nonce_b, 100, now, 100, expiry, 1));
-        assert_eq!(
-            overflow.expect_err("full cache must fail closed").to_string(),
-            "RPC replay cache capacity exceeded"
-        );
-        let metrics = metrics.expect("overflow should publish cache state");
-        assert!(metrics.record_scope.is_none());
-        let overflow_scope = metrics.overflow_scope.expect("overflow should keep diagnostic scope");
-        assert_eq!(overflow_scope.operation, INTERNODE_OPERATION_GRPC_READ_ALL);
-        assert_eq!(overflow_scope.backend, INTERNODE_TRANSPORT_BACKEND_GRPC);
-        assert_eq!(overflow_scope.rpc_path, "/node_service.NodeService/ReadAll");
-    }
-
    // The `rpc_body_digest_fallback_counter` serial group covers every test that drives (or
    // asserts on) the process-global body-digest fallback counter, so exact-delta assertions
    // cannot race with each other.
@@ -31,7 +31,7 @@ use rustfs_config::{
    DEFAULT_INTERNODE_DATA_TRANSPORT, ENV_RUSTFS_INTERNODE_DATA_TRANSPORT, INTERNODE_DATA_TRANSPORT_TCP,
    KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS,
 };
-use rustfs_rio::{ChunkReaderBox, HttpChunkReader, HttpReader, HttpWriter};
+use rustfs_rio::{HttpReader, HttpWriter};
 use sha2::{Digest, Sha256};
 use std::collections::HashMap;
 use std::future::Future;
@@ -221,11 +221,6 @@ pub struct NsScannerCapabilityRequest {
 #[async_trait]
 pub trait InternodeDataTransport: Send + Sync + std::fmt::Debug {
    async fn open_read(&self, request: ReadStreamRequest) -> Result<FileReader>;
-    /// Opens an owned-chunk stream when this transport can retain receive-buffer
-    /// ownership. `None` preserves the established `open_read` fallback.
-    async fn open_read_chunks(&self, _request: ReadStreamRequest) -> Result<Option<ChunkReaderBox>> {
-        Ok(None)
-    }
    async fn open_write(&self, request: WriteStreamRequest) -> Result<FileWriter>;
    async fn open_walk_dir(&self, request: WalkDirStreamRequest) -> Result<FileReader>;
    async fn open_ns_scanner(&self, _request: NsScannerStreamRequest) -> Result<FileReader> {
@@ -252,15 +247,6 @@ impl InternodeDataTransport for TcpHttpInternodeDataTransport {
        ))
    }

-    async fn open_read_chunks(&self, request: ReadStreamRequest) -> Result<Option<ChunkReaderBox>> {
-        let url = build_read_file_stream_url(&request);
-        let mut headers = json_headers();
-        build_auth_headers(&url, &Method::GET, &mut headers)?;
-        Ok(Some(Box::new(
-            HttpChunkReader::new_with_stall_timeout(url, Method::GET, headers, None, request.stall_timeout).await?,
-        )))
-    }
-
    async fn open_write(&self, request: WriteStreamRequest) -> Result<FileWriter> {
        let server_epoch = self.put_file_auth_capability(&request.endpoint).await?;
        let nonce = server_epoch.map(|_| Uuid::new_v4());
@@ -34,12 +34,11 @@ pub use client::{
 pub use http_auth::{
    TONIC_RPC_PREFIX, build_auth_headers, build_put_file_auth_trailer, check_and_record_signed_rpc_nonce, gen_signature_headers,
    gen_tonic_replay_scope_headers, gen_tonic_signature_headers, normalize_tonic_rpc_audience, set_tonic_canonical_body_digest,
-    set_tonic_mutation_body_digest, set_tonic_rolling_canonical_body_digest, set_tonic_rolling_mutation_body_digest,
-    sign_ns_scanner_capability, sign_put_file_capability, sign_tonic_rpc_response_proof, tonic_boot_epoch_challenge,
-    tonic_boot_epoch_response_headers, tonic_rpc_auth_failure_reason, verify_ns_scanner_capability, verify_put_file_auth_trailer,
-    verify_put_file_capability, verify_rpc_signature, verify_tonic_boot_epoch_response, verify_tonic_canonical_body_digest,
-    verify_tonic_mutation_body_digest, verify_tonic_rpc_response_proof, verify_tonic_rpc_signature,
-    verify_tonic_rpc_signature_with_bootstrap,
+    set_tonic_mutation_body_digest, sign_ns_scanner_capability, sign_put_file_capability, sign_tonic_rpc_response_proof,
+    tonic_boot_epoch_challenge, tonic_boot_epoch_response_headers, tonic_rpc_auth_failure_reason, verify_ns_scanner_capability,
+    verify_put_file_auth_trailer, verify_put_file_capability, verify_rpc_signature, verify_tonic_boot_epoch_response,
+    verify_tonic_canonical_body_digest, verify_tonic_mutation_body_digest, verify_tonic_rpc_response_proof,
+    verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
 };
 #[cfg(test)]
 pub(crate) use internode_data_transport::TcpHttpInternodeDataTransport;
@@ -16,6 +16,7 @@ use crate::cluster::rpc::client::{
    AuthenticatedChannel, TonicInterceptor, gen_tonic_signature_interceptor, is_network_like_disk_error,
    node_service_time_out_client, node_service_time_out_client_for_class, node_service_time_out_client_no_auth,
 };
+use crate::cluster::rpc::http_auth::set_tonic_canonical_body_digest;
 use crate::cluster::rpc::internode_data_transport::{
    InternodeDataTransport, NsScannerCapabilityRequest, NsScannerStreamRequest, ReadStreamRequest, WalkDirStreamRequest,
    WriteStreamRequest,
@@ -122,7 +123,7 @@ fn attach_mutation_body_digest<T>(
    op: &'static str,
 ) -> Result<()> {
    let canonical_body = canonical_body.map_err(|_| Error::other(format!("{op} request length cannot be represented")))?;
-    crate::cluster::rpc::set_tonic_rolling_canonical_body_digest(request, &canonical_body).map_err(Error::other)
+    set_tonic_canonical_body_digest(request, &canonical_body).map_err(Error::other)
 }

 fn decode_volume_infos(volume_infos: Vec<String>) -> Result<Vec<VolumeInfo>> {
@@ -522,33 +523,6 @@ impl RemoteDisk {
        }
    }

-    async fn open_read_chunks_with_retry(&self, request: ReadStreamRequest) -> Result<Option<rustfs_rio::ChunkReaderBox>> {
-        let mut attempt = 1;
-        let mut last_retry_classification = None;
-        loop {
-            match self.data_transport.open_read_chunks(request.clone()).await {
-                Ok(reader) => {
-                    if attempt > 1
-                        && let Some(classification) = last_retry_classification
-                    {
-                        crate::cluster::rpc::runtime_sources::record_remote_disk_open_read_retry_success(classification);
-                    }
-                    return Ok(reader);
-                }
-                Err(err) if attempt < REMOTE_DISK_OPEN_READ_MAX_ATTEMPTS && Self::is_retryable_open_read_error(&err) => {
-                    if let Some(classification) = err.internode_http_error_kind() {
-                        let classification = classification.metric_label();
-                        crate::cluster::rpc::runtime_sources::record_remote_disk_open_read_retry(classification);
-                        last_retry_classification = Some(classification);
-                    }
-                    tokio::time::sleep(REMOTE_DISK_OPEN_READ_RETRY_BACKOFF).await;
-                    attempt += 1;
-                }
-                Err(err) => return Err(err),
-            }
-        }
-    }
-
    pub fn record_capacity_probe(&self, total: u64, used: u64, free: u64) {
        self.health.record_capacity_probe(total, used, free);
    }
@@ -873,49 +847,31 @@ impl RemoteDisk {
    /// default to 1 (see [`internode_idempotent_read_retries`]). MUST NOT be used for write/lock
    /// RPCs — those must never auto-retry (quorum/idempotency safety). The `operation` closure is
    /// re-invoked per attempt, so it must be `Fn` (rebuild the request from borrowed inputs, do not
-    /// move captured state out). Attempts and backoff share one total timeout budget.
+    /// move captured state out).
    async fn execute_read_with_retry<T, F, Fut>(&self, op: &'static str, operation: F, timeout_duration: Duration) -> Result<T>
    where
        F: Fn() -> Fut,
        Fut: std::future::Future<Output = Result<T>>,
    {
-        let deadline = (!timeout_duration.is_zero()).then(|| {
-            time::Instant::now()
-                .checked_add(timeout_duration)
-                .unwrap_or_else(|| time::sleep(timeout_duration).deadline())
-        });
        let max_retries = internode_idempotent_read_retries();
        let mut attempt = 0usize;
        loop {
-            let attempt_timeout = deadline
-                .map(|deadline| deadline.saturating_duration_since(time::Instant::now()))
-                .unwrap_or(Duration::ZERO);
-            if deadline.is_some() && attempt_timeout.is_zero() {
-                self.record_timeout(op, timeout_duration);
-                return Err(DiskError::Timeout);
-            }
-
+            // Only the final attempt marks the disk faulty / evicts the channel. Earlier retries
+            // ignore the failure, so a transient error cannot flip the disk into a faulty
+            // short-circuit (which would defeat the retry) or over-count failures.
            let health_action = if attempt >= max_retries {
                FailureHealthAction::MarkFailure
            } else {
                FailureHealthAction::IgnoreFailure
            };
            match self
-                .execute_with_timeout_for_op_and_health_action(op, &operation, attempt_timeout, health_action)
+                .execute_with_timeout_for_op_and_health_action(op, &operation, timeout_duration, health_action)
                .await
            {
                Err(err) if attempt < max_retries && is_network_like_disk_error(&err) => {
-                    if matches!(err, DiskError::Timeout) && deadline.is_some_and(|deadline| time::Instant::now() >= deadline) {
-                        self.mark_faulty("read_operation_deadline");
-                        return Err(err);
-                    }
                    attempt += 1;
                    let backoff = REMOTE_DISK_READ_RETRY_BASE_BACKOFF
                        .saturating_mul(1u32 << u32::try_from(attempt - 1).unwrap_or(4).min(4));
-                    if deadline.is_some_and(|deadline| deadline.saturating_duration_since(time::Instant::now()) <= backoff) {
-                        attempt = max_retries;
-                        continue;
-                    }
                    debug!(
                        endpoint = %self.endpoint,
                        addr = %self.addr,
@@ -923,17 +879,7 @@ impl RemoteDisk {
                        attempt,
                        "retrying idempotent read-only RPC after transient network error"
                    );
-                    if let Some(deadline) = deadline {
-                        if time::timeout_at(deadline, time::sleep(backoff)).await.is_err() {
-                            self.record_timeout(op, timeout_duration);
-                            return Err(DiskError::Timeout);
-                        }
-                    } else {
-                        time::sleep(backoff).await;
-                    }
-                    if self.health.is_faulty() {
-                        return Err(DiskError::FaultyDisk);
-                    }
+                    tokio::time::sleep(backoff).await;
                }
                other => return other,
            }
@@ -1012,35 +958,32 @@ impl RemoteDisk {
                operation_result
            }
            Err(_) => {
-                self.record_timeout(op, timeout_duration);
+                // Timeout occurred, mark disk as potentially faulty
+                counter!(
+                    "rustfs_drive_op_timeout_total",
+                    "endpoint" => self.endpoint.to_string(),
+                    "op" => op.to_string()
+                )
+                .increment(1);
                if failure_health_action == FailureHealthAction::MarkFailure {
                    self.mark_faulty_and_evict("operation_timeout").await;
                }
+                warn!(
+                    event = EVENT_REMOTE_DISK_RPC,
+                    component = LOG_COMPONENT_ECSTORE,
+                    subsystem = LOG_SUBSYSTEM_REMOTE_DISK,
+                    endpoint = %self.endpoint,
+                    addr = %self.addr,
+                    op,
+                    timeout_ms = timeout_duration.as_millis(),
+                    state = "timeout",
+                    "Remote disk operation timed out"
+                );
                Err(DiskError::Timeout)
            }
        }
    }

-    fn record_timeout(&self, op: &'static str, timeout_duration: Duration) {
-        counter!(
-            "rustfs_drive_op_timeout_total",
-            "endpoint" => self.endpoint.to_string(),
-            "op" => op.to_string()
-        )
-        .increment(1);
-        warn!(
-            event = EVENT_REMOTE_DISK_RPC,
-            component = LOG_COMPONENT_ECSTORE,
-            subsystem = LOG_SUBSYSTEM_REMOTE_DISK,
-            endpoint = %self.endpoint,
-            addr = %self.addr,
-            op,
-            timeout_ms = timeout_duration.as_millis(),
-            state = "timeout",
-            "Remote disk operation timed out"
-        );
-    }
-
    async fn handle_network_like_error<T>(
        &self,
        op: &'static str,
@@ -1074,7 +1017,7 @@ impl RemoteDisk {
        }
    }

-    fn mark_faulty(&self, reason: &'static str) -> bool {
+    async fn mark_faulty_and_evict(&self, reason: &'static str) {
        let previous_state = self.runtime_state();
        let transitioned_to_offline = self.mark_suspect_or_offline(reason);
        let state = self.runtime_state();
@@ -1111,12 +1054,6 @@ impl RemoteDisk {
                    "Remote disk marked suspect"
                );
            }
-        }
-        state != previous_state
-    }
-
-    async fn mark_faulty_and_evict(&self, reason: &'static str) {
-        if self.mark_faulty(reason) {
            counter!(
                "rustfs_drive_connection_evict_total",
                "endpoint" => self.endpoint.to_string(),
@@ -2132,7 +2069,7 @@ impl DiskAPI for RemoteDisk {

                Ok(file_info)
            },
-            get_drive_metadata_timeout(),
+            get_max_timeout_duration(),
        )
        .await
    }
@@ -2481,30 +2418,6 @@ impl DiskAPI for RemoteDisk {
        .await
    }

-    async fn read_file_stream_chunks(
-        &self,
-        volume: &str,
-        path: &str,
-        offset: usize,
-        length: usize,
-    ) -> Result<Option<rustfs_rio::ChunkReaderBox>> {
-        if self.health.is_faulty() {
-            return Err(DiskError::FaultyDisk);
-        }
-        let disk = self.disk_ref().await;
-        let stall_timeout = get_object_disk_read_timeout();
-        self.open_read_chunks_with_retry(ReadStreamRequest {
-            endpoint: self.endpoint.grid_host(),
-            disk,
-            volume: volume.to_string(),
-            path: path.to_string(),
-            offset,
-            length,
-            stall_timeout: (!stall_timeout.is_zero()).then_some(stall_timeout),
-        })
-        .await
-    }
-
    /// Buffered read for remote disks.
    /// The transport stream is collected into owned Bytes for caller sharing.
    #[tracing::instrument(level = "trace", skip_all)]
@@ -3116,22 +3029,6 @@ mod tests {

    static INIT: Once = Once::new();

-    #[test]
-    fn disk_mutation_digest_marks_rolling_compatibility() {
-        let mut request = Request::new(());
-
-        attach_mutation_body_digest(&mut request, Ok(b"canonical disk mutation".to_vec()), "WriteAll")
-            .expect("disk mutation digest must be attached");
-
-        assert!(
-            request
-                .extensions()
-                .get::<crate::cluster::rpc::http_auth::RollingMutationBodyDigest>()
-                .is_some(),
-            "remote-disk mutations must reach the cache-free compatibility gate"
-        );
-    }
-
    // `#[serial(internode_metrics)]` marks every test that observes
    // `global_internode_metrics()`. Those counters are a process-wide singleton:
    // some of these tests snapshot a counter, run one decode, and assert on the
@@ -5182,452 +5079,6 @@ mod tests {
        );
    }

-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_reset_during_backoff_preserves_recovery() {
-        let remote_disk = Arc::new(new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await);
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let first_attempt = Arc::new(tokio::sync::Notify::new());
-        let started = time::Instant::now();
-
-        let task_disk = Arc::clone(&remote_disk);
-        let task_attempts = Arc::clone(&attempts);
-        let task_first_attempt = Arc::clone(&first_attempt);
-        let task = tokio::spawn(async move {
-            task_disk
-                .execute_read_with_retry(
-                    "read_version",
-                    move || {
-                        let attempt = task_attempts.fetch_add(1, Ordering::SeqCst);
-                        let first_attempt = Arc::clone(&task_first_attempt);
-                        async move {
-                            if attempt == 0 {
-                                time::sleep(Duration::from_millis(20)).await;
-                                first_attempt.notify_one();
-                                return Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                    std_io::ErrorKind::ConnectionRefused,
-                                    "connection refused",
-                                )));
-                            }
-                            Ok(())
-                        }
-                    },
-                    Duration::from_millis(100),
-                )
-                .await
-        });
-
-        first_attempt.notified().await;
-        tokio::task::yield_now().await;
-        remote_disk.health.reset_for_store_init_retry(&remote_disk.endpoint);
-        let channel = TonicEndpoint::from_shared(remote_disk.addr.clone())
-            .expect("remote disk address should parse")
-            .connect_lazy();
-        runtime_sources::cache_test_node_channel(remote_disk.addr.clone(), channel).await;
-        task.await
-            .expect("retry task should finish")
-            .expect("the retry should succeed after the health reset");
-
-        assert_eq!(attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(started.elapsed(), Duration::from_millis(70));
-        assert_eq!(
-            remote_disk.health.waiting_count(),
-            0,
-            "health reset must not underflow the waiting counter"
-        );
-        assert_eq!(remote_disk.runtime_state(), RuntimeDriveHealthState::Online);
-        assert!(
-            runtime_sources::test_node_channel_is_cached(&remote_disk.addr).await,
-            "a recovered channel must survive the retry backoff"
-        );
-        remote_disk.cancel_token.cancel();
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_still_retries_within_shared_deadline() {
-        let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let channel = TonicEndpoint::from_shared(remote_disk.addr.clone())
-            .expect("remote disk address should parse")
-            .connect_lazy();
-        runtime_sources::cache_test_node_channel(remote_disk.addr.clone(), channel).await;
-
-        remote_disk
-            .execute_read_with_retry(
-                "read_version",
-                || {
-                    let attempt = attempts.fetch_add(1, Ordering::SeqCst);
-                    async move {
-                        if attempt == 0 {
-                            return Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                std_io::ErrorKind::ConnectionReset,
-                                "connection reset",
-                            )));
-                        }
-                        Ok(())
-                    }
-                },
-                Duration::from_millis(100),
-            )
-            .await
-            .expect("a retry that fits the shared deadline should succeed");
-
-        assert_eq!(attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(remote_disk.runtime_state(), RuntimeDriveHealthState::Online);
-        assert!(runtime_sources::test_node_channel_is_cached(&remote_disk.addr).await);
-        remote_disk.cancel_token.cancel();
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_uses_remaining_budget_for_final_attempt() {
-        let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let started = time::Instant::now();
-        let channel = TonicEndpoint::from_shared(remote_disk.addr.clone())
-            .expect("remote disk address should parse")
-            .connect_lazy();
-        runtime_sources::cache_test_node_channel(remote_disk.addr.clone(), channel).await;
-
-        let err = remote_disk
-            .execute_read_with_retry(
-                "read_version",
-                || {
-                    let attempt = attempts.fetch_add(1, Ordering::SeqCst);
-                    async move {
-                        if attempt == 0 {
-                            time::sleep(Duration::from_millis(20)).await;
-                            return Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                std_io::ErrorKind::ConnectionRefused,
-                                "connection refused",
-                            )));
-                        }
-                        std::future::pending::<Result<()>>().await
-                    }
-                },
-                Duration::from_millis(100),
-            )
-            .await
-            .expect_err("the final retry should consume only the remaining total budget");
-
-        assert_eq!(err, DiskError::Timeout);
-        assert_eq!(attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(started.elapsed(), Duration::from_millis(100));
-        assert_eq!(remote_disk.runtime_state(), RuntimeDriveHealthState::Suspect);
-        assert!(!runtime_sources::test_node_channel_is_cached(&remote_disk.addr).await);
-        remote_disk.cancel_token.cancel();
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_uses_final_attempt_at_exact_backoff_boundary() {
-        let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let started = time::Instant::now();
-
-        let err = remote_disk
-            .execute_read_with_retry(
-                "read_version",
-                || {
-                    let attempt = attempts.fetch_add(1, Ordering::SeqCst);
-                    async move {
-                        if attempt == 0 {
-                            time::sleep(Duration::from_millis(50)).await;
-                            return Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                std_io::ErrorKind::ConnectionRefused,
-                                "connection refused",
-                            )));
-                        }
-                        std::future::pending::<Result<()>>().await
-                    }
-                },
-                Duration::from_millis(100),
-            )
-            .await
-            .expect_err("the exact backoff boundary should be reserved for a final attempt");
-
-        assert_eq!(err, DiskError::Timeout);
-        assert_eq!(attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(started.elapsed(), Duration::from_millis(100));
-        assert_eq!(remote_disk.runtime_state(), RuntimeDriveHealthState::Suspect);
-        remote_disk.cancel_token.cancel();
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_uses_final_attempt_below_backoff_budget() {
-        let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let started = time::Instant::now();
-
-        let err = remote_disk
-            .execute_read_with_retry(
-                "read_version",
-                || {
-                    let attempt = attempts.fetch_add(1, Ordering::SeqCst);
-                    async move {
-                        if attempt == 0 {
-                            time::sleep(Duration::from_millis(80)).await;
-                            return Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                std_io::ErrorKind::ConnectionRefused,
-                                "connection refused",
-                            )));
-                        }
-                        std::future::pending::<Result<()>>().await
-                    }
-                },
-                Duration::from_millis(100),
-            )
-            .await
-            .expect_err("remaining budget below backoff should be reserved for a final attempt");
-
-        assert_eq!(err, DiskError::Timeout);
-        assert_eq!(attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(started.elapsed(), Duration::from_millis(100));
-        assert_eq!(remote_disk.runtime_state(), RuntimeDriveHealthState::Suspect);
-        remote_disk.cancel_token.cancel();
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_zero_timeout_disables_the_deadline() {
-        let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let started = time::Instant::now();
-
-        remote_disk
-            .execute_read_with_retry(
-                "read_version",
-                || {
-                    let attempt = attempts.fetch_add(1, Ordering::SeqCst);
-                    async move {
-                        if attempt == 0 {
-                            return Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                std_io::ErrorKind::ConnectionReset,
-                                "connection reset",
-                            )));
-                        }
-                        Ok(())
-                    }
-                },
-                Duration::ZERO,
-            )
-            .await
-            .expect("zero timeout should allow a retry without a deadline");
-
-        assert_eq!(attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(started.elapsed(), REMOTE_DISK_READ_RETRY_BASE_BACKOFF);
-        remote_disk.cancel_token.cancel();
-    }
-
-    #[tokio::test]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_accepts_max_metadata_timeout() {
-        temp_env::async_with_vars([(rustfs_config::ENV_DRIVE_METADATA_TIMEOUT_SECS, Some(u64::MAX.to_string()))], async {
-            let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-
-            remote_disk
-                .execute_read_with_retry("read_version", || async { Ok::<(), Error>(()) }, get_drive_metadata_timeout())
-                .await
-                .expect("the maximum configured metadata timeout must not panic");
-
-            remote_disk.cancel_token.cancel();
-        })
-        .await;
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_zero_retries_runs_once() {
-        temp_env::async_with_vars([(rustfs_config::ENV_INTERNODE_IDEMPOTENT_READ_RETRIES, Some("0"))], async {
-            let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-            let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-            let started = time::Instant::now();
-            let channel = TonicEndpoint::from_shared(remote_disk.addr.clone())
-                .expect("remote disk address should parse")
-                .connect_lazy();
-            runtime_sources::cache_test_node_channel(remote_disk.addr.clone(), channel).await;
-
-            let err = remote_disk
-                .execute_read_with_retry(
-                    "read_version",
-                    || {
-                        attempts.fetch_add(1, Ordering::SeqCst);
-                        async {
-                            Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                std_io::ErrorKind::ConnectionReset,
-                                "connection reset",
-                            )))
-                        }
-                    },
-                    Duration::from_secs(1),
-                )
-                .await
-                .expect_err("zero retries should return the first network error");
-
-            assert!(matches!(err, DiskError::Io(ref io_err) if io_err.kind() == std_io::ErrorKind::ConnectionReset));
-            assert_eq!(attempts.load(Ordering::SeqCst), 1);
-            assert_eq!(started.elapsed(), Duration::ZERO);
-            assert_eq!(remote_disk.runtime_state(), RuntimeDriveHealthState::Suspect);
-            assert!(!runtime_sources::test_node_channel_is_cached(&remote_disk.addr).await);
-            remote_disk.cancel_token.cancel();
-        })
-        .await;
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_attempt_timeout_marks_health_without_evicting() {
-        let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-        let recorder = crate::test_metrics::CapturingRecorder::default();
-        let _recorder_guard = metrics::set_default_local_recorder(&recorder);
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let channel = TonicEndpoint::from_shared(remote_disk.addr.clone())
-            .expect("remote disk address should parse")
-            .connect_lazy();
-        runtime_sources::cache_test_node_channel(remote_disk.addr.clone(), channel).await;
-
-        let err = remote_disk
-            .execute_read_with_retry(
-                "read_version",
-                || {
-                    attempts.fetch_add(1, Ordering::SeqCst);
-                    std::future::pending::<Result<()>>()
-                },
-                Duration::from_millis(100),
-            )
-            .await
-            .expect_err("an in-flight attempt that consumes the deadline should time out");
-
-        assert_eq!(err, DiskError::Timeout);
-        assert_eq!(attempts.load(Ordering::SeqCst), 1);
-        assert_eq!(remote_disk.runtime_state(), RuntimeDriveHealthState::Suspect);
-        assert!(runtime_sources::test_node_channel_is_cached(&remote_disk.addr).await);
-        assert_eq!(
-            recorder.counter_value(
-                "rustfs_drive_op_timeout_total",
-                &[
-                    ("endpoint", remote_disk.endpoint.to_string().as_str()),
-                    ("op", "read_version")
-                ]
-            ),
-            1
-        );
-        remote_disk.cancel_token.cancel();
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_does_not_retry_business_errors() {
-        let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-
-        let err = remote_disk
-            .execute_read_with_retry(
-                "read_version",
-                || {
-                    attempts.fetch_add(1, Ordering::SeqCst);
-                    async { Err::<(), Error>(DiskError::FileNotFound) }
-                },
-                Duration::from_secs(1),
-            )
-            .await
-            .expect_err("business errors should be returned directly");
-
-        assert_eq!(err, DiskError::FileNotFound);
-        assert_eq!(attempts.load(Ordering::SeqCst), 1);
-        remote_disk.cancel_token.cancel();
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_honors_configured_retry_count() {
-        temp_env::async_with_vars([(rustfs_config::ENV_INTERNODE_IDEMPOTENT_READ_RETRIES, Some("2"))], async {
-            let remote_disk = new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await;
-            let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-            let started = time::Instant::now();
-            let channel = TonicEndpoint::from_shared(remote_disk.addr.clone())
-                .expect("remote disk address should parse")
-                .connect_lazy();
-            runtime_sources::cache_test_node_channel(remote_disk.addr.clone(), channel).await;
-
-            let err = remote_disk
-                .execute_read_with_retry(
-                    "read_version",
-                    || {
-                        attempts.fetch_add(1, Ordering::SeqCst);
-                        async {
-                            Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                std_io::ErrorKind::ConnectionReset,
-                                "connection reset",
-                            )))
-                        }
-                    },
-                    Duration::from_secs(1),
-                )
-                .await
-                .expect_err("exhausted retries should return the last network error");
-
-            assert!(matches!(err, DiskError::Io(ref io_err) if io_err.kind() == std_io::ErrorKind::ConnectionReset));
-            assert_eq!(attempts.load(Ordering::SeqCst), 3);
-            assert_eq!(started.elapsed(), Duration::from_millis(150));
-            assert_eq!(remote_disk.runtime_state(), RuntimeDriveHealthState::Suspect);
-            assert!(!runtime_sources::test_node_channel_is_cached(&remote_disk.addr).await);
-            remote_disk.cancel_token.cancel();
-        })
-        .await;
-    }
-
-    #[tokio::test(start_paused = true)]
-    #[serial(remote_disk_read_retry)]
-    async fn execute_read_with_retry_stops_when_disk_turns_offline_during_backoff() {
-        let remote_disk = Arc::new(new_remote_disk_with_transport(Arc::new(RecordingInternodeDataTransport::default())).await);
-        let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let first_attempt = Arc::new(tokio::sync::Notify::new());
-        let task_disk = Arc::clone(&remote_disk);
-        let task_attempts = Arc::clone(&attempts);
-        let task_first_attempt = Arc::clone(&first_attempt);
-
-        let task = tokio::spawn(async move {
-            task_disk
-                .execute_read_with_retry(
-                    "read_version",
-                    move || {
-                        let attempt = task_attempts.fetch_add(1, Ordering::SeqCst);
-                        let first_attempt = Arc::clone(&task_first_attempt);
-                        async move {
-                            if attempt == 0 {
-                                first_attempt.notify_one();
-                                return Err::<(), Error>(DiskError::Io(std_io::Error::new(
-                                    std_io::ErrorKind::ConnectionReset,
-                                    "connection reset",
-                                )));
-                            }
-                            Ok(())
-                        }
-                    },
-                    Duration::from_secs(1),
-                )
-                .await
-        });
-
-        first_attempt.notified().await;
-        tokio::task::yield_now().await;
-        remote_disk
-            .health
-            .force_runtime_state_for_test(RuntimeDriveHealthState::Offline);
-        time::advance(REMOTE_DISK_READ_RETRY_BASE_BACKOFF).await;
-        let err = task
-            .await
-            .expect("retry task should finish")
-            .expect_err("an offline disk must stop before the next attempt");
-
-        assert_eq!(err, DiskError::FaultyDisk);
-        assert_eq!(attempts.load(Ordering::SeqCst), 1);
-        remote_disk.cancel_token.cancel();
-    }
-
    #[tokio::test]
    async fn test_execute_with_timeout_evicts_cached_connection() {
        let addr = "http://127.0.0.1:59991".to_string();
@@ -6137,40 +5588,6 @@ mod tests {
        accept_task.abort();
    }

-    #[tokio::test]
-    async fn read_version_uses_the_metadata_timeout_on_a_stalled_peer() {
-        runtime_sources::ensure_test_rpc_secret();
-        let Some((base_addr, accept_task)) = spawn_stalled_grpc_peer().await else {
-            return;
-        };
-        let remote_disk = remote_disk_for_addr(&base_addr).await;
-
-        temp_env::async_with_vars(
-            [
-                (rustfs_config::ENV_DRIVE_METADATA_TIMEOUT_SECS, Some("1")),
-                (rustfs_config::ENV_DRIVE_MAX_TIMEOUT_DURATION, Some("10")),
-            ],
-            async {
-                let started = time::Instant::now();
-                let err = tokio::time::timeout(
-                    Duration::from_secs(5),
-                    remote_disk.read_version("bucket", "bucket", "object", "", &ReadOptions::default()),
-                )
-                .await
-                .expect("read_version must use the shorter metadata deadline")
-                .expect_err("a stalled peer must fail read_version");
-
-                assert!(matches!(err, DiskError::Timeout), "expected the metadata deadline to fire, got {err:?}");
-                assert!(started.elapsed() >= Duration::from_millis(900));
-                assert!(started.elapsed() < Duration::from_secs(2));
-            },
-        )
-        .await;
-
-        remote_disk.cancel_token.cancel();
-        accept_task.abort();
-    }
-
    #[tokio::test]
    async fn delete_volume_bounds_the_wait_on_a_stalled_peer() {
        runtime_sources::ensure_test_rpc_secret();
@@ -15,7 +15,7 @@
 use crate::cluster::rpc::client::{
    AuthenticatedChannel, TonicInterceptor, gen_tonic_signature_interceptor, node_service_time_out_client,
 };
-use crate::cluster::rpc::set_tonic_rolling_mutation_body_digest;
+use crate::cluster::rpc::set_tonic_mutation_body_digest;
 use async_trait::async_trait;
 use bytes::Bytes;
 use rustfs_lock::{
@@ -33,10 +33,6 @@ use tonic::Request;
 use tonic::service::interceptor::InterceptedService;
 use tracing::{debug, info, warn};

-fn attach_lock_mutation_body_digest<T: rustfs_protos::CanonicalMutationBody>(request: &mut Request<T>) -> std::io::Result<()> {
-    set_tonic_rolling_mutation_body_digest(request)
-}
-
 /// Remote lock client implementation
 #[derive(Debug, Clone)]
 pub struct RemoteClient {
@@ -323,7 +319,7 @@ impl LockClient for RemoteClient {
            args: serde_json::to_string(&request)
                .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
        });
-        attach_lock_mutation_body_digest(&mut req)?;
+        set_tonic_mutation_body_digest(&mut req)?;

        let resp = match self.execute_rpc("lock", &resource_summary, client.lock(req)).await {
            Ok(resp) => resp.into_inner(),
@@ -362,7 +358,7 @@ impl LockClient for RemoteClient {
                })
                .collect::<Result<Vec<_>>>()?,
        });
-        attach_lock_mutation_body_digest(&mut req)?;
+        set_tonic_mutation_body_digest(&mut req)?;

        let resp = match self
            .execute_rpc("lock_batch", &resource_summary, client.lock_batch(req))
@@ -404,7 +400,7 @@ impl LockClient for RemoteClient {
        let mut client = self.get_client().await?;
        let resource_summary = unlock_request.resource.to_string();
        let mut req = Request::new(GenerallyLockRequest { args: request_string });
-        attach_lock_mutation_body_digest(&mut req)?;
+        set_tonic_mutation_body_digest(&mut req)?;
        let resp = self
            .execute_rpc("release", &resource_summary, client.un_lock(req))
            .await?
@@ -431,7 +427,7 @@ impl LockClient for RemoteClient {
                })
                .collect::<Result<Vec<_>>>()?,
        });
-        attach_lock_mutation_body_digest(&mut req)?;
+        set_tonic_mutation_body_digest(&mut req)?;

        let resp = self
            .execute_rpc("release_batch", &resource_summary, client.un_lock_batch(req))
@@ -454,7 +450,7 @@ impl LockClient for RemoteClient {
            args: serde_json::to_string(&refresh_request)
                .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
        });
-        attach_lock_mutation_body_digest(&mut req)?;
+        set_tonic_mutation_body_digest(&mut req)?;
        let resp = self
            .execute_rpc("refresh", &resource_summary, client.refresh(req))
            .await?
@@ -474,7 +470,7 @@ impl LockClient for RemoteClient {
            args: serde_json::to_string(&force_request)
                .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
        });
-        attach_lock_mutation_body_digest(&mut req)?;
+        set_tonic_mutation_body_digest(&mut req)?;
        let resp = self
            .execute_rpc("force_release", &resource_summary, client.force_un_lock(req))
            .await?
@@ -499,7 +495,7 @@ impl LockClient for RemoteClient {
            args: serde_json::to_string(&status_request)
                .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
        });
-        attach_lock_mutation_body_digest(&mut req)?;
+        set_tonic_mutation_body_digest(&mut req)?;

        // Try exclusive lock first with very short timeout
        let resp = match self.execute_rpc("check_status", &resource_summary, client.lock(req)).await {
@@ -514,7 +510,7 @@ impl LockClient for RemoteClient {
                args: serde_json::to_string(&status_request)
                    .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
            });
-            attach_lock_mutation_body_digest(&mut release_req)?;
+            set_tonic_mutation_body_digest(&mut release_req)?;
            let _ = self
                .execute_rpc("check_status_release", &resource_summary, client.un_lock(release_req))
                .await;
@@ -630,31 +626,6 @@ mod tests {
            .with_priority(LockPriority::Normal)
    }

-    #[test]
-    fn lock_mutation_helper_marks_single_and_batch_requests_for_rolling_auth() {
-        let mut single = Request::new(GenerallyLockRequest {
-            args: "single-lock".to_string(),
-        });
-        attach_lock_mutation_body_digest(&mut single).expect("single lock digest must be attached");
-        assert!(
-            single
-                .extensions()
-                .get::<crate::cluster::rpc::http_auth::RollingMutationBodyDigest>()
-                .is_some()
-        );
-
-        let mut batch = Request::new(BatchGenerallyLockRequest {
-            args: vec!["batch-lock".to_string()],
-        });
-        attach_lock_mutation_body_digest(&mut batch).expect("batch lock digest must be attached");
-        assert!(
-            batch
-                .extensions()
-                .get::<crate::cluster::rpc::http_auth::RollingMutationBodyDigest>()
-                .is_some()
-        );
-    }
-
    #[tokio::test]
    #[serial_test::serial]
    async fn test_remote_client_acquire_lock_uses_rpc_timeout_and_evicts_connection() {
@@ -584,44 +584,6 @@ where
    .await
 }

-/// `delete_config` with `no_lock` set — for callers already holding the
-/// config object's namespace lock (e.g. inside `with_config_object_write_lock`),
-/// where the locked variant would self-deadlock.
-pub async fn delete_config_no_lock<S>(api: Arc<S>, file: &str) -> Result<()>
-where
-    S: ObjectOperations<
-            Error = Error,
-            ObjectInfo = ObjectInfo,
-            ObjectOptions = ObjectOptions,
-            FileInfo = FileInfo,
-            ObjectToDelete = ObjectToDelete,
-            DeletedObject = DeletedObject,
-        >,
-{
-    match api
-        .delete_object(
-            RUSTFS_META_BUCKET,
-            file,
-            ObjectOptions {
-                delete_prefix: true,
-                delete_prefix_object: true,
-                no_lock: true,
-                ..Default::default()
-            },
-        )
-        .await
-    {
-        Ok(_) => Ok(()),
-        Err(err) => {
-            if err == Error::FileNotFound || matches!(err, Error::ObjectNotFound(_, _)) {
-                Err(Error::ConfigNotFound)
-            } else {
-                Err(err)
-            }
-        }
-    }
-}
-
 #[instrument(skip(api))]
 pub async fn delete_config<S>(api: Arc<S>, file: &str) -> Result<()>
 where
@@ -101,7 +101,6 @@ const DEFAULT_RRS_STORAGE_CLASS: &str = "EC:1";
 const ZERO_SET_DRIVE_COUNT_ERROR: &str = "set drive count must be greater than zero";

 pub static DEFAULT_INLINE_BLOCK: usize = 128 * 1024;
-const DEFAULT_INLINE_OBJECT_BUDGET: usize = 2 * DEFAULT_INLINE_BLOCK;

 pub static DEFAULT_KVS: LazyLock<KVS> = LazyLock::new(|| {
    let kvs = vec![
@@ -151,8 +150,6 @@ pub struct Config {
    optimize: Option<String>,
    inline_block: usize,
    initialized: bool,
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    inline_block_explicit: bool,
    #[serde(skip)]
    standard_parities: Vec<PoolParity>,
    #[serde(skip)]
@@ -236,19 +233,17 @@ impl Config {
            .map(|(pool_index, pool)| (pool_index, pool.drives_per_set))
    }

-    pub fn should_inline(&self, shard_size: i64, data_shards: usize, versioned: bool) -> bool {
-        if shard_size < 0 || data_shards == 0 {
+    pub fn should_inline(&self, shard_size: i64, versioned: bool) -> bool {
+        if shard_size < 0 {
            return false;
        }

        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.
-        let inline_block = if self.initialized && self.inline_block_explicit {
-            self.inline_block
-        } else {
-            (DEFAULT_INLINE_OBJECT_BUDGET / data_shards).min(DEFAULT_INLINE_BLOCK)
-        };
+
+        let mut inline_block = DEFAULT_INLINE_BLOCK;
+        if self.initialized {
+            inline_block = self.inline_block;
+        }

        if versioned {
            shard_size <= inline_block / 8
@@ -397,7 +392,6 @@ fn lookup_config_for_pools_with_env(
    }

    let optimize = overrides.optimize;
-    let inline_block_explicit = overrides.inline_block.is_some();
    let inline_block = if let Some(value) = overrides.inline_block {
        let block = value
            .parse::<bytesize::ByteSize>()
@@ -430,7 +424,6 @@ fn lookup_config_for_pools_with_env(
        optimize,
        inline_block,
        initialized: true,
-        inline_block_explicit,
        standard_parities,
        rrs_parities,
    })
@@ -548,26 +541,22 @@ mod tests {
    }

    #[test]
-    fn should_inline_scales_default_threshold_by_data_shards() {
-        let config = lookup_config_for_pools_with_env(&KVS::new(), &[3, 12], no_env_overrides())
-            .expect("default inline policy should resolve for EC2+1 and EC8+4");
+    fn should_inline_preserves_exact_default_shard_boundaries() {
+        let config = Config::default();

-        for (case, shard_size, data_shards, versioned, expected) in [
-            ("EC2+1 unversioned exact", 128 * 1024, 2, false, true),
-            ("EC2+1 unversioned above", 128 * 1024 + 1, 2, false, false),
-            ("EC2+1 versioned exact", 16 * 1024, 2, true, true),
-            ("EC2+1 versioned above", 16 * 1024 + 1, 2, true, false),
-            ("EC8+4 unversioned exact", 32 * 1024, 8, false, true),
-            ("EC8+4 unversioned above", 32 * 1024 + 1, 8, false, false),
-            ("EC8+4 versioned exact", 4 * 1024, 8, true, true),
-            ("EC8+4 versioned above", 4 * 1024 + 1, 8, true, false),
-            ("negative", -1, 2, false, false),
-            ("zero data shards", 0, 0, false, false),
+        for (case, shard_size, versioned, expected) in [
+            ("unversioned below", 128 * 1024 - 1, false, true),
+            ("unversioned exact", 128 * 1024, false, true),
+            ("unversioned above", 128 * 1024 + 1, false, false),
+            ("versioned below", 16 * 1024 - 1, true, true),
+            ("versioned exact", 16 * 1024, true, true),
+            ("versioned above", 16 * 1024 + 1, true, false),
+            ("negative", -1, false, false),
        ] {
            assert_eq!(
-                config.should_inline(shard_size, data_shards, versioned),
+                config.should_inline(shard_size, versioned),
                expected,
-                "{case}: shard_size={shard_size}, data_shards={data_shards}, versioned={versioned}"
+                "{case}: shard_size={shard_size}, versioned={versioned}"
            );
        }
    }
@@ -588,28 +577,13 @@ mod tests {
            let shard_size = erasure.shard_file_size(object_size);
            assert_eq!(shard_size, expected_shard_size, "{case}: object_size={object_size}");
            assert_eq!(
-                config.should_inline(shard_size, erasure.data_shards, versioned),
+                config.should_inline(shard_size, versioned),
                expected,
                "{case}: object_size={object_size}, shard_size={shard_size}, versioned={versioned}"
            );
        }
    }

-    #[test]
-    fn explicit_inline_block_preserves_fixed_per_shard_rollback() {
-        let overrides = StorageClassEnvOverrides {
-            inline_block: Some("128KiB".to_string()),
-            ..Default::default()
-        };
-        let config = lookup_config_for_pools_with_env(&KVS::new(), &[12], overrides)
-            .expect("explicit inline block should resolve for EC8+4");
-
-        assert!(config.should_inline(128 * 1024, 8, false));
-        assert!(!config.should_inline(128 * 1024 + 1, 8, false));
-        assert!(config.should_inline(16 * 1024, 8, true));
-        assert!(!config.should_inline(16 * 1024 + 1, 8, true));
-    }
-
    #[test]
    fn write_capability_contract_only_accepts_implemented_layouts() {
        assert_eq!(SUPPORTED_WRITE_CLASSES, [STANDARD, RRS]);
@@ -803,7 +777,6 @@ mod tests {
        let encoded = serde_json::to_string(&cfg).expect("config should serialize");
        assert!(!encoded.contains("standard_parities"));
        assert!(!encoded.contains("rrs_parities"));
-        assert!(!encoded.contains("inline_block_explicit"));

        let decoded: Config = serde_json::from_str(&encoded).expect("legacy scalar config should deserialize");
        assert_eq!(decoded.get_parity_for_sc(STANDARD), Some(2));
@@ -813,25 +786,6 @@ mod tests {
        assert!(validate_parity(0, 0).is_err());
    }

-    #[test]
-    fn explicit_inline_block_survives_config_round_trip() {
-        let cfg = lookup_config_for_pools_with_env(
-            &KVS::new(),
-            &[12],
-            StorageClassEnvOverrides {
-                inline_block: Some("128KiB".to_string()),
-                ..Default::default()
-            },
-        )
-        .expect("explicit inline block should resolve");
-        assert!(cfg.should_inline(100 * 1024, 8, false));
-
-        let encoded = serde_json::to_string(&cfg).expect("config should serialize");
-        assert!(encoded.contains("\"inline_block_explicit\":true"));
-        let decoded: Config = serde_json::from_str(&encoded).expect("explicit inline config should deserialize");
-        assert!(decoded.should_inline(100 * 1024, 8, false));
-    }
-
    #[test]
    fn lookup_config_reads_rrs_from_class_rrs_key() {
        // Regression: kvs.get(RRS) used RRS="REDUCED_REDUNDANCY" instead of
@@ -2266,19 +2266,15 @@ fn decommission_delete_marker_opts(
    version: &rustfs_filemeta::FileInfo,
    version_id: Option<String>,
    src_pool_idx: usize,
-    expected_bucket_incarnation_id: Option<uuid::Uuid>,
 ) -> ObjectOptions {
-    let version_suspended = version.version_id.is_none() && version_id.is_none();
    ObjectOptions {
-        versioned: !version_suspended,
-        version_suspended,
-        version_id: version_id.or_else(|| version_suspended.then(|| uuid::Uuid::nil().to_string())),
+        versioned: true,
+        version_id,
        mod_time: version.mod_time,
        src_pool_idx,
        data_movement: true,
        delete_marker: true,
        skip_decommissioned: true,
-        expected_bucket_incarnation_id,
        delete_replication: version
            .replication_state_internal
            .as_ref()
@@ -2303,7 +2299,6 @@ fn decommission_remote_tiered_opts(
    version: &rustfs_filemeta::FileInfo,
    version_id: Option<String>,
    src_pool_idx: usize,
-    expected_bucket_incarnation_id: Option<uuid::Uuid>,
 ) -> ObjectOptions {
    ObjectOptions {
        versioned: version_id.is_some(),
@@ -2312,9 +2307,6 @@ fn decommission_remote_tiered_opts(
        user_defined: version.metadata.clone(),
        src_pool_idx,
        data_movement: true,
-        include_part_checksums: true,
-        http_preconditions: Some(crate::data_movement::data_movement_target_precondition()),
-        expected_bucket_incarnation_id,
        ..Default::default()
    }
 }
@@ -2813,7 +2805,6 @@ impl ECStore {
        lifecycle_config: Option<BucketLifecycleConfiguration>,
        object_lock_config: Option<ObjectLockConfiguration>,
        replication_config: Option<(ReplicationConfiguration, OffsetDateTime)>,
-        expected_bucket_incarnation_id: Option<uuid::Uuid>,
    ) -> Result<()> {
        debug!(
            event = EVENT_DECOMMISSION_ENTRY,
@@ -2843,11 +2834,6 @@ impl ECStore {
        }
        decommission_cancel_signal_result(rx.is_cancelled())?;

-        let bucket_incarnation_fence = match expected_bucket_incarnation_id {
-            Some(expected) => Some(self.acquire_bucket_incarnation_fence(&bucket, expected).await?),
-            None => None,
-        };
-
        let mut fivs = load_decommission_entry_exact_versions(&set, &entry, &bucket, "file_info_versions").await?;

        fivs.versions
@@ -2908,7 +2894,7 @@ impl ECStore {
                    .delete_object(
                        bucket.as_str(),
                        &version.name,
-                        decommission_delete_marker_opts(version, version_id.clone(), idx, expected_bucket_incarnation_id),
+                        decommission_delete_marker_opts(version, version_id.clone(), idx),
                    )
                    .await
                {
@@ -2998,7 +2984,7 @@ impl ECStore {
                            bucket.as_str(),
                            &version.name,
                            version,
-                            &decommission_remote_tiered_opts(version, version_id.clone(), idx, expected_bucket_incarnation_id),
+                            &decommission_remote_tiered_opts(version, version_id.clone(), idx),
                        )
                        .await
                    {
@@ -3070,11 +3056,7 @@ impl ECStore {
                )
                .await?;

-                if let Err(err) = self
-                    .clone()
-                    .decommission_object(idx, bucket, rd, expected_bucket_incarnation_id)
-                    .await
-                {
+                if let Err(err) = self.clone().decommission_object(idx, bucket, rd).await {
                    if is_decommission_copy_cleanup_safe_error(&err) {
                        ignore = true;
                        cleanup_ignored = true;
@@ -3151,9 +3133,6 @@ impl ECStore {
        }

        if should_cleanup_decommission_source_entry(decommissioned, fivs.versions.len(), expired) {
-            if bucket_incarnation_fence.as_ref().is_some_and(|guard| guard.is_lock_lost()) {
-                return Err(Error::other("decommission bucket incarnation fence was lost before source cleanup"));
-            }
            decommission_cancel_signal_result(rx.is_cancelled())?;

            self.save_decommission_entry_progress_stage(
@@ -3178,12 +3157,6 @@ impl ECStore {
                entry.name.as_str(),
                &fivs,
                &cleanup_preflight_allowed_missing,
-                data_movement::SourceCleanupBucketFence {
-                    expected_incarnation_id: expected_bucket_incarnation_id,
-                    lifecycle_guard: bucket_incarnation_fence
-                        .as_ref()
-                        .and_then(|guard| guard.namespace_lock_guard()),
-                },
                "decommission",
            )
            .await
@@ -3295,11 +3268,6 @@ impl ECStore {
        let mut lifecycle_config = None;
        let mut object_lock_config = None;
        let mut replication_config = None;
-        let expected_bucket_incarnation_id = if bi.name == RUSTFS_META_BUCKET {
-            None
-        } else {
-            Some(self.bucket_incarnation_id_from_disk(&bi.name).await?)
-        };

        if bi.name != RUSTFS_META_BUCKET {
            let _ = resolve_decommission_optional_bucket_config_result(
@@ -3353,7 +3321,6 @@ impl ECStore {
                    let lifecycle_config = lifecycle_config.clone();
                    let object_lock_config = object_lock_config.clone();
                    let replication_config = replication_config.clone();
-                    let expected_bucket_incarnation_id = expected_bucket_incarnation_id;
                    let entry_error = entry_error.clone();
                    let callback_rx = callback_rx.clone();

@@ -3416,7 +3383,6 @@ impl ECStore {
                                lifecycle_config,
                                object_lock_config,
                                replication_config,
-                                expected_bucket_incarnation_id,
                            )
                            .await
                        {
@@ -4202,24 +4168,10 @@ impl ECStore {
    }

    #[tracing::instrument(skip(self, rd))]
-    async fn decommission_object(
-        self: Arc<Self>,
-        pool_idx: usize,
-        bucket: String,
-        rd: GetObjectReader,
-        expected_bucket_incarnation_id: Option<uuid::Uuid>,
-    ) -> Result<()> {
+    async fn decommission_object(self: Arc<Self>, pool_idx: usize, bucket: String, rd: GetObjectReader) -> Result<()> {
        warn!("decommission_object: start {} {}", &bucket, &rd.object_info.name);
        let object_name = rd.object_info.name.clone();
-        let result = data_movement::migrate_object(
-            self,
-            pool_idx,
-            bucket.clone(),
-            rd,
-            expected_bucket_incarnation_id,
-            "decommission_object",
-        )
-        .await;
+        let result = data_movement::migrate_object(self, pool_idx, bucket.clone(), rd, "decommission_object").await;
        if result.is_ok() {
            warn!("decommission_object: migrated {} {}", &bucket, &object_name);
        }
@@ -4395,8 +4347,7 @@ mod tests {
            ..Default::default()
        };

-        let incarnation = uuid::Uuid::new_v4();
-        let opts = decommission_delete_marker_opts(&version, Some("version-id".to_string()), 7, Some(incarnation));
+        let opts = decommission_delete_marker_opts(&version, Some("version-id".to_string()), 7);
        let replication = opts.delete_replication.expect("replication state should be preserved");

        assert!(opts.versioned);
@@ -4406,25 +4357,11 @@ mod tests {
        assert_eq!(opts.src_pool_idx, 7);
        assert_eq!(opts.version_id.as_deref(), Some("version-id"));
        assert_eq!(opts.mod_time, Some(mod_time));
-        assert_eq!(opts.expected_bucket_incarnation_id, Some(incarnation));
        assert_eq!(replication.replica_status, ReplicationStatusType::Replica);
        assert!(replication.delete_marker);
        assert_eq!(replication.replicate_decision_str, "existing");
    }

-    #[test]
-    fn decommission_delete_marker_opts_preserves_suspended_null_version() {
-        let version = rustfs_filemeta::FileInfo {
-            deleted: true,
-            ..Default::default()
-        };
-        let opts = decommission_delete_marker_opts(&version, None, 7, None);
-
-        assert!(!opts.versioned);
-        assert!(opts.version_suspended);
-        assert_eq!(opts.version_id.as_deref(), Some(uuid::Uuid::nil().to_string().as_str()));
-    }
-
    #[test]
    fn test_decommission_object_migration_read_opts_are_raw_data_movement() {
        let opts = decommission_object_migration_read_opts(Some("vid-1".to_string()));
@@ -4446,8 +4383,7 @@ mod tests {
            ..Default::default()
        };

-        let incarnation = uuid::Uuid::new_v4();
-        let opts = decommission_remote_tiered_opts(&version, Some("version-id".to_string()), 9, Some(incarnation));
+        let opts = decommission_remote_tiered_opts(&version, Some("version-id".to_string()), 9);

        assert!(opts.versioned);
        assert!(opts.data_movement);
@@ -4455,9 +4391,6 @@ mod tests {
        assert_eq!(opts.version_id.as_deref(), Some("version-id"));
        assert_eq!(opts.mod_time, Some(mod_time));
        assert_eq!(opts.user_defined.get("x-amz-meta-key").map(String::as_str), Some("value"));
-        assert!(opts.include_part_checksums);
-        assert!(opts.http_preconditions.is_some());
-        assert_eq!(opts.expected_bucket_incarnation_id, Some(incarnation));
    }

    #[test]
@@ -59,6 +59,7 @@ use std::{
 use tokio::sync::RwLock;
 use tokio::sync::broadcast::{Receiver, Sender};
 use tokio::time::Duration;
+use tokio_util::sync::CancellationToken;
 use tracing::warn;
 use tracing::{error, info};
 use uuid::Uuid;
@@ -755,6 +756,67 @@ impl crate::storage_api_contracts::object::ObjectOperations for Sets {
    }
 }

+#[async_trait::async_trait]
+impl crate::storage_api_contracts::list::ListOperations for Sets {
+    type Error = Error;
+    type ListObjectsV2Info = ListObjectsV2Info;
+    type ListObjectVersionsInfo = ListObjectVersionsInfo;
+    type ObjectInfoOrErr = ObjectInfoOrErr;
+    type WalkOptions = WalkOptions;
+    type WalkCancellation = CancellationToken;
+    type WalkResultSender = tokio::sync::mpsc::Sender<ObjectInfoOrErr>;
+
+    #[tracing::instrument(level = "trace", skip(self))]
+    async fn list_objects_v2(
+        self: Arc<Self>,
+        bucket: &str,
+        prefix: &str,
+        continuation_token: Option<String>,
+        delimiter: Option<String>,
+        max_keys: i32,
+        fetch_owner: bool,
+        start_after: Option<String>,
+        incl_deleted: bool,
+    ) -> Result<ListObjectsV2Info> {
+        self.inner_list_objects_v2(
+            bucket,
+            prefix,
+            continuation_token,
+            delimiter,
+            max_keys,
+            fetch_owner,
+            start_after,
+            incl_deleted,
+        )
+        .await
+    }
+
+    #[tracing::instrument(skip(self))]
+    async fn list_object_versions(
+        self: Arc<Self>,
+        bucket: &str,
+        prefix: &str,
+        marker: Option<String>,
+        version_marker: Option<String>,
+        delimiter: Option<String>,
+        max_keys: i32,
+    ) -> Result<ListObjectVersionsInfo> {
+        self.inner_list_object_versions(bucket, prefix, marker, version_marker, delimiter, max_keys)
+            .await
+    }
+
+    async fn walk(
+        self: Arc<Self>,
+        rx: CancellationToken,
+        bucket: &str,
+        prefix: &str,
+        result: tokio::sync::mpsc::Sender<ObjectInfoOrErr>,
+        opts: WalkOptions,
+    ) -> Result<()> {
+        self.walk_internal(rx, bucket, prefix, result, opts).await
+    }
+}
+
 #[async_trait::async_trait]
 impl crate::storage_api_contracts::multipart::MultipartOperations for Sets {
    type Error = Error;
@@ -1841,7 +1903,7 @@ mod tests {

    #[tokio::test(flavor = "multi_thread")]
    #[serial]
-    async fn set_level_list_objects_v2_lists_objects_written_through_the_pool() {
+    async fn sets_list_objects_v2_lists_objects_within_the_pool() {
        let _setup_type_guard = SetupTypeGuard::switch_to(SetupType::Erasure).await;
        let format = FormatV3::new(1, 2);
        let mut endpoints = Vec::new();
@@ -1923,16 +1985,11 @@ mod tests {
            .await
            .expect("object should be written");

-        // Listing asserts against the set-level pipeline: the pool-level
-        // ListOperations impl for `Sets` was a pure forwarder over a duplicate
-        // pagination block that production never reached, and both were removed
-        // (backlog#1821). Writes still go through the pool, so this keeps
-        // covering the write-then-list round trip end to end.
-        let result = sets.disk_set[0]
+        let result = sets
            .clone()
            .list_objects_v2(&bucket, "", None, None, 1000, false, None, false)
            .await
-            .expect("set-level listing should succeed");
+            .expect("pool-level listing should succeed");

        assert_eq!(result.objects.len(), 1);
        assert_eq!(result.objects[0].name, object);
@@ -1638,7 +1638,7 @@ fn preserve_unknown_dirty_usage(
    Some(preserved)
 }

-#[cfg(any(test, feature = "test-util"))]
+#[cfg(test)]
 async fn replace_bucket_usage_memory_from_authoritative(bucket: &str, usage: BucketUsageInfo, refresh_started_at: SystemTime) {
    let mut cache = memory_cache().write().await;
    if let Some(existing) = cache.get(bucket)
@@ -1650,19 +1650,6 @@ async fn replace_bucket_usage_memory_from_authoritative(bucket: &str, usage: Buc
    cache.insert(bucket.to_string(), cached_bucket_usage_from_backend(usage, refresh_started_at, true));
 }

-#[cfg(feature = "test-util")]
-pub async fn seed_bucket_usage_memory_for_test(bucket: &str, size: u64) {
-    replace_bucket_usage_memory_from_authoritative(
-        bucket,
-        BucketUsageInfo {
-            size,
-            ..Default::default()
-        },
-        SystemTime::now(),
-    )
-    .await;
-}
-
 /// Fast in-memory update for immediate quota and admin usage consistency.
 pub async fn record_bucket_object_write_memory(bucket: &str, previous_current_size: Option<u64>, new_size: u64) {
    record_bucket_object_write_memory_inner(bucket, previous_current_size, new_size, false).await;
@@ -2150,6 +2137,30 @@ pub async fn load_data_usage_cache(store: &crate::set_disk::SetDisks, name: &str
    Ok(d)
 }

+#[instrument(skip(cache))]
+pub async fn save_data_usage_cache(cache: &DataUsageCache, name: &str) -> crate::error::Result<()> {
+    use crate::config::com::save_config;
+    use crate::disk::BUCKET_META_PREFIX;
+    use std::path::Path;
+
+    let Some(store) = runtime_sources::object_store_handle() else {
+        return Err(Error::other("errServerNotInitialized"));
+    };
+    let buf = cache.marshal_msg().map_err(Error::other)?;
+    let buf_clone = buf.clone();
+
+    let store_clone = store.clone();
+
+    let name = Path::new(BUCKET_META_PREFIX).join(name).to_string_lossy().to_string();
+
+    let name_clone = name.clone();
+    tokio::spawn(async move {
+        let _ = save_config(store_clone, &format!("{}{}", name_clone, ".bkp"), buf_clone).await;
+    });
+    save_config(store, &name, buf).await?;
+    Ok(())
+}
+
 /// Persist the current in-memory compression total to the backend.
 /// Resets the debounce counter so the next auto-persist won't fire
 /// immediately after this manual flush (intended for shutdown paths).
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use crate::cluster::rpc::{
-    ScannerBucketListing, TonicInterceptor, gen_tonic_signature_interceptor, node_service_time_out_client,
-};
+use crate::cluster::rpc::{TonicInterceptor, gen_tonic_signature_interceptor, node_service_time_out_client};
 use crate::data_usage::{DATA_USAGE_CACHE_NAME, DATA_USAGE_ROOT, load_data_usage_from_backend_cached};
 use crate::error::{Error, Result};
 use crate::{
@@ -25,7 +23,6 @@ use crate::{

 use crate::data_usage::load_data_usage_cache;
 use crate::storage_api_contracts::admin::StorageAdminApi;
-use crate::storage_api_contracts::bucket::BucketOptions;
 use rustfs_common::heal_channel::DriveState;
 use rustfs_madmin::{
    BackendDisks, Disk, ErasureSetInfo, ITEM_INITIALIZING, ITEM_OFFLINE, ITEM_ONLINE, ITEM_UNKNOWN, InfoMessage, MemStats,
@@ -77,19 +74,6 @@ fn apply_data_usage_result(
    }
 }

-fn apply_bucket_namespace_count(result: Result<ScannerBucketListing>, buckets: &mut rustfs_madmin::Buckets) {
-    if let Ok(listing) = result
-        && listing.topology_complete
-    {
-        let count = listing.buckets.iter().filter(|bucket| !bucket.name.starts_with('.')).count();
-        let Ok(count) = u64::try_from(count) else {
-            return;
-        };
-        buckets.count = count;
-        buckets.error = None;
-    }
-}
-
 // pub const ITEM_OFFLINE: &str = "offline";
 // pub const ITEM_INITIALIZING: &str = "initializing";
 // pub const ITEM_ONLINE: &str = "online";
@@ -301,18 +285,6 @@ pub async fn get_server_info(get_pools: bool) -> InfoMessage {
            &mut delete_markers,
            &mut usage,
        );
-        if buckets.error.is_some() {
-            apply_bucket_namespace_count(
-                store
-                    .list_bucket_for_scanner(&BucketOptions {
-                        cached: true,
-                        no_metadata: true,
-                        ..Default::default()
-                    })
-                    .await,
-                &mut buckets,
-            );
-        }

        let after3 = OffsetDateTime::now_utc();

@@ -733,13 +705,12 @@ mod tests {
        endpoints::{EndpointServerPools, Endpoints, PoolEndpoints},
    };
    use crate::runtime::sources as runtime_sources;
-    use crate::storage_api_contracts::bucket::BucketInfo;
    use rustfs_madmin::{Disk, ITEM_OFFLINE, ITEM_ONLINE, ITEM_UNKNOWN, ServerProperties};

    use super::{
-        DATA_USAGE_ROOT, DATA_USAGE_UNAVAILABLE_ERROR, apply_bucket_namespace_count, apply_data_usage_result,
-        apply_erasure_set_usage, get_local_server_property, get_online_offline_disks_stats, get_server_info,
-        reconcile_servers_with_endpoint_topology, server_topology_completeness_report,
+        DATA_USAGE_ROOT, DATA_USAGE_UNAVAILABLE_ERROR, apply_data_usage_result, apply_erasure_set_usage,
+        get_local_server_property, get_online_offline_disks_stats, get_server_info, reconcile_servers_with_endpoint_topology,
+        server_topology_completeness_report,
    };

    fn disk_with_state(endpoint: &str, state: &str) -> Disk {
@@ -989,75 +960,6 @@ mod tests {
        assert_eq!(usage.error.as_deref(), Some(DATA_USAGE_UNAVAILABLE_ERROR));
    }

-    #[test]
-    fn live_bucket_namespace_count_survives_unavailable_data_usage() {
-        let mut buckets = rustfs_madmin::Buckets {
-            count: 0,
-            error: Some(DATA_USAGE_UNAVAILABLE_ERROR.to_string()),
-        };
-
-        apply_bucket_namespace_count(
-            Ok(crate::cluster::rpc::ScannerBucketListing {
-                buckets: vec![
-                    BucketInfo {
-                        name: "bucket-a".to_string(),
-                        ..Default::default()
-                    },
-                    BucketInfo {
-                        name: ".rustfs.sys".to_string(),
-                        ..Default::default()
-                    },
-                    BucketInfo {
-                        name: "bucket-b".to_string(),
-                        ..Default::default()
-                    },
-                ],
-                set_buckets: Vec::new(),
-                topology_complete: true,
-            }),
-            &mut buckets,
-        );
-
-        assert_eq!(buckets.count, 2);
-        assert_eq!(buckets.error, None);
-    }
-
-    #[test]
-    fn incomplete_bucket_namespace_lookup_preserves_usage_state() {
-        let mut buckets = rustfs_madmin::Buckets {
-            count: 7,
-            error: Some(DATA_USAGE_UNAVAILABLE_ERROR.to_string()),
-        };
-
-        apply_bucket_namespace_count(
-            Ok(crate::cluster::rpc::ScannerBucketListing {
-                buckets: vec![BucketInfo {
-                    name: "bucket-a".to_string(),
-                    ..Default::default()
-                }],
-                set_buckets: Vec::new(),
-                topology_complete: false,
-            }),
-            &mut buckets,
-        );
-
-        assert_eq!(buckets.count, 7);
-        assert_eq!(buckets.error.as_deref(), Some(DATA_USAGE_UNAVAILABLE_ERROR));
-    }
-
-    #[test]
-    fn failed_bucket_namespace_lookup_preserves_usage_state() {
-        let mut buckets = rustfs_madmin::Buckets {
-            count: 7,
-            error: Some(DATA_USAGE_UNAVAILABLE_ERROR.to_string()),
-        };
-
-        apply_bucket_namespace_count(Err(crate::error::Error::DiskNotFound), &mut buckets);
-
-        assert_eq!(buckets.count, 7);
-        assert_eq!(buckets.error.as_deref(), Some(DATA_USAGE_UNAVAILABLE_ERROR));
-    }
-
    #[test]
    fn incomplete_erasure_set_cache_is_not_reported_as_zero() {
        let mut cache = rustfs_data_usage::DataUsageCache::default();
@@ -84,10 +84,6 @@ pub(crate) const GET_STAGE_READER_STREAM_FIRST_READ: &str = "reader_stream_first
 pub(crate) const GET_STAGE_READER_TASK_BITROT_READER_INIT: &str = "reader_task_bitrot_reader_init";
 pub(crate) const GET_STAGE_READER_TASK_FILE_OPEN: &str = "reader_task_file_open";
 pub(crate) const GET_STAGE_READER_TASK_READER_CONSTRUCTION: &str = "reader_task_reader_construction";
-pub(crate) const GET_STAGE_READ_VERSION_DECODE: &str = "read_version_decode";
-pub(crate) const GET_STAGE_READ_VERSION_PATH_CHECK: &str = "read_version_path_check";
-pub(crate) const GET_STAGE_READ_VERSION_PATH_RESOLVE: &str = "read_version_path_resolve";
-pub(crate) const GET_STAGE_READ_VERSION_XLMETA_READ: &str = "read_version_xlmeta_read";
 pub(crate) const GET_STAGE_RECONSTRUCT: &str = "reconstruct";
 pub(crate) const GET_STAGE_RESPONSE_HANDOFF: &str = "response_handoff";
 pub(crate) const GET_STAGE_SLOWEST_METADATA_RESPONSE: &str = "slowest_metadata_response";
@@ -141,7 +137,6 @@ pub(crate) const GET_METADATA_CACHE_REASON_NO_LOCK: &str = "no_lock";
 pub(crate) const GET_METADATA_CACHE_REASON_NOT_FOUND_OR_EXPIRED: &str = "not_found_or_expired";
 pub(crate) const GET_METADATA_CACHE_REASON_NOT_READ_DATA: &str = "not_read_data";
 pub(crate) const GET_METADATA_CACHE_REASON_PART_NUMBER: &str = "part_number";
-pub(crate) const GET_METADATA_CACHE_REASON_PART_CHECKSUMS: &str = "part_checksums";
 pub(crate) const GET_METADATA_CACHE_REASON_RAW_DATA_MOVEMENT_READ: &str = "raw_data_movement_read";
 pub(crate) const GET_METADATA_CACHE_REASON_STALE_PUBLICATION: &str = "stale_publication";
 pub(crate) const GET_METADATA_CACHE_REASON_USABLE: &str = "usable";
@@ -446,10 +441,6 @@ mod tests {
        assert_eq!(GET_STAGE_QUORUM_REACHED, "quorum_reached");
        assert_eq!(GET_STAGE_RANGE, "range");
        assert_eq!(GET_STAGE_READER_SETUP, "reader_setup");
-        assert_eq!(GET_STAGE_READ_VERSION_DECODE, "read_version_decode");
-        assert_eq!(GET_STAGE_READ_VERSION_PATH_CHECK, "read_version_path_check");
-        assert_eq!(GET_STAGE_READ_VERSION_PATH_RESOLVE, "read_version_path_resolve");
-        assert_eq!(GET_STAGE_READ_VERSION_XLMETA_READ, "read_version_xlmeta_read");
        assert_eq!(GET_STAGE_RECONSTRUCT, "reconstruct");
        assert_eq!(GET_STAGE_RESPONSE_HANDOFF, "response_handoff");
        assert_eq!(GET_STAGE_SLOWEST_METADATA_RESPONSE, "slowest_metadata_response");
@@ -489,7 +480,6 @@ mod tests {
        assert_eq!(GET_METADATA_CACHE_REASON_NO_LOCK, "no_lock");
        assert_eq!(GET_METADATA_CACHE_REASON_NOT_FOUND_OR_EXPIRED, "not_found_or_expired");
        assert_eq!(GET_METADATA_CACHE_REASON_NOT_READ_DATA, "not_read_data");
-        assert_eq!(GET_METADATA_CACHE_REASON_PART_CHECKSUMS, "part_checksums");
        assert_eq!(GET_METADATA_CACHE_REASON_PART_NUMBER, "part_number");
        assert_eq!(GET_METADATA_CACHE_REASON_RAW_DATA_MOVEMENT_READ, "raw_data_movement_read");
        assert_eq!(GET_METADATA_CACHE_REASON_STALE_PUBLICATION, "stale_publication");
@@ -2022,21 +2022,6 @@ impl DiskAPI for LocalDiskWrapper {
        .await
    }

-    async fn read_file_stream_chunks(
-        &self,
-        volume: &str,
-        path: &str,
-        offset: usize,
-        length: usize,
-    ) -> Result<Option<rustfs_rio::ChunkReaderBox>> {
-        self.track_disk_health_with_op(
-            "read_file_stream_chunks",
-            || async { self.disk.read_file_stream_chunks(volume, path, offset, length).await },
-            get_max_timeout_duration(),
-        )
-        .await
-    }
-
    async fn read_file_mmap_copy(&self, volume: &str, path: &str, offset: usize, length: usize) -> Result<bytes::Bytes> {
        self.track_disk_health_with_op(
            "read_file_mmap_copy",
@@ -113,9 +113,6 @@ pub enum DiskError {
    #[error("bit-rot hash algorithm is invalid")]
    BitrotHashAlgoInvalid,

-    /// Never constructed locally by RustFS (only reachable through wire
-    /// decoding, and no current node sends it). The wire code is kept for
-    /// cross-version compatibility — do not renumber or remove (backlog#1831).
    #[error("Rename across devices not allowed, please fix your backend configuration")]
    CrossDeviceLink,

@@ -146,9 +143,6 @@ pub enum DiskError {
    #[error("io error {0}")]
    Io(#[source] io::Error),

-    /// Never constructed locally by RustFS (only reachable through wire
-    /// decoding, and no current node sends it). The wire code is kept for
-    /// cross-version compatibility — do not renumber or remove (backlog#1831).
    #[error("source stalled")]
    SourceStalled,

@@ -337,14 +331,7 @@ impl From<std::io::Error> for DiskError {
        }
        match e.downcast::<DiskError>() {
            Ok(disk_error) => disk_error,
-            // Mirror `From<io::Error> for StorageError`: a StorageError boxed
-            // through `From<StorageError> for io::Error` must recover its typed
-            // classification instead of degrading to `DiskError::Io`, which
-            // quorum aggregation (`reduce_errs`) would count as a distinct error.
-            Err(io_error) => match io_error.downcast::<crate::error::StorageError>() {
-                Ok(storage_error) => storage_error.into(),
-                Err(io_error) => DiskError::Io(io_error),
-            },
+            Err(io_error) => DiskError::Io(io_error),
        }
    }
 }
@@ -648,6 +635,19 @@ impl Hash for DiskError {
 // is currently commented out to avoid complexity. These can be re-enabled
 // when needed for specific disk quorum checking and error aggregation logic.

+/// Bitrot errors
+#[derive(Debug, thiserror::Error)]
+pub enum BitrotErrorType {
+    #[error("bitrot checksum verification failed")]
+    BitrotChecksumMismatch { expected: String, got: String },
+}
+
+impl From<BitrotErrorType> for DiskError {
+    fn from(e: BitrotErrorType) -> Self {
+        DiskError::other(e)
+    }
+}
+
 /// Context wrapper for file access errors
 #[derive(Debug, thiserror::Error)]
 pub struct FileAccessDeniedWithContext {
@@ -862,6 +862,19 @@ mod tests {
        let _disk_error: DiskError = json_error.into();
    }

+    #[test]
+    fn test_bitrot_error_type() {
+        let bitrot_error = BitrotErrorType::BitrotChecksumMismatch {
+            expected: "abc123".to_string(),
+            got: "def456".to_string(),
+        };
+
+        assert!(bitrot_error.to_string().contains("bitrot checksum verification failed"));
+
+        let disk_error: DiskError = bitrot_error.into();
+        assert!(matches!(disk_error, DiskError::Io(_)));
+    }
+
    #[test]
    fn test_file_access_denied_with_context() {
        let path = PathBuf::from("/test/path");
@@ -940,27 +953,6 @@ mod tests {
        assert_eq!(original_disk_error, recovered_disk_error);
    }

-    #[test]
-    fn test_io_error_with_storage_error_inside() {
-        use crate::error::StorageError;
-
-        // An io::Error boxing a disk-representable StorageError (as produced by
-        // `From<StorageError> for io::Error`) must recover the typed DiskError
-        // variant instead of degrading to an opaque DiskError::Io.
-        let io_with_storage_error: std::io::Error = StorageError::FaultyRemoteDisk.into();
-        let recovered: DiskError = io_with_storage_error.into();
-        assert_eq!(recovered, DiskError::FaultyRemoteDisk);
-
-        let io_with_storage_error: std::io::Error = StorageError::FileAccessDenied.into();
-        let recovered: DiskError = io_with_storage_error.into();
-        assert_eq!(recovered, DiskError::FileAccessDenied);
-
-        // A StorageError with no DiskError analog stays an opaque Io error.
-        let io_with_bucket_error: std::io::Error = StorageError::BucketNotFound("bucket".to_string()).into();
-        let recovered: DiskError = io_with_bucket_error.into();
-        assert!(matches!(recovered, DiskError::Io(_)));
-    }
-
    #[test]
    fn test_io_error_different_kinds() {
        use std::io::ErrorKind;
@@ -65,7 +65,6 @@ use error::{Error, Result};
 use local::LocalDisk;
 use rustfs_filemeta::{FileInfo, ObjectPartInfo, RawFileInfo};
 use rustfs_madmin::info_commands::DiskMetrics;
-use rustfs_rio::ChunkReaderBox;
 use serde::{Deserialize, Serialize};
 use std::{fmt::Debug, path::PathBuf, sync::Arc, time::Duration};
 use time::OffsetDateTime;
@@ -428,19 +427,6 @@ impl DiskAPI for Disk {
        }
    }

-    async fn read_file_stream_chunks(
-        &self,
-        volume: &str,
-        path: &str,
-        offset: usize,
-        length: usize,
-    ) -> Result<Option<ChunkReaderBox>> {
-        match self {
-            Disk::Local(_) => Ok(None),
-            Disk::Remote(remote_disk) => remote_disk.read_file_stream_chunks(volume, path, offset, length).await,
-        }
-    }
-
    #[tracing::instrument(level = "trace", skip_all)]
    async fn read_file_mmap_copy(&self, volume: &str, path: &str, offset: usize, length: usize) -> Result<Bytes> {
        match self {
@@ -879,18 +865,6 @@ pub trait DiskAPI: Debug + Send + Sync + 'static {
    async fn read_file(&self, volume: &str, path: &str) -> Result<FileReader>;
    async fn read_file_stream(&self, volume: &str, path: &str, offset: usize, length: usize) -> Result<FileReader>;

-    /// Returns an owned-chunk stream when the backing transport can preserve
-    /// receive-buffer ownership. `None` retains the ordinary reader path.
-    async fn read_file_stream_chunks(
-        &self,
-        _volume: &str,
-        _path: &str,
-        _offset: usize,
-        _length: usize,
-    ) -> Result<Option<ChunkReaderBox>> {
-        Ok(None)
-    }
-
    /// File read using mmap-then-copy on Unix or an efficient read on non-Unix.
    async fn read_file_mmap_copy(&self, volume: &str, path: &str, offset: usize, length: usize) -> Result<Bytes>;

@@ -1277,7 +1251,7 @@ pub struct VolumeInfo {
    pub created: Option<OffsetDateTime>,
 }

-#[derive(Deserialize, Serialize, Debug, Default, Clone, Copy)]
+#[derive(Deserialize, Serialize, Debug, Default, Clone)]
 pub struct ReadOptions {
    pub incl_free_versions: bool,
    pub read_data: bool,
@@ -78,59 +78,28 @@ pub fn check_path_length(path_name: &str) -> Result<()> {
 /// their own unique tempdir to stay robust against parallel test execution.
 #[cfg(test)]
 pub(crate) mod fsync_dir_recorder {
-    use std::collections::HashMap;
    use std::path::{Path, PathBuf};
    use std::sync::Mutex;

-    type Hook = Box<dyn FnOnce() + Send>;
-
    static RECORDED: Mutex<Vec<PathBuf>> = Mutex::new(Vec::new());
-    static LIMITED: Mutex<Vec<PathBuf>> = Mutex::new(Vec::new());
-    static BEFORE_LIMITED: std::sync::LazyLock<Mutex<HashMap<PathBuf, Hook>>> =
-        std::sync::LazyLock::new(|| Mutex::new(HashMap::new()));
-
-    fn record_path(paths: &Mutex<Vec<PathBuf>>, path: &Path, description: &str) {
-        let mut paths = paths.lock().expect(description);
-        paths.push(path.to_path_buf());
-        if let Ok(canonical) = path.canonicalize()
-            && canonical != path
-        {
-            paths.push(canonical);
-        }
-    }
-
-    fn contains_path(paths: &[PathBuf], path: &Path) -> bool {
-        let canonical = path.canonicalize().ok();
-        paths
-            .iter()
-            .any(|recorded| recorded == path || canonical.as_ref().is_some_and(|canonical| recorded == canonical))
-    }

    pub(crate) fn record(dir: &Path) {
-        record_path(&RECORDED, dir, "fsync dir recorder");
+        let mut recorded = RECORDED.lock().expect("fsync dir recorder poisoned");
+        recorded.push(dir.to_path_buf());
+        if let Ok(canonical) = dir.canonicalize()
+            && canonical != dir
+        {
+            recorded.push(canonical);
+        }
    }

    pub(crate) fn was_fsynced(dir: &Path) -> bool {
-        contains_path(&RECORDED.lock().expect("fsync dir recorder poisoned"), dir)
-    }
-
-    pub(crate) fn record_limited(dir: &Path) {
-        record_path(&LIMITED, dir, "limited fsync dir recorder");
-        let hook = BEFORE_LIMITED.lock().expect("limited fsync hook poisoned").remove(dir);
-        if let Some(hook) = hook {
-            hook();
-        }
-    }
-
-    pub(crate) fn was_limited(dir: &Path) -> bool {
-        contains_path(&LIMITED.lock().expect("limited fsync dir recorder poisoned"), dir)
-    }
-
-    pub(crate) fn set_before_limited(dir: &Path, hook: impl FnOnce() + Send + 'static) {
-        BEFORE_LIMITED
+        let canonical = dir.canonicalize().ok();
+        RECORDED
            .lock()
-            .expect("limited fsync hook poisoned")
-            .insert(dir.to_path_buf(), Box::new(hook));
+            .expect("fsync dir recorder poisoned")
+            .iter()
+            .any(|p| p == dir || canonical.as_ref().is_some_and(|canonical| p == canonical))
    }
 }

@@ -528,7 +497,7 @@ pub(crate) mod file_sync_probe {
    }
 }

-pub(crate) fn sync_file(path: &Path) -> io::Result<()> {
+fn sync_file(path: &Path) -> io::Result<()> {
    #[cfg(test)]
    let _probe = file_sync_probe::enter(path);
    #[cfg(test)]
@@ -1151,79 +1120,6 @@ pub(crate) async fn run_blocking_namespace_operation<T: Send + 'static>(
    .map_err(|err| io::Error::other(format!("blocking namespace operation failed: {err}")))?
 }

-/// Admit one strict inline commit under the disk sync limit. The caller already
-/// owns the namespace lease, establishing namespace -> disk ordering. Holding
-/// admission across adjacent durability barriers prevents one transaction from
-/// repeatedly joining the disk semaphore tail.
-pub(crate) struct FileSyncAdmission {
-    disk_permit: Arc<OwnedSemaphorePermit>,
-}
-
-pub(crate) async fn acquire_file_sync_admission(disk_permits: Arc<Semaphore>) -> io::Result<FileSyncAdmission> {
-    let disk_permit = disk_permits
-        .acquire_owned()
-        .await
-        .map_err(|_| io::Error::other("disk file sync concurrency limiter closed"))?;
-    Ok(FileSyncAdmission {
-        disk_permit: Arc::new(disk_permit),
-    })
-}
-
-/// Keep the disk admission and namespace lease with the blocking syscall if
-/// the async waiter is cancelled. The process-wide admission remains with the
-/// waiter so cancellation cannot starve healthy disks.
-pub(crate) async fn run_blocking_namespace_file_sync_operation<T: Send + 'static>(
-    lease: Arc<NamespaceMutationLease>,
-    admission: &FileSyncAdmission,
-    operation: impl FnOnce() -> io::Result<T> + Send + 'static,
-) -> io::Result<T> {
-    run_blocking_namespace_file_sync_operation_with_global(lease, admission, &FILE_SYNC_PERMITS, operation).await
-}
-
-async fn run_blocking_namespace_file_sync_operation_with_global<T: Send + 'static>(
-    lease: Arc<NamespaceMutationLease>,
-    admission: &FileSyncAdmission,
-    global_permits: &Semaphore,
-    operation: impl FnOnce() -> io::Result<T> + Send + 'static,
-) -> io::Result<T> {
-    let global_permit = global_permits
-        .acquire()
-        .await
-        .map_err(|_| io::Error::other("global file sync concurrency limiter closed"))?;
-    let disk_permit = admission.disk_permit.clone();
-    let result = tokio::task::spawn_blocking(move || {
-        let _lease = lease;
-        let _disk_permit = disk_permit;
-        operation()
-    })
-    .await;
-    drop(global_permit);
-    result.map_err(|err| io::Error::other(format!("blocking namespace file sync operation failed: {err}")))?
-}
-
-pub(crate) async fn fsync_dir_with_namespace_file_sync_limit(
-    dir: impl AsRef<Path>,
-    lease: Arc<NamespaceMutationLease>,
-    admission: &FileSyncAdmission,
-) -> io::Result<()> {
-    #[cfg(unix)]
-    {
-        let dir = dir.as_ref().to_path_buf();
-        run_blocking_namespace_file_sync_operation(lease, admission, move || {
-            #[cfg(test)]
-            fsync_dir_recorder::record_limited(&dir);
-            fsync_dir_std(dir)
-        })
-        .await
-    }
-
-    #[cfg(not(unix))]
-    {
-        let _ = (lease, admission);
-        fsync_dir_std(dir)
-    }
-}
-
 struct RenamePreparation {
    parent_guard: Option<ExistingBaseDirectoryGuard>,
    #[cfg(windows)]
@@ -2888,7 +2784,6 @@ pub fn is_dir_not_empty_error(err: &io::Error) -> bool {
 mod tests {
    use super::*;
    use std::sync::Mutex;
-    use std::time::Duration;
    use tempfile::tempdir;
    use tracing_subscriber::fmt::MakeWriter;

@@ -4658,79 +4553,6 @@ mod tests {
        fsync_dir(temp_dir.path()).await.expect("fsync dir must succeed");
    }

-    #[tokio::test]
-    async fn file_sync_admission_is_reused_across_commit_barriers() {
-        let temp_dir = tempdir().expect("create temp dir");
-        let limiter = Arc::new(Semaphore::new(1));
-        let lease = acquire_namespace_mutation_lease(temp_dir.path()).await;
-        let admission = acquire_file_sync_admission(limiter.clone())
-            .await
-            .expect("first commit should acquire admission");
-
-        run_blocking_namespace_file_sync_operation(lease.clone(), &admission, || Ok(()))
-            .await
-            .expect("first barrier should complete under the admission");
-        let mut waiting = Box::pin(acquire_file_sync_admission(limiter));
-        assert!(
-            futures::poll!(&mut waiting).is_pending(),
-            "another commit must remain queued between durability barriers"
-        );
-        run_blocking_namespace_file_sync_operation(lease, &admission, || Ok(()))
-            .await
-            .expect("later barrier should reuse admission without requeuing");
-
-        drop(admission);
-        tokio::time::timeout(Duration::from_secs(30), waiting)
-            .await
-            .expect("queued commit should acquire admission after release")
-            .expect("queued commit should acquire admission");
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn cancelled_file_sync_waiter_keeps_disk_admission_until_blocking_work_finishes() {
-        use std::sync::mpsc;
-
-        let temp_dir = tempdir().expect("create temp dir");
-        let limiter = Arc::new(Semaphore::new(1));
-        let global_permits = Arc::new(Semaphore::new(1));
-        let lease = acquire_namespace_mutation_lease(temp_dir.path()).await;
-        let admission = acquire_file_sync_admission(limiter.clone())
-            .await
-            .expect("file sync admission should be acquired");
-        let (entered_tx, entered_rx) = mpsc::channel();
-        let (release_tx, release_rx) = mpsc::channel();
-        let waiter_global_permits = global_permits.clone();
-        let waiter = tokio::spawn(async move {
-            run_blocking_namespace_file_sync_operation_with_global(lease, &admission, waiter_global_permits.as_ref(), move || {
-                entered_tx.send(()).expect("signal blocking work");
-                release_rx.recv().expect("wait for blocking work release");
-                Ok(())
-            })
-            .await
-        });
-
-        tokio::task::spawn_blocking(move || entered_rx.recv_timeout(Duration::from_secs(30)))
-            .await
-            .expect("blocking work waiter should run")
-            .expect("blocking work should start");
-        waiter.abort();
-        assert!(waiter.await.expect_err("waiter should be cancelled").is_cancelled());
-        let returned_global_permit = global_permits
-            .try_acquire()
-            .expect("cancelled waiter must return global capacity for healthy disks");
-        assert!(
-            limiter.clone().try_acquire_owned().is_err(),
-            "cancelled waiter must not return disk capacity while blocking work is active"
-        );
-
-        release_tx.send(()).expect("release blocking work");
-        let _returned_permit = tokio::time::timeout(Duration::from_secs(30), limiter.acquire_owned())
-            .await
-            .expect("disk capacity should return after blocking work finishes")
-            .expect("disk limiter should remain open");
-        drop(returned_global_permit);
-    }
-
    #[tokio::test]
    #[serial_test::serial(file_sync_probe)]
    async fn sync_dir_files_syncs_regular_files_and_dir() {
@@ -76,13 +76,6 @@ impl ShardBufferPool {
        self.buffers[index] = Some(buf);
    }

-    #[cfg(test)]
-    pub(crate) fn stored_allocation(&self, index: usize) -> Option<(*const u8, usize)> {
-        self.buffers
-            .get(index)
-            .and_then(|buf| buf.as_ref().map(|buf| (buf.as_ptr(), buf.capacity())))
-    }
-
    #[cfg(test)]
    fn stored_capacity(&self, index: usize) -> Option<usize> {
        self.buffers.get(index).and_then(|buf| buf.as_ref().map(Vec::capacity))
@@ -14,30 +14,11 @@

 use pin_project_lite::pin_project;
 use rustfs_utils::HashAlgorithm;
-use std::future::poll_fn;
 use std::io::IoSlice;
-use std::pin::Pin;
-use std::task::{Context, Poll};
 use std::time::Duration;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use tracing::error;
-
-const LOG_COMPONENT_ECSTORE: &str = "ecstore";
-const LOG_SUBSYSTEM_ERASURE: &str = "erasure";
-const EVENT_BITROT_SHORT_SHARD_READ: &str = "bitrot_short_shard_read";
-const EVENT_BITROT_HASH_MISMATCH: &str = "bitrot_hash_mismatch";
-const MAX_RETAINED_CHUNKS_PER_BLOCK: usize = 64;
-const MAX_CHUNK_POLLS_PER_YIELD: usize = MAX_RETAINED_CHUNKS_PER_BLOCK + 1;
-
-/// Result of polling an optional owned-chunk handoff.
-pub enum ShardChunkRead {
-    /// The source does not support owned-chunk handoff and remains untouched.
-    Unsupported,
-    /// The source reached EOF.
-    Eof,
-    /// A non-empty chunk containing at most the requested number of bytes.
-    Chunk(bytes::Bytes),
-}
+use uuid::Uuid;

 /// A shard source that may already hold its bytes in memory.
 ///
@@ -57,12 +38,6 @@ pub trait ShardSource: AsyncRead + Send + Sync + Unpin {
    fn try_take_block(&mut self, _n: usize) -> Option<bytes::Bytes> {
        None
    }
-
-    /// Polls one owned chunk when the source supports chunk handoff.
-    /// `Unsupported` must leave the source untouched.
-    fn poll_read_chunk(self: Pin<&mut Self>, _cx: &mut Context<'_>, _max: usize) -> Poll<std::io::Result<ShardChunkRead>> {
-        Poll::Ready(Ok(ShardChunkRead::Unsupported))
-    }
 }

 /// Borrowed and owned byte slices are ordinary streaming sources: they carry no
@@ -96,11 +71,9 @@ pin_project! {
        // contiguous on-disk `[hash][data]` block so both are pulled in a single
        // pass; grown lazily and never shrunk.
        buf: Vec<u8>,
-        // Reused owned chunk vector for the remote HTTP fast path. Keeping the
-        // allocation with the reader avoids allocating once per bitrot block.
-        chunks: Vec<bytes::Bytes>,
        skip_verify: bool,
        last_verify_duration: Duration,
+        id: Uuid,
    }
 }

@@ -115,9 +88,9 @@ where
            hash_algo: algo,
            shard_size,
            buf: Vec::new(),
-            chunks: Vec::new(),
            skip_verify,
            last_verify_duration: Duration::ZERO,
+            id: Uuid::new_v4(),
        }
    }

@@ -125,11 +98,6 @@ where
        self.last_verify_duration
    }

-    #[cfg(test)]
-    pub(crate) fn inner_ref(&self) -> &R {
-        &self.inner
-    }
-
    /// Read a single (hash+data) block, verify hash, and copy `out.len()` bytes
    /// into `out`. Returns an error if the shard is short, the hash mismatches,
    /// or `out` is larger than one shard. On error `out`'s contents are
@@ -150,7 +118,7 @@ where

        let need = self.hash_algo.size() + want;
        self.read_scratch_block(need, want).await?;
-        let (data, verify) = split_and_verify(&self.hash_algo, self.skip_verify, &self.buf[..need])?;
+        let (data, verify) = split_and_verify(&self.hash_algo, self.skip_verify, &self.buf[..need], &self.id)?;
        out.copy_from_slice(data);
        self.last_verify_duration = verify;
        Ok(want)
@@ -189,7 +157,7 @@ where
        }
        let filled = fill(&mut self.inner, &mut self.buf[..need]).await?;
        if filled < need {
-            return Err(short_shard_read(filled.saturating_sub(self.hash_algo.size()), want));
+            return Err(short_shard_read(&self.id, filled.saturating_sub(self.hash_algo.size()), want));
        }
        Ok(())
    }
@@ -198,23 +166,15 @@ where
    /// buffer returns its length, a short read is UnexpectedEof (backlog#799 B2).
    fn finish_len(&self, data_len: usize, want: usize) -> std::io::Result<usize> {
        if data_len < want {
-            return Err(short_shard_read(data_len, want));
+            return Err(short_shard_read(&self.id, data_len, want));
        }
        Ok(data_len)
    }
 }

 /// A truncated shard is `UnexpectedEof`, not a short success (backlog#799 B2).
-fn short_shard_read(got: usize, want: usize) -> std::io::Error {
-    error!(
-        event = EVENT_BITROT_SHORT_SHARD_READ,
-        component = LOG_COMPONENT_ECSTORE,
-        subsystem = LOG_SUBSYSTEM_ERASURE,
-        state = "failed",
-        got,
-        want,
-        "short shard read: got {got} of {want} bytes"
-    );
+fn short_shard_read(id: &Uuid, got: usize, want: usize) -> std::io::Error {
+    error!("bitrot reader short shard read: id={id} got {got} of {want} bytes");
    std::io::Error::new(std::io::ErrorKind::UnexpectedEof, format!("short shard read: got {got} of {want} bytes"))
 }

@@ -224,7 +184,12 @@ fn short_shard_read(got: usize, want: usize) -> std::io::Error {
 /// hash never reaches the caller's buffer. The verify duration is returned
 /// rather than stored so this stays a free function usable while `self` is
 /// borrowed for the block.
-fn split_and_verify<'a>(hash_algo: &HashAlgorithm, skip_verify: bool, block: &'a [u8]) -> std::io::Result<(&'a [u8], Duration)> {
+fn split_and_verify<'a>(
+    hash_algo: &HashAlgorithm,
+    skip_verify: bool,
+    block: &'a [u8],
+    id: &Uuid,
+) -> std::io::Result<(&'a [u8], Duration)> {
    let (hash, data) = block.split_at(hash_algo.size());
    if skip_verify {
        return Ok((data, Duration::ZERO));
@@ -233,14 +198,7 @@ fn split_and_verify<'a>(hash_algo: &HashAlgorithm, skip_verify: bool, block: &'a
    let actual_hash = hash_algo.hash_encode(data);
    let verify = verify_start.elapsed();
    if actual_hash.as_ref() != hash {
-        error!(
-            event = EVENT_BITROT_HASH_MISMATCH,
-            component = LOG_COMPONENT_ECSTORE,
-            subsystem = LOG_SUBSYSTEM_ERASURE,
-            state = "failed",
-            data_len = data.len(),
-            "bitrot hash mismatch"
-        );
+        error!("bitrot reader hash mismatch, id={id} data_len={}", data.len());
        return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bitrot hash mismatch"));
    }
    Ok((data, verify))
@@ -290,138 +248,23 @@ where

        let need = hash_size + want;

+        // In-memory fast path: the block is already resident, so slice it instead
+        // of copying it into the scratch buffer first (rustfs/backlog#1159). One
+        // copy (`extend_from_slice`) instead of two. A source that cannot serve
+        // `need` bytes returns `None` and falls through to the scratch path,
+        // keeping the short-read contract.
        if let Some(block) = self.inner.try_take_block(need) {
-            let (data, verify) = split_and_verify(&self.hash_algo, self.skip_verify, &block)?;
+            let (data, verify) = split_and_verify(&self.hash_algo, self.skip_verify, &block, &self.id)?;
            out.extend_from_slice(data);
            self.last_verify_duration = verify;
            return Ok(want);
        }

-        self.chunks.clear();
-        let handed_off = {
-            let inner = &mut self.inner;
-            let chunks = &mut self.chunks;
-            let tail_buf = &mut self.buf;
-            let mut received = 0usize;
-            poll_fn(|cx| {
-                for _ in 0..MAX_CHUNK_POLLS_PER_YIELD {
-                    let next = match Pin::new(&mut *inner).poll_read_chunk(cx, need - received) {
-                        Poll::Ready(Ok(next)) => next,
-                        Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
-                        Poll::Pending => return Poll::Pending,
-                    };
-                    let chunk = match next {
-                        ShardChunkRead::Unsupported if received == 0 => return Poll::Ready(Ok(false)),
-                        ShardChunkRead::Unsupported => {
-                            return Poll::Ready(Err(std::io::Error::new(
-                                std::io::ErrorKind::InvalidData,
-                                "chunk handoff became unavailable after transferring data",
-                            )));
-                        }
-                        ShardChunkRead::Eof => {
-                            return Poll::Ready(Err(short_shard_read(received.saturating_sub(hash_size), want)));
-                        }
-                        ShardChunkRead::Chunk(chunk) => chunk,
-                    };
-
-                    if received == 0 {
-                        tail_buf.clear();
-                    }
-                    if chunk.is_empty() {
-                        return Poll::Ready(Err(std::io::Error::new(
-                            std::io::ErrorKind::InvalidData,
-                            "chunk handoff returned an empty chunk",
-                        )));
-                    }
-                    let remaining = need - received;
-                    if chunk.len() > remaining {
-                        return Poll::Ready(Err(std::io::Error::new(
-                            std::io::ErrorKind::InvalidData,
-                            "chunk handoff exceeded its requested boundary",
-                        )));
-                    }
-                    received += chunk.len();
-
-                    if chunks.len() == MAX_RETAINED_CHUNKS_PER_BLOCK {
-                        if tail_buf.is_empty() {
-                            tail_buf.reserve_exact(need - (received - chunk.len()));
-                        }
-                        tail_buf.extend_from_slice(&chunk);
-                    } else {
-                        chunks.push(chunk);
-                    }
-
-                    if received == need {
-                        return Poll::Ready(Ok(true));
-                    }
-                }
-                cx.waker().wake_by_ref();
-                Poll::Pending
-            })
-            .await?
-        };
-        if handed_off {
-            if self.chunks.len() == 1 && self.buf.is_empty() {
-                let block = &self.chunks[0];
-                let (data, verify) = split_and_verify(&self.hash_algo, self.skip_verify, block)?;
-                out.extend_from_slice(data);
-                self.last_verify_duration = verify;
-                return Ok(want);
-            }
-
-            let block_chunks = || {
-                self.chunks
-                    .iter()
-                    .map(|chunk| chunk.as_ref())
-                    .chain((!self.buf.is_empty()).then_some(self.buf.as_slice()))
-            };
-            if !self.skip_verify {
-                let verify_start = std::time::Instant::now();
-                let actual_hash = self
-                    .hash_algo
-                    .hash_encode_slices(block_chunks().scan(hash_size, |skip, chunk| {
-                        let start = (*skip).min(chunk.len());
-                        *skip -= start;
-                        Some(&chunk[start..])
-                    }));
-                let verify = verify_start.elapsed();
-                let mut hash_offset = 0;
-                let mut remaining = hash_size;
-                for chunk in block_chunks() {
-                    let take = remaining.min(chunk.len());
-                    if actual_hash.as_ref()[hash_offset..hash_offset + take] != chunk[..take] {
-                        error!(
-                            event = EVENT_BITROT_HASH_MISMATCH,
-                            component = LOG_COMPONENT_ECSTORE,
-                            subsystem = LOG_SUBSYSTEM_ERASURE,
-                            state = "failed",
-                            data_len = want,
-                            "bitrot hash mismatch"
-                        );
-                        return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bitrot hash mismatch"));
-                    }
-                    hash_offset += take;
-                    remaining -= take;
-                    if remaining == 0 {
-                        break;
-                    }
-                }
-                self.last_verify_duration = verify;
-            }
-            let mut skip = hash_size;
-            for chunk in block_chunks() {
-                let start = skip.min(chunk.len());
-                skip -= start;
-                out.extend_from_slice(&chunk[start..]);
-            }
-            return Ok(want);
-        }
-
        // Streaming path: same single pass and same verification as `read`; only
        // the sink differs (`extend_from_slice` into `out` instead of
        // `copy_from_slice` into a pre-zeroed buffer).
        self.read_scratch_block(need, want).await?;
-        let (data, verify) = split_and_verify(&self.hash_algo, self.skip_verify, &self.buf[..need])?;
+        let (data, verify) = split_and_verify(&self.hash_algo, self.skip_verify, &self.buf[..need], &self.id)?;
        out.extend_from_slice(data);
        self.last_verify_duration = verify;
        Ok(want)
@@ -822,167 +665,18 @@ impl BitrotWriterWrapper {

 #[cfg(test)]
 mod tests {
+    use super::ShardSource;
    use super::{
        BitrotReader, BitrotWriter, BitrotWriterWrapper, CustomWriter, bitrot_shard_file_size, bitrot_verify, write_all_vectored,
    };
-    use super::{MAX_RETAINED_CHUNKS_PER_BLOCK, ShardChunkRead, ShardSource};
-    use bytes::Bytes;
    use rustfs_utils::HashAlgorithm;
-    use std::collections::VecDeque;
-    use std::io::{self, Cursor, IoSlice};
-    use std::pin::Pin;
+    use std::io::{Cursor, IoSlice};
    use std::sync::{
        Arc,
        atomic::{AtomicUsize, Ordering},
    };
    use std::task::{Context, Poll};
-    use std::time::Duration;
-    use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, ReadBuf};
-
-    struct FragmentedSource {
-        chunks: VecDeque<Bytes>,
-    }
-
-    impl FragmentedSource {
-        fn new(bytes: Vec<u8>, fragment_sizes: &[usize]) -> Self {
-            let mut chunks = VecDeque::new();
-            let mut offset = 0;
-            for &size in fragment_sizes {
-                let end = (offset + size).min(bytes.len());
-                if offset < end {
-                    chunks.push_back(Bytes::copy_from_slice(&bytes[offset..end]));
-                }
-                offset = end;
-            }
-            if offset < bytes.len() {
-                chunks.push_back(Bytes::copy_from_slice(&bytes[offset..]));
-            }
-            Self { chunks }
-        }
-    }
-
-    impl AsyncRead for FragmentedSource {
-        fn poll_read(self: Pin<&mut Self>, _cx: &mut Context<'_>, _buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
-            Poll::Ready(Err(io::Error::other("fragmented source must use chunk handoff")))
-        }
-    }
-
-    impl ShardSource for FragmentedSource {
-        fn poll_read_chunk(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, max: usize) -> Poll<io::Result<ShardChunkRead>> {
-            let Some(mut chunk) = self.chunks.pop_front() else {
-                return Poll::Ready(Ok(ShardChunkRead::Eof));
-            };
-            if chunk.len() > max {
-                self.chunks.push_front(chunk.split_off(max));
-                chunk.truncate(max);
-            }
-            Poll::Ready(Ok(ShardChunkRead::Chunk(chunk)))
-        }
-    }
-
-    struct GeneratedChunkSource {
-        bytes: Bytes,
-        offset: usize,
-        fragment_size: usize,
-        fail_at: Option<usize>,
-    }
-
-    impl GeneratedChunkSource {
-        fn new(bytes: Vec<u8>, fragment_size: usize) -> Self {
-            assert!(fragment_size > 0);
-            Self {
-                bytes: Bytes::from(bytes),
-                offset: 0,
-                fragment_size,
-                fail_at: None,
-            }
-        }
-
-        fn failing(bytes: Vec<u8>, fragment_size: usize, fail_at: usize) -> Self {
-            Self {
-                fail_at: Some(fail_at),
-                ..Self::new(bytes, fragment_size)
-            }
-        }
-    }
-
-    impl AsyncRead for GeneratedChunkSource {
-        fn poll_read(self: Pin<&mut Self>, _cx: &mut Context<'_>, _buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
-            Poll::Ready(Err(io::Error::other("generated source must use chunk handoff")))
-        }
-    }
-
-    impl ShardSource for GeneratedChunkSource {
-        fn poll_read_chunk(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, max: usize) -> Poll<io::Result<ShardChunkRead>> {
-            if self.fail_at == Some(self.offset) {
-                return Poll::Ready(Err(rustfs_rio::new_test_internode_http_io_error(
-                    rustfs_rio::InternodeHttpErrorKind::BodyStreamAborted,
-                )));
-            }
-            if self.offset == self.bytes.len() {
-                return Poll::Ready(Ok(ShardChunkRead::Eof));
-            }
-            let error_limit = self.fail_at.unwrap_or(self.bytes.len());
-            let take = self
-                .fragment_size
-                .min(max)
-                .min(error_limit - self.offset)
-                .min(self.bytes.len() - self.offset);
-            let start = self.offset;
-            self.offset += take;
-            Poll::Ready(Ok(ShardChunkRead::Chunk(self.bytes.slice(start..start + take))))
-        }
-    }
-
-    struct InvalidChunkSource {
-        mode: InvalidChunkMode,
-    }
-
-    #[derive(Clone, Copy)]
-    enum InvalidChunkMode {
-        Empty,
-        Oversized,
-        UnsupportedAfterChunk,
-        Unsupported,
-    }
-
-    impl AsyncRead for InvalidChunkSource {
-        fn poll_read(self: Pin<&mut Self>, _cx: &mut Context<'_>, _buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
-            Poll::Ready(Err(io::Error::other("invalid source must use chunk handoff")))
-        }
-    }
-
-    impl ShardSource for InvalidChunkSource {
-        fn poll_read_chunk(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, max: usize) -> Poll<io::Result<ShardChunkRead>> {
-            match self.mode {
-                InvalidChunkMode::Empty => Poll::Ready(Ok(ShardChunkRead::Chunk(Bytes::new()))),
-                InvalidChunkMode::Oversized => Poll::Ready(Ok(ShardChunkRead::Chunk(Bytes::from(vec![0; max + 1])))),
-                InvalidChunkMode::UnsupportedAfterChunk => {
-                    self.mode = InvalidChunkMode::Unsupported;
-                    Poll::Ready(Ok(ShardChunkRead::Chunk(Bytes::from_static(b"x"))))
-                }
-                InvalidChunkMode::Unsupported => Poll::Ready(Ok(ShardChunkRead::Unsupported)),
-            }
-        }
-    }
-
-    struct ScratchReuseSource {
-        block: Option<Bytes>,
-        saw_reused_scratch: bool,
-    }
-
-    impl AsyncRead for ScratchReuseSource {
-        fn poll_read(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
-            let Some(block) = self.block.take() else {
-                return Poll::Ready(Ok(()));
-            };
-            self.saw_reused_scratch = buf.initialize_unfilled()[..block.len()].iter().all(|byte| *byte == 0xa5);
-            buf.put_slice(&block);
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    impl ShardSource for ScratchReuseSource {}
+    use tokio::io::{AsyncWrite, AsyncWriteExt};

    #[derive(Default)]
    struct VectoredCountingWriter {
@@ -1740,70 +1434,6 @@ mod tests {
        assert!(out.is_empty(), "corrupt bytes must never reach the caller's buffer");
    }

-    #[tokio::test]
-    async fn chunked_handoff_verifies_data_split_across_hash_boundaries() {
-        const SHARD: usize = 4096;
-        let algo = HashAlgorithm::HighwayHash256S;
-        let data: Vec<u8> = (0..SHARD).map(|index| (index % 251) as u8).collect();
-        let mut encoded = Vec::new();
-        BitrotWriter::new(&mut encoded, SHARD, algo.clone())
-            .write(&data)
-            .await
-            .expect("write shard");
-
-        let mut output = Vec::with_capacity(SHARD);
-        BitrotReader::new(FragmentedSource::new(encoded, &[3, 11, 19, 37, 128]), SHARD, algo, false)
-            .read_appending(&mut output, SHARD)
-            .await
-            .expect("fragmented shard must verify");
-
-        assert_eq!(output, data);
-    }
-
-    #[tokio::test]
-    async fn chunked_handoff_never_appends_a_corrupt_shard() {
-        const SHARD: usize = 4096;
-        let algo = HashAlgorithm::HighwayHash256S;
-        let mut encoded = Vec::new();
-        BitrotWriter::new(&mut encoded, SHARD, algo.clone())
-            .write(&vec![9u8; SHARD])
-            .await
-            .expect("write shard");
-        let last = encoded.len() - 1;
-        encoded[last] ^= 0xff;
-
-        let mut output = Vec::with_capacity(SHARD);
-        let err = BitrotReader::new(FragmentedSource::new(encoded, &[7, 17, 31]), SHARD, algo, false)
-            .read_appending(&mut output, SHARD)
-            .await
-            .expect_err("corrupt fragmented shard must fail");
-
-        assert_eq!(err.kind(), io::ErrorKind::InvalidData);
-        assert!(output.is_empty());
-    }
-
-    #[tokio::test]
-    async fn chunked_handoff_does_not_hash_when_verification_is_skipped() {
-        const SHARD: usize = 4096;
-        let algo = HashAlgorithm::HighwayHash256S;
-        let mut encoded = Vec::new();
-        BitrotWriter::new(&mut encoded, SHARD, algo.clone())
-            .write(&vec![9u8; SHARD])
-            .await
-            .expect("write shard");
-        encoded[0] ^= 0xff;
-
-        let mut output = Vec::with_capacity(SHARD);
-        let mut reader = BitrotReader::new(FragmentedSource::new(encoded, &[7, 17, 31]), SHARD, algo, true);
-        reader
-            .read_appending(&mut output, SHARD)
-            .await
-            .expect("skipped verification must accept fragmented shard bytes");
-
-        assert_eq!(reader.last_verify_duration(), Duration::ZERO);
-        assert_eq!(output, vec![9u8; SHARD]);
-    }
-
    #[tokio::test]
    async fn read_appending_rejects_a_want_larger_than_the_shard() {
        let algo = HashAlgorithm::HighwayHash256;
@@ -1855,21 +1485,10 @@ mod tests {

        // Equivalence: same bytes out of both paths.
        let mut via_mem: Vec<u8> = Vec::with_capacity(SHARD);
-        let mut memory_reader = BitrotReader::new(Cursor::new(Bytes::from(encoded.clone())), SHARD, algo.clone(), false);
-        memory_reader
+        BitrotReader::new(Cursor::new(Bytes::from(encoded.clone())), SHARD, algo.clone(), false)
            .read_appending(&mut via_mem, SHARD)
            .await
            .expect("in-memory read");
-        assert_eq!(
-            memory_reader.chunks.capacity(),
-            0,
-            "the synchronous fast path must not allocate chunk storage"
-        );
-        assert_eq!(
-            memory_reader.buf.capacity(),
-            0,
-            "the synchronous fast path must not allocate scratch storage"
-        );

        let mut via_stream: Vec<u8> = Vec::with_capacity(SHARD);
        BitrotReader::new(Cursor::new(encoded), SHARD, algo, false)
@@ -1906,152 +1525,4 @@ mod tests {
        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
        assert!(out.is_empty(), "corrupt bytes must never reach the caller's buffer");
    }
-
-    #[tokio::test]
-    async fn streaming_fallback_reuses_initialized_scratch() {
-        const SHARD: usize = 4096;
-        let algo = HashAlgorithm::HighwayHash256S;
-        let data = vec![7u8; SHARD];
-        let encoded = encode_one_block(&data, SHARD, algo.clone()).await;
-        let source = ScratchReuseSource {
-            block: Some(Bytes::copy_from_slice(&encoded)),
-            saw_reused_scratch: false,
-        };
-        let mut reader = BitrotReader::new(source, SHARD, algo, false);
-        reader.buf = vec![0xa5; encoded.len()];
-        let mut output = Vec::new();
-
-        reader
-            .read_appending(&mut output, SHARD)
-            .await
-            .expect("streaming fallback should verify");
-
-        assert!(reader.inner.saw_reused_scratch, "capability probing must not clear reusable scratch");
-        assert_eq!(output, data);
-    }
-
-    #[tokio::test]
-    async fn chunked_handoff_bounds_production_sized_one_byte_fragments() {
-        const SHARD: usize = 1024 * 1024 / 4;
-        let algo = HashAlgorithm::HighwayHash256S;
-        let data: Vec<u8> = (0..SHARD).map(|index| (index % 251) as u8).collect();
-        let encoded = encode_one_block(&data, SHARD, algo.clone()).await;
-        let encoded_len = encoded.len();
-        let mut reader = BitrotReader::new(GeneratedChunkSource::new(encoded, 1), SHARD, algo, false);
-        let mut output = Vec::with_capacity(SHARD);
-
-        reader
-            .read_appending(&mut output, SHARD)
-            .await
-            .expect("one-byte fragments should verify with bounded retained state");
-
-        assert_eq!(output, data);
-        assert_eq!(reader.chunks.len(), MAX_RETAINED_CHUNKS_PER_BLOCK);
-        assert!(reader.chunks.capacity() <= MAX_RETAINED_CHUNKS_PER_BLOCK);
-        assert_eq!(reader.buf.len(), encoded_len - MAX_RETAINED_CHUNKS_PER_BLOCK);
-    }
-
-    #[tokio::test]
-    async fn chunked_handoff_keeps_sixty_four_frames_zero_copy_and_respects_poll_budget() {
-        const SHARD: usize = 1024 * 1024;
-        const FRAME: usize = 16 * 1024;
-        let algo = HashAlgorithm::HighwayHash256S;
-
-        let small_data = vec![3u8; 4096];
-        let small_encoded = encode_one_block(&small_data, 4096, algo.clone()).await;
-        let mut exact_reader =
-            BitrotReader::new(FragmentedSource::new(small_encoded.clone(), &[1; 63]), 4096, algo.clone(), false);
-        let mut exact_output = Vec::new();
-        exact_reader
-            .read_appending(&mut exact_output, 4096)
-            .await
-            .expect("exactly sixty-four frames should verify");
-        assert_eq!(exact_output, small_data);
-        assert_eq!(exact_reader.chunks.len(), MAX_RETAINED_CHUNKS_PER_BLOCK);
-        assert!(exact_reader.buf.is_empty(), "the threshold itself must remain zero-copy");
-
-        let mut yielded_reader = BitrotReader::new(FragmentedSource::new(small_encoded, &[1; 65]), 4096, algo.clone(), false);
-        let mut yielded_output = Vec::new();
-        let mut yielded_read = Box::pin(yielded_reader.read_appending(&mut yielded_output, 4096));
-        let mut cx = Context::from_waker(std::task::Waker::noop());
-        assert!(std::future::Future::poll(yielded_read.as_mut(), &mut cx).is_pending());
-        assert!(matches!(std::future::Future::poll(yielded_read.as_mut(), &mut cx), Poll::Ready(Ok(4096))));
-        drop(yielded_read);
-        assert_eq!(yielded_output, small_data);
-
-        let data = vec![7u8; SHARD];
-        let encoded = encode_one_block(&data, SHARD, algo.clone()).await;
-        let mut reader = BitrotReader::new(FragmentedSource::new(encoded, &[FRAME; 64]), SHARD, algo, false);
-        let mut output = Vec::with_capacity(SHARD);
-        let mut read = Box::pin(reader.read_appending(&mut output, SHARD));
-        assert!(
-            matches!(std::future::Future::poll(read.as_mut(), &mut cx), Poll::Ready(Ok(SHARD))),
-            "sixty-five normal HTTP frames should complete without a cooperative yield"
-        );
-        drop(read);
-
-        assert_eq!(output, data);
-        assert_eq!(reader.chunks.len(), MAX_RETAINED_CHUNKS_PER_BLOCK);
-        assert_eq!(reader.buf.len(), HashAlgorithm::HighwayHash256S.size());
-    }
-
-    #[tokio::test]
-    async fn chunked_tail_failures_preserve_errors_and_output() {
-        const SHARD: usize = 4096;
-        let algo = HashAlgorithm::HighwayHash256S;
-        let data = vec![7u8; SHARD];
-        let encoded = encode_one_block(&data, SHARD, algo.clone()).await;
-        let sentinel = vec![1u8, 2, 3];
-
-        let mut short_output = sentinel.clone();
-        let short_err = BitrotReader::new(GeneratedChunkSource::new(encoded[..100].to_vec(), 1), SHARD, algo.clone(), false)
-            .read_appending(&mut short_output, SHARD)
-            .await
-            .expect_err("EOF after the retention threshold must stay a short read");
-        assert_eq!(short_err.kind(), io::ErrorKind::UnexpectedEof);
-        assert_eq!(short_output, sentinel);
-
-        let mut corrupt = encoded.clone();
-        let last = corrupt.len() - 1;
-        corrupt[last] ^= 0xff;
-        let mut corrupt_output = sentinel.clone();
-        let corrupt_err = BitrotReader::new(GeneratedChunkSource::new(corrupt, 1), SHARD, algo.clone(), false)
-            .read_appending(&mut corrupt_output, SHARD)
-            .await
-            .expect_err("corrupt coalesced tail must fail verification");
-        assert_eq!(corrupt_err.kind(), io::ErrorKind::InvalidData);
-        assert_eq!(corrupt_output, sentinel);
-
-        let mut failed_output = sentinel.clone();
-        let body_err = BitrotReader::new(GeneratedChunkSource::failing(encoded, 1, 65), SHARD, algo, false)
-            .read_appending(&mut failed_output, SHARD)
-            .await
-            .expect_err("a terminal body error must not become EOF");
-        let source = body_err
-            .get_ref()
-            .and_then(|source| source.downcast_ref::<rustfs_rio::InternodeHttpError>())
-            .expect("body error should retain internode classification");
-        assert_eq!(source.kind(), rustfs_rio::InternodeHttpErrorKind::BodyStreamAborted);
-        assert_eq!(failed_output, sentinel);
-    }
-
-    #[tokio::test]
-    async fn chunked_handoff_rejects_invalid_source_contracts() {
-        const SHARD: usize = 64;
-        for mode in [
-            InvalidChunkMode::Empty,
-            InvalidChunkMode::Oversized,
-            InvalidChunkMode::UnsupportedAfterChunk,
-        ] {
-            let source = InvalidChunkSource { mode };
-            let mut output = vec![9u8];
-            let err = BitrotReader::new(source, SHARD, HashAlgorithm::HighwayHash256S, false)
-                .read_appending(&mut output, SHARD)
-                .await
-                .expect_err("invalid chunk contracts must fail closed");
-
-            assert_eq!(err.kind(), io::ErrorKind::InvalidData);
-            assert_eq!(output, vec![9u8]);
-        }
-    }
 }
@@ -25,13 +25,10 @@ use crate::disk::error_reduce::reduce_errs;
 use crate::erasure::codec::workspace::ShardBufferPool;
 use crate::erasure::coding::{BitrotReader, Erasure};
 use crate::io_support::bitrot::DeferredReaderStripeHandle;
-use crate::set_disk::shard_source::{
-    INLINE_SHARD_SLOTS, ShardBuffers, ShardErrors, ShardReadCost, ShardStripeSource, StripeReadState,
-};
+use crate::set_disk::shard_source::{ShardReadCost, ShardStripeSource, StripeReadState};
 use futures::FutureExt;
 use futures::stream::{FuturesUnordered, StreamExt};
 use pin_project_lite::pin_project;
-use smallvec::{SmallVec, smallvec};
 use std::future::Future;
 use std::io;
 use std::io::ErrorKind;
@@ -43,12 +40,9 @@ use tracing::{debug, error, warn};

 type ShardReadFuture<'a> = Pin<Box<dyn Future<Output = (usize, ShardReadCost, Result<Vec<u8>, Error>, bool)> + Send + 'a>>;

-type ShardIndexes = SmallVec<[usize; INLINE_SHARD_SLOTS]>;
-type ActiveReaders = SmallVec<[bool; INLINE_SHARD_SLOTS]>;
-
 /// One stripe's worth of shard buffers plus the per-shard read errors, as
 /// returned by `ParallelReader::read` / `read_stripe_timed`.
-type StripeReadOutput = (ShardBuffers, ShardErrors);
+type StripeReadOutput = (Vec<Option<Vec<u8>>>, Vec<Option<Error>>);

 const ENV_RUSTFS_SHARD_LOCALITY_SCHEDULING: &str = "RUSTFS_SHARD_LOCALITY_SCHEDULING";
 const ENV_RUSTFS_GET_SHARD_LOCALITY_PREFERENCE_ENABLE: &str = "RUSTFS_GET_SHARD_LOCALITY_PREFERENCE_ENABLE";
@@ -391,13 +385,12 @@ pub(crate) struct ParallelReader<R> {
    // Request-scoped shard buffers keyed by shard index. Keeping ownership in
    // `ParallelReader` avoids dropping unused parity/backup slot buffers between stripes.
    buffers: ShardBufferPool,
-    stripe_state: Option<Box<StripeReadState>>,
    // Lockstep-path state (verify_reconstruction == true). `engaged[i]` marks
    // readers that participate in each stripe read: all data slots from the
    // start, parity slots only once a data shard is missing/dead. Unengaged
    // parity stays an unopened deferred reader; `deferred_handles[i]` realigns
    // it to the current stripe when it is engaged mid-object (backlog#923).
-    engaged: SmallVec<[bool; INLINE_SHARD_SLOTS]>,
+    engaged: Vec<bool>,
    deferred_handles: Vec<Option<DeferredReaderStripeHandle>>,
    stripe_index: usize,
 }
@@ -580,7 +573,7 @@ where
        // behavior. With the gate on, only data slots start engaged; parity is
        // engaged on demand, stripe-aligned through its deferred handle.
        let data_shards_only = get_lockstep_data_shards_only_enabled();
-        let engaged: SmallVec<_> = (0..readers.len())
+        let engaged = (0..readers.len())
            .map(|index| !data_shards_only || index < e.data_shards)
            .collect();
        ParallelReader {
@@ -596,7 +589,6 @@ where
            verify_reconstruction,
            locality_preference_enabled: get_shard_locality_preference_enabled(),
            buffers: ShardBufferPool::new(e.data_shards + e.parity_shards),
-            stripe_state: None,
            engaged,
            deferred_handles: Vec::new(),
            stripe_index: 0,
@@ -620,7 +612,7 @@ where
 fn record_shard_read_result(
    shards: &mut [Option<Vec<u8>>],
    errs: &mut [Option<Error>],
-    retire_readers: &mut ShardIndexes,
+    retire_readers: &mut Vec<usize>,
    success: &mut usize,
    successful_costs: &mut ShardReadCostCounts,
    i: usize,
@@ -645,7 +637,7 @@ fn record_shard_read_result(
    }
 }

-fn retire_abandoned_readers(errs: &mut [Option<Error>], retire_readers: &mut ShardIndexes, active_readers: &[bool]) {
+fn retire_abandoned_readers(errs: &mut [Option<Error>], retire_readers: &mut Vec<usize>, active_readers: &[bool]) {
    for (i, active) in active_readers.iter().enumerate() {
        if !*active {
            continue;
@@ -700,13 +692,7 @@ where
    R: crate::erasure::coding::ShardSource,
 {
    #[hotpath::measure(impl_type = "ParallelReader")]
-    pub async fn read(&mut self) -> StripeReadOutput {
-        let mut state = StripeReadState::with_slot_count(self.readers.len(), self.data_shards);
-        self.read_into_state(&mut state).await;
-        state.into_parts()
-    }
-
-    async fn read_into_state(&mut self, state: &mut StripeReadState) {
+    pub async fn read(&mut self) -> (Vec<Option<Vec<u8>>>, Vec<Option<Error>>) {
        // On the reconstruction-verifying GET path, read every live shard reader
        // in lockstep so all readers advance one block per stripe and stay
        // mutually aligned. The adaptive data-first path below only reads
@@ -716,14 +702,12 @@ where
        // than the data shards, producing "inconsistent read source shards" and
        // truncating large-object GETs under concurrency (backlog#832).
        if self.verify_reconstruction {
-            self.read_lockstep(state).await;
-            return;
+            return self.read_lockstep().await;
        }
        // if self.readers.len() != self.total_shards {
        //     return Err(io::Error::new(ErrorKind::InvalidInput, "Invalid number of readers"));
        // }
        let num_readers = self.readers.len();
-        state.reset(num_readers, self.data_shards);

        let shard_size = if self.offset + self.shard_size > self.shard_file_size {
            self.shard_file_size - self.offset
@@ -732,7 +716,7 @@ where
        };

        if shard_size == 0 {
-            return;
+            return (vec![None; num_readers], vec![None; num_readers]);
        }

        // Advance to the next stripe so the following read() computes the correct
@@ -743,7 +727,8 @@ where
        // is only read above to derive `shard_size`, so advancing here is safe.
        self.offset += shard_size;

-        let (shards, errs) = state.parts_mut();
+        let mut shards: Vec<Option<Vec<u8>>> = vec![None; num_readers];
+        let mut errs = vec![None; num_readers];
        let read_costs = self.read_costs.as_slice();
        let locality_preference_enabled = self.locality_preference_enabled;
        let low_cost_available = self
@@ -774,11 +759,11 @@ where

        self.buffers.ensure_slots(num_readers);

-        let mut retire_readers = ShardIndexes::new();
+        let mut retire_readers = Vec::new();
        if num_readers >= self.data_shards {
            let mut reader_iter = ReaderLaunchIter::new(&mut self.readers, read_costs, locality_preference_enabled);
            let mut sets = FuturesUnordered::new();
-            let mut active_readers: ActiveReaders = smallvec![false; num_readers];
+            let mut active_readers = vec![false; num_readers];
            let stripe_read_start = self.metrics_path.map(|_| Instant::now());
            let mut scheduled = 0usize;
            for _ in 0..self.data_shards {
@@ -890,8 +875,8 @@ where
                }

                let result_is_err = record_shard_read_result(
-                    shards,
-                    errs,
+                    &mut shards,
+                    &mut errs,
                    &mut retire_readers,
                    &mut success,
                    &mut successful_costs,
@@ -952,8 +937,8 @@ where
                    active_readers[i] = false;
                    completed += 1;
                    if record_shard_read_result(
-                        shards,
-                        errs,
+                        &mut shards,
+                        &mut errs,
                        &mut retire_readers,
                        &mut success,
                        &mut successful_costs,
@@ -965,7 +950,7 @@ where
                        failed += 1;
                    }
                }
-                retire_abandoned_readers(errs, &mut retire_readers, &active_readers);
+                retire_abandoned_readers(&mut errs, &mut retire_readers, &active_readers);
            }

            if let Some(path) = self.metrics_path {
@@ -1009,6 +994,8 @@ where
        for i in retire_readers {
            self.readers[i] = None;
        }
+
+        (shards, errs)
    }

    /// Lockstep stripe read for the reconstruction-verifying GET path.
@@ -1036,18 +1023,18 @@ where
    /// stripe would reintroduce the desync. A parity reader that cannot be
    /// realigned (no pending deferred handle) is likewise retired instead of
    /// being read out of position.
-    async fn read_lockstep(&mut self, state: &mut StripeReadState) {
+    async fn read_lockstep(&mut self) -> (Vec<Option<Vec<u8>>>, Vec<Option<Error>>) {
        let num_readers = self.readers.len();
-        state.reset(num_readers, self.data_shards);
        let shard_size = if self.offset + self.shard_size > self.shard_file_size {
            self.shard_file_size - self.offset
        } else {
            self.shard_size
        };

-        let (shards, errs) = state.parts_mut();
+        let mut shards: Vec<Option<Vec<u8>>> = vec![None; num_readers];
+        let mut errs: Vec<Option<Error>> = vec![None; num_readers];
        if shard_size == 0 {
-            return;
+            return (shards, errs);
        }

        // Advance to the next stripe (see the matching note in `read`); the
@@ -1084,7 +1071,7 @@ where
        // Pre-claim per-slot buffers so the `self.readers` borrow below stays
        // disjoint from `self.buffers`; `Some(buffer)` also records which slots
        // participate, avoiding a per-stripe sidecar allocation.
-        let mut bufs: ShardBuffers = SmallVec::with_capacity(num_readers);
+        let mut bufs: Vec<Option<Vec<u8>>> = Vec::with_capacity(num_readers);
        for i in 0..num_readers {
            bufs.push(if self.engaged[i] && self.readers[i].is_some() {
                Some(self.buffers.take(i, shard_size))
@@ -1099,7 +1086,7 @@ where
        let locality_preference_enabled = self.locality_preference_enabled;
        let stripe_read_start = metrics_path.map(|_| Instant::now());

-        let mut retire_readers = ShardIndexes::new();
+        let mut retire_readers = Vec::new();
        let mut scheduled = 0usize;
        let mut success = 0usize;
        let mut completed = 0usize;
@@ -1285,6 +1272,8 @@ where
        for i in retire_readers {
            self.readers[i] = None;
        }
+
+        (shards, errs)
    }

    /// Attempt to bring an as-yet-unread parity reader into the lockstep read
@@ -1341,20 +1330,10 @@ impl<R> ShardStripeSource for ParallelReader<R>
 where
    R: crate::erasure::coding::ShardSource,
 {
-    async fn read_next_stripe(&mut self) -> Box<StripeReadState> {
-        let mut state = self
-            .stripe_state
-            .take()
-            .unwrap_or_else(|| Box::new(StripeReadState::with_slot_count(self.readers.len(), self.data_shards)));
-        self.read_into_state(&mut state).await;
-        state
-    }
-
-    fn recycle_stripe(&mut self, mut state: Box<StripeReadState>) {
-        self.recycle_shards(state.shards_mut());
-        state.reset(0, self.data_shards);
-        debug_assert!(self.stripe_state.is_none(), "a stripe cannot be recycled twice");
-        self.stripe_state = Some(state);
+    async fn read_next_stripe(&mut self) -> StripeReadState {
+        let read_quorum = self.data_shards;
+        let (shards, errors) = ParallelReader::read(self).await;
+        StripeReadState::from_parts_with_read_costs(shards, errors, &self.read_costs, read_quorum)
    }
 }

@@ -1372,7 +1351,10 @@ fn get_data_block_len(shards: &[Option<Vec<u8>>], data_blocks: usize) -> usize {
 /// stripe-read stage timer. Factored out so the depth-1 prefetch loop and the
 /// serial loop time reads identically. A free `async fn` (rather than a closure)
 /// so the returned future's borrow of `reader` is correctly tied to the call.
-async fn read_stripe_timed<R>(reader: &mut ParallelReader<R>, stage_metrics_enabled: bool) -> StripeReadOutput
+async fn read_stripe_timed<R>(
+    reader: &mut ParallelReader<R>,
+    stage_metrics_enabled: bool,
+) -> (Vec<Option<Vec<u8>>>, Vec<Option<Error>>)
 where
    R: crate::erasure::coding::ShardSource,
 {
@@ -1985,93 +1967,6 @@ mod tests {

    type BoxedShardReader = crate::io_support::bitrot::ShardReader;

-    #[test]
-    fn parallel_reader_keeps_stripe_scratch_out_of_line() {
-        eprintln!(
-            "parallel_reader={} stripe_state={} cached_state={}",
-            std::mem::size_of::<ParallelReader<Cursor<Vec<u8>>>>(),
-            std::mem::size_of::<StripeReadState>(),
-            std::mem::size_of::<Option<Box<StripeReadState>>>()
-        );
-        assert_eq!(
-            std::mem::size_of::<Option<Box<StripeReadState>>>(),
-            std::mem::size_of::<usize>(),
-            "the request-scoped cache must remain pointer-sized",
-        );
-    }
-
-    #[tokio::test]
-    async fn parallel_reader_preserves_slot_count_above_inline_capacity() {
-        const DATA_SHARDS: usize = INLINE_SHARD_SLOTS;
-        const TOTAL_SHARDS: usize = INLINE_SHARD_SLOTS + 1;
-        let readers = std::iter::repeat_with(|| None).take(TOTAL_SHARDS).collect();
-        let erasure = Erasure::new(DATA_SHARDS, 1, DATA_SHARDS);
-        let mut reader: ParallelReader<Cursor<Vec<u8>>> = ParallelReader::new(readers, erasure, 0, DATA_SHARDS);
-
-        let (shards, errors) = reader.read().await;
-
-        assert!(shards.spilled());
-        assert!(errors.spilled());
-        assert_eq!(shards.len(), TOTAL_SHARDS);
-        assert_eq!(errors.len(), TOTAL_SHARDS);
-    }
-
-    #[tokio::test]
-    async fn codec_reader_reuses_inline_and_spilled_stripe_scratch_between_reads() {
-        for total_shards in [INLINE_SHARD_SLOTS, INLINE_SHARD_SLOTS + 1] {
-            let data_shards = total_shards - 1;
-            let readers = std::iter::repeat_with(|| None).take(total_shards).collect();
-            let erasure = Erasure::new(data_shards, 1, data_shards * 2);
-            let mut reader: ParallelReader<Cursor<Vec<u8>>> = ParallelReader::new(readers, erasure, 0, data_shards * 2);
-
-            let first = ShardStripeSource::read_next_stripe(&mut reader).await;
-            let first_state = (&*first) as *const StripeReadState;
-            let first_storage = first.scratch_storage();
-            assert_eq!(first_storage.2, total_shards > INLINE_SHARD_SLOTS);
-            assert_eq!(first_storage.3, total_shards > INLINE_SHARD_SLOTS);
-            ShardStripeSource::recycle_stripe(&mut reader, first);
-
-            let second = ShardStripeSource::read_next_stripe(&mut reader).await;
-            let second_storage = second.scratch_storage();
-
-            assert_eq!(
-                (&*second) as *const StripeReadState,
-                first_state,
-                "the request-scoped state must be reused"
-            );
-            assert_eq!(second_storage.0, first_storage.0, "shard slots must reuse their allocation");
-            assert_eq!(second_storage.1, first_storage.1, "error slots must reuse their allocation");
-            assert_eq!(second.into_parts().0.len(), total_shards);
-        }
-    }
-
-    #[tokio::test]
-    async fn codec_reader_returns_shard_allocations_to_the_request_pool() {
-        const SHARD_SIZE: usize = 16;
-        let hash_algo = HashAlgorithm::None;
-        let readers = vec![Some(create_reader(SHARD_SIZE, 2, 0x5a, &hash_algo, false).await)];
-        let erasure = Erasure::new(1, 0, SHARD_SIZE);
-        let mut reader = ParallelReader::new(readers, erasure, 0, SHARD_SIZE * 2);
-
-        let first = ShardStripeSource::read_next_stripe(&mut reader).await;
-        let first_allocation = first
-            .shard_allocation(0)
-            .expect("the first stripe should own its shard allocation");
-        ShardStripeSource::recycle_stripe(&mut reader, first);
-        assert_eq!(
-            reader.buffers.stored_allocation(0),
-            Some(first_allocation),
-            "recycling a stripe must return its shard allocation to the request pool"
-        );
-
-        let second = ShardStripeSource::read_next_stripe(&mut reader).await;
-        assert_eq!(
-            second.shard_allocation(0),
-            Some(first_allocation),
-            "the next stripe must reuse the pooled shard allocation"
-        );
-    }
-
    /// Counts the raw bytes pulled from a shard stream, to prove which shards
    /// a decode path actually touches (backlog#923 call-count evidence).
    struct CountingShardReader {
@@ -2448,19 +2343,6 @@ mod tests {
        assert_eq!(err.expect("range beyond total length should fail").kind(), ErrorKind::InvalidInput);
    }

-    #[tokio::test]
-    async fn test_erasure_decode_zero_length_does_not_read_or_emit() {
-        let erasure = Erasure::new(2, 1, 64);
-        let readers: Vec<Option<BitrotReader<Cursor<Vec<u8>>>>> = vec![None, None, None];
-        let mut output = Vec::new();
-
-        let (written, err) = erasure.decode(&mut output, readers, 0, 0, 0).await;
-
-        assert_eq!(written, 0);
-        assert!(err.is_none());
-        assert!(output.is_empty());
-    }
-
    #[tokio::test]
    async fn test_erasure_decode_with_read_costs_restores_missing_data_shard_range() {
        const DATA_SHARDS: usize = 2;
@@ -65,7 +65,7 @@ enum FillPolicy {
 }

 impl FillPolicy {
-    fn load() -> Self {
+    fn from_env() -> Self {
        match rustfs_utils::get_env_usize(
            ENV_RUSTFS_GET_CODEC_STREAMING_MAX_INFLIGHT,
            DEFAULT_RUSTFS_GET_CODEC_STREAMING_MAX_INFLIGHT,
@@ -75,22 +75,6 @@ impl FillPolicy {
        }
    }

-    fn from_env() -> Self {
-        #[cfg(test)]
-        {
-            Self::load()
-        }
-        #[cfg(not(test))]
-        {
-            Self::cached_core(Self::load)
-        }
-    }
-
-    fn cached_core(load: impl FnOnce() -> Self) -> Self {
-        static CACHED: std::sync::OnceLock<FillPolicy> = std::sync::OnceLock::new();
-        *CACHED.get_or_init(load)
-    }
-
    const fn max_inflight(self) -> usize {
        match self {
            Self::SingleInFlight => 1,
@@ -495,30 +479,22 @@ where
    let mut deferred_error = None;
    let fill_stage_start = get_stage_timer_if_enabled(stage_metrics_enabled);
    let stripe_read_stage_start = get_stage_timer_if_enabled(stage_metrics_enabled);
-    let mut state = source.read_next_stripe().await;
+    let state = source.read_next_stripe().await;
    record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_STRIPE_READ, stripe_read_stage_start);
    let decode_stage_start = get_stage_timer_if_enabled(stage_metrics_enabled);
    let mut output_buf = reusable_buffers.pop().unwrap_or_default();
-    let result = match decode_stripe_into(
-        metrics_path,
-        stage_metrics_enabled,
-        engine,
-        workspace,
-        &mut state,
-        remaining,
-        &mut output_buf,
-    ) {
-        Ok(true) => Ok(Some(output_buf)),
-        Ok(false) => {
-            reusable_buffers.push(output_buf);
-            Ok(None)
-        }
-        Err(err) => {
-            reusable_buffers.push(output_buf);
-            Err(err)
-        }
-    };
-    source.recycle_stripe(state);
+    let result =
+        match decode_stripe_into(metrics_path, stage_metrics_enabled, engine, workspace, state, remaining, &mut output_buf) {
+            Ok(true) => Ok(Some(output_buf)),
+            Ok(false) => {
+                reusable_buffers.push(output_buf);
+                Ok(None)
+            }
+            Err(err) => {
+                reusable_buffers.push(output_buf);
+                Err(err)
+            }
+        };
    record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_DECODE, decode_stage_start);
    if let Ok(Some(first_buf)) = result.as_ref() {
        let mut remaining_after_first = remaining.saturating_sub(first_buf.len());
@@ -527,7 +503,7 @@ where
                break;
            }
            let stripe_read_stage_start = get_stage_timer_if_enabled(stage_metrics_enabled);
-            let mut state = source.read_next_stripe().await;
+            let state = source.read_next_stripe().await;
            record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_STRIPE_READ, stripe_read_stage_start);
            let decode_stage_start = get_stage_timer_if_enabled(stage_metrics_enabled);
            let mut queued_buf = reusable_buffers.pop().unwrap_or_default();
@@ -536,11 +512,10 @@ where
                stage_metrics_enabled,
                engine,
                workspace,
-                &mut state,
+                state,
                remaining_after_first,
                &mut queued_buf,
            );
-            source.recycle_stripe(state);
            record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_DECODE, decode_stage_start);
            match queued_result {
                Ok(true) => {
@@ -742,7 +717,7 @@ fn decode_stripe_into<E>(
    stage_metrics_enabled: bool,
    engine: &E,
    workspace: &mut E::Workspace,
-    state: &mut StripeReadState,
+    state: StripeReadState,
    remaining: usize,
    output: &mut Vec<u8>,
 ) -> io::Result<bool>
@@ -750,7 +725,7 @@ where
    E: ErasureDecodeEngine,
 {
    output.clear();
-    if state.is_empty() {
+    if state.slots().is_empty() {
        return Ok(false);
    }
    if !state.can_decode() {
@@ -766,12 +741,13 @@ where
        );
        record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_RECONSTRUCT, reconstruct_stage_start);
        let emit_stage_start = get_stage_timer_if_enabled(stage_metrics_enabled);
-        emit_data_shards_into(state, engine.data_shards(), engine.block_size(), remaining, output)?;
+        emit_data_shards_into(&state, engine.data_shards(), engine.block_size(), remaining, output)?;
        record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_EMIT, emit_stage_start);
        return Ok(true);
    }

-    let reconstruct_outcome = match engine.reconstruct_into(state.shards_mut(), workspace) {
+    let (mut shards, _errs) = state.into_parts();
+    let reconstruct_outcome = match engine.reconstruct_into(&mut shards, workspace) {
        Ok(outcome) => outcome,
        Err(err) => {
            record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_RECONSTRUCT, reconstruct_stage_start);
@@ -781,7 +757,7 @@ where
    rustfs_io_metrics::record_get_object_reconstruct_outcome(metrics_path, engine.engine_name(), reconstruct_outcome);
    record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_RECONSTRUCT, reconstruct_stage_start);

-    if state.shards_mut().len() < engine.data_shards() {
+    if shards.len() < engine.data_shards() {
        return Err(io::Error::new(
            ErrorKind::UnexpectedEof,
            "decoded stripe has fewer shards than data shard count",
@@ -790,7 +766,7 @@ where

    let emit_stage_start = get_stage_timer_if_enabled(stage_metrics_enabled);
    reserve_output_capacity(output, engine.block_size().min(remaining));
-    for shard in state.shards_mut().iter().take(engine.data_shards()) {
+    for shard in shards.iter().take(engine.data_shards()) {
        if output.len() >= remaining {
            break;
        }
@@ -830,7 +806,10 @@ fn emit_data_shards_into(
        if output.len() >= remaining {
            break;
        }
-        let Some(shard) = state.data_bytes(index) else {
+        let Some(slot) = state.slot_by_index(index) else {
+            return Err(io::Error::new(ErrorKind::UnexpectedEof, "decoded stripe is missing a data shard"));
+        };
+        let Some(shard) = slot.data_bytes() else {
            return Err(io::Error::new(ErrorKind::UnexpectedEof, "decoded stripe is missing a data shard"));
        };
        let copy_len = shard.len().min(remaining - output.len());
@@ -847,7 +826,7 @@ mod tests {
    };
    use crate::erasure::coding::decode::ParallelReader;
    use crate::erasure::coding::{BitrotReader, BitrotWriter, Erasure};
-    use crate::set_disk::shard_source::StripeReadState;
+    use crate::set_disk::shard_source::{ShardSlot, StripeReadState};
    use rustfs_utils::HashAlgorithm;
    use std::collections::VecDeque;
    use std::future::{pending, poll_fn};
@@ -866,13 +845,6 @@ mod tests {
        read_count: Option<Arc<AtomicUsize>>,
    }

-    struct RecordingStripeSource {
-        stripes: VecDeque<StripeReadState>,
-        read_quorum: usize,
-        reads: usize,
-        recycles: usize,
-    }
-
    struct BlockingSource {
        started: Arc<Notify>,
        dropped: Arc<AtomicUsize>,
@@ -927,43 +899,25 @@ mod tests {

    #[async_trait::async_trait]
    impl ShardStripeSource for VecStripeSource {
-        async fn read_next_stripe(&mut self) -> Box<StripeReadState> {
+        async fn read_next_stripe(&mut self) -> StripeReadState {
            if let Some(read_count) = &self.read_count {
                read_count.fetch_add(1, Ordering::SeqCst);
            }
-            Box::new(
-                self.stripes
-                    .pop_front()
-                    .unwrap_or_else(|| StripeReadState::from_parts(Vec::new(), Vec::new(), self.read_quorum)),
-            )
-        }
-    }
-
-    #[async_trait::async_trait]
-    impl ShardStripeSource for RecordingStripeSource {
-        async fn read_next_stripe(&mut self) -> Box<StripeReadState> {
-            self.reads += 1;
-            Box::new(
-                self.stripes
-                    .pop_front()
-                    .unwrap_or_else(|| StripeReadState::from_parts(Vec::new(), Vec::new(), self.read_quorum)),
-            )
-        }
-
-        fn recycle_stripe(&mut self, _state: Box<StripeReadState>) {
-            self.recycles += 1;
+            self.stripes
+                .pop_front()
+                .unwrap_or_else(|| StripeReadState::new(Vec::new(), self.read_quorum))
        }
    }

    #[async_trait::async_trait]
    impl ShardStripeSource for BlockingSource {
-        async fn read_next_stripe(&mut self) -> Box<StripeReadState> {
+        async fn read_next_stripe(&mut self) -> StripeReadState {
            let _guard = BlockingSourceDropGuard {
                dropped: Arc::clone(&self.dropped),
            };
            self.started.notify_one();
            pending::<()>().await;
-            Box::new(StripeReadState::from_parts(Vec::new(), Vec::new(), self.read_quorum))
+            StripeReadState::new(Vec::new(), self.read_quorum)
        }
    }

@@ -1136,23 +1090,6 @@ mod tests {
        });
    }

-    #[test]
-    fn fill_policy_production_cache_loads_once() {
-        use std::cell::Cell;
-
-        let loads = Cell::new(0);
-        for _ in 0..3 {
-            assert_eq!(
-                FillPolicy::cached_core(|| {
-                    loads.set(loads.get() + 1);
-                    FillPolicy::DualInFlight
-                }),
-                FillPolicy::DualInFlight
-            );
-        }
-        assert_eq!(loads.get(), 1, "the production fill policy must not re-read the environment per reader");
-    }
-
    #[test]
    fn erasure_decode_reader_rejects_invalid_engine_shape() {
        let source = VecStripeSource {
@@ -1752,10 +1689,7 @@ mod tests {
            .pop_front()
            .expect("first stripe should exist");
        let mut source = VecStripeSource {
-            stripes: VecDeque::from([
-                first_state,
-                StripeReadState::from_parts(Vec::new(), Vec::new(), erasure.data_shards),
-            ]),
+            stripes: VecDeque::from([first_state, StripeReadState::new(Vec::new(), erasure.data_shards)]),
            read_quorum: erasure.data_shards,
            read_count: None,
        };
@@ -1790,14 +1724,13 @@ mod tests {
            .stripes
            .pop_front()
            .expect("first stripe should exist");
-        let mut source = RecordingStripeSource {
+        let mut source = VecStripeSource {
            stripes: VecDeque::from([
                first_state,
-                StripeReadState::from_parts(vec![Some(vec![1])], Vec::new(), erasure.data_shards),
+                StripeReadState::new(vec![ShardSlot::data(0, vec![1])], erasure.data_shards),
            ]),
            read_quorum: erasure.data_shards,
-            reads: 0,
-            recycles: 0,
+            read_count: None,
        };
        let engine = LegacyEcDecodeEngine::new(erasure);
        let mut workspace = engine.prepare_workspace(4).expect("workspace should be prepared");
@@ -1823,8 +1756,6 @@ mod tests {
                .kind(),
            ErrorKind::Other
        );
-        assert_eq!(source.reads, 2, "the fill must read the primary and queued stripe");
-        assert_eq!(source.recycles, source.reads, "every completed stripe read must be recycled");
    }

    #[tokio::test]
@@ -1837,7 +1768,7 @@ mod tests {
                    .stripes
                    .pop_front()
                    .expect("first stripe should exist"),
-                StripeReadState::from_parts(Vec::new(), Vec::new(), erasure.data_shards),
+                StripeReadState::new(Vec::new(), erasure.data_shards),
            ]),
            read_quorum: erasure.data_shards,
            read_count: None,
@@ -2097,11 +2028,17 @@ mod tests {
    }

    #[test]
-    fn emit_data_shards_preserves_output_order() {
-        let state =
-            StripeReadState::from_parts(vec![Some(b"ab".to_vec()), Some(b"cd".to_vec()), Some(b"ef".to_vec())], Vec::new(), 2);
+    fn emit_data_shards_preserves_output_order_for_out_of_order_slots() {
+        let state = StripeReadState::new(
+            vec![
+                ShardSlot::data(1, b"cd".to_vec()),
+                ShardSlot::data(0, b"ab".to_vec()),
+                ShardSlot::data(2, b"ef".to_vec()),
+            ],
+            2,
+        );

-        let output = emit_data_shards(&state, 3, 6, 5).expect("data slots should emit by shard index");
+        let output = emit_data_shards(&state, 3, 6, 5).expect("out-of-order data slots should emit by shard index");

        assert_eq!(output, b"abcde");
    }
@@ -2114,27 +2051,27 @@ mod tests {
        };
        let mut workspace = engine.prepare_workspace(4).expect("workspace should be prepared");
        let mut output = Vec::with_capacity(1);
-        let mut short_state = StripeReadState::from_parts(vec![Some(vec![1, 2, 3, 4])], Vec::new(), 1);
+        let short_state = StripeReadState::new(vec![ShardSlot::data(0, vec![1, 2, 3, 4])], 1);

        let err = decode_stripe_into(
            GET_OBJECT_PATH_CODEC_STREAMING,
            false,
            &engine,
            &mut workspace,
-            &mut short_state,
+            short_state,
            8,
            &mut output,
        )
        .expect_err("decoded stripe shorter than data shard count must fail");
        assert_eq!(err.kind(), ErrorKind::UnexpectedEof);

-        let mut missing_state = StripeReadState::from_parts(vec![None, Some(vec![5, 6, 7, 8])], Vec::new(), 1);
+        let missing_state = StripeReadState::from_parts(vec![None, Some(vec![5, 6, 7, 8])], Vec::new(), 1);
        let err = decode_stripe_into(
            GET_OBJECT_PATH_CODEC_STREAMING,
            false,
            &engine,
            &mut workspace,
-            &mut missing_state,
+            missing_state,
            8,
            &mut output,
        )
@@ -2145,35 +2082,6 @@ mod tests {
        assert!(output.capacity() >= 32);
    }

-    #[test]
-    fn decode_stripe_reconstructs_in_place_without_replacing_slot_storage() {
-        let erasure = Erasure::new(2, 1, 8);
-        let engine = LegacyEcDecodeEngine::new(erasure.clone());
-        let mut workspace = engine.prepare_workspace(4).expect("workspace should be prepared");
-        let encoded = erasure.encode_data(b"abcdefgh").expect("test stripe should encode");
-        let mut shards = encoded.into_iter().map(|shard| Some(shard.to_vec())).collect::<Vec<_>>();
-        shards[0] = None;
-        let mut state = StripeReadState::from_parts(shards, vec![Some(DiskError::FileCorrupt)], 2);
-        let before = state.scratch_storage();
-        let mut output = Vec::new();
-
-        let decoded = decode_stripe_into(
-            GET_OBJECT_PATH_CODEC_STREAMING,
-            false,
-            &engine,
-            &mut workspace,
-            &mut state,
-            8,
-            &mut output,
-        )
-        .expect("degraded stripe should reconstruct");
-
-        assert!(decoded);
-        assert_eq!(output, b"abcdefgh");
-        assert_eq!(state.scratch_storage().0, before.0, "reconstruction must retain shard slot storage");
-        assert_eq!(state.scratch_storage().1, before.1, "unused error storage must not be rebuilt");
-    }
-
    #[tokio::test]
    async fn erasure_decode_reader_reports_short_source() {
        let erasure = Erasure::new(4, 2, 32);
@@ -18,12 +18,10 @@ use crate::disk::error_reduce::{
 };
 use crate::erasure::coding::BitrotWriterWrapper;
 use crate::erasure::coding::Erasure;
-use crate::erasure::coding::erasure::EncodedBlock;
 use crate::runtime::sources as runtime_sources;
 use bytes::{Bytes, BytesMut};
 use futures::StreamExt;
 use futures::stream::FuturesUnordered;
-use rustfs_utils::HashAlgorithm;
 use std::sync::Arc;
 use std::time::Instant;
 use std::vec;
@@ -93,11 +91,6 @@ fn use_bytesmut_ingest() -> bool {
    })
 }

-fn small_ingest_capacity(erasure: &Erasure, size_hint: usize) -> usize {
-    let data_len = size_hint.min(erasure.block_size);
-    erasure.encoded_capacity_for_data_len(data_len).min(erasure.block_size)
-}
-
 /// Keeps the encoder producer scoped to its parent future. Tokio detaches a
 /// task when its `JoinHandle` is dropped, so the producer must be aborted when
 /// an upload is cancelled before the encode pipeline finishes.
@@ -225,8 +218,8 @@ async fn send_queued<T>(
    sender.send(InflightEntry::new(entry, bytes)).await
 }

-fn queued_batch_bytes(batch: &[EncodedBlock]) -> usize {
-    batch.iter().map(EncodedBlock::queued_bytes).sum()
+fn queued_batch_bytes(batch: &[Vec<Bytes>]) -> usize {
+    batch.iter().map(|block| queued_block_bytes(block)).sum()
 }

 fn dominant_error_summary_label(summary: &WriteQuorumFailureSummary) -> &'static str {
@@ -338,7 +331,7 @@ impl<'a> MultiWriter<'a> {
        }
    }

-    async fn write_shard(writer_opt: &mut Option<BitrotWriterWrapper>, err: &mut Option<Error>, shard: &[u8]) {
+    async fn write_shard(writer_opt: &mut Option<BitrotWriterWrapper>, err: &mut Option<Error>, shard: &Bytes) {
        match writer_opt {
            Some(writer) => {
                match writer.write(shard).await {
@@ -363,20 +356,12 @@ impl<'a> MultiWriter<'a> {
    }

    pub async fn write(&mut self, data: Vec<Bytes>) -> std::io::Result<()> {
-        self.write_shards(data.iter().map(Bytes::as_ref)).await
-    }
-
-    async fn write_block(&mut self, block: &EncodedBlock) -> std::io::Result<()> {
-        self.write_shards(block.shards()).await
-    }
-
-    async fn write_shards<'b>(&mut self, shards: impl ExactSizeIterator<Item = &'b [u8]>) -> std::io::Result<()> {
-        assert_eq!(shards.len(), self.writers.len());
+        assert_eq!(data.len(), self.writers.len());

        let budget = self.next_progress_budget();
        {
            let mut futures = FuturesUnordered::new();
-            for ((writer_opt, err), shard) in self.writers.iter_mut().zip(self.errs.iter_mut()).zip(shards) {
+            for ((writer_opt, err), shard) in self.writers.iter_mut().zip(self.errs.iter_mut()).zip(data.iter()) {
                if err.is_some() {
                    continue; // Skip if we already have an error for this writer
                }
@@ -500,10 +485,10 @@ impl<'a> MultiWriter<'a> {
 }

 impl Erasure {
-    async fn encode_block(self: Arc<Self>, encode_buf: Vec<u8>, len: usize) -> std::io::Result<(EncodedBlock, Vec<u8>)> {
+    async fn encode_block(self: Arc<Self>, encode_buf: Vec<u8>, len: usize) -> std::io::Result<(Vec<Bytes>, Vec<u8>)> {
        let encode_stage_start = stage_timer_if_enabled();
        let encode_once = move || {
-            let res = self.encode_data_block(&encode_buf[..len]);
+            let res = self.encode_data(&encode_buf[..len]);
            (res, encode_buf)
        };

@@ -528,9 +513,9 @@ impl Erasure {
        Ok((res?, returned_buf))
    }

-    async fn encode_block_bytes_mut(self: Arc<Self>, encode_buf: BytesMut, len: usize) -> std::io::Result<EncodedBlock> {
+    async fn encode_block_bytes_mut(self: Arc<Self>, encode_buf: BytesMut, len: usize) -> std::io::Result<Vec<Bytes>> {
        let encode_stage_start = stage_timer_if_enabled();
-        let encode_once = move || self.encode_data_bytes_mut_block(encode_buf, len);
+        let encode_once = move || self.encode_data_bytes_mut(encode_buf, len);

        let res = match tokio::runtime::Handle::current().runtime_flavor() {
            // Same rationale as encode_block: inline the short EC burst on the
@@ -555,14 +540,13 @@ impl Erasure {
        writers: &mut [Option<BitrotWriterWrapper>],
        quorum: usize,
        require_single_block: bool,
-        size_hint: usize,
    ) -> std::io::Result<(R, usize)>
    where
        R: AsyncRead + Send + Sync + Unpin,
    {
        use tokio::io::AsyncReadExt;

-        let mut buf = Vec::with_capacity(small_ingest_capacity(&self, size_hint));
+        let mut buf = Vec::with_capacity(self.block_size);
        let total = if require_single_block {
            let read_limit = self
                .block_size
@@ -586,46 +570,13 @@ impl Erasure {
            ));
        }

-        let block = self.encode_data_owned_block(buf)?;
+        let shards = self.encode_data_owned(buf)?;
        let mut mw = MultiWriter::new(writers, quorum);
-        mw.write_block(&block).await?;
+        mw.write(shards).await?;
        mw.shutdown().await?;
        Ok((reader, total))
    }

-    /// Encode a small inline object directly into its per-disk bitrot payloads.
-    /// The returned bytes are the same `[hash][shard]` representation produced
-    /// by `BitrotWriter`, ready to be embedded in each disk's staged `xl.meta`.
-    #[hotpath::measure(impl_type = "Erasure")]
-    pub(crate) async fn encode_inline_shards_with_size_hint<R>(
-        self: Arc<Self>,
-        mut reader: R,
-        size_hint: usize,
-    ) -> std::io::Result<(R, usize, Vec<Bytes>)>
-    where
-        R: AsyncRead + Send + Sync + Unpin,
-    {
-        use tokio::io::AsyncReadExt;
-
-        let mut buf = Vec::with_capacity(small_ingest_capacity(&self, size_hint));
-        let total = reader.read_to_end(&mut buf).await?;
-        if total == 0 {
-            return Ok((reader, 0, Vec::new()));
-        }
-
-        let block = self.encode_data_owned_block(buf)?;
-        let mut inline_shards = Vec::with_capacity(block.shards().len());
-        for shard in block.shards() {
-            let hash = HashAlgorithm::HighwayHash256S.hash_encode(shard);
-            let mut encoded = BytesMut::with_capacity(hash.as_ref().len() + shard.len());
-            encoded.extend_from_slice(hash.as_ref());
-            encoded.extend_from_slice(shard);
-            inline_shards.push(encoded.freeze());
-        }
-
-        Ok((reader, total, inline_shards))
-    }
-
    #[hotpath::measure(impl_type = "Erasure")]
    pub async fn encode<R>(
        self: Arc<Self>,
@@ -667,7 +618,7 @@ impl Erasure {
        let expanded_block_bytes = self.shard_size().saturating_mul(self.total_shard_count());
        let max_inflight_bytes = erasure_encode_max_inflight_bytes();
        let inflight_blocks = encode_channel_capacity(expanded_block_bytes, max_inflight_bytes);
-        let (tx, mut rx) = mpsc::channel::<InflightEntry<EncodedBlock>>(inflight_blocks);
+        let (tx, mut rx) = mpsc::channel::<InflightEntry<Vec<Bytes>>>(inflight_blocks);

        let mut task = AbortOnDropTask::new(tokio::spawn(async move {
            let block_size = self.block_size;
@@ -689,7 +640,7 @@ impl Erasure {
                            let encode_buf = buf;
                            let res = self.clone().encode_block_bytes_mut(encode_buf, n).await?;
                            buf = BytesMut::with_capacity(ingest_capacity);
-                            let queued_bytes = res.queued_bytes();
+                            let queued_bytes = queued_block_bytes(&res);
                            let _producer_stage = rustfs_io_metrics::track_ec_encode_producer_bytes(queued_bytes);
                            let send_wait_stage_start = stage_timer_if_enabled();
                            if let Err(err) = send_queued(&tx, res, queued_bytes).await {
@@ -719,7 +670,7 @@ impl Erasure {
                            let encode_buf = std::mem::take(&mut buf);
                            let (res, returned_buf) = self.clone().encode_block(encode_buf, n).await?;
                            buf = returned_buf;
-                            let queued_bytes = res.queued_bytes();
+                            let queued_bytes = queued_block_bytes(&res);
                            let _producer_stage = rustfs_io_metrics::track_ec_encode_producer_bytes(queued_bytes);
                            let send_wait_stage_start = stage_timer_if_enabled();
                            if let Err(err) = send_queued(&tx, res, queued_bytes).await {
@@ -763,9 +714,9 @@ impl Erasure {
            if block.is_empty() {
                break;
            }
-            let _writer_stage = rustfs_io_metrics::track_ec_encode_writer_bytes(block.queued_bytes());
+            let _writer_stage = rustfs_io_metrics::track_ec_encode_writer_bytes(queued_block_bytes(&block));
            let write_stage_start = stage_timer_if_enabled();
-            if let Err(err) = writers.write_block(&block).await {
+            if let Err(err) = writers.write(block).await {
                write_err = Some(err);
                break;
            }
@@ -812,7 +763,7 @@ impl Erasure {
        let inflight_blocks = encode_channel_capacity(expanded_block_bytes, max_inflight_bytes);
        let batch_blocks = encode_batch_block_count().min(inflight_blocks);
        let channel_capacity = inflight_blocks.div_ceil(batch_blocks).max(1);
-        let (tx, mut rx) = mpsc::channel::<InflightEntry<Vec<EncodedBlock>>>(channel_capacity);
+        let (tx, mut rx) = mpsc::channel::<InflightEntry<Vec<Vec<Bytes>>>>(channel_capacity);

        let mut task = AbortOnDropTask::new(tokio::spawn(async move {
            let block_size = self.block_size;
@@ -829,7 +780,7 @@ impl Erasure {
                        let encode_buf = std::mem::take(&mut buf);
                        let (res, returned_buf) = self.clone().encode_block(encode_buf, n).await?;
                        buf = returned_buf;
-                        let queued_bytes = res.queued_bytes();
+                        let queued_bytes = queued_block_bytes(&res);
                        pending_batch_bytes = pending_batch_bytes.saturating_add(queued_bytes);
                        pending_batch.push(res);
                        drop(pending_batch_stage.take());
@@ -888,7 +839,7 @@ impl Erasure {
            let _writer_stage = rustfs_io_metrics::track_ec_encode_writer_bytes(queued_batch_bytes(&batch));
            let write_stage_start = stage_timer_if_enabled();
            for block in batch {
-                if let Err(err) = writers.write_block(&block).await {
+                if let Err(err) = writers.write(block).await {
                    write_err = Some(err);
                    break;
                }
@@ -929,24 +880,7 @@ impl Erasure {
    where
        R: AsyncRead + Send + Sync + Unpin,
    {
-        let size_hint = self.block_size;
-        self.encode_small_direct(reader, writers, quorum, false, size_hint).await
-    }
-
-    /// Size-aware inline fast path. `size_hint` only controls the bounded initial
-    /// allocation; reads remain authoritative.
-    #[hotpath::measure(impl_type = "Erasure")]
-    pub async fn encode_inline_small_with_size_hint<R>(
-        self: Arc<Self>,
-        reader: R,
-        writers: &mut [Option<BitrotWriterWrapper>],
-        quorum: usize,
-        size_hint: usize,
-    ) -> std::io::Result<(R, usize)>
-    where
-        R: AsyncRead + Send + Sync + Unpin,
-    {
-        self.encode_small_direct(reader, writers, quorum, false, size_hint).await
+        self.encode_small_direct(reader, writers, quorum, false).await
    }

    /// Fast path for single-block non-inline objects: avoids the producer/consumer
@@ -961,24 +895,7 @@ impl Erasure {
    where
        R: AsyncRead + Send + Sync + Unpin,
    {
-        let size_hint = self.block_size;
-        self.encode_small_direct(reader, writers, quorum, true, size_hint).await
-    }
-
-    /// Size-aware single-block fast path. `size_hint` only controls the bounded
-    /// initial allocation; reads remain authoritative.
-    #[hotpath::measure(impl_type = "Erasure")]
-    pub async fn encode_single_block_non_inline_with_size_hint<R>(
-        self: Arc<Self>,
-        reader: R,
-        writers: &mut [Option<BitrotWriterWrapper>],
-        quorum: usize,
-        size_hint: usize,
-    ) -> std::io::Result<(R, usize)>
-    where
-        R: AsyncRead + Send + Sync + Unpin,
-    {
-        self.encode_small_direct(reader, writers, quorum, true, size_hint).await
+        self.encode_small_direct(reader, writers, quorum, true).await
    }
 }

@@ -1938,11 +1855,7 @@ mod tests {
        let baseline = rustfs_io_metrics::current_ec_encode_inflight_bytes();
        let (tx, rx) = mpsc::channel(2);
        let mut rx = rx;
-        let erasure = Erasure::new(1, 0, 16);
-        let batch = vec![
-            erasure.encode_data_block(b"queued").expect("first block should encode"),
-            erasure.encode_data_block(b"batch").expect("second block should encode"),
-        ];
+        let batch = vec![vec![Bytes::from_static(b"queued")], vec![Bytes::from_static(b"batch")]];
        let batch_bytes = queued_batch_bytes(&batch);

        send_queued(&tx, batch, batch_bytes).await.expect("batch should be queued");
@@ -2164,39 +2077,6 @@ mod tests {
        );
    }

-    #[tokio::test]
-    async fn cancelling_inline_small_drops_stalled_write() {
-        const BLOCK_SIZE: usize = 16;
-
-        let (writer_entered_tx, writer_entered) = oneshot::channel();
-        let writes = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let mut writers = vec![Some(bitrot_writer_plain(
-            StallOnWriteWithSignal {
-                entered: Some(writer_entered_tx),
-                writes: writes.clone(),
-            },
-            BLOCK_SIZE,
-        ))];
-        let erasure = Arc::new(Erasure::new(1, 0, BLOCK_SIZE));
-        let reader = tokio::io::BufReader::new(Cursor::new(vec![0xA5; BLOCK_SIZE - 1]));
-        let encode = tokio::spawn(async move { erasure.encode_inline_small(reader, &mut writers, 1).await });
-
-        tokio::time::timeout(Duration::from_secs(1), writer_entered)
-            .await
-            .expect("inline writer should enter before cancellation")
-            .expect("stalling writer should signal entry");
-        encode.abort();
-        assert!(
-            matches!(encode.await, Err(err) if err.is_cancelled()),
-            "inline encode task should be cancelled"
-        );
-        assert_eq!(
-            writes.load(std::sync::atomic::Ordering::SeqCst),
-            1,
-            "cancellation must drop the stalled write instead of polling it again"
-        );
-    }
-
    #[tokio::test]
    async fn encode_returns_unexpected_eof_for_truncated_limited_reader() {
        let committed = Arc::new(Mutex::new(Vec::new()));
@@ -2316,11 +2196,11 @@ mod tests {
            .expect("bytesmut encode should succeed on current-thread runtime");

        let expected_shard_size = payload.len().div_ceil(erasure.data_shards);
-        assert_eq!(shards.shards().len(), erasure.total_shard_count());
-        assert!(shards.shards().all(|shard| shard.len() == expected_shard_size));
+        assert_eq!(shards.len(), erasure.total_shard_count());
+        assert!(shards.iter().all(|shard| shard.len() == expected_shard_size));

        let mut restored = Vec::new();
-        for shard in shards.shards().take(erasure.data_shards) {
+        for shard in shards.iter().take(erasure.data_shards) {
            restored.extend_from_slice(shard);
        }
        restored.truncate(payload.len());
@@ -2413,51 +2293,13 @@ mod tests {

        let erasure = Arc::new(Erasure::new(1, 0, 16));
        let reader = tokio::io::BufReader::new(Cursor::new(Vec::<u8>::new()));
-        let (_reader, total) = erasure
-            .encode_inline_small_with_size_hint(reader, &mut writers, 1, 0)
-            .await
-            .unwrap();
+        let (_reader, total) = erasure.encode_inline_small(reader, &mut writers, 1).await.unwrap();

        assert_eq!(total, 0);
        // No shutdown was called, so nothing should be committed
        assert!(committed.lock().unwrap().is_empty());
    }

-    #[tokio::test]
-    async fn encode_inline_shards_matches_writer_bitrot_layout() {
-        const DATA_SHARDS: usize = 2;
-        const PARITY_SHARDS: usize = 2;
-        const BLOCK_SIZE: usize = 64;
-        let checksum_algo = HashAlgorithm::HighwayHash256S;
-        for uses_legacy in [false, true] {
-            let erasure = Arc::new(Erasure::new_with_options(DATA_SHARDS, PARITY_SHARDS, BLOCK_SIZE, uses_legacy));
-            for payload in [Vec::new(), vec![0xA5], vec![0x5A; BLOCK_SIZE - 1], vec![0xC3; BLOCK_SIZE]] {
-                let reader = tokio::io::BufReader::new(Cursor::new(payload.clone()));
-                let (_reader, total, inline_shards) = erasure
-                    .clone()
-                    .encode_inline_shards_with_size_hint(reader, payload.len())
-                    .await
-                    .expect("inline shards should encode");
-
-                assert_eq!(total, payload.len());
-                if payload.is_empty() {
-                    assert!(inline_shards.is_empty());
-                    continue;
-                }
-
-                let raw_shards = erasure.encode_data(&payload).expect("reference shards should encode");
-                assert_eq!(inline_shards.len(), DATA_SHARDS + PARITY_SHARDS);
-                for (inline, raw) in inline_shards.iter().zip(raw_shards) {
-                    let mut writer =
-                        BitrotWriterWrapper::new(CustomWriter::new_inline_buffer(), raw.len(), checksum_algo.clone());
-                    writer.write(&raw).await.expect("reference writer should accept shard");
-                    writer.shutdown().await.expect("reference writer should shutdown");
-                    assert_eq!(inline.as_ref(), writer.into_inline_data().expect("reference writer should retain bytes"));
-                }
-            }
-        }
-    }
-
    /// encode_inline_small: small payload is encoded into the correct number of shards
    /// and each writer receives data after shutdown.
    #[tokio::test]
@@ -2483,10 +2325,7 @@ mod tests {
        let payload = b"hello inline small";
        let erasure = Arc::new(Erasure::new(DATA_SHARDS, PARITY_SHARDS, BLOCK_SIZE));
        let reader = tokio::io::BufReader::new(Cursor::new(payload.to_vec()));
-        let (_reader, total) = erasure
-            .encode_inline_small_with_size_hint(reader, &mut writers, DATA_SHARDS, 1)
-            .await
-            .unwrap();
+        let (_reader, total) = erasure.encode_inline_small(reader, &mut writers, DATA_SHARDS).await.unwrap();

        assert_eq!(total, payload.len());
        // All shards must have received data (shutdown flushed the bitrot header + shard bytes)
@@ -2553,7 +2392,7 @@ mod tests {
        let erasure = Arc::new(Erasure::new(DATA_SHARDS, PARITY_SHARDS, BLOCK_SIZE));
        let reader = tokio::io::BufReader::new(Cursor::new(payload));
        let err = erasure
-            .encode_single_block_non_inline_with_size_hint(reader, &mut writers, DATA_SHARDS, BLOCK_SIZE)
+            .encode_single_block_non_inline(reader, &mut writers, DATA_SHARDS)
            .await
            .expect_err("single-block fast path must reject oversized readers");

@@ -2564,21 +2403,6 @@ mod tests {
        }
    }

-    #[test]
-    fn small_ingest_capacity_uses_bounded_size_hint() {
-        let erasure = Erasure::new(4, 2, 1024 * 1024);
-        assert_eq!(small_ingest_capacity(&erasure, 0), 0);
-        assert_eq!(small_ingest_capacity(&erasure, 4 * 1024), 6 * 1024);
-        assert_eq!(small_ingest_capacity(&erasure, 16 * 1024), 24 * 1024);
-        assert_eq!(small_ingest_capacity(&erasure, usize::MAX), 1024 * 1024);
-
-        let legacy = Erasure::new_with_options(4, 2, 1024 * 1024, true);
-        assert_eq!(small_ingest_capacity(&legacy, 4 * 1024), 6 * 1024);
-
-        let high_parity = Erasure::new(4, 12, 1024 * 1024);
-        assert_eq!(small_ingest_capacity(&high_parity, usize::MAX), 1024 * 1024);
-    }
-
    #[tokio::test]
    async fn read_full_buf_or_eof_returns_none_on_empty_reader() {
        let mut reader = Cursor::new(Vec::<u8>::new());
@@ -2621,7 +2445,7 @@ mod tests {
        assert_eq!(&next[..], &data[16..]);
    }

-    async fn committed_shards_for_pipeline(pipeline: EncodePipeline, uses_legacy: bool, payload: &[u8]) -> Vec<Vec<u8>> {
+    async fn committed_shards_for_ingest_mode(use_bytesmut_ingest: bool, uses_legacy: bool, payload: &[u8]) -> Vec<Vec<u8>> {
        const DATA_SHARDS: usize = 2;
        const PARITY_SHARDS: usize = 2;
        const TOTAL_SHARDS: usize = DATA_SHARDS + PARITY_SHARDS;
@@ -2635,16 +2459,10 @@ mod tests {

        let erasure = Arc::new(Erasure::new_with_options(DATA_SHARDS, PARITY_SHARDS, BLOCK_SIZE, uses_legacy));
        let reader = tokio::io::BufReader::new(Cursor::new(payload.to_vec()));
-        let (_reader, total) = match pipeline {
-            EncodePipeline::Vec => {
-                erasure
-                    .encode_with_ingest_mode(reader, &mut writers, DATA_SHARDS, false)
-                    .await
-            }
-            EncodePipeline::BytesMut => erasure.encode_with_ingest_mode(reader, &mut writers, DATA_SHARDS, true).await,
-            EncodePipeline::Batched => erasure.encode_batched(reader, &mut writers, DATA_SHARDS).await,
-        }
-        .expect("encode should succeed");
+        let (_reader, total) = erasure
+            .encode_with_ingest_mode(reader, &mut writers, DATA_SHARDS, use_bytesmut_ingest)
+            .await
+            .expect("encode should succeed");
        assert_eq!(total, payload.len());

        committed
@@ -2653,64 +2471,31 @@ mod tests {
            .collect()
    }

-    async fn expected_committed_shards(uses_legacy: bool, payload: &[u8]) -> Vec<Vec<u8>> {
-        const DATA_SHARDS: usize = 2;
-        const PARITY_SHARDS: usize = 2;
-        const TOTAL_SHARDS: usize = DATA_SHARDS + PARITY_SHARDS;
-        const BLOCK_SIZE: usize = 64;
-
-        let committed: Vec<Arc<Mutex<Vec<u8>>>> = (0..TOTAL_SHARDS).map(|_| Arc::new(Mutex::new(Vec::new()))).collect();
-        let mut writers: Vec<BitrotWriterWrapper> = committed
-            .iter()
-            .map(|c| bitrot_writer(DeferredCommitWriter::new(c.clone()), BLOCK_SIZE / DATA_SHARDS))
-            .collect();
-        let erasure = Erasure::new_with_options(DATA_SHARDS, PARITY_SHARDS, BLOCK_SIZE, uses_legacy);
-
-        for block in payload.chunks(BLOCK_SIZE) {
-            let shards = erasure.encode_data(block).expect("reference block should encode");
-            for (writer, shard) in writers.iter_mut().zip(shards) {
-                let written = writer.write(&shard).await.expect("reference shard should write");
-                assert_eq!(written, shard.len());
-            }
-        }
-        for writer in &mut writers {
-            writer.shutdown().await.expect("reference writer should commit");
-        }
-
-        committed
-            .iter()
-            .map(|c| c.lock().expect("committed buffer should be lockable").clone())
-            .collect()
-    }
-
-    /// The streaming and batched paths must produce the same bitrot-wrapped shard
-    /// bytes as the public block encoder for both shard-size formulas and all block
-    /// boundary shapes.
+    /// HP-10 (rustfs/backlog#931) merge gate: the BytesMut ingest path must produce
+    /// byte-for-byte identical shard streams to the default Vec ingest path, for both
+    /// legacy-aware shard-size formulas, across empty, sub-block, exactly-full-block,
+    /// and multi-block-with-partial-tail payloads.
    #[tokio::test]
    async fn bytesmut_ingest_matches_vec_ingest_byte_for_byte() {
        const BLOCK_SIZE: usize = 64;
        let payloads: Vec<Vec<u8>> = vec![
            Vec::new(),
-            vec![1],
-            vec![2; BLOCK_SIZE - 1],
+            b"tiny".to_vec(),
            (0..BLOCK_SIZE as u32).map(|i| i as u8).collect(), // exactly one full block
-            vec![4; BLOCK_SIZE + 1],
-            vec![3u8; BLOCK_SIZE * 4],                                           // whole number of blocks
+            vec![3u8; BLOCK_SIZE * 4],                         // whole number of blocks
            (0..(BLOCK_SIZE * 3 + 7) as u32).map(|i| (i % 251) as u8).collect(), // partial tail
        ];

        for uses_legacy in [false, true] {
            for payload in &payloads {
-                let expected = expected_committed_shards(uses_legacy, payload).await;
-                for pipeline in [EncodePipeline::Vec, EncodePipeline::BytesMut, EncodePipeline::Batched] {
-                    let actual = committed_shards_for_pipeline(pipeline, uses_legacy, payload).await;
-                    assert_eq!(
-                        actual,
-                        expected,
-                        "streaming shards must match the public block encoder (legacy={uses_legacy}, payload_len={})",
-                        payload.len()
-                    );
-                }
+                let vec_path = committed_shards_for_ingest_mode(false, uses_legacy, payload).await;
+                let bytesmut_path = committed_shards_for_ingest_mode(true, uses_legacy, payload).await;
+                assert_eq!(
+                    vec_path,
+                    bytesmut_path,
+                    "ingest paths must be byte-identical (legacy={uses_legacy}, payload_len={})",
+                    payload.len()
+                );
            }
        }
    }
@@ -29,58 +29,12 @@ use tokio::io::AsyncRead;
 use tracing::warn;
 use uuid::Uuid;

-pub(crate) struct EncodedBlock {
-    data: Bytes,
-    shard_size: usize,
-}
-
-impl EncodedBlock {
-    fn empty() -> Self {
-        Self {
-            data: Bytes::new(),
-            shard_size: 0,
-        }
-    }
-
-    pub(crate) fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-
-    pub(crate) fn queued_bytes(&self) -> usize {
-        self.data.len()
-    }
-
-    pub(crate) fn shards(&self) -> impl ExactSizeIterator<Item = &[u8]> {
-        debug_assert!(self.shard_size > 0, "only non-empty encoded blocks reach shard writers");
-        debug_assert_eq!(self.data.len() % self.shard_size, 0);
-        self.data.chunks_exact(self.shard_size)
-    }
-
-    fn into_shards(mut self, shard_count: usize) -> Vec<Bytes> {
-        if self.shard_size == 0 {
-            return vec![Bytes::new(); shard_count];
-        }
-
-        let mut shards = Vec::with_capacity(shard_count);
-        for _ in 0..shard_count {
-            shards.push(self.data.split_to(self.shard_size));
-        }
-        shards
-    }
-}
-
 const MODERN_MAX_TOTAL_SHARDS: usize = <reed_solomon_erasure::galois_8::Field as reed_solomon_erasure::Field>::ORDER;
 const MODERN_REED_SOLOMON_CACHE_MAX_ENTRIES: usize = 64;
-const LEGACY_REED_SOLOMON_CACHE_MAX_ENTRIES: usize = 16;
-// Vec growth may retain twice the requested logical length. Keeping the logical
-// workspace at half the budget bounds each cached workspace's shard allocation to 1 MiB.
-const LEGACY_REED_SOLOMON_CACHE_MAX_LOGICAL_SHARD_BYTES_PER_WORKSPACE: usize = 512 * 1024;

 type ModernReedSolomonCache = RwLock<HashMap<(usize, usize), Arc<ReedSolomon>>>;
-type LegacyReedSolomonCache = RwLock<HashMap<(usize, usize), Arc<LegacyReedSolomonEncoder>>>;

 static MODERN_REED_SOLOMON_CACHE: OnceLock<ModernReedSolomonCache> = OnceLock::new();
-static LEGACY_REED_SOLOMON_CACHE: OnceLock<LegacyReedSolomonCache> = OnceLock::new();

 /// Errors returned when constructing an [`Erasure`] codec.
 #[derive(Debug, thiserror::Error)]
@@ -147,61 +101,43 @@ pub fn calc_shard_size_legacy(block_size: usize, data_shards: usize) -> usize {
 struct LegacyReedSolomonEncoder {
    data_shards: usize,
    parity_shards: usize,
-    cache_workspaces: bool,
-    encoder_cache: RwLock<Option<reed_solomon_simd::ReedSolomonEncoder>>,
-    decoder_cache: RwLock<Option<reed_solomon_simd::ReedSolomonDecoder>>,
+    encoder_cache: std::sync::RwLock<Option<reed_solomon_simd::ReedSolomonEncoder>>,
+    decoder_cache: std::sync::RwLock<Option<reed_solomon_simd::ReedSolomonDecoder>>,
+}
+
+impl Clone for LegacyReedSolomonEncoder {
+    fn clone(&self) -> Self {
+        Self {
+            data_shards: self.data_shards,
+            parity_shards: self.parity_shards,
+            encoder_cache: std::sync::RwLock::new(None),
+            decoder_cache: std::sync::RwLock::new(None),
+        }
+    }
 }

 impl LegacyReedSolomonEncoder {
-    fn new(data_shards: usize, parity_shards: usize) -> io::Result<Self> {
-        Self::with_workspace_cache(data_shards, parity_shards, false)
-    }
-
-    fn with_workspace_cache(data_shards: usize, parity_shards: usize, cache_workspaces: bool) -> io::Result<Self> {
+    fn new(_data_shards: usize, _parity_shards: usize) -> io::Result<Self> {
        Ok(Self {
-            data_shards,
-            parity_shards,
-            cache_workspaces,
-            encoder_cache: RwLock::new(None),
-            decoder_cache: RwLock::new(None),
+            data_shards: _data_shards,
+            parity_shards: _parity_shards,
+            encoder_cache: std::sync::RwLock::new(None),
+            decoder_cache: std::sync::RwLock::new(None),
        })
    }

-    fn logical_shard_bytes_upper_bound(&self, shard_len: usize) -> Option<usize> {
-        let aligned_shard_len = shard_len.checked_add(63)?.checked_div(64)?.checked_mul(64)?;
-        let high_rate_decoder_work_count = self
-            .parity_shards
-            .checked_next_power_of_two()?
-            .checked_add(self.data_shards)?
-            .checked_next_power_of_two()?;
-        let low_rate_decoder_work_count = self
-            .data_shards
-            .checked_next_power_of_two()?
-            .checked_add(self.parity_shards)?
-            .checked_next_power_of_two()?;
-        aligned_shard_len.checked_mul(high_rate_decoder_work_count.max(low_rate_decoder_work_count))
-    }
-
-    fn should_cache_workspace(&self, shard_len: usize) -> bool {
-        self.cache_workspaces
-            && self
-                .logical_shard_bytes_upper_bound(shard_len)
-                .is_some_and(|bytes| bytes <= LEGACY_REED_SOLOMON_CACHE_MAX_LOGICAL_SHARD_BYTES_PER_WORKSPACE)
-    }
-
    fn encode(&self, shards: SmallVec<[&mut [u8]; 16]>) -> io::Result<()> {
        let mut shards_vec: Vec<&mut [u8]> = shards.into_vec();
        if shards_vec.is_empty() {
            return Ok(());
        }
        let shard_len = shards_vec[0].len();
-        let cached_encoder = self
-            .encoder_cache
-            .write()
-            .map_err(|_| io::Error::other("Failed to acquire encoder cache lock"))?
-            .take();
        let mut encoder = {
-            match cached_encoder {
+            let mut cache_guard = self
+                .encoder_cache
+                .write()
+                .map_err(|_| io::Error::other("Failed to acquire encoder cache lock"))?;
+            match cache_guard.take() {
                Some(mut cached) => {
                    if cached.reset(self.data_shards, self.parity_shards, shard_len).is_err() {
                        reed_solomon_simd::ReedSolomonEncoder::new(self.data_shards, self.parity_shards, shard_len)
@@ -228,15 +164,10 @@ impl LegacyReedSolomonEncoder {
            }
        }
        drop(result);
-        if self.should_cache_workspace(shard_len) {
-            let mut cache = self
-                .encoder_cache
-                .write()
-                .map_err(|_| io::Error::other("Failed to return encoder to cache"))?;
-            if cache.is_none() {
-                *cache = Some(encoder);
-            }
-        }
+        *self
+            .encoder_cache
+            .write()
+            .map_err(|_| io::Error::other("Failed to return encoder to cache"))? = Some(encoder);
        Ok(())
    }

@@ -250,13 +181,13 @@ impl LegacyReedSolomonEncoder {
            .find_map(|s| s.as_ref().map(|v| v.len()))
            .ok_or_else(|| io::Error::other("No valid shards found for reconstruction"))?;

-        let cached_decoder = self
-            .decoder_cache
-            .write()
-            .map_err(|_| io::Error::other("Failed to acquire decoder cache lock"))?
-            .take();
        let mut decoder = {
-            match cached_decoder {
+            let mut cache_guard = self
+                .decoder_cache
+                .write()
+                .map_err(|_| io::Error::other("Failed to acquire decoder cache lock"))?;
+
+            match cache_guard.take() {
                Some(mut cached_decoder) => {
                    if let Err(e) = cached_decoder.reset(self.data_shards, self.parity_shards, shard_len) {
                        warn!("Failed to reset SIMD decoder: {:?}, creating new one", e);
@@ -303,15 +234,10 @@ impl LegacyReedSolomonEncoder {

        drop(result);

-        if self.should_cache_workspace(shard_len) {
-            let mut cache = self
-                .decoder_cache
-                .write()
-                .map_err(|_| io::Error::other("Failed to return decoder to cache"))?;
-            if cache.is_none() {
-                *cache = Some(decoder);
-            }
-        }
+        *self
+            .decoder_cache
+            .write()
+            .map_err(|_| io::Error::other("Failed to return decoder to cache"))? = Some(decoder);

        Ok(())
    }
@@ -469,39 +395,6 @@ fn cached_modern_reed_solomon(data_shards: usize, parity_shards: usize) -> Resul
    Ok(encoder)
 }

-fn cached_legacy_reed_solomon(data_shards: usize, parity_shards: usize) -> io::Result<Arc<LegacyReedSolomonEncoder>> {
-    let cache = LEGACY_REED_SOLOMON_CACHE.get_or_init(|| RwLock::new(HashMap::new()));
-    cached_legacy_reed_solomon_in(cache, data_shards, parity_shards)
-}
-
-fn cached_legacy_reed_solomon_in(
-    cache: &LegacyReedSolomonCache,
-    data_shards: usize,
-    parity_shards: usize,
-) -> io::Result<Arc<LegacyReedSolomonEncoder>> {
-    let key = (data_shards, parity_shards);
-    if let Some(encoder) = cache
-        .read()
-        .unwrap_or_else(|poisoned| poisoned.into_inner())
-        .get(&key)
-        .cloned()
-    {
-        return Ok(encoder);
-    }
-
-    let mut cache = cache.write().unwrap_or_else(|poisoned| poisoned.into_inner());
-    if let Some(existing) = cache.get(&key) {
-        return Ok(Arc::clone(existing));
-    }
-    if cache.len() < LEGACY_REED_SOLOMON_CACHE_MAX_ENTRIES {
-        let encoder = Arc::new(LegacyReedSolomonEncoder::with_workspace_cache(data_shards, parity_shards, true)?);
-        cache.insert(key, Arc::clone(&encoder));
-        return Ok(encoder);
-    }
-    drop(cache);
-    Ok(Arc::new(LegacyReedSolomonEncoder::new(data_shards, parity_shards)?))
-}
-
 fn encode_parity_shards<F>(shards: &mut [Option<Vec<u8>>], data_shards: usize, parity_shards: usize, encode: F) -> io::Result<()>
 where
    F: FnOnce(SmallVec<[&mut [u8]; 16]>) -> io::Result<()>,
@@ -618,7 +511,7 @@ pub struct Erasure {
    pub data_shards: usize,
    pub parity_shards: usize,
    encoder: Option<ReedSolomonEncoder>,
-    legacy_encoder: Option<Arc<LegacyReedSolomonEncoder>>,
+    legacy_encoder: Option<LegacyReedSolomonEncoder>,
    pub block_size: usize,
    uses_legacy: bool,
    _id: Uuid,
@@ -754,7 +647,7 @@ impl Erasure {

        let legacy_encoder = if uses_legacy && parity_shards > 0 {
            Some(
-                cached_legacy_reed_solomon(data_shards, parity_shards)
+                LegacyReedSolomonEncoder::new(data_shards, parity_shards)
                    .map_err(|source| ErasureConstructionError::LegacyEncoder { source })?,
            )
        } else {
@@ -782,48 +675,106 @@ impl Erasure {
    #[tracing::instrument(level = "debug", skip_all, fields(data_len=data.len()))]
    #[hotpath::measure(impl_type = "Erasure")]
    pub fn encode_data(&self, data: &[u8]) -> io::Result<Vec<Bytes>> {
-        self.encode_data_block_inner(data)
-            .map(|block| block.into_shards(self.total_shard_count()))
-    }
+        let shard_size_fn = if self.uses_legacy {
+            calc_shard_size_legacy
+        } else {
+            calc_shard_size
+        };
+        let per_shard_size = shard_size_fn(data.len(), self.data_shards);
+        if per_shard_size == 0 {
+            return Ok(vec![Bytes::new(); self.total_shard_count()]);
+        }
+        let need_total_size = per_shard_size * self.total_shard_count();

-    #[tracing::instrument(level = "debug", skip_all, fields(data_len=data.len()))]
-    #[hotpath::measure(label = "Erasure::encode_data", impl_type = "Erasure")]
-    pub(crate) fn encode_data_block(&self, data: &[u8]) -> io::Result<EncodedBlock> {
-        self.encode_data_block_inner(data)
-    }
-
-    fn encode_data_block_inner(&self, data: &[u8]) -> io::Result<EncodedBlock> {
-        let mut data_buffer = BytesMut::with_capacity(self.encoded_capacity_for_data_len(data.len()));
+        let mut data_buffer = BytesMut::with_capacity(need_total_size);
        data_buffer.extend_from_slice(data);
-        self.encode_buffer(data_buffer, data.len())
+        data_buffer.resize(need_total_size, 0u8);
+
+        {
+            let data_slices: SmallVec<[&mut [u8]; 16]> = data_buffer.chunks_exact_mut(per_shard_size).collect();
+
+            if self.parity_shards > 0 {
+                if self.uses_legacy {
+                    if let Some(encoder) = self.legacy_encoder.as_ref() {
+                        encoder.encode(data_slices)?;
+                    } else {
+                        warn!("parity_shards > 0, uses_legacy but legacy_encoder is None");
+                    }
+                } else if let Some(encoder) = self.encoder.as_ref() {
+                    encoder.encode(data_slices)?;
+                } else {
+                    warn!("parity_shards > 0, but encoder is None");
+                }
+            }
+        }
+
+        // Zero-copy split, all shards reference data_buffer
+        let mut data_buffer = data_buffer.freeze();
+        let mut shards = Vec::with_capacity(self.total_shard_count());
+        for _ in 0..self.total_shard_count() {
+            let shard = data_buffer.split_to(per_shard_size);
+            shards.push(shard);
+        }
+
+        Ok(shards)
    }

    /// Encode owned data, avoiding a copy when the caller already has a heap buffer.
    /// Falls back to copying into a new buffer if zero-copy conversion fails.
    #[hotpath::measure(impl_type = "Erasure")]
    pub fn encode_data_owned(&self, data: Vec<u8>) -> io::Result<Vec<Bytes>> {
-        self.encode_data_owned_block_inner(data)
-            .map(|block| block.into_shards(self.total_shard_count()))
-    }
+        let shard_size_fn = if self.uses_legacy {
+            calc_shard_size_legacy
+        } else {
+            calc_shard_size
+        };
+        let per_shard_size = shard_size_fn(data.len(), self.data_shards);
+        if per_shard_size == 0 {
+            return Ok(vec![Bytes::new(); self.total_shard_count()]);
+        }
+        let need_total_size = per_shard_size * self.total_shard_count();

-    #[hotpath::measure(label = "Erasure::encode_data_owned", impl_type = "Erasure")]
-    pub(crate) fn encode_data_owned_block(&self, data: Vec<u8>) -> io::Result<EncodedBlock> {
-        self.encode_data_owned_block_inner(data)
-    }
-
-    fn encode_data_owned_block_inner(&self, data: Vec<u8>) -> io::Result<EncodedBlock> {
-        let data_len = data.len();
        // Try zero-copy: Vec<u8> -> Bytes -> BytesMut (succeeds when refcount == 1)
-        let data_buffer = match Bytes::from(data).try_into_mut() {
-            Ok(data_buffer) => data_buffer,
+        let mut data_buffer = match Bytes::from(data).try_into_mut() {
+            Ok(mut bm) => {
+                bm.resize(need_total_size, 0u8);
+                bm
+            }
            Err(b) => {
                // Rare path: refcount != 1, fall back to copy
-                let mut data_buffer = BytesMut::with_capacity(self.encoded_capacity_for_data_len(data_len));
-                data_buffer.extend_from_slice(&b);
-                data_buffer
+                let mut bm = BytesMut::with_capacity(need_total_size);
+                bm.extend_from_slice(&b);
+                bm.resize(need_total_size, 0u8);
+                bm
            }
        };
-        self.encode_buffer(data_buffer, data_len)
+
+        {
+            let data_slices: SmallVec<[&mut [u8]; 16]> = data_buffer.chunks_exact_mut(per_shard_size).collect();
+
+            if self.parity_shards > 0 {
+                if self.uses_legacy {
+                    if let Some(encoder) = self.legacy_encoder.as_ref() {
+                        encoder.encode(data_slices)?;
+                    } else {
+                        warn!("parity_shards > 0, uses_legacy but legacy_encoder is None");
+                    }
+                } else if let Some(encoder) = self.encoder.as_ref() {
+                    encoder.encode(data_slices)?;
+                } else {
+                    warn!("parity_shards > 0, but encoder is None");
+                }
+            }
+        }
+
+        let mut data_buffer = data_buffer.freeze();
+        let mut shards = Vec::with_capacity(self.total_shard_count());
+        for _ in 0..self.total_shard_count() {
+            let shard = data_buffer.split_to(per_shard_size);
+            shards.push(shard);
+        }
+
+        Ok(shards)
    }

    /// Encode data from an owned `BytesMut` buffer, avoiding the initial copy
@@ -835,17 +786,7 @@ impl Erasure {
    /// `data_len <= block_size` — both shard-size formulas are monotone in
    /// `data_len` — so this function never reallocates the buffer.
    #[hotpath::measure(impl_type = "Erasure")]
-    pub fn encode_data_bytes_mut(&self, data_buffer: BytesMut, data_len: usize) -> io::Result<Vec<Bytes>> {
-        self.encode_buffer(data_buffer, data_len)
-            .map(|block| block.into_shards(self.total_shard_count()))
-    }
-
-    #[hotpath::measure(label = "Erasure::encode_data_bytes_mut", impl_type = "Erasure")]
-    pub(crate) fn encode_data_bytes_mut_block(&self, data_buffer: BytesMut, data_len: usize) -> io::Result<EncodedBlock> {
-        self.encode_buffer(data_buffer, data_len)
-    }
-
-    fn encode_buffer(&self, mut data_buffer: BytesMut, data_len: usize) -> io::Result<EncodedBlock> {
+    pub fn encode_data_bytes_mut(&self, mut data_buffer: BytesMut, data_len: usize) -> io::Result<Vec<Bytes>> {
        let shard_size_fn = if self.uses_legacy {
            calc_shard_size_legacy
        } else {
@@ -853,7 +794,7 @@ impl Erasure {
        };
        let per_shard_size = shard_size_fn(data_len, self.data_shards);
        if per_shard_size == 0 {
-            return Ok(EncodedBlock::empty());
+            return Ok(vec![Bytes::new(); self.total_shard_count()]);
        }
        let need_total_size = per_shard_size * self.total_shard_count();

@@ -880,10 +821,14 @@ impl Erasure {
            }
        }

-        Ok(EncodedBlock {
-            data: data_buffer.freeze(),
-            shard_size: per_shard_size,
-        })
+        let mut data_buffer = data_buffer.freeze();
+        let mut shards = Vec::with_capacity(self.total_shard_count());
+        for _ in 0..self.total_shard_count() {
+            let shard = data_buffer.split_to(per_shard_size);
+            shards.push(shard);
+        }
+
+        Ok(shards)
    }

    /// Decode and reconstruct missing data shards in-place.
@@ -1023,15 +968,6 @@ impl Erasure {
        self.data_shards + self.parity_shards
    }

-    pub(crate) fn encoded_capacity_for_data_len(&self, data_len: usize) -> usize {
-        let shard_size_fn = if self.uses_legacy {
-            calc_shard_size_legacy
-        } else {
-            calc_shard_size
-        };
-        shard_size_fn(data_len, self.data_shards).saturating_mul(self.total_shard_count())
-    }
-
    /// Whether the erasure dimensions are safe for the shard/offset arithmetic.
    ///
    /// `block_size` and `data_shards` come straight from on-disk metadata; a
@@ -1472,7 +1408,7 @@ mod tests {
        assert_eq!(cloned.block_size, legacy.block_size);
        assert!(cloned.uses_legacy);

-        let data = b"legacy clone should preserve SIMD codec behavior";
+        let data = b"legacy clone should keep independent SIMD caches";
        let encoded = cloned.encode_data(data).expect("legacy clone should encode");
        let mut shards = optional_shards(&encoded);
        shards[0] = None;
@@ -1480,93 +1416,6 @@ mod tests {
        assert_eq!(recover_data(&shards, cloned.data_shards, data.len()), data);
    }

-    #[test]
-    fn legacy_codecs_share_process_cache_across_erasure_instances() {
-        let first = Erasure::new_with_options(6, 3, 64, true)
-            .legacy_encoder
-            .expect("legacy codec should be initialized");
-        let second = Erasure::new_with_options(6, 3, 128, true)
-            .legacy_encoder
-            .expect("same legacy shard layout should be initialized");
-
-        assert!(Arc::ptr_eq(&first, &second));
-    }
-
-    #[test]
-    fn legacy_workspace_cache_rejects_oversize_buffers_and_isolates_layouts() {
-        let four_plus_two = Erasure::new_with_options(4, 2, 64, true)
-            .legacy_encoder
-            .expect("legacy codec should be initialized");
-        let four_plus_one = Erasure::new_with_options(4, 1, 64, true)
-            .legacy_encoder
-            .expect("distinct parity layout should be initialized");
-        let three_plus_two = Erasure::new_with_options(3, 2, 64, true)
-            .legacy_encoder
-            .expect("distinct data layout should be initialized");
-
-        assert!(!Arc::ptr_eq(&four_plus_two, &four_plus_one));
-        assert!(!Arc::ptr_eq(&four_plus_two, &three_plus_two));
-        assert_eq!(four_plus_two.logical_shard_bytes_upper_bound(64 * 1024), Some(512 * 1024));
-        assert!(four_plus_two.should_cache_workspace(64 * 1024));
-        assert!(!four_plus_two.should_cache_workspace(64 * 1024 + 1));
-
-        let nine_plus_seven =
-            LegacyReedSolomonEncoder::with_workspace_cache(9, 7, true).expect("9+7 legacy codec should construct");
-        assert_eq!(nine_plus_seven.logical_shard_bytes_upper_bound(16 * 1024), Some(512 * 1024));
-        assert!(nine_plus_seven.should_cache_workspace(16 * 1024));
-        assert!(!nine_plus_seven.should_cache_workspace(16 * 1024 + 1));
-
-        let uncached = LegacyReedSolomonEncoder::new(4, 2).expect("uncached legacy codec should construct");
-        assert!(!uncached.should_cache_workspace(64));
-    }
-
-    #[test]
-    fn saturated_legacy_codec_cache_does_not_retain_more_workspaces() {
-        let cache = RwLock::new(HashMap::new());
-        for parity_shards in 1..=LEGACY_REED_SOLOMON_CACHE_MAX_ENTRIES {
-            let cached =
-                cached_legacy_reed_solomon_in(&cache, 32, parity_shards).expect("cacheable legacy codec should construct");
-            assert!(cached.cache_workspaces);
-        }
-
-        let uncached =
-            cached_legacy_reed_solomon_in(&cache, 31, 1).expect("uncached legacy codec should construct after saturation");
-        assert!(!uncached.cache_workspaces);
-        assert_eq!(
-            cache.read().expect("cache lock should remain healthy").len(),
-            LEGACY_REED_SOLOMON_CACHE_MAX_ENTRIES
-        );
-    }
-
-    #[test]
-    fn concurrent_legacy_codecs_preserve_byte_exact_results() {
-        let barrier = Arc::new(std::sync::Barrier::new(2));
-        let payloads = [vec![0x35; 257], vec![0xca; 1025]];
-
-        std::thread::scope(|scope| {
-            let handles = payloads.each_ref().map(|payload| {
-                let barrier = Arc::clone(&barrier);
-                scope.spawn(move || {
-                    let erasure = Erasure::new_with_options(6, 3, 2048, true);
-                    barrier.wait();
-                    let encoded = erasure.encode_data(payload).expect("concurrent legacy encode should succeed");
-                    barrier.wait();
-
-                    let mut shards = optional_shards(&encoded);
-                    shards[0] = None;
-                    erasure
-                        .decode_data(&mut shards)
-                        .expect("concurrent legacy decode should reconstruct the missing shard");
-                    recover_data(&shards, erasure.data_shards, payload.len())
-                })
-            });
-
-            for (handle, payload) in handles.into_iter().zip(payloads.iter()) {
-                assert_eq!(handle.join().expect("concurrent legacy codec worker should not panic"), *payload);
-            }
-        });
-    }
-
    #[test]
    fn legacy_verify_reports_invalid_empty_valid_and_corrupt_parity_sets() {
        let legacy = LegacyReedSolomonEncoder::new(2, 2).expect("legacy encoder should construct");
@@ -1640,16 +1489,10 @@ mod tests {
    fn encode_data_owned_matches_borrowed_path() {
        for uses_legacy in [false, true] {
            let erasure = Erasure::new_with_options(4, 2, 64, uses_legacy);
-            for data in [
-                Vec::new(),
-                vec![0xA5; 1],
-                b"small payload".to_vec(),
-                (0_u8..37).collect(),
-                vec![0xA5; erasure.block_size - 1],
-                vec![0x5A; erasure.block_size],
-            ] {
-                assert_owned_encode_matches_borrowed(&erasure, data);
-            }
+
+            assert_owned_encode_matches_borrowed(&erasure, Vec::new());
+            assert_owned_encode_matches_borrowed(&erasure, b"small payload".to_vec());
+            assert_owned_encode_matches_borrowed(&erasure, (0_u8..37).collect());
        }
    }

@@ -1695,52 +1538,6 @@ mod tests {
        }
    }

-    #[test]
-    fn streaming_encoded_block_uses_one_contiguous_backing_buffer() {
-        for uses_legacy in [false, true] {
-            let erasure = Erasure::new_with_options(8, 8, 64, uses_legacy);
-
-            for data_len in [0, 1, 63, 64] {
-                let data = (0..data_len).map(|i| i as u8).collect::<Vec<_>>();
-                let expected = erasure.encode_data(&data).expect("public encode should succeed");
-                let borrowed = erasure
-                    .encode_data_block(&data)
-                    .expect("borrowed streaming encode should succeed");
-                let owned = erasure
-                    .encode_data_owned_block(data.clone())
-                    .expect("owned streaming encode should succeed");
-                let bytes_mut = erasure
-                    .encode_data_bytes_mut_block(BytesMut::from(&data[..]), data.len())
-                    .expect("BytesMut streaming encode should succeed");
-
-                assert_eq!(borrowed.queued_bytes(), owned.queued_bytes());
-                assert_eq!(borrowed.queued_bytes(), bytes_mut.queued_bytes());
-
-                if data_len == 0 {
-                    assert!(expected.iter().all(Bytes::is_empty));
-                    assert!(borrowed.is_empty());
-                    assert!(owned.is_empty());
-                    assert!(bytes_mut.is_empty());
-                    continue;
-                }
-
-                assert!(borrowed.shards().eq(expected.iter().map(Bytes::as_ref)));
-                assert!(owned.shards().eq(expected.iter().map(Bytes::as_ref)));
-                assert!(bytes_mut.shards().eq(expected.iter().map(Bytes::as_ref)));
-                assert_eq!(borrowed.shards().len(), 16);
-                let first = borrowed.shards().next().expect("encoded block should have shards").as_ptr();
-                for (index, shard) in borrowed.shards().enumerate() {
-                    assert_eq!(shard.as_ptr(), first.wrapping_add(index * shard.len()));
-                }
-            }
-        }
-        assert_eq!(
-            std::mem::size_of::<EncodedBlock>(),
-            std::mem::size_of::<Bytes>() + std::mem::size_of::<usize>(),
-            "queue entries must contain one backing buffer handle, not per-shard handles"
-        );
-    }
-
    /// HP-10 capacity invariant: both shard-size formulas are monotone in `data_len`,
    /// so pre-reserving `shard_size(block_size) * total_shard_count` covers the
    /// `need_total_size` of every block-or-smaller payload and the ingest buffer
@@ -204,8 +204,6 @@ pub enum StorageError {
        required: usize,
        achieved: usize,
    },
-    #[error("Bucket quota exceeded. Current usage: {current} bytes, limit: {limit} bytes")]
-    QuotaExceeded { current: u64, limit: u64 },

    // ── Generic ──────────────────────────────────────────────────────
    #[error("Unexpected error")]
@@ -358,13 +356,6 @@ impl From<StorageError> for DiskError {
            StorageError::VolumeNotFound => DiskError::VolumeNotFound,
            StorageError::VolumeExists => DiskError::VolumeExists,
            StorageError::FileNameTooLong => DiskError::FileNameTooLong,
-            StorageError::FaultyRemoteDisk => DiskError::FaultyRemoteDisk,
-            StorageError::DiskAccessDenied => DiskError::DiskAccessDenied,
-            StorageError::DriveIsRoot => DiskError::DriveIsRoot,
-            StorageError::IsNotRegular => DiskError::IsNotRegular,
-            StorageError::VolumeNotEmpty => DiskError::VolumeNotEmpty,
-            StorageError::VolumeAccessDenied => DiskError::VolumeAccessDenied,
-            StorageError::FileAccessDenied => DiskError::FileAccessDenied,
            _ => DiskError::other(val),
        }
    }
@@ -549,10 +540,6 @@ impl Clone for StorageError {
                required: *required,
                achieved: *achieved,
            },
-            StorageError::QuotaExceeded { current, limit } => StorageError::QuotaExceeded {
-                current: *current,
-                limit: *limit,
-            },
        }
    }
 }
@@ -640,7 +627,6 @@ impl StorageError {
            StorageError::NotModified => StorageErrorCode::NotModified,
            StorageError::InvalidPartNumber(_) => StorageErrorCode::InvalidPartNumber,
            StorageError::NamespaceLockQuorumUnavailable { .. } => StorageErrorCode::NamespaceLockQuorumUnavailable,
-            StorageError::QuotaExceeded { .. } => StorageErrorCode::QuotaExceeded,
        }
    }

@@ -766,10 +752,6 @@ impl StorageError {
                required: Default::default(),
                achieved: Default::default(),
            }),
-            StorageErrorCode::QuotaExceeded => Some(StorageError::QuotaExceeded {
-                current: Default::default(),
-                limit: Default::default(),
-            }),
        }
    }
 }
@@ -1319,7 +1301,6 @@ mod tests {
            .to_u32(),
            0x42
        );
-        assert_eq!(StorageError::QuotaExceeded { current: 1, limit: 2 }.to_u32(), 0x53);
    }

    #[test]
@@ -1338,10 +1319,6 @@ mod tests {
            StorageError::from_u32(0x42),
            Some(StorageError::NamespaceLockQuorumUnavailable { .. })
        ));
-        assert!(matches!(
-            StorageError::from_u32(0x53),
-            Some(StorageError::QuotaExceeded { current: 0, limit: 0 })
-        ));

        // Test invalid code returns None
        assert!(StorageError::from_u32(0xFF).is_none());
@@ -1499,49 +1476,6 @@ mod tests {
        }
    }

-    // Every DiskError variant must survive DiskError -> StorageError -> DiskError
-    // unchanged. A variant that degrades to `DiskError::Io` on the way back loses
-    // its identity for quorum aggregation (`reduce_errs` classifies by variant
-    // equality), so ignore-list entries such as FaultyRemoteDisk and
-    // DiskAccessDenied would silently stop matching.
-    #[test]
-    fn test_disk_error_storage_error_round_trip_identity_all_variants() {
-        // DiskError codes are contiguous from 0x01, so enumerating via from_u32
-        // covers every variant and picks up newly appended ones automatically.
-        let all_variants: Vec<DiskError> = (1u32..).map_while(DiskError::from_u32).collect();
-        assert!(
-            all_variants.len() >= 42,
-            "DiskError variant enumeration shrank: got {}, expected at least 42",
-            all_variants.len()
-        );
-
-        for original in all_variants {
-            let storage_error: StorageError = original.clone().into();
-            let round_tripped: DiskError = storage_error.into();
-
-            assert_eq!(
-                std::mem::discriminant(&original),
-                std::mem::discriminant(&round_tripped),
-                "round trip changed variant: {original:?} -> {round_tripped:?}"
-            );
-            assert_eq!(original, round_tripped, "round trip not identical for {original:?}");
-        }
-
-        // Io is the only payload-carrying variant: a representative kind and
-        // message must both survive the round trip.
-        let io_original = DiskError::Io(IoError::new(ErrorKind::PermissionDenied, "denied"));
-        let storage_error: StorageError = io_original.clone().into();
-        let io_round_tripped: DiskError = storage_error.into();
-        assert_eq!(io_original, io_round_tripped);
-        match io_round_tripped {
-            DiskError::Io(inner) => {
-                assert_eq!(inner.kind(), ErrorKind::PermissionDenied);
-                assert_eq!(inner.to_string(), "denied");
-            }
-            other => panic!("expected DiskError::Io, got {other:?}"),
-        }
-    }
-
    #[test]
    fn test_storage_error_from_io_error() {
        // Test direct IO error conversion
@@ -1615,7 +1549,6 @@ mod tests {
            StorageError::DecommissionAlreadyRunning,
            StorageError::RebalanceAlreadyRunning,
            StorageError::OperationCanceled,
-            StorageError::QuotaExceeded { current: 1, limit: 2 },
        ];

        for original_error in test_errors {
@@ -22,13 +22,12 @@ use crate::diagnostics::get::{
 #[cfg(feature = "hotpath")]
 use crate::disk::FileWriter;
 use crate::disk::{self, DiskAPI as _, DiskStore, FileReader, MmapCopyStageMetrics, error::DiskError};
-use crate::erasure::coding::{BitrotReader, BitrotWriterWrapper, CustomWriter, ShardChunkRead};
+use crate::erasure::coding::{BitrotReader, BitrotWriterWrapper, CustomWriter};
 use bytes::Bytes;
 use rustfs_config::{
    DEFAULT_OBJECT_MMAP_READ_ENABLE, DEFAULT_OBJECT_MMAP_READ_MAX_LENGTH, ENV_OBJECT_MMAP_READ_ENABLE,
    ENV_OBJECT_MMAP_READ_MAX_LENGTH, ENV_OBJECT_ZERO_COPY_ENABLE,
 };
-use rustfs_rio::ChunkReaderBox;
 use rustfs_utils::HashAlgorithm;
 use std::future::Future;
 use std::io::{self, Cursor};
@@ -52,25 +51,13 @@ tokio::task_local! {
 /// (rustfs/backlog#1159). Everything else is a stream and keeps the old path.
 pub enum ShardReader {
    InMemory(Cursor<Bytes>),
-    Chunked(ChunkReaderBox),
    Stream(Box<dyn AsyncRead + Send + Sync + Unpin>),
 }

-#[cfg(test)]
-impl ShardReader {
-    pub(crate) fn inline_bytes(&self) -> Option<&Bytes> {
-        match self {
-            Self::InMemory(cursor) => Some(cursor.get_ref()),
-            Self::Chunked(_) | Self::Stream(_) => None,
-        }
-    }
-}
-
 impl AsyncRead for ShardReader {
    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut tokio::io::ReadBuf<'_>) -> Poll<std::io::Result<()>> {
        match self.get_mut() {
            Self::InMemory(cursor) => Pin::new(cursor).poll_read(cx, buf),
-            Self::Chunked(reader) => Pin::new(&mut **reader).poll_read(cx, buf),
            Self::Stream(reader) => Pin::new(reader).poll_read(cx, buf),
        }
    }
@@ -80,19 +67,7 @@ impl crate::erasure::coding::ShardSource for ShardReader {
    fn try_take_block(&mut self, n: usize) -> Option<Bytes> {
        match self {
            Self::InMemory(cursor) => cursor.try_take_block(n),
-            Self::Chunked(_) | Self::Stream(_) => None,
-        }
-    }
-
-    fn poll_read_chunk(self: Pin<&mut Self>, cx: &mut Context<'_>, max: usize) -> Poll<io::Result<ShardChunkRead>> {
-        let Self::Chunked(reader) = self.get_mut() else {
-            return Poll::Ready(Ok(ShardChunkRead::Unsupported));
-        };
-        match Pin::new(&mut **reader).poll_read_chunk(cx, max) {
-            Poll::Ready(Ok(Some(chunk))) => Poll::Ready(Ok(ShardChunkRead::Chunk(chunk))),
-            Poll::Ready(Ok(None)) => Poll::Ready(Ok(ShardChunkRead::Eof)),
-            Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
-            Poll::Pending => Poll::Pending,
+            Self::Stream(_) => None,
        }
    }
 }
@@ -145,41 +120,26 @@ struct BitrotReaderSource {

 impl BitrotReaderSource {
    async fn open(self) -> disk::error::Result<Option<BoxedObjectReader>> {
-        open_reader_source(
-            self.inline_data,
-            self.disk.as_ref(),
-            &self.bucket,
-            &self.path,
-            self.offset,
-            self.length,
-            self.use_mmap_read,
-            self.stage_metrics.map(|metrics| metrics.path),
-        )
-        .await
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn open_reader_source(
-    inline_data: Option<Bytes>,
-    disk: Option<&DiskStore>,
-    bucket: &str,
-    path: &str,
-    offset: usize,
-    length: usize,
-    use_mmap_read: bool,
-    metrics_path: Option<&'static str>,
-) -> disk::error::Result<Option<BoxedObjectReader>> {
-    if let Some(data) = inline_data {
-        let mut reader = Cursor::new(data);
-        reader.set_position(u64::try_from(offset).map_err(|_| DiskError::FileCorrupt)?);
-        Ok(Some(ShardReader::InMemory(reader)))
-    } else if let Some(disk) = disk {
-        open_disk_reader(disk, bucket, path, offset, length, use_mmap_read, metrics_path)
+        if let Some(data) = self.inline_data {
+            let mut rd = Cursor::new(data);
+            let offset = u64::try_from(self.offset).map_err(|_| DiskError::FileCorrupt)?;
+            rd.set_position(offset);
+            Ok(Some(ShardReader::InMemory(rd)))
+        } else if let Some(disk) = self.disk {
+            open_disk_reader(
+                &disk,
+                &self.bucket,
+                &self.path,
+                self.offset,
+                self.length,
+                self.use_mmap_read,
+                self.stage_metrics.map(|metrics| metrics.path),
+            )
            .await
            .map(Some)
-    } else {
-        Ok(None)
+        } else {
+            Ok(None)
+        }
    }
 }

@@ -370,17 +330,6 @@ async fn open_disk_reader(
    let metrics_path = metrics_path.filter(|_| rustfs_io_metrics::get_stage_metrics_enabled());
    let stage_metrics_enabled = metrics_path.is_some();

-    // Preserve HTTP body ownership only on healthy remote reads. Instrumented
-    // and local paths retain their existing AsyncRead wrappers.
-    if use_mmap_read
-        && !disk.is_local()
-        && !stage_metrics_enabled
-        && !cfg!(feature = "hotpath")
-        && let Some(reader) = disk.read_file_stream_chunks(bucket, path, offset, length).await?
-    {
-        return Ok(ShardReader::Chunked(reader));
-    }
-
    // Mmap-copy materializes the whole `offset..offset+length` range as one
    // owned allocation before any byte is served, and GET/heal shard reads
    // request the entire part span in one call. Over-cap reads (e.g. a huge
@@ -656,7 +605,7 @@ pub async fn create_bitrot_reader_from_bytes(
 }

 #[allow(clippy::too_many_arguments)]
-pub(crate) async fn create_bitrot_reader_from_bytes_with_stage_metrics(
+async fn create_bitrot_reader_from_bytes_with_stage_metrics(
    inline_data: Option<Bytes>,
    disk: Option<&DiskStore>,
    bucket: &str,
@@ -674,22 +623,22 @@ pub(crate) async fn create_bitrot_reader_from_bytes_with_stage_metrics(

    let reader_construction_start = stage_metrics_enabled.then(Instant::now);
    let (offset, length) = bitrot_encoded_range(offset, length, shard_size, checksum_algo.clone());
+    let source = BitrotReaderSource {
+        inline_data,
+        disk: disk.cloned(),
+        bucket: bucket.to_string(),
+        path: path.to_string(),
+        offset,
+        length,
+        use_mmap_read,
+        stage_metrics,
+    };
    if let Some(metrics) = stage_metrics {
        record_get_stage_duration_if_enabled(metrics.path, metrics.reader_construction_stage, reader_construction_start);
    }

    let file_open_start = stage_metrics_enabled.then(Instant::now);
-    let reader = open_reader_source(
-        inline_data,
-        disk,
-        bucket,
-        path,
-        offset,
-        length,
-        use_mmap_read,
-        stage_metrics.map(|metrics| metrics.path),
-    )
-    .await?;
+    let reader = source.open().await?;
    if let Some(metrics) = stage_metrics {
        record_get_stage_duration_if_enabled(metrics.path, metrics.file_open_stage, file_open_start);
    }
@@ -749,12 +698,11 @@ pub(crate) fn create_deferred_bitrot_reader_with_stripe_handle(
 ) -> (BitrotReader<ShardReader>, DeferredReaderStripeHandle) {
    let stripe_stride = shard_size + checksum_algo.size();
    let (offset, length) = bitrot_encoded_range(offset, length, shard_size, checksum_algo.clone());
-    let inline_source = inline_data.is_some();
    let source = BitrotReaderSource {
        inline_data,
        disk,
-        bucket: if inline_source { String::new() } else { bucket.to_string() },
-        path: if inline_source { String::new() } else { path.to_string() },
+        bucket: bucket.to_string(),
+        path: path.to_string(),
        offset,
        length,
        use_mmap_read,
@@ -816,50 +764,6 @@ pub async fn create_bitrot_writer(
 #[cfg(test)]
 mod tests {
    use super::*;
-    use rustfs_rio::ChunkReader;
-    use std::collections::VecDeque;
-
-    struct TestChunkReader {
-        chunks: VecDeque<Bytes>,
-    }
-
-    impl TestChunkReader {
-        fn new(bytes: Bytes, fragment_sizes: &[usize]) -> Self {
-            let mut chunks = VecDeque::new();
-            let mut offset = 0;
-            for &size in fragment_sizes {
-                let end = (offset + size).min(bytes.len());
-                if offset < end {
-                    chunks.push_back(bytes.slice(offset..end));
-                }
-                offset = end;
-            }
-            if offset < bytes.len() {
-                chunks.push_back(bytes.slice(offset..));
-            }
-            Self { chunks }
-        }
-    }
-
-    impl AsyncRead for TestChunkReader {
-        fn poll_read(self: Pin<&mut Self>, _cx: &mut Context<'_>, _buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
-            Poll::Ready(Err(io::Error::other("test chunk reader must use chunk handoff")))
-        }
-    }
-
-    impl ChunkReader for TestChunkReader {
-        fn poll_read_chunk(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, max: usize) -> Poll<io::Result<Option<Bytes>>> {
-            let Some(mut chunk) = self.chunks.pop_front() else {
-                return Poll::Ready(Ok(None));
-            };
-            let take = chunk.len().min(max);
-            if take < chunk.len() {
-                self.chunks.push_front(chunk.split_off(take));
-            }
-            chunk.truncate(take);
-            Poll::Ready(Ok(Some(chunk)))
-        }
-    }

    #[cfg(feature = "hotpath")]
    use crate::cluster::rpc::RemoteDisk;
@@ -1749,49 +1653,4 @@ mod tests {
        println!("error: {error:?}");
        assert_eq!(error, DiskError::DiskNotFound);
    }
-
-    #[tokio::test]
-    async fn shard_reader_chunked_path_verifies_fragmented_remote_block() {
-        const SHARD_SIZE: usize = 1024;
-        let algo = HashAlgorithm::HighwayHash256S;
-        let data = vec![42u8; SHARD_SIZE];
-        let mut encoded = Vec::new();
-        crate::erasure::coding::BitrotWriter::new(&mut encoded, SHARD_SIZE, algo.clone())
-            .write(&data)
-            .await
-            .expect("test shard should encode");
-
-        let source = TestChunkReader::new(Bytes::from(encoded), &[3, 7, 17, 31]);
-        let mut reader = BitrotReader::new(ShardReader::Chunked(Box::new(source)), SHARD_SIZE, algo, false);
-        let mut output = Vec::with_capacity(SHARD_SIZE);
-        reader
-            .read_appending(&mut output, SHARD_SIZE)
-            .await
-            .expect("fragmented remote shard should verify");
-
-        assert_eq!(output, data);
-    }
-
-    #[tokio::test]
-    async fn shard_reader_chunked_path_handles_more_than_one_poll_budget() {
-        const SHARD_SIZE: usize = 1024;
-        let algo = HashAlgorithm::HighwayHash256S;
-        let data = vec![42u8; SHARD_SIZE];
-        let mut encoded = Vec::new();
-        crate::erasure::coding::BitrotWriter::new(&mut encoded, SHARD_SIZE, algo.clone())
-            .write(&data)
-            .await
-            .expect("test shard should encode");
-
-        let fragment_sizes = vec![1; encoded.len()];
-        let source = TestChunkReader::new(Bytes::from(encoded), &fragment_sizes);
-        let mut reader = BitrotReader::new(ShardReader::Chunked(Box::new(source)), SHARD_SIZE, algo, false);
-        let mut output = Vec::with_capacity(SHARD_SIZE);
-        reader
-            .read_appending(&mut output, SHARD_SIZE)
-            .await
-            .expect("fragmented remote shard should verify after multiple polls");
-
-        assert_eq!(output, data);
-    }
 }
@@ -21,8 +21,7 @@ use tracing::debug;

 /// Supported set sizes this is used to find the optimal
 /// single set size.
-pub(crate) const MAX_ERASURE_SET_DRIVE_COUNT: usize = 16;
-const SET_SIZES: [usize; 15] = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, MAX_ERASURE_SET_DRIVE_COUNT];
+const SET_SIZES: [usize; 15] = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
 const ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT: &str = "RUSTFS_ERASURE_SET_DRIVE_COUNT";

 #[derive(Deserialize, Debug, Default)]
@@ -328,7 +327,7 @@ fn possible_set_counts(set_size: usize) -> Vec<usize> {

 /// checks whether given count is a valid set size for erasure coding.
 fn is_valid_set_size(count: usize) -> bool {
-    count >= SET_SIZES[0] && count <= MAX_ERASURE_SET_DRIVE_COUNT
+    count >= SET_SIZES[0] && count <= SET_SIZES[SET_SIZES.len() - 1]
 }

 /// Final set size with all the symmetry accounted for.
@@ -234,17 +234,11 @@ mod test {

    #[test]
    fn test_format_v1() {
-        // A freshly created format must survive a serialize -> parse roundtrip
-        // unchanged (identity on every on-disk field).
        let format = FormatV3::new(1, 4);
-        let serialized = serde_json::to_string(&format).expect("FormatV3 must serialize to JSON");
-        let reparsed = FormatV3::try_from(serialized.as_str()).expect("serialized FormatV3 must parse back");
-        assert_eq!(reparsed, format);

-        // minio-file-format-compat: this literal pins the on-disk format.json
-        // shape (erasure version "1", distributionAlgo "CRCMOD"). `this` always
-        // carries the disk's own UUID in real format.json files; a JSON null
-        // there was never parseable and never written by MinIO or RustFS.
+        let str = serde_json::to_string(&format);
+        println!("{str:?}");
+
        let data = r#"
        {
            "version": "1",
@@ -252,7 +246,7 @@ mod test {
            "id": "321b3874-987d-4c15-8fa5-757c956b1243",
            "xl": {
                "version": "1",
-                "this": "8ab9a908-f869-4f1f-8e42-eb067ffa7eb5",
+                "this": null,
                "sets": [
                    [
                        "8ab9a908-f869-4f1f-8e42-eb067ffa7eb5",
@@ -265,23 +259,9 @@ mod test {
            }
        }"#;

-        let parsed = FormatV3::try_from(data).expect("pinned v1 format.json literal must keep parsing");
+        let p = FormatV3::try_from(data);

-        assert_eq!(parsed.version, FormatMetaVersion::V1);
-        assert_eq!(parsed.format, FormatBackend::Erasure);
-        assert_eq!(
-            parsed.id,
-            Uuid::parse_str("321b3874-987d-4c15-8fa5-757c956b1243").expect("literal id is a valid UUID")
-        );
-        assert_eq!(parsed.erasure.version, FormatErasureVersion::V1);
-        assert_eq!(
-            parsed.erasure.this,
-            Uuid::parse_str("8ab9a908-f869-4f1f-8e42-eb067ffa7eb5").expect("literal this is a valid UUID")
-        );
-        assert_eq!(parsed.erasure.sets.len(), 1);
-        assert_eq!(parsed.erasure.sets[0].len(), 4);
-        assert_eq!(parsed.erasure.sets[0][0], parsed.erasure.this);
-        assert_eq!(parsed.erasure.distribution_algo, DistributionAlgoVersion::V1);
+        println!("{p:?}");
    }

    #[test]
@@ -15,7 +15,6 @@
 use super::*;

 use crate::io_support::rio::Index;
-use std::mem::MaybeUninit;

 #[cfg(feature = "rio-v2")]
 const DARE_PAYLOAD_SIZE: i64 = 64 * 1024;
@@ -923,7 +922,7 @@ struct SkipReader<R> {
    inner: R,
    bytes_to_skip: usize,
    bytes_skipped: usize,
-    scratch: Box<[MaybeUninit<u8>]>,
+    scratch: Vec<u8>,
 }

 impl<R: AsyncRead + Unpin + Send + Sync> SkipReader<R> {
@@ -932,7 +931,7 @@ impl<R: AsyncRead + Unpin + Send + Sync> SkipReader<R> {
            inner,
            bytes_to_skip,
            bytes_skipped: 0,
-            scratch: Box::<[u8]>::new_uninit_slice(8192),
+            scratch: vec![0u8; 8192],
        }
    }
 }
@@ -944,7 +943,7 @@ impl<R: AsyncRead + Unpin + Send + Sync> AsyncRead for SkipReader<R> {
        while this.bytes_skipped < this.bytes_to_skip {
            let remaining = this.bytes_to_skip - this.bytes_skipped;
            let scratch_len = remaining.min(this.scratch.len());
-            let mut scratch_buf = ReadBuf::uninit(&mut this.scratch[..scratch_len]);
+            let mut scratch_buf = ReadBuf::new(&mut this.scratch[..scratch_len]);
            match Pin::new(&mut this.inner).poll_read(cx, &mut scratch_buf) {
                Poll::Pending => return Poll::Pending,
                Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
@@ -975,7 +974,7 @@ pub struct RangedDecompressReader<R: AsyncRead + Unpin + Send + Sync + 'static>
    target_length: usize,
    current_offset: usize,
    bytes_returned: usize,
-    scratch: Box<[MaybeUninit<u8>]>,
+    scratch: Vec<u8>,
    drain_on_done: bool,
    drain_task: Option<tokio::task::JoinHandle<()>>,
 }
@@ -1013,7 +1012,7 @@ impl<R: AsyncRead + Unpin + Send + Sync + 'static> RangedDecompressReader<R> {
            target_length: actual_length,
            current_offset: 0,
            bytes_returned: 0,
-            scratch: Box::<[u8]>::new_uninit_slice(8192),
+            scratch: vec![0u8; 8192],
            drain_on_done,
            drain_task: None,
        })
@@ -1063,7 +1062,7 @@ impl<R: AsyncRead + Unpin + Send + Sync + 'static> AsyncRead for RangedDecompres
            }

            let scratch_len = std::cmp::min(this.scratch.len(), std::cmp::max(buf_capacity, 1));
-            let mut temp_read_buf = ReadBuf::uninit(&mut this.scratch[..scratch_len]);
+            let mut temp_read_buf = ReadBuf::new(&mut this.scratch[..scratch_len]);

            let Some(inner) = this.inner.as_mut() else {
                return Poll::Ready(Ok(()));
@@ -1115,8 +1114,7 @@ impl<R: AsyncRead + Unpin + Send + Sync + 'static> AsyncRead for RangedDecompres
                            );

                            if bytes_to_return > 0 {
-                                let data_slice =
-                                    &temp_read_buf.filled()[data_start_in_buffer..data_start_in_buffer + bytes_to_return];
+                                let data_slice = &this.scratch[data_start_in_buffer..data_start_in_buffer + bytes_to_return];
                                buf.put_slice(data_slice);
                                this.bytes_returned += bytes_to_return;

@@ -1135,7 +1133,7 @@ impl<R: AsyncRead + Unpin + Send + Sync + 'static> AsyncRead for RangedDecompres
                            std::cmp::min(n, std::cmp::min(buf.remaining(), this.target_length - this.bytes_returned));

                        if bytes_to_return > 0 {
-                            buf.put_slice(&temp_read_buf.filled()[..bytes_to_return]);
+                            buf.put_slice(&this.scratch[..bytes_to_return]);
                            this.bytes_returned += bytes_to_return;

                            tracing::trace!("Returned {} bytes at offset {}", bytes_to_return, old_offset);
@@ -1265,43 +1263,6 @@ mod tests {
    use temp_env::async_with_vars;
    use tokio::io::AsyncReadExt;

-    #[derive(Debug)]
-    struct PendingPartialReader {
-        data: &'static [u8],
-        position: usize,
-        pending: bool,
-    }
-
-    impl PendingPartialReader {
-        fn new(data: &'static [u8]) -> Self {
-            Self {
-                data,
-                position: 0,
-                pending: true,
-            }
-        }
-    }
-
-    impl AsyncRead for PendingPartialReader {
-        fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
-            if self.pending {
-                self.pending = false;
-                cx.waker().wake_by_ref();
-                return Poll::Pending;
-            }
-            if self.position == self.data.len() {
-                return Poll::Ready(Ok(()));
-            }
-
-            let length = buf.remaining().min(3).min(self.data.len() - self.position);
-            let end = self.position + length;
-            buf.put_slice(&self.data[self.position..end]);
-            self.position = end;
-            self.pending = true;
-            Poll::Ready(Ok(()))
-        }
-    }
-
    const TEST_DIRECT_KEY_HEADER: &str = "x-rustfs-test-direct-key";
    const TEST_OBJECT_KEY_HEADER: &str = "x-rustfs-test-object-key";
    const TEST_NONCE_HEADER: &str = "x-rustfs-test-nonce";
@@ -1439,36 +1400,6 @@ mod tests {
        assert_eq!(result, b"World");
    }

-    #[tokio::test]
-    async fn uninitialized_scratch_preserves_partial_pending_and_eof_reads() {
-        let mut skipped = SkipReader::new(PendingPartialReader::new(b"0123456789abcdef"), 5);
-        let mut skipped_output = Vec::new();
-        skipped
-            .read_to_end(&mut skipped_output)
-            .await
-            .expect("skip reader should survive partial pending reads through EOF");
-        assert_eq!(skipped_output, b"56789abcdef");
-
-        let mut ranged = RangedDecompressReader::new(PendingPartialReader::new(b"0123456789abcdef"), 5, 7, 16)
-            .expect("valid range should construct");
-        let mut ranged_output = Vec::new();
-        ranged
-            .read_to_end(&mut ranged_output)
-            .await
-            .expect("range reader should survive partial pending reads through EOF");
-        assert_eq!(ranged_output, b"56789ab");
-    }
-
-    #[tokio::test]
-    async fn uninitialized_skip_scratch_reports_early_eof() {
-        let mut reader = SkipReader::new(PendingPartialReader::new(b"short"), 6);
-        let error = reader
-            .read_to_end(&mut Vec::new())
-            .await
-            .expect_err("EOF before the skip boundary must remain visible");
-        assert_eq!(error.kind(), std::io::ErrorKind::UnexpectedEof);
-    }
-
    #[tokio::test]
    async fn test_ranged_decompress_reader_from_start() {
        let original_data = b"Hello, World! This is a test.";
@@ -211,26 +211,6 @@ impl ObjectLockConfigSnapshot {
    }
 }

-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct QuotaAdmission {
-    current_usage: u64,
-    quota_limit: u64,
-}
-
-impl QuotaAdmission {
-    pub(crate) fn current_usage(self) -> u64 {
-        self.current_usage
-    }
-
-    pub(crate) fn quota_limit(self) -> u64 {
-        self.quota_limit
-    }
-
-    pub(crate) fn remaining(self) -> u64 {
-        self.quota_limit - self.current_usage
-    }
-}
-
 #[derive(Debug, Default, Clone)]
 pub struct ObjectOptions {
    // Use the maximum parity (N/2), used when saving server configuration files
@@ -260,9 +240,6 @@ pub struct ObjectOptions {

    pub data_movement: bool,
    pub raw_data_movement_read: bool,
-    /// Materialize the data-movement per-part checksum sidecar for APIs that
-    /// return part checksums. Ordinary object reads leave it encoded.
-    pub include_part_checksums: bool,
    pub src_pool_idx: usize,
    pub user_defined: HashMap<String, String>,
    pub preserve_etag: Option<String>,
@@ -298,22 +275,12 @@ pub struct ObjectOptions {
    pub want_checksum: Option<Checksum>,
    pub skip_verify_bitrot: bool,
    pub capacity_scope_token: Option<Uuid>,
-    /// Server-derived bucket-quota snapshot for commit-boundary admission.
-    pub quota_admission: Option<QuotaAdmission>,
    /// Storage-owned journal writer used by the atomic delete path. This is
    /// populated only by the `ECStore` wrapper that holds the namespace locks.
    pub tier_delete_journal_api: Option<Arc<crate::store::ECStore>>,
 }

 impl ObjectOptions {
-    pub fn set_quota_admission(&mut self, current_usage: u64, quota_limit: u64) -> bool {
-        self.quota_admission = (current_usage <= quota_limit).then_some(QuotaAdmission {
-            current_usage,
-            quota_limit,
-        });
-        self.quota_admission.is_some()
-    }
-
    pub(crate) fn overwrites_existing_version(&self) -> bool {
        self.version_id.is_some() || !self.versioned || self.version_suspended
    }
@@ -164,9 +164,6 @@ pub(crate) async fn local_node_name() -> String {
 }

 pub(crate) async fn set_local_node_name(node_name: String) {
-    // Also stamp the internode-metrics server label: io-metrics is a leaf
-    // crate and no longer resolves node identity itself (backlog#1834).
-    rustfs_io_metrics::internode_metrics::set_internode_server_label(node_name.as_str());
    rustfs_common::set_global_local_node_name(&node_name).await;
 }

@@ -236,6 +233,10 @@ pub(crate) fn storage_class_parity(storage_class: Option<&str>) -> Option<usize>
    get_global_storage_class_snapshot().get_parity_for_sc(storage_class.unwrap_or_default())
 }

+pub(crate) fn storage_class_should_inline(shard_size: i64, versioned: bool) -> bool {
+    get_global_storage_class_snapshot().should_inline(shard_size, versioned)
+}
+
 pub(crate) fn deployment_upload_id(upload_id: &str) -> String {
    base64_simd::URL_SAFE_NO_PAD
        .encode_to_string(format!("{}.{}", get_global_deployment_id().unwrap_or_default(), upload_id).as_bytes())
@@ -206,38 +206,6 @@ pub(crate) fn remote_version_state_fleet_proof_matches(proof: &RemoteVersionStat
    })
 }

-#[cfg(test)]
-pub(crate) struct RemoteVersionStateFleetProofGuard;
-
-#[cfg(test)]
-impl Drop for RemoteVersionStateFleetProofGuard {
-    fn drop(&mut self) {
-        replace_remote_version_state_fleet_proof(None);
-    }
-}
-
-#[cfg(test)]
-pub(crate) fn install_remote_version_state_fleet_proof_for_test(topology_fingerprint: &str) -> RemoteVersionStateFleetProofGuard {
-    match REMOTE_VERSION_STATE_PROBE_TOPOLOGY.set(topology_fingerprint.to_string()) {
-        Ok(()) => {}
-        Err(_)
-            if REMOTE_VERSION_STATE_PROBE_TOPOLOGY
-                .get()
-                .is_some_and(|current| current == topology_fingerprint) => {}
-        Err(_) => panic!("remote version state test topology is already bound to another fingerprint"),
-    }
-    let peer_epochs = BTreeMap::new();
-    if let Some(err) = publish_remote_version_state_probe_result(
-        remote_version_state_fleet_proof_slot(),
-        topology_fingerprint,
-        Ok(peer_epochs),
-        Instant::now(),
-    ) {
-        panic!("test proof installation must not fail: {err}");
-    }
-    RemoteVersionStateFleetProofGuard
-}
-
 fn remote_version_state_fleet_proof_valid_at(
    proof: Option<&RemoteVersionStateFleetProof>,
    expected_topology: &str,
@@ -16,7 +16,7 @@ use super::meta::{
    clone_arc_by_index, ensure_valid_rebalance_pool_index, invalid_rebalance_pool_index_error,
    rebalance_metadata_not_initialized_error, should_ignore_rebalance_data_usage_cache,
 };
-use super::migration::{RebalanceMigrationBackend, migrate_entry_version};
+use super::migration::migrate_entry_version;
 use super::worker::{
    RebalanceEntryCleanupResult, RebalanceEntryTask, load_rebalance_bucket_configs, rebalance_max_attempts,
    resolve_rebalance_bucket_error, resolve_rebalance_entry_cleanup_delete_result, resolve_rebalance_file_info_versions_result,
@@ -144,11 +144,6 @@ impl ECStore {
            return Ok(RebalanceEntryOutcome::Completed);
        }

-        let bucket_incarnation_fence = match bucket_configs.bucket_incarnation_id {
-            Some(expected) => Some(self.acquire_bucket_incarnation_fence(&bucket, expected).await?),
-            None => None,
-        };
-
        let mut fivs =
            resolve_rebalance_file_info_versions_result(entry.file_info_versions(&bucket), bucket.as_str(), entry.name.as_str())?;

@@ -208,14 +203,9 @@ impl ECStore {
            }

            let version_id = version.version_id.map(|v| v.to_string());
-            let expected_bucket_incarnation_id = bucket_configs.bucket_incarnation_id;
            let mut transfer = |src_pool_idx: usize, bucket: String, rd: GetObjectReader| {
                let store = self.clone();
-                async move {
-                    store
-                        .rebalance_object(src_pool_idx, bucket, rd, expected_bucket_incarnation_id)
-                        .await
-                }
+                async move { store.rebalance_object(src_pool_idx, bucket, rd).await }
            };
            // Route delete-marker migration through the store layer so it lands on the
            // cross-pool target (excluding the source pool), not back onto the source set.
@@ -224,12 +214,11 @@ impl ECStore {
                async move { store.delete_object(&bucket, &object, opts).await }
            };
            let result = migrate_entry_version(
-                &RebalanceMigrationBackend::new(set.as_ref(), self.as_ref()),
+                set.as_ref(),
                bucket.clone(),
                pool_index,
                version,
                version_id.clone(),
-                expected_bucket_incarnation_id,
                rebalance_max_attempts(),
                should_ignore_rebalance_data_usage_cache(bucket.as_str()),
                &mut transfer,
@@ -314,9 +303,6 @@ impl ECStore {
        }

        if should_cleanup_rebalance_source_entry(rebalanced, fivs.versions.len(), expired) {
-            if bucket_incarnation_fence.as_ref().is_some_and(|guard| guard.is_lock_lost()) {
-                return Err(Error::other("rebalance bucket incarnation fence was lost before source cleanup"));
-            }
            let cleanup_result = self
                .finish_rebalance_entry_after_cleanup(
                    pool_index,
@@ -329,12 +315,6 @@ impl ECStore {
                        entry.name.as_str(),
                        &fivs,
                        &cleanup_preflight_allowed_missing,
-                        data_movement::SourceCleanupBucketFence {
-                            expected_incarnation_id: bucket_configs.bucket_incarnation_id,
-                            lifecycle_guard: bucket_incarnation_fence
-                                .as_ref()
-                                .and_then(|guard| guard.namespace_lock_guard()),
-                        },
                        "rebalance",
                    ),
                )
@@ -409,14 +389,8 @@ impl ECStore {
    }

    #[tracing::instrument(skip(self, rd))]
-    async fn rebalance_object(
-        self: Arc<Self>,
-        pool_idx: usize,
-        bucket: String,
-        rd: GetObjectReader,
-        expected_bucket_incarnation_id: Option<uuid::Uuid>,
-    ) -> Result<()> {
-        data_movement::migrate_object(self, pool_idx, bucket, rd, expected_bucket_incarnation_id, "rebalance_object").await
+    async fn rebalance_object(self: Arc<Self>, pool_idx: usize, bucket: String, rd: GetObjectReader) -> Result<()> {
+        data_movement::migrate_object(self, pool_idx, bucket, rd, "rebalance_object").await
    }

    async fn update_rebalance_last_error(&self, pool_idx: usize, message: String) -> Result<()> {
@@ -5,7 +5,6 @@ use crate::error::{Error, Result, is_err_object_not_found, is_err_version_not_fo
 use crate::object_api::{GetObjectReader, ObjectInfo, ObjectOptions};
 use crate::set_disk::SetDisks;
 use crate::storage_api_contracts::{object::ObjectIO, range::HTTPRangeSpec};
-use crate::store::ECStore;
 use http::HeaderMap;
 use rustfs_filemeta::FileInfo;
 use rustfs_utils::path::encode_dir_object;
@@ -22,23 +21,15 @@ pub(crate) struct MigrationVersionResult {
    pub error: Option<Error>,
 }

-pub(super) fn rebalance_delete_marker_opts(
-    version: &FileInfo,
-    version_id: Option<String>,
-    src_pool_idx: usize,
-    expected_bucket_incarnation_id: Option<uuid::Uuid>,
-) -> ObjectOptions {
-    let version_suspended = version.version_id.is_none() && version_id.is_none();
+pub(super) fn rebalance_delete_marker_opts(version: &FileInfo, version_id: Option<String>, src_pool_idx: usize) -> ObjectOptions {
    ObjectOptions {
-        versioned: !version_suspended,
-        version_suspended,
-        version_id: version_id.or_else(|| version_suspended.then(|| uuid::Uuid::nil().to_string())),
+        versioned: true,
+        version_id,
        mod_time: version.mod_time,
        src_pool_idx,
        data_movement: true,
        delete_marker: true,
        skip_decommissioned: true,
-        expected_bucket_incarnation_id,
        delete_replication: version
            .replication_state_internal
            .as_ref()
@@ -47,12 +38,7 @@ pub(super) fn rebalance_delete_marker_opts(
    }
 }

-fn rebalance_remote_tiered_opts(
-    version: &FileInfo,
-    version_id: Option<String>,
-    src_pool_idx: usize,
-    expected_bucket_incarnation_id: Option<uuid::Uuid>,
-) -> ObjectOptions {
+fn rebalance_remote_tiered_opts(version: &FileInfo, version_id: Option<String>, src_pool_idx: usize) -> ObjectOptions {
    ObjectOptions {
        versioned: version_id.is_some(),
        version_id,
@@ -60,21 +46,6 @@ fn rebalance_remote_tiered_opts(
        user_defined: version.metadata.clone(),
        src_pool_idx,
        data_movement: true,
-        include_part_checksums: true,
-        http_preconditions: Some(crate::data_movement::data_movement_target_precondition()),
-        expected_bucket_incarnation_id,
-        ..Default::default()
-    }
-}
-
-pub(super) fn rebalance_object_migration_read_opts(version_id: Option<String>) -> ObjectOptions {
-    ObjectOptions {
-        version_id,
-        no_lock: true,
-        data_movement: true,
-        raw_data_movement_read: true,
-        skip_decommissioned: true,
-        skip_rebalancing: true,
        ..Default::default()
    }
 }
@@ -99,19 +70,8 @@ pub(crate) trait MigrationBackend: Send + Sync {
    ) -> Result<()>;
 }

-pub(crate) struct RebalanceMigrationBackend<'a> {
-    source: &'a SetDisks,
-    store: &'a ECStore,
-}
-
-impl<'a> RebalanceMigrationBackend<'a> {
-    pub(crate) fn new(source: &'a SetDisks, store: &'a ECStore) -> Self {
-        Self { source, store }
-    }
-}
-
 #[async_trait::async_trait]
-impl MigrationBackend for RebalanceMigrationBackend<'_> {
+impl MigrationBackend for SetDisks {
    async fn get_object_reader_for_migration(
        &self,
        bucket: &str,
@@ -120,7 +80,7 @@ impl MigrationBackend for RebalanceMigrationBackend<'_> {
        h: HeaderMap,
        opts: &ObjectOptions,
    ) -> Result<GetObjectReader> {
-        self.source.get_object_reader(bucket, object, range, h, opts).await
+        self.get_object_reader(bucket, object, range, h, opts).await
    }

    async fn move_remote_version_for_migration(
@@ -130,7 +90,7 @@ impl MigrationBackend for RebalanceMigrationBackend<'_> {
        fi: &FileInfo,
        opts: &ObjectOptions,
    ) -> Result<()> {
-        self.store.decommission_tiered_object(bucket, object, fi, opts).await
+        self.decommission_tiered_object(bucket, object, fi, opts).await
    }
 }

@@ -141,7 +101,6 @@ pub(crate) async fn migrate_entry_version<Backend, F, Fut, D, DFut>(
    pool_index: usize,
    version: &FileInfo,
    version_id: Option<String>,
-    expected_bucket_incarnation_id: Option<uuid::Uuid>,
    max_attempts: usize,
    ignore_data_usage_cache: bool,
    transfer: F,
@@ -154,13 +113,12 @@ where
    D: FnMut(String, String, ObjectOptions) -> DFut + Send,
    DFut: Future<Output = Result<ObjectInfo>> + Send,
 {
-    migrate_entry_version_with_retry_wait_and_incarnation(
+    migrate_entry_version_with_retry_wait(
        set,
        bucket,
        pool_index,
        version,
        version_id,
-        expected_bucket_incarnation_id,
        max_attempts,
        ignore_data_usage_cache,
        transfer,
@@ -179,45 +137,6 @@ pub(super) async fn migrate_entry_version_with_retry_wait<Backend, F, Fut, D, DF
    version_id: Option<String>,
    max_attempts: usize,
    ignore_data_usage_cache: bool,
-    transfer: F,
-    delete_marker: D,
-    wait_retry: W,
-) -> MigrationVersionResult
-where
-    Backend: MigrationBackend + ?Sized,
-    F: FnMut(usize, String, GetObjectReader) -> Fut + Send,
-    Fut: Future<Output = Result<()>> + Send,
-    D: FnMut(String, String, ObjectOptions) -> DFut + Send,
-    DFut: Future<Output = Result<ObjectInfo>> + Send,
-    W: FnMut(Duration) -> WFut + Send,
-    WFut: Future<Output = ()> + Send,
-{
-    migrate_entry_version_with_retry_wait_and_incarnation(
-        set,
-        bucket,
-        pool_index,
-        version,
-        version_id,
-        None,
-        max_attempts,
-        ignore_data_usage_cache,
-        transfer,
-        delete_marker,
-        wait_retry,
-    )
-    .await
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn migrate_entry_version_with_retry_wait_and_incarnation<Backend, F, Fut, D, DFut, W, WFut>(
-    set: &Backend,
-    bucket: String,
-    pool_index: usize,
-    version: &FileInfo,
-    version_id: Option<String>,
-    expected_bucket_incarnation_id: Option<uuid::Uuid>,
-    max_attempts: usize,
-    ignore_data_usage_cache: bool,
    mut transfer: F,
    mut delete_marker: D,
    mut wait_retry: W,
@@ -250,7 +169,7 @@ where
                &bucket,
                &version.name,
                version,
-                &rebalance_remote_tiered_opts(version, version_id, pool_index, expected_bucket_incarnation_id),
+                &rebalance_remote_tiered_opts(version, version_id, pool_index),
            )
            .await
        {
@@ -293,7 +212,7 @@ where
        if let Err(err) = delete_marker(
            bucket.clone(),
            version.name.clone(),
-            rebalance_delete_marker_opts(version, version_id, pool_index, expected_bucket_incarnation_id),
+            rebalance_delete_marker_opts(version, version_id, pool_index),
        )
        .await
        {
@@ -336,7 +255,11 @@ where
                &encode_dir_object(&version.name),
                None,
                HeaderMap::new(),
-                &rebalance_object_migration_read_opts(version_id.clone()),
+                &ObjectOptions {
+                    version_id: version_id.clone(),
+                    no_lock: true,
+                    ..Default::default()
+                },
            )
            .await
        {
@@ -113,8 +113,6 @@ struct LegacyRebalanceMeta {
 struct MigrationBackendSpy {
    get_object_reader: Mutex<Option<core::result::Result<GetObjectReader, Error>>>,
    move_remote: Mutex<Option<core::result::Result<(), Error>>>,
-    get_opts: Mutex<Vec<ObjectOptions>>,
-    move_remote_opts: Mutex<Vec<ObjectOptions>>,
    get_calls: AtomicUsize,
    move_remote_calls: AtomicUsize,
 }
@@ -127,8 +125,6 @@ impl MigrationBackendSpy {
        Self {
            get_object_reader: Mutex::new(get_object_reader),
            move_remote: Mutex::new(move_remote),
-            get_opts: Mutex::new(Vec::new()),
-            move_remote_opts: Mutex::new(Vec::new()),
            get_calls: AtomicUsize::new(0),
            move_remote_calls: AtomicUsize::new(0),
        }
@@ -142,24 +138,6 @@ impl MigrationBackendSpy {
        self.move_remote_calls.load(Ordering::SeqCst)
    }

-    fn last_get_opts(&self) -> ObjectOptions {
-        self.get_opts
-            .lock()
-            .unwrap()
-            .last()
-            .cloned()
-            .expect("reader opts should be captured")
-    }
-
-    fn last_move_remote_opts(&self) -> ObjectOptions {
-        self.move_remote_opts
-            .lock()
-            .unwrap()
-            .last()
-            .cloned()
-            .expect("remote opts should be captured")
-    }
-
    fn make_reader() -> GetObjectReader {
        GetObjectReader {
            stream: Box::new(Cursor::new(vec![0_u8; 3])),
@@ -178,10 +156,9 @@ impl MigrationBackend for MigrationBackendSpy {
        _object: &str,
        _range: Option<HTTPRangeSpec>,
        _h: http::HeaderMap,
-        opts: &ObjectOptions,
+        _opts: &ObjectOptions,
    ) -> Result<GetObjectReader> {
        self.get_calls.fetch_add(1, Ordering::SeqCst);
-        self.get_opts.lock().unwrap().push(opts.clone());
        if let Some(result) = self.get_object_reader.lock().unwrap().take() {
            return result;
        }
@@ -194,10 +171,9 @@ impl MigrationBackend for MigrationBackendSpy {
        _bucket: &str,
        _object: &str,
        _fi: &FileInfo,
-        opts: &ObjectOptions,
+        _opts: &ObjectOptions,
    ) -> Result<()> {
        self.move_remote_calls.fetch_add(1, Ordering::SeqCst);
-        self.move_remote_opts.lock().unwrap().push(opts.clone());
        if let Some(result) = self.move_remote.lock().unwrap().take() {
            return result;
        }
@@ -241,8 +217,7 @@ fn test_rebalance_delete_marker_opts_preserves_replication_state() {
        ..version_deleted()
    };

-    let incarnation = uuid::Uuid::new_v4();
-    let opts = rebalance_delete_marker_opts(&version, Some("version-id".to_string()), 7, Some(incarnation));
+    let opts = rebalance_delete_marker_opts(&version, Some("version-id".to_string()), 7);
    let replication = opts.delete_replication.expect("replication state should be preserved");

    assert!(opts.versioned);
@@ -252,22 +227,11 @@ fn test_rebalance_delete_marker_opts_preserves_replication_state() {
    assert_eq!(opts.src_pool_idx, 7);
    assert_eq!(opts.version_id.as_deref(), Some("version-id"));
    assert_eq!(opts.mod_time, Some(mod_time));
-    assert_eq!(opts.expected_bucket_incarnation_id, Some(incarnation));
    assert_eq!(replication.replica_status, ReplicationStatusType::Replica);
    assert!(replication.delete_marker);
    assert_eq!(replication.replicate_decision_str, "existing");
 }

-#[test]
-fn test_rebalance_delete_marker_opts_preserves_suspended_null_version() {
-    let version = version_deleted();
-    let opts = rebalance_delete_marker_opts(&version, None, 7, None);
-
-    assert!(!opts.versioned);
-    assert!(opts.version_suspended);
-    assert_eq!(opts.version_id.as_deref(), Some(uuid::Uuid::nil().to_string().as_str()));
-}
-
 #[tokio::test]
 async fn test_migrate_entry_version_remote_version_is_moved_without_transfer() {
    let backend = MigrationBackendSpy::new(None, Some(Ok(())));
@@ -284,14 +248,12 @@ async fn test_migrate_entry_version_remote_version_is_moved_without_transfer() {
        }
    };

-    let incarnation = uuid::Uuid::new_v4();
    let result = migrate_entry_version(
        &backend,
        "bucket".to_string(),
        0,
        &version,
        version.version_id.map(|v| v.to_string()),
-        Some(incarnation),
        3,
        false,
        &mut transfer,
@@ -307,10 +269,6 @@ async fn test_migrate_entry_version_remote_version_is_moved_without_transfer() {
    assert_eq!(transfer_count.load(Ordering::SeqCst), 0);
    assert_eq!(backend.move_remote_calls(), 1);
    assert_eq!(backend.get_calls(), 0);
-    let remote_opts = backend.last_move_remote_opts();
-    assert!(remote_opts.include_part_checksums);
-    assert!(remote_opts.http_preconditions.is_some());
-    assert_eq!(remote_opts.expected_bucket_incarnation_id, Some(incarnation));
 }

 #[tokio::test]
@@ -336,7 +294,6 @@ async fn test_migrate_entry_version_remote_not_found_is_cleanup_ignored() {
        0,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -373,7 +330,6 @@ async fn test_migrate_entry_version_remote_overwrite_is_not_ignored() {
        0,
        &version,
        Some("vid-1".to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -412,7 +368,6 @@ async fn test_migrate_entry_version_remote_failure_is_reported() {
        0,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -455,7 +410,6 @@ async fn test_migrate_entry_version_deleted_version_routes_delete_through_store_
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -495,7 +449,6 @@ async fn test_migrate_entry_version_deleted_version_not_found_is_ignored() {
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -538,7 +491,6 @@ async fn test_migrate_entry_version_deleted_version_overwrite_is_not_ignored() {
        1,
        &version,
        Some("vid-1".to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -568,7 +520,6 @@ async fn test_migrate_entry_version_reader_not_found_is_ignored() {
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -696,7 +647,6 @@ async fn test_migrate_entry_version_reader_fails_after_retries() {
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -735,7 +685,6 @@ async fn test_migrate_entry_version_zero_max_attempts_still_attempts_once() {
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        0,
        false,
        &mut transfer,
@@ -801,13 +750,6 @@ async fn test_migrate_entry_version_transfer_retries_before_success() {
    assert_eq!(backend.get_calls(), 2);
    assert_eq!(transfer_count.load(Ordering::SeqCst), 2);
    assert_eq!(wait_count.load(Ordering::SeqCst), 1);
-    let read_opts = backend.last_get_opts();
-    assert_eq!(read_opts.version_id.as_deref(), version.version_id.map(|id| id.to_string()).as_deref());
-    assert!(read_opts.no_lock);
-    assert!(read_opts.data_movement);
-    assert!(read_opts.raw_data_movement_read);
-    assert!(read_opts.skip_decommissioned);
-    assert!(read_opts.skip_rebalancing);
 }

 #[tokio::test]
@@ -880,7 +822,6 @@ async fn test_migrate_entry_version_transfer_fails_after_retries() {
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        2,
        false,
        &mut transfer,
@@ -919,7 +860,6 @@ async fn test_migrate_entry_version_transfer_not_found_is_ignored() {
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -961,7 +901,6 @@ async fn test_migrate_entry_version_transfer_overwrite_is_not_ignored() {
        1,
        &version,
        Some("vid-1".to_string()),
-        None,
        3,
        false,
        &mut transfer,
@@ -1004,7 +943,6 @@ async fn test_migrate_entry_version_ignores_data_usage_cache_when_enabled() {
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        2,
        true,
        &mut transfer,
@@ -1047,7 +985,6 @@ async fn test_migrate_entry_version_data_usage_cache_moves_when_ignore_disabled(
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        2,
        false,
        &mut transfer,
@@ -2089,7 +2026,6 @@ async fn test_migrate_entry_version_transfer_failure_reports_write_target_stage(
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        1,
        false,
        &mut transfer,
@@ -2114,7 +2050,6 @@ async fn test_migrate_entry_version_reader_failure_reports_read_source_stage() {
        1,
        &version,
        version.version_id.map(|v| v.to_string()),
-        None,
        1,
        false,
        &mut transfer,
@@ -36,7 +36,6 @@ pub type RStats = Vec<Arc<RebalanceStats>>;

 #[derive(Debug, Default)]
 pub(super) struct RebalanceBucketConfigs {
-    pub(super) bucket_incarnation_id: Option<uuid::Uuid>,
    pub(super) lifecycle_config: Option<s3s::dto::BucketLifecycleConfiguration>,
    pub(super) object_lock_config: Option<s3s::dto::ObjectLockConfiguration>,
    pub(super) replication_config: Option<(s3s::dto::ReplicationConfiguration, OffsetDateTime)>,
@@ -406,7 +406,6 @@ pub(super) async fn load_rebalance_bucket_configs(api: &ECStore, bucket: &str) -

    let expiry_configs = crate::bucket::lifecycle::get_expiry_configs(api, bucket).await?;
    Ok(RebalanceBucketConfigs {
-        bucket_incarnation_id: Some(api.bucket_incarnation_id_from_disk(bucket).await?),
        lifecycle_config: expiry_configs.lifecycle.map(|config| (*config).clone()),
        object_lock_config: expiry_configs.object_lock.map(|config| (*config).clone()),
        replication_config: resolve_rebalance_optional_bucket_config_result(
--- a/Show More
+++ b/Show More