refactor(admin): drop the legacy target descriptor JSON response helper (#8968)

`target_descriptor::build_json_response` returned the s3s response and
had no production caller left once the event, audit and plugin instance
handlers moved to `owned_build_json_response`; it survived only for the
legacy/owned equivalence test. Remove it, give the owned helper its own
documentation, and make the test assert the owned response directly:
status, `application/json`, the echoed `x-request-id` when present and
only then, and the body bytes. The file no longer imports s3s, so the
footprint baseline drops from 66 to 65 files.

.agents/skills/security-advisory-lessons/SKILL.md

@@ -36,6 +36,21 @@ changed lesson.
 
 ## Finding Standard
 
-Each finding includes severity, `file:line`, attacker prerequisites, concrete
-input/path, impact, smallest safe fix, and a regression check. Do not exaggerate
-unauthenticated impact when the actual issue requires authenticated low privilege.
+Every candidate names the lower-trust principal, the boundary it crosses, the
+affected resource, and the observable result. A best-practice gap or an impact
+confined to the caller's own principal is hardening, not a candidate.
+
+Report each candidate under exactly one verdict:
+
+- `confirmed`: a complete `file:line` source trace and a bounded observed
+  result. Only confirmed findings carry severity; each also states attacker
+  prerequisites, concrete input/path, impact, smallest safe fix, and a
+  regression check.
+- `needs_validation`: the trace is blocked on one exact unresolved fact, such
+  as deployment or infrastructure behavior. State that fact; assign no severity
+  and do not substitute an assumption.
+- `rejected`: a disproved candidate, with the caller, invariant, or test that
+  disproves it.
+
+Do not exaggerate unauthenticated impact when the actual issue requires
+authenticated low privilege.

.config/e2e-distributed-selection.txt

@@ -1,2 +1,2 @@
-sha256-linux=39e8ed9c36ba9e3b89e0ab395c93a778d3f3a956eb433f09b5459b7c1e559bd5
-sha256-darwin=39e8ed9c36ba9e3b89e0ab395c93a778d3f3a956eb433f09b5459b7c1e559bd5
+sha256-linux=cf31ed27e4e6bf42da5bf81f248d9d2619ac8e8615186cdacb30bd63996d7607
+sha256-darwin=cf31ed27e4e6bf42da5bf81f248d9d2619ac8e8615186cdacb30bd63996d7607

.config/e2e-full-selection.txt

@@ -1,2 +1,2 @@
-sha256-darwin=f801018455712d8767ff6d467f3883036f762936f75435a22de74317274bf90d
-sha256-linux=1621c50e25d63f124b411babbf613c04474c5e68864d2e810e50ec892379e91e
+sha256-darwin=7893834728e2dadb98110c2aa018e6aa150c882c8a39c753e8095c3aef94cf0e
+sha256-linux=fb95ac8ba4b68aec9182fe32a59923e6b0d37b45a62ce87ea7db0dc3c40375e6

.config/e2e-repl-nightly-selection.txt

@@ -1 +1 @@
-sha256=e4ee3898b840a8374cb02c64342cc15f8d7ecd1becaf4b4a2a4657290f9e7ff1
+sha256=4eac269f9a59b2f9be4e7a87ea6aa38454f5ebe10ede35c9b8d4218137d2cd35

.config/e2e-smoke-selection.txt

@@ -1 +1 @@
-sha256=eaa140bb7c7fff74c92a0cd191805f7fdee3174eaa6a649a1b807e1e6b497a31
+sha256=aa603dbbae2e0dc0803489a88887a630c542a6949466c2b0e73b8a6b5e57fcaa

.config/make/lint-fmt.mak

@@ -70,6 +70,11 @@ s3s-footprint-check: ## Check the s3s dependency footprint ratchet stays frozen
 	@echo "📦 Checking s3s footprint ratchet..."
 	./scripts/check_s3s_footprint.sh
 
+.PHONY: test-count-ratchet-check
+test-count-ratchet-check: ## Check no workspace crate lost tests or gained #[ignore] against the committed baseline
+	@echo "🧪 Checking per-crate test-count ratchet..."
+	./scripts/check_test_count_ratchet.sh
+
 .PHONY: fips-wording-check
 fips-wording-check: ## Check docs and crates/kms do not over-claim crypto capabilities
 	@echo "📣 Checking cryptographic capability wording guard..."

.config/make/pre-commit.mak

@@ -20,11 +20,11 @@ planning-docs-check: ## Check that no planning-type documents are committed
 	./scripts/check_no_planning_docs.sh
 
 .PHONY: pre-commit
-pre-commit: fmt-check unsafe-code-check architecture-migration-check logging-guardrails-check error-other-ratchet-check tokio-io-uring-check extension-schema-check body-cache-whitelist-check s3s-footprint-check fips-wording-check embedded-secrets-check test-wiring-check doc-paths-check planning-docs-check quick-check ## Run fast pre-commit checks without clippy/full tests
+pre-commit: fmt-check unsafe-code-check architecture-migration-check logging-guardrails-check error-other-ratchet-check tokio-io-uring-check extension-schema-check body-cache-whitelist-check s3s-footprint-check test-count-ratchet-check fips-wording-check embedded-secrets-check test-wiring-check doc-paths-check planning-docs-check quick-check ## Run fast pre-commit checks without clippy/full tests
 	@echo "✅ All pre-commit checks passed!"
 
 .PHONY: pre-pr
-pre-pr: fmt-check unsafe-code-check architecture-migration-check logging-guardrails-check error-other-ratchet-check tokio-io-uring-check extension-schema-check body-cache-whitelist-check s3s-footprint-check fips-wording-check embedded-secrets-check test-wiring-check doc-paths-check planning-docs-check log-analyzer-rules-check offline-enrollment-e2e-check clippy-check test ## Run full pre-PR checks with clippy and tests
+pre-pr: fmt-check unsafe-code-check architecture-migration-check logging-guardrails-check error-other-ratchet-check tokio-io-uring-check extension-schema-check body-cache-whitelist-check s3s-footprint-check test-count-ratchet-check fips-wording-check embedded-secrets-check test-wiring-check doc-paths-check planning-docs-check log-analyzer-rules-check offline-enrollment-e2e-check clippy-check test ## Run full pre-PR checks with clippy and tests
 	@echo "✅ All pre-PR checks passed!"
 
 .PHONY: dev-check

.config/make/tests.mak

@@ -50,7 +50,9 @@ script-tests: ## Run shell script tests
 	./scripts/test_fuzz_runner.sh
 	./scripts/test_python_bin.sh
 	./scripts/check_embedded_secrets.sh --self-test
+	./scripts/check_s3s_footprint.sh --self-test
 	$(RUSTFS_PYTHON_BIN) ./scripts/check_test_wiring.py --self-test
+	$(RUSTFS_PYTHON_BIN) ./scripts/codemods/s3_error_to_s3_types.py --self-test
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_e2e_binary.py
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_release_build_workflow.py
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_release_glibc.py

.config/nextest.toml

@@ -83,6 +83,13 @@ threads-required = "num-test-threads"
 filter = '(package(rustfs-ecstore) & test(=core::pools_test::decommission_lock_order_tests::active_decommission_migration_does_not_invert_capacity_and_delete_object_tag_locks)) | (package(rustfs-heal) & test(=heal::mrf_queue::partial_write::tests::durable_retry_submission_error_keeps_checkpoint_and_uses_backoff))'
 threads-required = "num-test-threads"
 
+# These eight-disk decommission fixtures exercise concurrent retries,
+# free-version cleanup, and real capacity probes under production lock deadlines.
+# Reserve the run's capacity so unrelated IO cannot exhaust those budgets.
+[[profile.default.overrides]]
+filter = 'package(rustfs-ecstore) & (test(/^store::init::tests::decommission_entry_(retries_source_changed_without_canceling_other_bucket|skips_cleanup_only_marker_when_free_version_is_present)$/) | test(=core::pools::tests::decommission_capacity_mutation_limits_prewrite_sampling_to_target))'
+threads-required = "num-test-threads"
+
 # This registration/backup lock probe uses an isolated eight-disk store.
 # Reserve capacity so sibling disk-heavy tests cannot consume its 2s
 # registration budget; retain the queued backup and deadlock assertions.
@@ -94,8 +101,11 @@ threads-required = "num-test-threads"
 filter = 'package(rustfs-heal) & (binary(mrf_partial_write_test) | (binary(mrf_pipeline_test) & test(/^journal_replay_survives_/)) | test(=admin_selector_survives_sigkill_with_original_scope_and_receipts))'
 threads-required = "num-test-threads"
 
+# Native scanner backlog fixtures include 24-set and pool-expansion cases.
+# Reserve capacity across test processes while preserving each scenario's fixed
+# budget, assertions, and internal concurrency.
 [[profile.default.overrides]]
-filter = 'package(rustfs-scanner) & (test(/^scanner::backlog::tests::native_(writer|retirement)_/) | test(=scanner_folder::tests::mrf_ownership::mrf_ownership_manager_completion_preserves_scanner_pending) | test(/^scanner_io::tests::service_cohort::/))'
+filter = 'package(rustfs-scanner) & (test(/^scanner::backlog::tests::native_/) | test(=scanner_folder::tests::mrf_ownership::mrf_ownership_manager_completion_preserves_scanner_pending) | test(/^scanner_io::tests::service_cohort::/))'
 threads-required = "num-test-threads"
 
 [[profile.default.scripts]]
@@ -324,6 +334,12 @@ threads-required = "num-test-threads"
 filter = 'package(rustfs-ecstore) & test(=store::init::tests::dispatch_manifest_rollback_bounded_concurrency_reaches_tail_behind_slow_member)'
 threads-required = "num-test-threads"
 
+# These short-deadline real-disk progress probes need the test run's capacity
+# for scanner and object-lock handoffs; keep their assertions and deadlines.
+[[profile.default.overrides]]
+filter = '(package(rustfs-scanner) & (test(=scanner::tests::cycle_persist_failure::later_cycle_post_commit_failure_reloads_durable_state) | test(=scanner::tests::running_main_loop_catches_up_pause_cleared_after_startup_observe))) | (package(rustfs-ecstore) & test(=store::init::tests::restored_transitioned_delete_causally_enqueues_free_version))'
+threads-required = "num-test-threads"
+
 # ---------------------------------------------------------------------------
 # ci profile — the strict CI gate (ci.yml `cargo nextest run --profile ci`)
 # ---------------------------------------------------------------------------
@@ -356,6 +372,13 @@ threads-required = "num-test-threads"
 filter = '(package(rustfs-ecstore) & test(=core::pools_test::decommission_lock_order_tests::active_decommission_migration_does_not_invert_capacity_and_delete_object_tag_locks)) | (package(rustfs-heal) & test(=heal::mrf_queue::partial_write::tests::durable_retry_submission_error_keeps_checkpoint_and_uses_backoff))'
 threads-required = "num-test-threads"
 
+# These eight-disk decommission fixtures exercise concurrent retries,
+# free-version cleanup, and real capacity probes under production lock deadlines.
+# Reserve the run's capacity so unrelated IO cannot exhaust those budgets.
+[[profile.ci.overrides]]
+filter = 'package(rustfs-ecstore) & (test(/^store::init::tests::decommission_entry_(retries_source_changed_without_canceling_other_bucket|skips_cleanup_only_marker_when_free_version_is_present)$/) | test(=core::pools::tests::decommission_capacity_mutation_limits_prewrite_sampling_to_target))'
+threads-required = "num-test-threads"
+
 # This registration/backup lock probe uses an isolated eight-disk store.
 # Reserve capacity so sibling disk-heavy tests cannot consume its 2s
 # registration budget; retain the queued backup and deadlock assertions.
@@ -367,8 +390,17 @@ threads-required = "num-test-threads"
 filter = 'package(rustfs-heal) & (binary(mrf_partial_write_test) | (binary(mrf_pipeline_test) & test(/^journal_replay_survives_/)) | test(=admin_selector_survives_sigkill_with_original_scope_and_receipts))'
 threads-required = "num-test-threads"
 
+# Native scanner backlog fixtures include 24-set and pool-expansion cases.
+# Reserve capacity across test processes while preserving each scenario's fixed
+# budget, assertions, and internal concurrency.
 [[profile.ci.overrides]]
-filter = 'package(rustfs-scanner) & (test(/^scanner::backlog::tests::native_(writer|retirement)_/) | test(=scanner_folder::tests::mrf_ownership::mrf_ownership_manager_completion_preserves_scanner_pending) | test(/^scanner_io::tests::service_cohort::/))'
+filter = 'package(rustfs-scanner) & (test(/^scanner::backlog::tests::native_/) | test(=scanner_folder::tests::mrf_ownership::mrf_ownership_manager_completion_preserves_scanner_pending) | test(/^scanner_io::tests::service_cohort::/))'
+threads-required = "num-test-threads"
+
+# Keep short-deadline real-disk progress probes from competing with unrelated
+# tests for scanner and object-lock capacity. Assertions and deadlines stay on.
+[[profile.ci.overrides]]
+filter = '(package(rustfs-scanner) & (test(=scanner::tests::cycle_persist_failure::later_cycle_post_commit_failure_reloads_durable_state) | test(=scanner::tests::running_main_loop_catches_up_pause_cleared_after_startup_observe))) | (package(rustfs-ecstore) & test(=store::init::tests::restored_transitioned_delete_causally_enqueues_free_version))'
 threads-required = "num-test-threads"
 
 [[profile.ci.scripts]]
@@ -630,6 +662,14 @@ test-group = 'ecstore-serial-flaky'
 # the PR-lane e2e coverage for scanner usage snapshots consumed by quota and
 # admin surfaces. It uses the same single-node, random-port, isolated-temp-dir
 # fixture as the existing smoke modules.
+#
+# Dual-stack differential (rustfs/backlog#2740): `dual_stack_differential::`
+# starts two single-node servers from the same binary, one per
+# RUSTFS_S3_STACK value, on random ports with isolated temp dirs, and runs one
+# SDK script covering every operation of `impl S3 for FS` against both. Its
+# comparator unit tests need no server. It meets the admission criteria
+# unchanged; the module clause admits a new differential test without another
+# filter edit.
 [profile.e2e-smoke]
 default-filter = """
     package(e2e_test) & (
@@ -638,6 +678,7 @@ default-filter = """
         | test(/^reliant::lifecycle::/)
         | test(/^conditional_delete_objects_test::/)
         | test(/^reliant::tiering::/)
+        | test(/^dual_stack_differential::/)
         | test(/^upgrade_compatibility_test::upgrade_write_readiness_tests::/)
         | test(/^on_demand_migration::(get_basic_test::(get_miss_pulls_inline_and_serves_locally_afterwards|head_miss_answers_from_the_source_without_persisting)|interaction_test::test_odm_admin_config_is_redacted_and_status_counts_match_the_source)$/)
     )

.config/s3s-edge-allowlist.txt

@@ -0,0 +1,37 @@
+# Files that may still reference s3s (`s3s::` or `s3s_sigv4`) when Phase 1 of
+# the gateway migration ends (rustfs/backlog#2734 task T0.6, rustfs/backlog#2741).
+# Consumed only by `scripts/check_s3s_footprint.sh --mode allowlist`.
+#
+# One entry per line: a repository-relative file path or a git `:(glob)`
+# pathspec. `**` matches across directories, `*` stays within one path
+# component, and a directory entry matches everything under it. Blank lines
+# and lines starting with `#` are ignored; an entry may not contain whitespace,
+# so a note belongs on its own comment line.
+#
+# Every Rust file listed by `git grep -l '\bs3s\(::\|_sigv4\)' -- '*.rs'` that
+# no entry matches fails the allowlist mode. Task T1.9 switches CI to that
+# mode; until then `--dry-run` prints the files still outside this list, which
+# is the Phase 1 tracking list.
+#
+# Never add crates/** other than crates/e2e_test: the engine crates leave s3s
+# entirely, and the script rejects such an entry. Only the s3s-facing edge of
+# the rustfs binary and the e2e oracle keep it.
+
+# rustfs binary: the s3s-facing edge that survives Phase 1
+rustfs/src/storage/ecfs.rs
+rustfs/src/storage/s3_compat/**
+rustfs/src/storage/access.rs
+rustfs/src/auth.rs
+rustfs/src/error.rs
+rustfs/src/storage_api.rs
+rustfs/src/app/storage_api.rs
+rustfs/src/admin/router.rs
+rustfs/src/app/metadata_route.rs
+rustfs/src/server/http.rs
+rustfs/src/server/layer.rs
+rustfs/src/server/hybrid.rs
+rustfs/src/protocols/client.rs
+
+# e2e oracle: the test target that verifies S3 behaviour against s3s
+crates/e2e_test/src/fake_s3_target/**
+crates/e2e_test/src/**

.config/s3s-footprint-baseline.txt

@@ -0,0 +1,17 @@
+# Exact baseline for the direct s3s footprint, consumed only by
+# scripts/check_s3s_footprint.sh (rustfs/backlog#1677; rustfs/backlog#2734 T0.4).
+#
+# Each value is the exact measurement of the tree, not a ceiling. CI fails when a
+# measured counter differs from its line here in either direction:
+#   - a larger measurement means new code widened the s3s surface: route it
+#     through the gateway abstractions instead; never raise a value here;
+#   - a smaller measurement means the PR shrank the surface: lower the matching
+#     value to the measured number in the same PR.
+#
+# files           Rust files referencing s3s paths, repo-wide minus crates/e2e_test
+# s3_error_lines  lines holding s3_error!, same scope, minus those the script
+#                 header's rule clears (rustfs_s3_types's macro); fails closed
+# ecstore_files   Rust files referencing s3s paths under crates/ecstore/src
+files=65
+s3_error_lines=289
+ecstore_files=0

.config/test-count-baseline.txt

@@ -0,0 +1,63 @@
+# Per-crate test-count baseline consumed by scripts/check_test_count_ratchet.sh
+# (rustfs/backlog#2734 section 1 rule 3; T0.3 in rustfs/backlog#2738).
+#
+# One row per workspace member: <package>, tests, ignored, tab-separated.
+# tests counts #[test], #[tokio::test], #[tokio::test(...)] and #[test_case(...)]
+# attribute lines under the package directory; ignored counts #[ignore] and
+# #[ignore = "..."]. Both columns are exact: CI fails when a crate's tests fall
+# below or rise above its row, or when its ignored count changes. Raise a row in
+# the PR that adds tests; lowering one is a reviewed statement that tests were
+# intentionally removed. Regenerate with:
+#   scripts/check_test_count_ratchet.sh --update
+e2e_test	956	20
+rustfs	5955	64
+rustfs-audit	70	0
+rustfs-checksums	26	0
+rustfs-common	36	0
+rustfs-concurrency	53	0
+rustfs-config	43	0
+rustfs-connect-symbol-catalog	6	0
+rustfs-credentials	24	0
+rustfs-crypto	67	0
+rustfs-data-usage	55	0
+rustfs-ecstore	7081	1
+rustfs-extension-schema	23	0
+rustfs-filemeta	364	0
+rustfs-heal	984	3
+rustfs-heal-contracts	7	0
+rustfs-iam	394	0
+rustfs-io-core	49	0
+rustfs-io-metrics	153	0
+rustfs-keystone	29	0
+rustfs-kms	715	25
+rustfs-license	2	0
+rustfs-lifecycle	155	0
+rustfs-lock	138	0
+rustfs-log-analyzer	90	0
+rustfs-madmin	210	0
+rustfs-notify	137	0
+rustfs-object-capacity	92	0
+rustfs-object-data-cache	140	0
+rustfs-obs	379	0
+rustfs-policy	725	0
+rustfs-protocols	738	1
+rustfs-protos	66	0
+rustfs-replication	209	0
+rustfs-rio	206	0
+rustfs-rio-v2	34	6
+rustfs-s3-client	69	0
+rustfs-s3-ops	8	0
+rustfs-s3-types	103	0
+rustfs-s3select-api	207	0
+rustfs-s3select-query	189	2
+rustfs-scanner	1205	20
+rustfs-scanner-metrics	87	0
+rustfs-security-governance	20	0
+rustfs-signer	31	0
+rustfs-storage-api	34	0
+rustfs-targets	603	26
+rustfs-test-utils	1	0
+rustfs-tls-runtime	43	0
+rustfs-trusted-proxies	68	0
+rustfs-utils	247	0
+rustfs-zip	30	0

.github/actions/quick-checks/action.yml

@@ -86,6 +86,10 @@ runs:
       shell: bash
       run: ./scripts/check_s3s_footprint.sh
 
+    - name: Check per-crate test-count ratchet
+      shell: bash
+      run: ./scripts/check_test_count_ratchet.sh
+
     - name: Check cryptographic capability wording
       shell: bash
       run: ./scripts/check_fips_wording.sh

.github/workflows/ci.yml

@@ -16,7 +16,9 @@ name: Continuous Integration
 
 on:
   push:
-    branches: [ main ]
+    # gateway/integration receives the daily merge of main as a direct push
+    # (rustfs/backlog#2734), so its pushes must prove the result like main's.
+    branches: [ main, gateway/integration ]
     paths-ignore:
       - "**.md"
       - "docs/**"
@@ -737,6 +739,8 @@ jobs:
     needs: [ build-rustfs-debug-binary ]
     runs-on: sm-standard-2
     timeout-minutes: 30
+    env:
+      RUSTFS_S3_STACK: legacy
     steps:
       - name: Checkout repository
         uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
@@ -855,18 +859,105 @@ jobs:
           path: ${{ runner.temp }}/rustfs-e2e-*/rustfs.log
           retention-days: 3
 
+  # The same e2e-smoke suite against the same debug binary with the gateway
+  # S3 stack selected (rustfs/backlog#2734). Report-only: it is outside the
+  # Test and Lint aggregate and becomes required at T2.10. The archive and run
+  # steps must stay identical to e2e-tests; scripts/ci_gate.py enforces that.
+  e2e-tests-gateway:
+    name: e2e-smoke (gateway, report-only until T2.10)
+    needs: [ build-rustfs-debug-binary ]
+    runs-on: sm-standard-2
+    timeout-minutes: 30
+    continue-on-error: true
+    env:
+      RUSTFS_S3_STACK: gateway
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
+        with:
+          persist-credentials: false
+
+      - name: Setup Rust environment
+        uses: ./.github/actions/setup
+        with:
+          rust-version: stable
+          cache-shared-key: ci-dev
+          cache-save-if: 'false'
+          install-build-packaging-tools: 'false'
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.12"
+
+      - name: Install awscurl
+        run: |
+          python3 -m pip install --user --upgrade pip "awscurl==0.44"
+          echo "AWSCURL_PATH=$HOME/.local/bin/awscurl" >> "$GITHUB_ENV"
+
+      - name: Verify awscurl
+        run: test -x "$AWSCURL_PATH"
+
+      - name: Download debug binary
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: rustfs-debug-binary
+          path: target/debug
+
+      - name: Make binary executable
+        run: chmod +x ./target/debug/rustfs
+
+      - name: Archive e2e smoke test binaries
+        env:
+          NEXTEST_ARCHIVE: ${{ runner.temp }}/rustfs-e2e-smoke.tar.zst
+          NEXTEST_LISTING: ${{ runner.temp }}/rustfs-e2e-smoke-list.json
+        run: |
+          cargo nextest archive --profile e2e-smoke -p e2e_test --archive-file "${NEXTEST_ARCHIVE}"
+          cargo nextest list --profile e2e-smoke --archive-file "${NEXTEST_ARCHIVE}" --message-format json > "${NEXTEST_LISTING}"
+          python3 ./scripts/check_test_wiring.py --check-profile e2e-smoke "${NEXTEST_LISTING}"
+          ./scripts/check_security_smoke_count.sh check "${NEXTEST_LISTING}"
+
+      - name: Run e2e smoke suite
+        env:
+          NEXTEST_ARCHIVE: ${{ runner.temp }}/rustfs-e2e-smoke.tar.zst
+          RUSTFS_E2E_LOG_DIR: ${{ runner.temp }}/rustfs-e2e-smoke-logs
+          SAMPLER_INTERVAL_SECS: "15"
+        run: |
+          ./scripts/ci/resource_sampler.sh start e2e-smoke
+          trap './scripts/ci/resource_sampler.sh stop' EXIT
+          python3 scripts/e2e_binary.py run --features e2e-test-hooks -- cargo nextest run --profile e2e-smoke --archive-file "${NEXTEST_ARCHIVE}" \
+            --status-level all --final-status-level all --failure-output final
+
+      - name: Upload e2e smoke diagnostics
+        if: always()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: e2e-smoke-gateway-diagnostics-${{ github.run_number }}
+          path: |
+            ${{ runner.temp }}/rustfs-e2e-smoke-logs/
+            ${{ runner.temp }}/rustfs-e2e-smoke-list.json
+          if-no-files-found: warn
+
+      - name: Upload e2e smoke JUnit report
+        if: always()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: e2e-smoke-gateway-junit-${{ github.run_number }}
+          path: target/nextest/e2e-smoke/junit.xml
+          if-no-files-found: warn
+
   e2e-full:
     name: End-to-End Tests (full merge gate)
     # Merge gate only (backlog#1149 ci-5): the never-automated user-visible
     # suites — KMS, object_lock, multipart_auth, quota, checksum, encryption,
     # security-boundary, ... — via the e2e-full nextest profile. Too heavy for
-    # every PR, so it is gated to main pushes, the merge queue, and manual
-    # dispatch. protocols / the 7 cluster suites / replication / #[ignore] are
-    # owned by other lanes (see .config/nextest.toml profile.e2e-full).
+    # every PR, so it is gated to main and gateway/integration pushes, the merge
+    # queue, and manual dispatch. protocols / the 7 cluster suites / replication
+    # / #[ignore] are owned by other lanes (see .config/nextest.toml profile.e2e-full).
     if: >-
       github.event_name == 'workflow_dispatch' ||
       github.event_name == 'merge_group' ||
-      (github.event_name == 'push' && github.ref == 'refs/heads/main')
+      (github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/gateway/integration'))
     needs: [ build-rustfs-debug-binary ]
     runs-on: sm-standard-2
     timeout-minutes: 55

.github/workflows/e2e-distributed.yml

@@ -153,7 +153,7 @@ jobs:
 
       - name: Build rustfs binary
         run: |
-          python3 scripts/e2e_binary.py build --bins
+          python3 scripts/e2e_binary.py build --bins --features e2e-test-hooks
 
       - name: Verify distributed e2e membership
         env:
@@ -170,9 +170,9 @@ jobs:
           set -euo pipefail
           rm -f target/nextest/e2e-distributed/junit.xml
           if [ -n "${FILTER}" ]; then
-            python3 scripts/e2e_binary.py run -- cargo nextest run --profile e2e-distributed -p e2e_test -E "${FILTER}"
+            python3 scripts/e2e_binary.py run --features e2e-test-hooks -- cargo nextest run --profile e2e-distributed -p e2e_test -E "${FILTER}"
           else
-            python3 scripts/e2e_binary.py run -- cargo nextest run --profile e2e-distributed -p e2e_test --no-tests=fail
+            python3 scripts/e2e_binary.py run --features e2e-test-hooks -- cargo nextest run --profile e2e-distributed -p e2e_test --no-tests=fail
           fi
           test -s target/nextest/e2e-distributed/junit.xml
 

.github/workflows/e2e-upgrade.yml

@@ -25,6 +25,7 @@ on:
       - "crates/e2e_test/src/upgrade_compatibility_test.rs"
       - "crates/ecstore/**"
       - "crates/filemeta/**"
+      - "crates/heal/**"
       - "crates/kms/**"
       - "crates/storage-api/**"
       - "rustfs/**"
@@ -160,6 +161,7 @@ jobs:
           )
           if [[ "$UPGRADE_SOURCE_VERSION" == "1.0.0-rc.5" ]]; then
             cases+=(odm-config-rollback:rc5_rollback_requires_restoring_odm_configuration)
+            cases+=(checkpoint-upgrade:rc5_checkpoint_upgrade_rewinds_signed_progress_without_losing_objects)
           else
             cases+=(legacy-delete-reservation:stable_upgrade_deletes_foreign_reservations_without_losing_live_objects)
           fi

.github/workflows/rustfs-pool-expand-test.yml

@@ -279,7 +279,9 @@ jobs:
           if [ "${{ inputs.pools || '3' }}" = "3" ]; then
             STEPS="$STEPS,7,8"
             if [ "${{ inputs.run_decommission != 'false' }}" = "true" ]; then
-              STEPS="$STEPS,9"
+              # Step 10 asserts the surviving pools after the removal
+              # (rustfs#8726), so it only runs together with step 9.
+              STEPS="$STEPS,9,10"
             fi
           fi
           ARGS=(--steps "$STEPS" --with-warp -y \
@@ -293,6 +295,10 @@ jobs:
           if [ -n "${RUSTFS_POOL_PROXY_ENDPOINT}" ]; then
             ARGS+=(--proxy-endpoint "${RUSTFS_POOL_PROXY_ENDPOINT}")
           fi
+          # Finalize the removal so step 10 can exercise the surviving
+          # pools; passing it without step 9 selected would run step 10
+          # against a topology where nothing was removed.
+          case ",${STEPS}," in *,9,*) ARGS+=(--finalize-decommission) ;; esac
           if [ -n "${{ inputs.package_url }}" ]; then
             ARGS+=(--package-url "${{ inputs.package_url }}")
           elif [ -n "${{ inputs.rustfs_version }}" ]; then

ARCHITECTURE.md

@@ -155,7 +155,7 @@ default build (lifecycle:
    - ⚠️ PARTIALLY VIOLATED: serving-side `s3s` references remain in ecstore
      (bucket metadata/replication/lifecycle DTOs and error mapping). The
      count is ratcheted shrink-only by `scripts/check_s3s_footprint.sh`
-     (`S3S_ECSTORE_FILES_BASELINE`; the `object_lock` module was converted to
+     (the `ecstore_files` line of `.config/s3s-footprint-baseline.txt`; the `object_lock` module was converted to
      storage-level types as the first ratchet step). Target state: the
      baseline reaches zero and ecstore's `Cargo.toml` drops `s3s`.
 

CHANGELOG.md

@@ -19,12 +19,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Single-part source checksums are forwarded as `x-amz-checksum-*` headers instead of user metadata, so the replica preserves checksum responses ([#7313](https://github.com/rustfs/rustfs/pull/7313)). This changes the default outbound headers for checksummed objects.
 - Site-replication outage recovery now uses a bounded 30-second retry drain plus the 600-second full reconciliation pass, persists destructive liabilities before local deletion, and fences replay settlement and peer edits ([#7148](https://github.com/rustfs/rustfs/pull/7148)). Persisted additions are optional and ignored by older readers.
 - IAM snapshot/deletion replay, target-assigned delete-marker purges, timestamp ordering, and best-effort peer broadcast now close the control-plane gaps found by the R6 review ([#7195](https://github.com/rustfs/rustfs/pull/7195)).
+- A `set-remote-target?update=true&creds=true` request on a site-replication peer's bucket target is now rejected with `400 InvalidRequest`, naming the target and why it counts as peer-owned. It used to return success while keeping the stored endpoint, credentials, and TLS settings, so an endpoint edit from the Console's bucket replication form appeared to apply but did not. Change a peer's address with a site-replication edit instead; see "Changing a site's address" in `docs/operations/site-replication-operations.md`. The `sync`, `bandwidth`, `proxy`, and `path` update groups are unchanged.
+- Site-replication edits that omit the site name, such as `mc admin replicate update --deployment-id <ID> --endpoint <URL>`, now keep the stored name on the editing site and on every receiver instead of renaming the site after the new endpoint host. No persisted format changes.
 - Upgrade and rollback: upgrade every node in one site consecutively and verify reconciliation before moving to the next site; do not intentionally run a site mixed-version. Target-version ledger keys are harmless on rollback, although old code cannot use their routing. Before rolling back past [#7307](https://github.com/rustfs/rustfs/pull/7307), drain or repair every pending version purge: older code can free a retained version's data directory before its remote purge is acknowledged. See `docs/operations/site-replication-operations.md`.
 
 ### Security
 - **Presigned URLs honour only signed headers** (GHSA-g8w9-qw9q-fghr): a SigV4 presigned request that carries an `x-amz-*` request header not listed in `X-Amz-SignedHeaders` is now rejected with `403 AccessDenied` ("There were headers present in the request which were not signed"), matching AWS S3. Previously the holder of a presigned `PutObject` URL could add unsigned `x-amz-tagging`, `x-amz-storage-class`, `x-amz-website-redirect-location`, ACL, metadata, Object Lock or SSE headers and have them applied. Presigners that intend a property must set it before signing so the SDK lists the header in `SignedHeaders`; `x-amz-cf-id` (CloudFront) remains tolerated unsigned. Header-signed SigV4 and SigV2 requests are unchanged.
 
 ### Fixed
+- **`mc admin info` and `mc admin replicate resync` work again**: since the cluster snapshot view (#3803), `GET /v3/info` and `GET /v3/storageinfo` returned the madmin `InfoMessage` / `StorageInfo` nested under an `info` key next to `admin_discovery` (and, for `/info`, `bitrotSelftest`). madmin decodes those bodies directly, so `mc admin info` printed empty values and `mc admin replicate resync start/status` rejected every alias with "alias provided is not part of cluster replication" because the local `deploymentID` read as empty. Requests on the MinIO-compatible `/minio/admin/v3` prefix now receive the bare madmin body again; `/rustfs/admin/v3`, which rc and the console use, keeps the envelope unchanged.
 - **Replication status writebacks no longer invalidate scanner cycles**: every replication status writeback (`persist_replication_state_if_current` in `Update` mode, including the heals the scanner queues during its own walk) marked the bucket dirty on the namespace path, advanced the dirty-usage generation and woke the scanner, so a site-replication resync or any steadily replicated bucket ended every cycle `superseded`, the authoritative usage baseline was never certified, and the console reported usage freshness as stale for as long as replication ran (#8375). Those writebacks are now status class: they do not touch the dirty-usage generation, the activity snapshot, the dirty-usage wake or the durable dirty journal, and only the process-local producer coverage is recorded. They need no rescan queue, because a deployment with an active replication rule already walks every bucket on every cycle and that walk refreshes `replication_stats`. Tier-expiration cleanup, which removes data, stays on the namespace path. No persisted format, protocol, admin API or configuration changes. Design: `docs/architecture/scanner-per-bucket-convergence.md`.
 - **A bucket written during a scanner walk no longer supersedes the whole cycle**: the post-walk cluster activity proof required the entire activity snapshot and the dirty-usage generation to be unchanged, so a single-node deployment with one bucket written every few seconds never reached a `Complete` cycle, `usage_snapshot_converged` never became true and the authoritative usage baseline was never certified (#8494). Dirty usage is now certified per bucket: a structurally complete walk that the guardrail did not veto is `Complete`, buckets whose dirty generation still matches the start snapshot are cleared, and buckets written during the walk stay dirty and are published as the pending set, so `usage_snapshot_converged` means "no bucket pending" and the next cycle is scoped to the pending buckets. Such a cycle writes the authoritative usage object; the observed object is now selected by an explicit observational mark that vetoed cycles carry. The guardrail itself vetoes only on the fields that change which namespace the walk described (peer set, process instance, protocol version, topology, maintenance generation, data movement, movement generation, publication blocked) and reports the field and host in the scanner log and in the new `usage_freshness` fields `guardrail_veto_total`, `last_guardrail_veto_unix_secs` and `last_guardrail_veto_reason`. In a distributed deployment a remote peer whose dirty usage moved during the walk still supersedes the cycle until scoped acknowledgements can name its buckets. `.usage.v2.json` gains the additive, default-when-absent fields `usage_snapshot_pending_buckets`, `usage_snapshot_pending_bucket_count` and `usage_snapshot_observational`; older readers ignore them and treat the snapshot as an authoritative but unconverged publication. Quota is unchanged: an uncertified bucket keeps its last usage value as the floor and live writes do not advance it. No protocol or configuration changes. Design: `docs/architecture/scanner-per-bucket-convergence.md`.
 - **SSE-C TLS requirement now covers copy-source keys**: with `RUSTFS_SSE_C_REQUIRE_TLS=true`, a `CopyObject` or `UploadPartCopy` that carried only the `x-amz-copy-source-server-side-encryption-customer-*` headers (an SSE-C source copied to a destination that is not SSE-C) was accepted on a plaintext transport and was not counted in `rustfs_ssec_plaintext_requests_total`, although those headers carry the source object's customer key. They now count as SSE-C headers: such requests are counted, and refused with `400 InvalidRequest` when the switch is on. Requests over TLS are unaffected.

Cargo.toml

@@ -48,7 +48,7 @@ members = [
     "crates/replication", # Replication contracts and wire formats
     "crates/concurrency", # Concurrency management for RustFS - timeout, locking, backpressure, and I/O scheduling
     "crates/s3-client", # S3 client for engine-side consumption of remote S3 endpoints (tiering, transition targets)
-    "crates/s3-types", # S3 event type definitions
+    "crates/s3-types", # S3 event and error type definitions
     "crates/s3-ops", # S3 operation definitions and mapping
     "crates/s3select-api", # S3 Select API interface
     "crates/s3select-query", # S3 Select query engine
@@ -142,6 +142,13 @@ rustfs-tls-runtime = { path = "crates/tls-runtime", version = "1.0.2" }
 rustfs-utils = { path = "crates/utils", version = "1.0.2" }
 rustfs-zip = { path = "./crates/zip", version = "1.0.2" }
 
+# The gateway's S3 types: the DTOs and persisted bucket-configuration codecs the
+# engine crates move onto from s3s (rustfs/backlog#2745). The one pin of the
+# gateway in this workspace; no crate may enable a `compat-s3s*` feature except
+# the s3s-facing edge of the rustfs binary.
+rustfs-gateway-types = { git = "https://github.com/rustfs/gateway.git", rev = "21283e874c2381bab611e9347acbc5b92e9e2b3c", version = "0.32.0", default-features = false }
+rustfs-gateway-stream = { git = "https://github.com/rustfs/gateway.git", rev = "21283e874c2381bab611e9347acbc5b92e9e2b3c", version = "0.2.0", default-features = false }
+
 # Async Runtime and Networking
 async-channel = "2.5.0"
 async_zip = { default-features = false, version = "0.0.19" }
@@ -169,7 +176,7 @@ minlz = "1.2.3"
 reqwest = "0.13.5"
 rustfs-kafka-async = { version = "1.4.0" }
 socket2 = { version = "0.6.5" }
-tokio = { version = "1.54.0" }
+tokio = { version = "1.54.1" }
 tokio-rustls = { default-features = false, version = "0.26.6" }
 tokio-stream = { version = "0.1.19" }
 tokio-test = "0.4.6"
@@ -252,9 +259,9 @@ atoi = "3.1.1"
 atomic_enum = "0.3.0"
 aws-config = { version = "1.13.0" }
 aws-credential-types = { version = "1.3.1" }
-aws-sdk-kms = { default-features = false, version = "1.124.0" }
-aws-sdk-s3 = { default-features = false, version = "1.153.0" }
-aws-sdk-sts = { default-features = false, version = "1.120.0" }
+aws-sdk-kms = { default-features = false, version = "1.126.0" }
+aws-sdk-s3 = { default-features = false, version = "1.155.0" }
+aws-sdk-sts = { default-features = false, version = "1.122.0" }
 aws-smithy-async = { version = "1.3.1" }
 aws-smithy-http-client = { default-features = false, version = "1.5.1" }
 aws-smithy-runtime-api = { version = "1.19.1" }
@@ -272,12 +279,12 @@ crossbeam-utils = "0.8.23"
 datafusion = { default-features = false, version = "55.2.0" }
 derive_builder = "0.20.2"
 ed25519-dalek = "3.0.0"
-enumset = "1.1.14"
+enumset = "1.1.15"
 faster-hex = "1.0.0"
 flate2 = "1.1.10"
 glob = "0.3.4"
-google-cloud-storage = "1.20.0"
-google-cloud-auth = "1.17.0"
+google-cloud-storage = "1.21.0"
+google-cloud-auth = "1.18.0"
 hashbrown = { version = "0.17.1" }
 # Base32 for RFC 6238 TOTP shared secrets (RFC 4648 unpadded, the alphabet
 # every authenticator app expects). Already in the graph transitively.
@@ -291,7 +298,7 @@ libc = "0.2.191"
 libsystemd = "0.7.2"
 local-ip-address = "0.6.13"
 log = "0.4"
-memmap2 = "0.9.11"
+memmap2 = "0.9.12"
 lz4 = "1.28.1"
 matchit = "0.9.2"
 md-5 = "0.11.0"
@@ -301,7 +308,7 @@ netif = "0.1.6"
 num_cpus = { version = "1.17.0" }
 nvml-wrapper = "0.13.0"
 object = { version = "=0.40.0", default-features = false }
-parking_lot = "0.12.5"
+parking_lot = "0.13.0"
 path-absolutize = "4.0.1"
 percent-encoding = "2.3.2"
 # Server-side QR rendering for TOTP enrollment, so neither the console nor the
@@ -317,21 +324,26 @@ rustfs-erasure-codec = { version = "9.0.0" }
 reed-solomon-simd = "3.1.0"
 regex = { version = "1.13.1" }
 rumqttc = { package = "rumqttc-next", version = "0.34.0" }
-redis = { version = "1.7.1" }
+redis = { version = "1.8.0" }
 rustify = { version = "0.7", default-features = false }
 rustix = { version = "1.1.5" }
 rust-embed = { version = "8.13.0" }
 rustc-hash = { version = "2.1.3" }
 s3s = { git = "https://github.com/s3s-project/s3s", rev = "5761ddfe4c509fcac87e3b99fd5bd9e176b442c0", features = ["minio"] }
 s3s-sigv4 = { git = "https://github.com/s3s-project/s3s", rev = "5761ddfe4c509fcac87e3b99fd5bd9e176b442c0" }
+# The same s3s pin under the name the legacy edge of the gateway migration uses
+# (crates/s3-types, feature `compat-s3s`). Keep `rev` identical to `s3s` above.
+# DELETE BY T4.2 (rustfs/backlog#2784).
+legacy-s3s = { package = "s3s", git = "https://github.com/s3s-project/s3s", rev = "5761ddfe4c509fcac87e3b99fd5bd9e176b442c0", features = ["minio"] }
 serial_test = "4.0.1"
 shadow-rs = { default-features = false, version = "2.0.0" }
 siphasher = "1.0.4"
-smallvec = { version = "1.16.3" }
+smallvec = { version = "1.16.4" }
 compact_str = "0.10.0"
 snap = "1.1.2"
 starshard = { version = "2.4.0" }
 strum = { version = "0.28.0" }
+sync_wrapper = "1.0.2"
 sysinfo = "0.39.6"
 temp-env = "0.3.6"
 tempfile = "3.27.0"
@@ -346,7 +358,7 @@ tracing-subscriber = { version = "0.3.23" }
 transform-stream = "0.3.1"
 url = "2.5.8"
 urlencoding = "2.1.3"
-uuid = { version = "1.28.0" }
+uuid = { version = "1.29.0" }
 vaultrs = { version = "0.8.0" }
 tar = "0.4.46"
 walkdir = "2.5.0"
@@ -354,7 +366,7 @@ winapi-util = "0.1.11"
 windows = { version = "0.62.2" }
 windows-sys = "0.61.2"
 xxhash-rust = { version = "0.8.19" }
-zip = "9.0.5"
+zip = "9.1.0"
 zstd = "0.14.3"
 
 # Observability and Metrics
@@ -368,7 +380,7 @@ opentelemetry-proto = { version = "0.33.1", default-features = false, features =
 opentelemetry_sdk = { version = "0.33.1" }
 opentelemetry-semantic-conventions = { version = "0.33.1" }
 opentelemetry-stdout = { version = "0.33.1" }
-pyroscope = { version = "2.1.2" }
+pyroscope = { version = "2.1.5" }
 
 # FTP and SFTP
 libunftp = { version = "0.23.1" }
@@ -382,9 +394,9 @@ russh-sftp = "3.0.1"
 dav-server = "0.11.0"
 
 # Performance Analysis and Memory Profiling
-rustfs-mimalloc = { version = "0.7.0" }
+rustfs-mimalloc = { version = "0.7.2" }
 # Preserve Unicode focus filters until rustfs/backlog#2302 is resolved.
-hotpath = { version = "0.28.7", default-features = false }
+hotpath = { version = "0.29.1", default-features = false }
 # Snapshot testing for output format regression detection
 insta = { version = "1.49" }
 
@@ -421,3 +433,19 @@ inherits = "release"
 inherits = "release"
 debug = true
 strip = "none"
+
+# Pin upstream fixes until compatible crates.io releases are available.
+[patch.crates-io]
+# Preserve RustFS OIDC flows while migrating the old elliptic-curve dependency chain.
+# Upstream: openidconnect-rs#244 and oauth2-rs#352.
+openidconnect = { git = "https://github.com/ramosbugs/openidconnect-rs", rev = "2f77ee73bc4554e1cb6279adb386005429fb4e41" }
+oauth2 = { git = "https://github.com/ramosbugs/oauth2-rs", rev = "89585f4a280afd7b285eaf1c9be0068874e03d22" }
+aws-sigv4 = { git = "https://github.com/smithy-lang/smithy-rs", rev = "5c1c4bca2ea7af97496e077c9f1a718eaac64bf8" }
+
+# Keep the signer's path dependencies on the SDK's existing registry types.
+[patch."https://github.com/smithy-lang/smithy-rs"]
+aws-credential-types = { version = "=1.3.1" }
+aws-smithy-eventstream = { version = "=0.61.6" }
+aws-smithy-http = { version = "=0.64.2" }
+aws-smithy-runtime-api = { version = "=1.19.1" }
+aws-smithy-types = { version = "=1.9.0" }

crates/common/Cargo.toml

@@ -29,6 +29,7 @@ workspace = true
 
 [features]
 default = []
+test-util = []
 hotpath = ["hotpath/hotpath", "hotpath/tokio"]
 hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
 hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]

crates/common/src/globals.rs

@@ -97,6 +97,18 @@ pub fn try_get_global_local_node_name() -> Option<String> {
         .filter(|name| !name.is_empty())
 }
 
+/// Run a synchronous test callback while publishing a name under its writer lock.
+/// Call from a blocking worker; returning or unwinding releases the writer.
+#[cfg(any(test, feature = "test-util"))]
+#[doc(hidden)]
+pub fn with_local_node_name_write_lock_for_test<T>(name: &str, work: impl FnOnce() -> T) -> T {
+    let mut writer = GLOBAL_LOCAL_NODE_NAME.blocking_write();
+    *writer = name.to_string();
+    let result = work();
+    drop(writer);
+    result
+}
+
 #[cfg(test)]
 mod node_identity_tests {
     use super::*;
@@ -104,15 +116,23 @@ mod node_identity_tests {
     #[tokio::test]
     async fn local_node_name_nonblocking_read_recovers_after_writer_release() {
         let previous = get_global_local_node_name().await;
-        let mut writer = GLOBAL_LOCAL_NODE_NAME.write().await;
-        *writer = "published-node".to_string();
-        let unavailable = try_get_global_local_node_name();
-        drop(writer);
-        let published = try_get_global_local_node_name();
+        let (unavailable, published, panicked) = tokio::task::spawn_blocking(|| {
+            let unavailable = with_local_node_name_write_lock_for_test("published-node", try_get_global_local_node_name);
+            let published = try_get_global_local_node_name();
+            let panicked = std::panic::catch_unwind(|| {
+                with_local_node_name_write_lock_for_test("unwound-node", || panic!("identity callback failed"));
+            });
+            (unavailable, published, panicked)
+        })
+        .await
+        .expect("identity writer worker must complete");
+        let after_unwind = try_get_global_local_node_name();
         set_global_local_node_name(&previous).await;
 
         assert!(unavailable.is_none(), "a held writer must make the nonblocking getter unavailable");
         assert_eq!(published.as_deref(), Some("published-node"));
+        assert!(panicked.is_err(), "the callback panic must propagate after releasing the lock");
+        assert_eq!(after_unwind.as_deref(), Some("unwound-node"));
     }
 }
 

crates/common/src/mrf_channel.rs

@@ -172,11 +172,41 @@ pub struct MrfUnverifiedLegacyEvent {
     pub anchor: MrfDurableRepairAnchor,
 }
 
+#[derive(Clone, Copy)]
+struct ResolvedMrfRepairIdentity {
+    version_id: Option<[u8; 16]>,
+    scope: Option<MrfScope>,
+    delete_marker_purge: Option<MrfDeleteMarkerPurgeIdentity>,
+    lease: MrfIngressLease,
+    bucket_incarnation_id: Uuid,
+}
+
 impl MrfDurableRepairAnchor {
     /// Build a dischargeable anchor only when the caller supplies the storage
     /// incarnation and the original ingress lease. Legacy replay records lack
     /// both pieces and therefore remain fail-closed.
     pub fn from_intent(intent: &MrfIntent, bucket_incarnation_id: Uuid) -> Option<Self> {
+        let identity = Self::resolve_identity(intent, bucket_incarnation_id)?;
+        Some(Self {
+            kind: intent.kind,
+            bucket: intent.bucket.clone(),
+            object: intent.object.clone(),
+            version_id: identity.version_id,
+            scope: identity.scope,
+            delete_marker_purge: identity.delete_marker_purge,
+            lease: identity.lease,
+            bucket_incarnation_id: identity.bucket_incarnation_id,
+        })
+    }
+
+    /// Check whether the intent can form an anchor for this exact source,
+    /// without retaining its bucket/object handles. This checks identity shape,
+    /// not storage verification or retirement authority.
+    pub fn is_eligible_for_source(intent: &MrfIntent, source: Uuid) -> bool {
+        Self::resolve_identity(intent, source).is_some_and(|identity| identity.bucket_incarnation_id == source)
+    }
+
+    fn resolve_identity(intent: &MrfIntent, bucket_incarnation_id: Uuid) -> Option<ResolvedMrfRepairIdentity> {
         let lease = intent.lease?;
         let (version_id, scope) = canonical_identity(intent.kind, intent.version_id, intent.scope);
         let delete_marker_purge = canonical_delete_marker_purge_identity(intent)?;
@@ -186,10 +216,7 @@ impl MrfDurableRepairAnchor {
         if bucket_incarnation_id.is_nil() {
             return None;
         }
-        Some(Self {
-            kind: intent.kind,
-            bucket: intent.bucket.clone(),
-            object: intent.object.clone(),
+        Some(ResolvedMrfRepairIdentity {
             version_id,
             scope,
             delete_marker_purge,
@@ -233,24 +260,32 @@ pub fn consume_recorded_verified_mrf_repair_events_for(bucket: &str, anchors: &m
     let Ok(mut events) = registry.lock() else {
         return 0;
     };
+    consume_verified_mrf_repair_events_from_queue(bucket, anchors, &mut events)
+}
+
+fn consume_verified_mrf_repair_events_from_queue(
+    bucket: &str,
+    anchors: &mut Vec<MrfDurableRepairAnchor>,
+    events: &mut std::collections::VecDeque<MrfVerifiedRepairEvent>,
+) -> usize {
     let before = anchors.len();
-    let mut retained = std::collections::VecDeque::with_capacity(events.len());
-    while let Some(event) = events.pop_front() {
+    let previous_event_count = events.len();
+    events.retain(|event| {
         if event.bucket.as_ref() != bucket {
-            retained.push_back(event);
-            continue;
+            return true;
         }
         let mut matched = false;
         anchors.retain(|anchor| {
-            let proven = anchor.is_proven_by(&event);
+            let proven = anchor.is_proven_by(event);
             matched |= proven;
             !proven
         });
-        if !matched {
-            retained.push_back(event);
-        }
-    }
-    *events = retained;
+        !matched
+    });
+    // The old queue rebuild reserved the pre-consumption event count. Reuse
+    // that buffer when possible without extending its capacity lifetime:
+    // an emptied queue releases its backing storage on the next consumption.
+    events.shrink_to(previous_event_count);
     before.saturating_sub(anchors.len())
 }
 
@@ -821,6 +856,21 @@ static MRF_VERIFIED_REPAIR_EVENTS: OnceLock<std::sync::Mutex<std::collections::V
 static MRF_UNVERIFIED_LEGACY_EVENTS: OnceLock<std::sync::Mutex<std::collections::VecDeque<MrfUnverifiedLegacyEvent>>> =
     OnceLock::new();
 
+/// Whether durable repair events may need consumption. This is only a work
+/// hint: either queue can receive an event after its empty observation, and a
+/// bounded queue can evict that event before the next consumer invocation.
+/// An unavailable lock is unknown, so callers must keep their normal path.
+/// An allocated empty verified queue also needs the normal consumer pass to
+/// release its buffer; this hint must not extend that buffer's lifetime.
+pub fn mrf_durable_repair_events_may_be_pending() -> bool {
+    MRF_VERIFIED_REPAIR_EVENTS
+        .get()
+        .is_some_and(|registry| registry.try_lock().map_or(true, |events| events.capacity() != 0))
+        || MRF_UNVERIFIED_LEGACY_EVENTS
+            .get()
+            .is_some_and(|registry| registry.try_lock().map_or(true, |events| !events.is_empty()))
+}
+
 /// Record a legacy notification for compatibility. This is not an
 /// acknowledgement of storage verification or durable repair completion.
 pub fn note_mrf_repaired(bucket: &str, object: &str, version_id: Option<[u8; 16]>) {
@@ -935,6 +985,15 @@ pub fn take_mrf_unverified_legacy_events_for(bucket: &str) -> Vec<MrfUnverifiedL
     taken
 }
 
+#[cfg(test)]
+mod event_presence_tests;
+
+#[cfg(test)]
+mod proof_queue_tests;
+
+#[cfg(test)]
+mod repair_identity_tests;
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/common/src/mrf_channel/event_presence_tests.rs

@@ -0,0 +1,140 @@
+// Copyright 2026 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 super::*;
+
+fn isolated(name: &str) -> bool {
+    const CHILD: &str = "RUSTFS_MRF_EVENT_PRESENCE_TEST";
+    let test = format!("mrf_channel::event_presence_tests::{name}");
+    if let Ok(current) = std::env::var(CHILD) {
+        assert_eq!(current, test, "only the selected registry test may run in the child");
+        return false;
+    }
+    let output = std::process::Command::new(std::env::current_exe().expect("test executable"))
+        .args([&test, "--exact", "--test-threads=1"])
+        .env(CHILD, &test)
+        .output()
+        .expect("run isolated global registry test");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(
+        output.status.success() && stdout.contains("1 passed; 0 failed"),
+        "registry child must execute exactly once: {stdout}{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    true
+}
+
+#[test]
+fn event_presence_covers_both_queues_and_contention_without_consuming() {
+    if isolated("event_presence_covers_both_queues_and_contention_without_consuming") {
+        return;
+    }
+    assert!(!mrf_durable_repair_events_may_be_pending());
+    let anchor = MrfDurableRepairAnchor {
+        kind: MrfKind::PartialWrite,
+        bucket: Arc::from("presence-test"),
+        object: Arc::from("object"),
+        version_id: Some([7; 16]),
+        scope: Some(MrfScope {
+            pool_index: 0,
+            set_index: 0,
+        }),
+        delete_marker_purge: None,
+        lease: MrfIngressLease::new(21),
+        bucket_incarnation_id: Uuid::new_v4(),
+    };
+    let event = MrfVerifiedRepairEvent {
+        kind: anchor.kind,
+        bucket: anchor.bucket.clone(),
+        object: anchor.object.clone(),
+        version_id: anchor.version_id,
+        scope: anchor.scope,
+        delete_marker_purge: None,
+        lease: Some(anchor.lease),
+        bucket_incarnation_id: anchor.bucket_incarnation_id,
+        disposition: MrfVerifiedRepairDisposition::VerifiedHealthy,
+    };
+    note_mrf_verified_repair(event.clone());
+    assert!(mrf_durable_repair_events_may_be_pending());
+    assert!(mrf_durable_repair_events_may_be_pending(), "the hint must not consume a proof");
+    assert_eq!(take_mrf_verified_repair_events_for(&anchor.bucket), vec![event]);
+    assert!(
+        mrf_durable_repair_events_may_be_pending(),
+        "the empty allocated verified buffer still needs its original maintenance pass"
+    );
+    let mut retained = vec![anchor.clone()];
+    assert_eq!(consume_recorded_verified_mrf_repair_events_for(&anchor.bucket, &mut retained), 0);
+    assert_eq!(retained, vec![anchor.clone()], "buffer maintenance cannot discharge an anchor");
+    assert_eq!(
+        MRF_VERIFIED_REPAIR_EVENTS
+            .get()
+            .expect("verified registry")
+            .lock()
+            .expect("verified storage")
+            .capacity(),
+        0,
+        "the actual consumer releases empty proof storage before subsequent idle passes can skip it"
+    );
+    assert!(!mrf_durable_repair_events_may_be_pending());
+    let legacy = MrfUnverifiedLegacyEvent { anchor };
+    note_mrf_unverified_legacy(legacy.clone());
+    assert!(mrf_durable_repair_events_may_be_pending(), "legacy-only work must not be skipped");
+    assert_eq!(take_mrf_unverified_legacy_events_for(&legacy.anchor.bucket), vec![legacy]);
+    assert!(!mrf_durable_repair_events_may_be_pending());
+    let verified = MRF_VERIFIED_REPAIR_EVENTS.get().expect("verified registry initialized");
+    let guard = verified.lock().expect("hold verified registry");
+    assert!(mrf_durable_repair_events_may_be_pending(), "contended verified is unknown");
+    drop(guard);
+    let legacy = MRF_UNVERIFIED_LEGACY_EVENTS.get().expect("legacy registry initialized");
+    let guard = legacy.lock().expect("hold legacy registry");
+    assert!(mrf_durable_repair_events_may_be_pending(), "contended legacy is unknown");
+    drop(guard);
+    assert!(!mrf_durable_repair_events_may_be_pending());
+}
+
+#[test]
+fn event_presence_keeps_poisoned_verified_unknown() {
+    if isolated("event_presence_keeps_poisoned_verified_unknown") {
+        return;
+    }
+    assert!(!mrf_durable_repair_events_may_be_pending());
+    let registry = MRF_VERIFIED_REPAIR_EVENTS.get_or_init(|| Mutex::new(Default::default()));
+    assert!(
+        std::panic::catch_unwind(|| {
+            let _guard = registry.lock().expect("unpoisoned registry");
+            panic!("poison the isolated verified registry");
+        })
+        .is_err()
+    );
+    assert!(mrf_durable_repair_events_may_be_pending());
+    assert!(registry.is_poisoned(), "the hint must not clear or recover poisoned state");
+}
+
+#[test]
+fn event_presence_keeps_poisoned_legacy_unknown() {
+    if isolated("event_presence_keeps_poisoned_legacy_unknown") {
+        return;
+    }
+    assert!(!mrf_durable_repair_events_may_be_pending());
+    let registry = MRF_UNVERIFIED_LEGACY_EVENTS.get_or_init(|| Mutex::new(Default::default()));
+    assert!(
+        std::panic::catch_unwind(|| {
+            let _guard = registry.lock().expect("unpoisoned registry");
+            panic!("poison the isolated legacy registry");
+        })
+        .is_err()
+    );
+    assert!(mrf_durable_repair_events_may_be_pending());
+    assert!(registry.is_poisoned(), "the hint must not clear or recover poisoned state");
+}

crates/common/src/mrf_channel/proof_queue_tests.rs

@@ -0,0 +1,304 @@
+// Copyright 2026 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 super::*;
+use std::collections::VecDeque;
+
+fn proof_fixture() -> (MrfDurableRepairAnchor, MrfVerifiedRepairEvent) {
+    let anchor = MrfDurableRepairAnchor {
+        kind: MrfKind::PartialWrite,
+        bucket: Arc::from("proof-queue"),
+        object: Arc::from("matched"),
+        version_id: Some([7; 16]),
+        scope: Some(MrfScope {
+            pool_index: 1,
+            set_index: 2,
+        }),
+        delete_marker_purge: None,
+        lease: MrfIngressLease::new(21),
+        bucket_incarnation_id: Uuid::new_v4(),
+    };
+    let event = MrfVerifiedRepairEvent {
+        kind: anchor.kind,
+        bucket: anchor.bucket.clone(),
+        object: anchor.object.clone(),
+        version_id: anchor.version_id,
+        scope: anchor.scope,
+        delete_marker_purge: anchor.delete_marker_purge,
+        lease: Some(anchor.lease),
+        bucket_incarnation_id: anchor.bucket_incarnation_id,
+        disposition: MrfVerifiedRepairDisposition::Repaired,
+    };
+    (anchor, event)
+}
+
+#[test]
+fn proof_queue_reuses_unmatched_storage_in_contiguous_and_wrapped_layouts() {
+    for wrapped in [false, true] {
+        for foreign in [false, true] {
+            let (anchor, mut event) = proof_fixture();
+            if foreign {
+                event.bucket = Arc::from("another-bucket");
+            } else {
+                event.lease = None;
+            }
+            let mut events = VecDeque::with_capacity(8);
+            events.extend(std::iter::repeat_n(event, events.capacity()));
+            if wrapped {
+                let first = events.pop_front().expect("full local proof queue");
+                events.push_back(first);
+                assert!(!events.as_slices().1.is_empty(), "exercise a wrapped producer queue");
+            }
+            let capacity = events.capacity();
+            let storage = events
+                .iter()
+                .map(std::ptr::from_ref)
+                .min()
+                .expect("nonempty local proof storage");
+            let expected = events.clone();
+            let mut anchors = vec![anchor.clone()];
+            for _ in 0..4 {
+                assert_eq!(
+                    consume_verified_mrf_repair_events_from_queue(&anchor.bucket, &mut anchors, &mut events),
+                    0
+                );
+                assert_eq!(events, expected);
+                assert_eq!(anchors, vec![anchor.clone()]);
+                assert_eq!(events.capacity(), capacity);
+                assert_eq!(
+                    events.iter().map(std::ptr::from_ref).min(),
+                    Some(storage),
+                    "a full unmatched queue must reuse its buffer instead of rebuilding it for every bucket"
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn proof_queue_consumes_all_exact_anchor_copies_and_preserves_duplicate_proof_order() {
+    let (anchor, event) = proof_fixture();
+    let waiting = MrfDurableRepairAnchor {
+        object: Arc::from("waiting"),
+        ..anchor.clone()
+    };
+    let foreign = MrfVerifiedRepairEvent {
+        bucket: Arc::from("foreign"),
+        ..event.clone()
+    };
+    let unleased = MrfVerifiedRepairEvent {
+        lease: None,
+        ..event.clone()
+    };
+    let future = MrfVerifiedRepairEvent {
+        object: Arc::from("future"),
+        ..event.clone()
+    };
+    let mut events = VecDeque::from(vec![
+        foreign.clone(),
+        event.clone(),
+        unleased.clone(),
+        event.clone(),
+        future.clone(),
+    ]);
+    let first = events.pop_front().expect("foreign proof starts the queue");
+    events.push_back(first);
+    assert!(!events.as_slices().1.is_empty(), "match and retain proofs across the wrap boundary");
+    let mut anchors = vec![anchor.clone(), waiting.clone(), anchor.clone()];
+    assert_eq!(
+        consume_verified_mrf_repair_events_from_queue(&anchor.bucket, &mut anchors, &mut events),
+        2
+    );
+    assert_eq!(anchors, vec![waiting]);
+    assert_eq!(
+        events,
+        VecDeque::from(vec![unleased, event, future, foreign]),
+        "the later duplicate proof remains available after the first proof consumes every exact anchor"
+    );
+    let retained = events.clone();
+    assert_eq!(
+        consume_verified_mrf_repair_events_from_queue(&anchor.bucket, &mut anchors, &mut events),
+        0
+    );
+    assert_eq!(events, retained, "a later consumer must still be able to match the retained proofs");
+}
+
+#[test]
+fn proof_queue_keeps_every_incomplete_or_mismatched_identity() {
+    let (anchor, event) = proof_fixture();
+    let different_purge = MrfDeleteMarkerPurgeIdentity {
+        bucket_incarnation_id: anchor.bucket_incarnation_id,
+        marker_incarnation_id: anchor.bucket_incarnation_id,
+        marker_identity: [3; 32],
+    };
+    for rejected in [
+        MrfVerifiedRepairEvent {
+            kind: MrfKind::DecodeFailure,
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            bucket: Arc::from("foreign"),
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            object: Arc::from("other"),
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            version_id: None,
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            version_id: Some([8; 16]),
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            scope: None,
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            scope: Some(MrfScope {
+                pool_index: 2,
+                set_index: 2,
+            }),
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            scope: Some(MrfScope {
+                pool_index: 1,
+                set_index: 3,
+            }),
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            lease: None,
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            lease: Some(MrfIngressLease::new(22)),
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            bucket_incarnation_id: Uuid::new_v4(),
+            ..event.clone()
+        },
+        MrfVerifiedRepairEvent {
+            delete_marker_purge: Some(different_purge),
+            ..event
+        },
+    ] {
+        let mut anchors = vec![anchor.clone()];
+        let mut events = VecDeque::from([rejected.clone()]);
+        assert_eq!(
+            consume_verified_mrf_repair_events_from_queue(&anchor.bucket, &mut anchors, &mut events),
+            0
+        );
+        assert_eq!(anchors, vec![anchor.clone()]);
+        assert_eq!(events, VecDeque::from([rejected]));
+    }
+}
+
+#[test]
+fn proof_queue_requires_the_complete_delete_marker_purge_identity() {
+    let (mut anchor, mut event) = proof_fixture();
+    let purge = MrfDeleteMarkerPurgeIdentity {
+        bucket_incarnation_id: anchor.bucket_incarnation_id,
+        marker_incarnation_id: anchor.bucket_incarnation_id,
+        marker_identity: [3; 32],
+    };
+    anchor.kind = MrfKind::DeleteMarkerPurge;
+    anchor.delete_marker_purge = Some(purge);
+    event.kind = anchor.kind;
+    event.delete_marker_purge = anchor.delete_marker_purge;
+    for rejected in [
+        None,
+        Some(MrfDeleteMarkerPurgeIdentity {
+            bucket_incarnation_id: Uuid::new_v4(),
+            ..purge
+        }),
+        Some(MrfDeleteMarkerPurgeIdentity {
+            marker_incarnation_id: Uuid::new_v4(),
+            ..purge
+        }),
+        Some(MrfDeleteMarkerPurgeIdentity {
+            marker_identity: [4; 32],
+            ..purge
+        }),
+    ] {
+        let rejected = MrfVerifiedRepairEvent {
+            delete_marker_purge: rejected,
+            ..event.clone()
+        };
+        let mut anchors = vec![anchor.clone()];
+        let mut events = VecDeque::from([rejected.clone(), event.clone()]);
+        assert_eq!(
+            consume_verified_mrf_repair_events_from_queue(&anchor.bucket, &mut anchors, &mut events),
+            1
+        );
+        assert!(anchors.is_empty());
+        assert_eq!(events, VecDeque::from([rejected]));
+    }
+}
+
+#[test]
+fn proof_queue_capacity_follows_the_preconsumption_length_and_releases_on_the_next_empty_call() {
+    let (anchor, event) = proof_fixture();
+    let future_events = (0..3)
+        .map(|index| MrfVerifiedRepairEvent {
+            object: Arc::from(format!("future-{index}")),
+            ..event.clone()
+        })
+        .collect::<Vec<_>>();
+    let mut events = VecDeque::with_capacity(64);
+    events.push_back(event);
+    events.extend(future_events.iter().cloned());
+    let previous_event_count = events.len();
+    let mut anchors = vec![anchor.clone()];
+    assert_eq!(
+        consume_verified_mrf_repair_events_from_queue(&anchor.bucket, &mut anchors, &mut events),
+        1
+    );
+    assert_eq!(events.iter().cloned().collect::<Vec<_>>(), future_events);
+    assert_eq!(
+        events.capacity(),
+        VecDeque::<MrfVerifiedRepairEvent>::with_capacity(previous_event_count).capacity(),
+        "preserve the former queue rebuild's capacity lifetime instead of retaining the producer high water"
+    );
+    let previous_event_count = events.len();
+    let mut anchors = future_events
+        .iter()
+        .map(|event| MrfDurableRepairAnchor {
+            object: event.object.clone(),
+            ..anchor.clone()
+        })
+        .collect();
+    assert_eq!(
+        consume_verified_mrf_repair_events_from_queue(&anchor.bucket, &mut anchors, &mut events),
+        3
+    );
+    assert!(events.is_empty());
+    assert_eq!(
+        events.capacity(),
+        VecDeque::<MrfVerifiedRepairEvent>::with_capacity(previous_event_count).capacity()
+    );
+    assert_eq!(
+        consume_verified_mrf_repair_events_from_queue(&anchor.bucket, &mut anchors, &mut events),
+        0
+    );
+    assert_eq!(
+        events.capacity(),
+        0,
+        "the next empty consumption releases backing storage just as a rebuild did"
+    );
+}

crates/common/src/mrf_channel/repair_identity_tests.rs

@@ -0,0 +1,256 @@
+// Copyright 2026 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 super::*;
+
+// Compatibility reference from a47649fb60c0492cc0fb02bff28439c5e357f8e4.
+// Keep this independent of the shared resolver and its canonical helpers.
+fn original_anchor(intent: &MrfIntent, bucket_incarnation_id: Uuid) -> Option<MrfDurableRepairAnchor> {
+    let lease = intent.lease?;
+    let version_id = intent.version_id.filter(|bytes| *bytes != [0; 16]);
+    let (version_id, scope) = match intent.kind {
+        MrfKind::MetadataCorruption => (None, None),
+        MrfKind::DecodeFailure | MrfKind::PartialWrite | MrfKind::DeleteMarkerPurge => (version_id, intent.scope),
+    };
+    let delete_marker_purge = match intent.kind {
+        MrfKind::DeleteMarkerPurge => intent
+            .delete_marker_purge
+            .as_ref()
+            .filter(|payload| {
+                !payload.bucket_incarnation_id.is_nil()
+                    && payload.marker_incarnation_id == payload.bucket_incarnation_id
+                    && !payload.marker.is_empty()
+                    && payload.marker.len() <= MRF_MAX_DELETE_MARKER_BYTES
+            })
+            .map(|payload| {
+                Some(MrfDeleteMarkerPurgeIdentity {
+                    bucket_incarnation_id: payload.bucket_incarnation_id,
+                    marker_incarnation_id: payload.marker_incarnation_id,
+                    marker_identity: payload.marker_identity,
+                })
+            })?,
+        _ if intent.delete_marker_purge.is_none() => None,
+        _ => return None,
+    };
+    let bucket_incarnation_id = delete_marker_purge
+        .map(|identity| identity.bucket_incarnation_id)
+        .unwrap_or(bucket_incarnation_id);
+    if bucket_incarnation_id.is_nil() {
+        return None;
+    }
+    Some(MrfDurableRepairAnchor {
+        kind: intent.kind,
+        bucket: intent.bucket.clone(),
+        object: intent.object.clone(),
+        version_id,
+        scope,
+        delete_marker_purge,
+        lease,
+        bucket_incarnation_id,
+    })
+}
+
+#[test]
+fn shared_repair_identity_matches_the_original_constructor_and_source_filter() {
+    let source = Uuid::from_u128(1);
+    let foreign = Uuid::from_u128(2);
+    let purge = MrfDeleteMarkerPurge {
+        bucket_incarnation_id: source,
+        marker_incarnation_id: source,
+        marker_identity: [9; 32],
+        marker: Arc::from([7_u8]),
+    };
+    let payloads = [
+        None,
+        Some(purge.clone()),
+        Some(MrfDeleteMarkerPurge {
+            bucket_incarnation_id: foreign,
+            marker_incarnation_id: foreign,
+            ..purge.clone()
+        }),
+        Some(MrfDeleteMarkerPurge {
+            marker: Arc::from([]),
+            ..purge.clone()
+        }),
+        Some(MrfDeleteMarkerPurge {
+            marker: Arc::from(vec![7; MRF_MAX_DELETE_MARKER_BYTES]),
+            ..purge.clone()
+        }),
+        Some(MrfDeleteMarkerPurge {
+            marker: Arc::from(vec![7; MRF_MAX_DELETE_MARKER_BYTES + 1]),
+            ..purge.clone()
+        }),
+        Some(MrfDeleteMarkerPurge {
+            marker_incarnation_id: foreign,
+            ..purge.clone()
+        }),
+        Some(MrfDeleteMarkerPurge {
+            bucket_incarnation_id: Uuid::nil(),
+            marker_incarnation_id: Uuid::nil(),
+            ..purge
+        }),
+    ];
+    let mut cases = 0;
+    for kind in [
+        MrfKind::DecodeFailure,
+        MrfKind::MetadataCorruption,
+        MrfKind::PartialWrite,
+        MrfKind::DeleteMarkerPurge,
+    ] {
+        for lease in [None, Some(MrfIngressLease::new(0)), Some(MrfIngressLease::new(7))] {
+            for version_id in [None, Some([0; 16]), Some([7; 16])] {
+                for scope in [
+                    None,
+                    Some(MrfScope {
+                        pool_index: u32::MAX,
+                        set_index: 3,
+                    }),
+                ] {
+                    for input_source in [Uuid::nil(), source, foreign] {
+                        for (payload_index, payload) in payloads.iter().enumerate() {
+                            let intent = MrfIntent {
+                                bucket: Arc::from("source-shape"),
+                                object: Arc::from("object"),
+                                version_id,
+                                kind,
+                                delete_marker_purge: payload.clone(),
+                                scope,
+                                lease,
+                                enqueued_at_ms: 0,
+                                attempts: 0,
+                            };
+                            let expected = original_anchor(&intent, input_source);
+                            assert_eq!(
+                                MrfDurableRepairAnchor::from_intent(&intent, input_source),
+                                expected,
+                                "kind={kind:?}, lease={lease:?}, version={version_id:?}, scope={scope:?}, source={input_source}, payload={payload_index}"
+                            );
+                            assert_eq!(
+                                MrfDurableRepairAnchor::is_eligible_for_source(&intent, input_source),
+                                expected
+                                    .as_ref()
+                                    .is_some_and(|anchor| anchor.bucket_incarnation_id == input_source),
+                                "source eligibility must preserve the exact source: kind={kind:?}, lease={lease:?}, version={version_id:?}, scope={scope:?}, source={input_source}, payload={payload_index}"
+                            );
+                            cases += 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assert_eq!(cases, 1728, "exercise the complete explicit identity-shape matrix");
+}
+
+#[test]
+fn repair_identity_preserves_literal_purge_source_lease_and_metadata_boundaries() {
+    let source = Uuid::from_u128(1);
+    let purge_source = Uuid::from_u128(2);
+    let mut intent = MrfIntent {
+        bucket: Arc::from("literal-bucket"),
+        object: Arc::from("marker"),
+        version_id: None,
+        kind: MrfKind::DeleteMarkerPurge,
+        delete_marker_purge: Some(MrfDeleteMarkerPurge {
+            bucket_incarnation_id: purge_source,
+            marker_incarnation_id: purge_source,
+            marker_identity: [9; 32],
+            marker: Arc::from([7_u8]),
+        }),
+        scope: None,
+        lease: Some(MrfIngressLease::new(17)),
+        enqueued_at_ms: 0,
+        attempts: 0,
+    };
+    assert!(
+        !valid_intent_payload(&intent),
+        "constructor compatibility is broader than durable admission"
+    );
+    assert_eq!(
+        MrfDurableRepairAnchor::from_intent(&intent, Uuid::nil()),
+        Some(MrfDurableRepairAnchor {
+            kind: MrfKind::DeleteMarkerPurge,
+            bucket: Arc::from("literal-bucket"),
+            object: Arc::from("marker"),
+            version_id: None,
+            scope: None,
+            delete_marker_purge: Some(MrfDeleteMarkerPurgeIdentity {
+                bucket_incarnation_id: purge_source,
+                marker_incarnation_id: purge_source,
+                marker_identity: [9; 32],
+            }),
+            lease: MrfIngressLease::new(17),
+            bucket_incarnation_id: purge_source,
+        })
+    );
+    assert!(
+        !MrfDurableRepairAnchor::is_eligible_for_source(&intent, source),
+        "a purge cannot borrow a conflicting entry source"
+    );
+    assert!(!MrfDurableRepairAnchor::is_eligible_for_source(&intent, Uuid::nil()));
+    assert!(MrfDurableRepairAnchor::is_eligible_for_source(&intent, purge_source));
+    intent.lease = None;
+    assert!(MrfDurableRepairAnchor::from_intent(&intent, purge_source).is_none());
+    assert!(!MrfDurableRepairAnchor::is_eligible_for_source(&intent, purge_source));
+    intent.lease = Some(MrfIngressLease::new(17));
+    intent
+        .delete_marker_purge
+        .as_mut()
+        .expect("purge fixture")
+        .marker_incarnation_id = Uuid::nil();
+    assert!(MrfDurableRepairAnchor::from_intent(&intent, purge_source).is_none());
+    intent
+        .delete_marker_purge
+        .as_mut()
+        .expect("purge fixture")
+        .bucket_incarnation_id = Uuid::nil();
+    assert!(
+        !MrfDurableRepairAnchor::is_eligible_for_source(&intent, source),
+        "nil marker identity cannot borrow a non-nil source"
+    );
+    intent.kind = MrfKind::PartialWrite;
+    assert!(
+        MrfDurableRepairAnchor::from_intent(&intent, source).is_none(),
+        "ordinary intents cannot carry a purge payload"
+    );
+    intent.delete_marker_purge = None;
+    intent.kind = MrfKind::MetadataCorruption;
+    intent.version_id = Some([7; 16]);
+    intent.scope = Some(MrfScope {
+        pool_index: 8,
+        set_index: 9,
+    });
+    assert_eq!(
+        MrfDurableRepairAnchor::from_intent(&intent, source),
+        Some(MrfDurableRepairAnchor {
+            kind: MrfKind::MetadataCorruption,
+            bucket: Arc::from("literal-bucket"),
+            object: Arc::from("marker"),
+            version_id: None,
+            scope: None,
+            delete_marker_purge: None,
+            lease: MrfIngressLease::new(17),
+            bucket_incarnation_id: source,
+        })
+    );
+    assert!(MrfDurableRepairAnchor::is_eligible_for_source(&intent, source));
+    assert!(MrfDurableRepairAnchor::from_intent(&intent, Uuid::nil()).is_none());
+    intent.lease = Some(MrfIngressLease::new(0));
+    assert_eq!(
+        MrfDurableRepairAnchor::from_intent(&intent, source)
+            .expect("preserve the existing opaque lease shape")
+            .lease,
+        MrfIngressLease::new(0)
+    );
+}

crates/concurrency/src/adaptive.rs

@@ -0,0 +1,957 @@
+// Copyright 2026 RustFS Team
+// Licensed under the Apache License, Version 2.0.
+
+//! Mutable admission capacity without replacing or revoking held permits.
+
+use std::num::NonZeroU16;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+use std::time::Duration;
+use tokio::sync::{Notify, Semaphore};
+use tokio::time::Instant;
+
+/// A resource owner publishes a capacity; running units retain their permits
+/// after a reduction. Lease slots are reserved once, with no per-unit Arc
+/// allocation. Tokio wait queues may lazily initialize platform mutex storage
+/// on first contention. It does not discover devices, start
+/// workers, or decide resource policy. Cancellation drops the acquire future.
+///
+/// Uncontended admission is atomic. Parked work takes a FIFO admission turn,
+/// so repeated fast acquisitions cannot starve an older waiter. Source/age
+/// priority still belongs to the caller's scheduler, before joining this queue.
+pub struct AdaptiveAdmission {
+    // One CAS observes both capacity and active count, so a concurrent shrink
+    // cannot admit a new unit using an already superseded capacity.
+    state: AtomicU64,
+    origin: Instant,
+    valid_until_millis: AtomicU64,
+    // Only the FIFO turn holder subscribes. A stored notification is harmless:
+    // capacity and freshness are always checked again after waking.
+    changed: Notify,
+    queued: AtomicUsize,
+    // FIFO admission turn, not a mutable-state lock. No storage lock or
+    // admitted permit may be held while joining. This private semaphore is
+    // never closed; release and resize do not acquire it.
+    turn: Semaphore,
+    maximum: u32,
+    slots: Box<[PermitSlots]>,
+    next_chunk: AtomicUsize,
+}
+
+struct PermitSlots {
+    free: AtomicU64,
+    references: [AtomicUsize; 64],
+}
+
+struct QueuedAdmission<'a>(&'a AdaptiveAdmission);
+
+impl Drop for QueuedAdmission<'_> {
+    fn drop(&mut self) {
+        self.0.queued.fetch_sub(1, Ordering::AcqRel);
+    }
+}
+
+/// One active unit. Clones share that unit without allocating; the final drop
+/// returns it to the same owner, including after resize or waiter cancellation.
+#[must_use = "hold the permit for the admitted unit's complete lifetime"]
+pub struct AdaptivePermit {
+    owner: Arc<AdaptiveAdmission>,
+    slot: usize,
+}
+
+impl Clone for AdaptivePermit {
+    fn clone(&self) -> Self {
+        // Every slot reference owns a strong owner reference. Clone the Arc
+        // first, so its overflow protection also bounds the slot refcount.
+        let owner = Arc::clone(&self.owner);
+        owner.slots[self.slot / 64].references[self.slot % 64].fetch_add(1, Ordering::Relaxed);
+        Self { owner, slot: self.slot }
+    }
+}
+
+impl std::fmt::Debug for AdaptivePermit {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AdaptivePermit")
+            .field("slot", &self.slot)
+            .field("owner", &self.owner.snapshot())
+            .finish()
+    }
+}
+
+/// One coherent view of configured capacity and actual active units.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AdaptiveAdmissionSnapshot {
+    /// Current cap on new admissions. Zero pauses all new units.
+    pub limit: u32,
+    /// Existing units, which may temporarily exceed a reduced limit.
+    pub active: u32,
+}
+
+/// Node scheduling capacity, separate from physical I/O and buffer ownership.
+/// Its non-cloneable units end with the async operation; a native tail must
+/// retain its own physical-resource unit, never this scheduling unit.
+pub struct NodeAdmission {
+    capacity: Arc<AdaptiveAdmission>,
+    completed: AtomicU64,
+}
+
+/// One async operation's scheduling unit. Dropping a cancelled or failed
+/// operation releases capacity without claiming completed work.
+#[must_use = "retain the unit until the async operation ends"]
+pub struct NodePermit {
+    _capacity: AdaptivePermit,
+    owner: Arc<NodeAdmission>,
+}
+
+impl NodeAdmission {
+    /// Construct one node owner with no capacity until a resource sample arrives.
+    pub fn new(maximum: NonZeroU16) -> Arc<Self> {
+        Arc::new(Self {
+            capacity: AdaptiveAdmission::new(maximum, 0),
+            completed: AtomicU64::new(0),
+        })
+    }
+
+    /// Publish feedback with this owner's actual completed-work counter.
+    pub fn update(&self, controller: &mut FeedbackController, observation: Option<FeedbackObservation>) -> FeedbackDecision {
+        let observation = observation.map(|mut observation| {
+            observation.completed_units = self.completed();
+            observation
+        });
+        controller.update(&self.capacity, observation)
+    }
+
+    /// Current leased scheduling cap and held async units.
+    pub fn snapshot(&self) -> AdaptiveAdmissionSnapshot {
+        self.capacity.snapshot()
+    }
+
+    /// Completed operations, or unknown after the counter exhausts its range.
+    pub fn completed(&self) -> Option<u64> {
+        let value = self.completed.load(Ordering::Acquire);
+        (value != u64::MAX).then_some(value)
+    }
+
+    /// Try without waiting, including when the caller already owns a lock.
+    pub fn try_acquire(self: &Arc<Self>) -> Option<NodePermit> {
+        self.capacity.try_acquire().map(|capacity| NodePermit {
+            _capacity: capacity,
+            owner: self.clone(),
+        })
+    }
+
+    /// Wait in FIFO order. Callers must provide a deadline/cancellation and
+    /// acquire before storage locks, not while retaining another node unit.
+    pub async fn acquire(self: &Arc<Self>) -> NodePermit {
+        NodePermit {
+            _capacity: self.capacity.acquire().await,
+            owner: self.clone(),
+        }
+    }
+}
+
+impl NodePermit {
+    /// Count a completed operation exactly once, then release its node unit.
+    /// This counter is scheduling progress, not an authoritative heal receipt.
+    pub fn complete(self) {
+        let _ = self
+            .owner
+            .completed
+            .try_update(Ordering::AcqRel, Ordering::Acquire, |value| value.checked_add(1));
+    }
+}
+
+/// Confidence-qualified pressure for one complete sampling window.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ResourcePressure {
+    /// Missing, stale, reset, or insufficient observations; never evidence of idle.
+    Unknown,
+    /// A resource or foreground-protection threshold was reached.
+    Busy,
+    /// All required observations were fresh and below their low watermarks.
+    Stable,
+}
+
+/// Resource-owner input to the controller, after applying operator and kernel
+/// caps. This describes one owner; callers must not duplicate a device's budget
+/// for aliases, pools, or remote requesters.
+#[derive(Debug, Clone, Copy)]
+pub struct FeedbackObservation {
+    /// Identity of the resource/telemetry generation. Replacement resets probes.
+    pub generation: u64,
+    /// Upper bound imposed by resources and explicit configuration; zero blocks.
+    pub max_concurrency: u32,
+    /// Complete-window pressure, including the confidence of its sources.
+    pub pressure: ResourcePressure,
+    /// Cumulative completed work in this generation, not just scheduled work.
+    pub completed_units: Option<u64>,
+}
+
+/// Why the latest concurrency limit was selected.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum FeedbackReason {
+    /// The resource cap is unavailable; no new unit can be bounded safely.
+    Unavailable,
+    /// A changed owner or reset work counter requires a new baseline.
+    NewBaseline,
+    /// The resource or operator cap reduced the permitted concurrency.
+    CapReduced,
+    /// Pressure caused an immediate multiplicative reduction.
+    Pressure,
+    /// Incomplete telemetry retains at most one maintenance unit.
+    LowConfidence,
+    /// Waiting for consecutive stable windows, work progress and cooldown.
+    Recovering,
+    /// One additional unit is being probed after a stable recovery period.
+    Probe,
+}
+
+/// One controller decision, suitable for metrics without dynamic labels.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct FeedbackDecision {
+    /// New admissions use this cap; existing permits remain valid.
+    pub limit: u32,
+    /// Decision cause, distinct from a proof of work completion or storage health.
+    pub reason: FeedbackReason,
+}
+
+/// Single-owner additive probe/multiplicative decrease controller. It adjusts
+/// only concurrency. Every source must be fresh before declaring `Stable`.
+///
+/// The sampler runs every second. A gap over two seconds resets recovery; eight
+/// consecutive stable seconds and observed completed work allow one extra unit.
+/// Pressure or lower caps apply immediately. This policy is not a performance
+/// claim; its parameters require the same workload/foreground-SLO acceptance.
+pub struct FeedbackController {
+    previous: Option<(Instant, FeedbackObservation)>,
+    stable_since: Option<Instant>,
+    last_change: Instant,
+    limit: u32,
+}
+
+impl Default for FeedbackController {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl FeedbackController {
+    /// Start without a resource observation or an admission grant.
+    pub fn new() -> Self {
+        Self {
+            previous: None,
+            stable_since: None,
+            last_change: Instant::now(),
+            limit: 0,
+        }
+    }
+
+    /// Consume one sample and publish a three-second lease to the same gate.
+    /// If this function stops being called, admission expires independently.
+    pub fn update(&mut self, gate: &AdaptiveAdmission, observation: Option<FeedbackObservation>) -> FeedbackDecision {
+        let observation = observation.map(|mut observation| {
+            observation.max_concurrency = observation.max_concurrency.min(gate.maximum);
+            observation
+        });
+        let decision = self.decide(Instant::now(), observation);
+        gate.set_sampled_limit(decision.limit, Duration::from_secs(3));
+        decision
+    }
+
+    fn decide(&mut self, now: Instant, observation: Option<FeedbackObservation>) -> FeedbackDecision {
+        let Some(observation) = observation else {
+            self.previous = None;
+            self.stable_since = None;
+            self.last_change = now;
+            self.limit = 0;
+            return FeedbackDecision {
+                limit: 0,
+                reason: FeedbackReason::Unavailable,
+            };
+        };
+        let previous = self.previous.replace((now, observation));
+        let contiguous = previous.is_some_and(|(at, old)| {
+            now.saturating_duration_since(at) <= Duration::from_secs(2)
+                && old.generation == observation.generation
+                && matches!((old.completed_units, observation.completed_units), (Some(a), Some(b)) if b >= a)
+        });
+        let advanced = previous
+            .is_some_and(|(_, old)| matches!((old.completed_units, observation.completed_units), (Some(a), Some(b)) if b > a));
+        let old_limit = self.limit;
+        let reason = if observation.max_concurrency == 0 {
+            self.limit = 0;
+            self.stable_since = None;
+            FeedbackReason::CapReduced
+        } else if observation.pressure == ResourcePressure::Busy {
+            self.limit = (self.limit / 2).max(1).min(observation.max_concurrency);
+            self.stable_since = None;
+            // Repeated busy windows restart cooldown, even at the minimum cap.
+            self.last_change = now;
+            FeedbackReason::Pressure
+        } else if observation.max_concurrency < self.limit {
+            self.limit = observation.max_concurrency;
+            self.stable_since = None;
+            FeedbackReason::CapReduced
+        } else if observation.pressure == ResourcePressure::Unknown || observation.completed_units.is_none() {
+            self.limit = 1.min(observation.max_concurrency);
+            self.stable_since = None;
+            FeedbackReason::LowConfidence
+        } else if !contiguous || self.limit == 0 {
+            self.limit = 1.min(observation.max_concurrency);
+            self.stable_since = None;
+            self.last_change = now;
+            FeedbackReason::NewBaseline
+        } else {
+            let since = *self.stable_since.get_or_insert(now);
+            if advanced
+                && now.saturating_duration_since(since) >= Duration::from_secs(8)
+                && now.saturating_duration_since(self.last_change) >= Duration::from_secs(8)
+                && self.limit < observation.max_concurrency
+            {
+                self.limit += 1;
+                FeedbackReason::Probe
+            } else {
+                FeedbackReason::Recovering
+            }
+        };
+        if old_limit != self.limit {
+            self.last_change = now;
+        }
+        FeedbackDecision {
+            limit: self.limit,
+            reason,
+        }
+    }
+}
+
+impl AdaptiveAdmission {
+    /// Construct a bounded owner, with zero initial capacity allowed for unknown
+    /// input. The immutable maximum reserves at most 65,535 lease slots once;
+    /// acquiring or cloning a permit does not allocate a per-unit Arc.
+    pub fn new(maximum: NonZeroU16, limit: u32) -> Arc<Self> {
+        let maximum_u32 = u32::from(maximum.get());
+        let maximum = usize::from(maximum.get());
+        let slots = (0..maximum.div_ceil(64))
+            .map(|chunk| {
+                let count = (maximum - chunk * 64).min(64);
+                PermitSlots {
+                    free: AtomicU64::new(if count == 64 { u64::MAX } else { (1_u64 << count) - 1 }),
+                    references: std::array::from_fn(|_| AtomicUsize::new(0)),
+                }
+            })
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        Arc::new(Self {
+            state: AtomicU64::new(u64::from(limit.min(maximum_u32)) << 32),
+            origin: Instant::now(),
+            valid_until_millis: AtomicU64::new(u64::MAX),
+            changed: Notify::new(),
+            queued: AtomicUsize::new(0),
+            turn: Semaphore::new(1),
+            maximum: maximum_u32,
+            slots,
+            next_chunk: AtomicUsize::new(0),
+        })
+    }
+
+    /// Publish a cap bounded by the immutable maximum, without losing held work
+    /// or changing owner identity.
+    pub fn set_limit(&self, limit: u32) {
+        let limit = limit.min(self.maximum);
+        let _ = self.state.try_update(Ordering::AcqRel, Ordering::Acquire, |state| {
+            Some((u64::from(limit) << 32) | (state & u64::from(u32::MAX)))
+        });
+        self.changed.notify_one();
+    }
+
+    /// Publish a cap with a finite observation lifetime. Expired observations
+    /// block new admissions even if the sampling worker has stopped. Existing
+    /// permits are retained. A single resource owner must serialize publishers.
+    ///
+    /// Capacity is published before freshness, so a concurrent reader can
+    /// temporarily reject a fresh update but cannot use an increased lifetime
+    /// with the previous, potentially larger capacity.
+    pub fn set_sampled_limit(&self, limit: u32, valid_for: Duration) {
+        self.set_limit(limit);
+        let deadline = self
+            .elapsed_millis()
+            .saturating_add(u64::try_from(valid_for.as_millis()).unwrap_or(u64::MAX));
+        self.valid_until_millis.store(deadline, Ordering::Release);
+        self.changed.notify_one();
+    }
+
+    fn elapsed_millis(&self) -> u64 {
+        u64::try_from(self.origin.elapsed().as_millis()).unwrap_or(u64::MAX)
+    }
+
+    fn fresh(&self) -> bool {
+        self.elapsed_millis() < self.valid_until_millis.load(Ordering::Acquire)
+    }
+
+    /// Read the cap and active count from the same atomic observation.
+    pub fn snapshot(&self) -> AdaptiveAdmissionSnapshot {
+        // Acquire freshness first: a newly published lease must not be paired
+        // with capacity loaded before its preceding reduction.
+        let fresh = self.fresh();
+        let state = self.state.load(Ordering::Acquire);
+        AdaptiveAdmissionSnapshot {
+            limit: if fresh {
+                u32::try_from(state >> 32).unwrap_or(u32::MAX)
+            } else {
+                0
+            },
+            active: u32::try_from(state & u64::from(u32::MAX)).unwrap_or(u32::MAX),
+        }
+    }
+
+    /// Admit immediately if capacity remains, without a per-unit allocation.
+    /// The uncontended path uses atomics; refunding a racing acquisition may
+    /// wake the FIFO head through Tokio's notification queue.
+    pub fn try_acquire(self: &Arc<Self>) -> Option<AdaptivePermit> {
+        if self.queued.load(Ordering::Acquire) != 0 {
+            return None;
+        }
+        let permit = self.acquire_capacity()?;
+        // A waiter can register between the first queue check and the capacity
+        // CAS. Refund before exposing the permit rather than stealing its turn.
+        (self.queued.load(Ordering::Acquire) == 0).then_some(permit)
+    }
+
+    fn acquire_capacity(self: &Arc<Self>) -> Option<AdaptivePermit> {
+        if !self.fresh() {
+            return None;
+        }
+        let state = self.state.load(Ordering::Acquire);
+        if state & u64::from(u32::MAX) >= state >> 32 {
+            return None;
+        }
+        let slot = self.reserve_slot()?;
+        if self
+            .state
+            .try_update(Ordering::AcqRel, Ordering::Acquire, |state| {
+                let active = state & u64::from(u32::MAX);
+                (active < state >> 32).then(|| state + 1)
+            })
+            .is_err()
+        {
+            self.release_slot(slot);
+            self.changed.notify_one();
+            return None;
+        }
+        self.slots[slot / 64].references[slot % 64].store(1, Ordering::Release);
+        let permit = AdaptivePermit {
+            owner: self.clone(),
+            slot,
+        };
+        // The capacity CAS can retry across an observation expiry. Recheck
+        // before giving ownership to the caller; dropping refunds this unit.
+        self.fresh().then_some(permit)
+    }
+
+    fn reserve_slot(&self) -> Option<usize> {
+        let first = self.next_chunk.fetch_add(1, Ordering::Relaxed) % self.slots.len();
+        for offset in 0..self.slots.len() {
+            let chunk_index = (first + offset) % self.slots.len();
+            let free = &self.slots[chunk_index].free;
+            if let Ok(bits) = free.try_update(Ordering::AcqRel, Ordering::Acquire, |bits| (bits != 0).then(|| bits & (bits - 1)))
+            {
+                // trailing_zeros is in 0..64 because the zero word is rejected.
+                return Some(chunk_index * 64 + bits.trailing_zeros() as usize);
+            }
+        }
+        None
+    }
+
+    fn release_slot(&self, slot: usize) {
+        self.slots[slot / 64].free.fetch_or(1_u64 << (slot % 64), Ordering::Release);
+    }
+
+    /// Wait for capacity. The future owns no permit until it returns; dropping
+    /// a pending future leaves capacity untouched. Wrap in the caller's existing
+    /// cancellation/deadline select before acquiring any storage commit locks.
+    pub async fn acquire(self: &Arc<Self>) -> AdaptivePermit {
+        if let Some(permit) = self.try_acquire() {
+            return permit;
+        }
+        self.queued.fetch_add(1, Ordering::AcqRel);
+        let _queued = QueuedAdmission(self);
+        // Retain the successful permit inside its Result. No code can close
+        // this private semaphore, so acquisition cannot return an error.
+        let _turn = self.turn.acquire().await;
+        loop {
+            let notified = self.changed.notified();
+            tokio::pin!(notified);
+            // Register before checking capacity to avoid a lost release/resize.
+            notified.as_mut().enable();
+            if let Some(permit) = self.acquire_capacity() {
+                return permit;
+            }
+            notified.await;
+        }
+    }
+}
+
+impl Drop for AdaptivePermit {
+    fn drop(&mut self) {
+        if self.owner.slots[self.slot / 64].references[self.slot % 64].fetch_sub(1, Ordering::AcqRel) != 1 {
+            return;
+        }
+        // Publish the free slot before exposing another admission capacity.
+        self.owner.release_slot(self.slot);
+        self.owner.state.fetch_sub(1, Ordering::AcqRel);
+        self.owner.changed.notify_one();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn node_progress_requires_explicit_completion_and_never_wraps() {
+        let node = NodeAdmission::new(NonZeroU16::new(2).expect("two slots"));
+        node.capacity.set_limit(2);
+        drop(node.acquire().await);
+        assert_eq!(node.completed(), Some(0), "cancellation is not progress");
+        node.acquire().await.complete();
+        assert_eq!(node.completed(), Some(1));
+        node.completed.store(u64::MAX - 1, Ordering::Release);
+        node.acquire().await.complete();
+        node.acquire().await.complete();
+        assert_eq!(node.completed(), None, "exhausted progress stays unknown");
+        assert_eq!(node.snapshot().active, 0);
+    }
+
+    #[tokio::test]
+    async fn cancelled_node_work_does_not_reserve_capacity_for_unrelated_native_tail() {
+        let node = NodeAdmission::new(NonZeroU16::new(1).expect("one slot"));
+        node.capacity.set_limit(1);
+        let physical = AdaptiveAdmission::new(NonZeroU16::new(1).expect("one disk unit"), 1);
+        let scheduling = node.acquire().await;
+        let native_tail = physical.acquire().await;
+        drop(scheduling);
+        assert_eq!(node.completed(), Some(0));
+        assert!(node.try_acquire().is_some(), "healthy resources can still be scheduled");
+        assert!(physical.try_acquire().is_none(), "the stalled disk remains charged");
+        drop(native_tail);
+        assert!(physical.try_acquire().is_some());
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn node_feedback_expires_without_revoking_held_work_or_fabricating_progress() {
+        let node = NodeAdmission::new(NonZeroU16::new(2).expect("two slots"));
+        let mut controller = FeedbackController::new();
+        let input = FeedbackObservation {
+            generation: 1,
+            max_concurrency: 2,
+            pressure: ResourcePressure::Stable,
+            completed_units: Some(99),
+        };
+        node.update(&mut controller, Some(input));
+        let held = node.acquire().await;
+        assert_eq!(node.completed(), Some(0));
+        tokio::time::advance(Duration::from_secs(4)).await;
+        assert_eq!(node.snapshot(), AdaptiveAdmissionSnapshot { limit: 0, active: 1 });
+        assert!(node.try_acquire().is_none());
+        held.complete();
+        assert_eq!(node.completed(), Some(1));
+        assert_eq!(node.snapshot().active, 0);
+    }
+
+    #[tokio::test]
+    async fn shared_unit_stays_admitted_until_native_worker_releases_its_last_clone() {
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(1).expect("one unit"), 1);
+        let outer = gate.acquire().await;
+        let native = outer.clone();
+        let (started_tx, started_rx) = tokio::sync::oneshot::channel();
+        let (release_tx, release_rx) = tokio::sync::oneshot::channel();
+        let worker = tokio::task::spawn_blocking(move || {
+            started_tx.send(()).expect("worker started");
+            release_rx.blocking_recv().expect("release native worker");
+            drop(native);
+        });
+        started_rx.await.expect("native worker is live");
+        drop(outer);
+        assert_eq!(gate.snapshot().active, 1);
+        assert!(gate.try_acquire().is_none());
+        gate.set_limit(0);
+        assert_eq!(gate.snapshot().active, 1);
+        release_tx.send(()).expect("release tail");
+        worker.await.expect("native tail completed");
+        assert_eq!(gate.snapshot().active, 0);
+        gate.set_limit(1);
+        assert!(gate.try_acquire().is_some());
+    }
+
+    #[tokio::test]
+    async fn bounded_slots_cross_word_boundaries_and_recycle_only_after_final_drop() {
+        let maximum = NonZeroU16::new(65).expect("partial second chunk");
+        let gate = AdaptiveAdmission::new(maximum, u32::MAX);
+        assert_eq!(gate.snapshot().limit, 65);
+        for _ in 0..4 {
+            let units: Vec<_> = (0..65).map(|_| gate.try_acquire().expect("free slot")).collect();
+            let tails = units.clone();
+            assert_eq!(gate.snapshot().active, 65);
+            assert!(gate.try_acquire().is_none());
+            drop(units);
+            assert_eq!(gate.snapshot().active, 65);
+            gate.set_limit(0);
+            for (remaining, tail) in (0..65).rev().zip(tails) {
+                drop(tail);
+                assert_eq!(gate.snapshot().active, remaining);
+            }
+            gate.set_limit(u32::MAX);
+            assert_eq!(gate.snapshot().limit, 65);
+        }
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    async fn shared_units_survive_concurrent_clone_drop_reuse_and_resize() {
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded owner"), 8);
+        let mut workers = Vec::new();
+        for _ in 0..16 {
+            let gate = gate.clone();
+            workers.push(tokio::spawn(async move {
+                for _ in 0..64 {
+                    let root = gate.acquire().await;
+                    let one = root.clone();
+                    let two = one.clone();
+                    drop(root);
+                    tokio::task::yield_now().await;
+                    drop(two);
+                    tokio::task::yield_now().await;
+                    drop(one);
+                }
+            }));
+        }
+        for limit in [0, 1, 8, 2, 0, 8] {
+            gate.set_limit(limit);
+            tokio::task::yield_now().await;
+        }
+        tokio::time::timeout(Duration::from_secs(5), async {
+            for worker in workers {
+                worker.await.expect("lease worker");
+            }
+        })
+        .await
+        .expect("all lease workers complete");
+        assert_eq!(gate.snapshot(), AdaptiveAdmissionSnapshot { limit: 8, active: 0 });
+        let full: Vec<_> = (0..8).map(|_| gate.try_acquire().expect("all slots returned")).collect();
+        assert!(gate.try_acquire().is_none());
+        drop(full);
+    }
+
+    #[tokio::test]
+    async fn queued_work_cannot_be_starved_by_new_fast_acquisitions() {
+        use std::task::{Context, Poll, Waker};
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 1);
+        let held = gate.acquire().await;
+        let mut first = Box::pin(gate.acquire());
+        let mut second = Box::pin(gate.acquire());
+        let mut context = Context::from_waker(Waker::noop());
+        assert!(first.as_mut().poll(&mut context).is_pending());
+        assert!(second.as_mut().poll(&mut context).is_pending());
+        drop(held);
+        assert!(gate.try_acquire().is_none(), "new work must not steal a parked worker's turn");
+        assert!(second.as_mut().poll(&mut context).is_pending(), "later work cannot pass the queue head");
+        let Poll::Ready(first_permit) = first.as_mut().poll(&mut context) else {
+            panic!("queue head must run")
+        };
+        drop(first_permit);
+        let Poll::Ready(second_permit) = second.as_mut().poll(&mut context) else {
+            panic!("second waiter must run")
+        };
+        drop(second_permit);
+        assert!(gate.try_acquire().is_some(), "drained queue restores the atomic fast path");
+    }
+
+    #[tokio::test]
+    async fn cancelling_queued_work_preserves_fifo_capacity_and_fast_path() {
+        use std::task::{Context, Poll, Waker};
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 0);
+        let mut head = Box::pin(gate.acquire());
+        let mut middle = Box::pin(gate.acquire());
+        let mut tail = Box::pin(gate.acquire());
+        let mut context = Context::from_waker(Waker::noop());
+        assert!(head.as_mut().poll(&mut context).is_pending());
+        assert!(middle.as_mut().poll(&mut context).is_pending());
+        assert!(tail.as_mut().poll(&mut context).is_pending());
+        drop(middle);
+        drop(head);
+        gate.set_limit(1);
+        assert!(
+            gate.try_acquire().is_none(),
+            "cancelled head must not expose the surviving waiter's capacity"
+        );
+        let Poll::Ready(permit) = tail.as_mut().poll(&mut context) else {
+            panic!("surviving waiter must run")
+        };
+        drop(permit);
+        assert!(gate.try_acquire().is_some());
+
+        gate.set_limit(0);
+        let mut cancelled = Box::pin(gate.acquire());
+        assert!(cancelled.as_mut().poll(&mut context).is_pending());
+        drop(cancelled);
+        gate.set_limit(1);
+        assert!(
+            gate.try_acquire().is_some(),
+            "cancelling the final waiter must not strand an admission turn"
+        );
+    }
+
+    #[tokio::test]
+    async fn cancelling_a_notified_head_hands_capacity_to_the_next_waiter() {
+        use std::task::{Context, Poll, Waker};
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(2).expect("two units"), 0);
+        let mut head = Box::pin(gate.acquire());
+        let mut next = Box::pin(gate.acquire());
+        let mut context = Context::from_waker(Waker::noop());
+        assert!(head.as_mut().poll(&mut context).is_pending());
+        assert!(next.as_mut().poll(&mut context).is_pending());
+        gate.set_limit(1);
+        // Cancel after notification, before the head consumes its capacity.
+        drop(head);
+        let Poll::Ready(permit) = next.as_mut().poll(&mut context) else {
+            panic!("successor must observe capacity without another notification")
+        };
+        assert_eq!(gate.snapshot(), AdaptiveAdmissionSnapshot { limit: 1, active: 1 });
+        drop(permit);
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn one_resize_serves_multiple_fifo_turns_but_stored_wakes_cannot_bypass_expiry() {
+        use std::task::{Context, Poll, Waker};
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(2).expect("two units"), 0);
+        let mut first = Box::pin(gate.acquire());
+        let mut second = Box::pin(gate.acquire());
+        let mut context = Context::from_waker(Waker::noop());
+        assert!(first.as_mut().poll(&mut context).is_pending());
+        assert!(second.as_mut().poll(&mut context).is_pending());
+        gate.set_sampled_limit(2, Duration::from_secs(1));
+        let Poll::Ready(one) = first.as_mut().poll(&mut context) else {
+            panic!("first turn must observe resize")
+        };
+        let Poll::Ready(two) = second.as_mut().poll(&mut context) else {
+            panic!("second turn must observe resize without releasing the first unit")
+        };
+        tokio::time::advance(Duration::from_secs(1)).await;
+        drop(one);
+        drop(two);
+        let mut expired = Box::pin(gate.acquire());
+        assert!(expired.as_mut().poll(&mut context).is_pending(), "stored wake is not a fresh lease");
+        gate.set_sampled_limit(1, Duration::from_secs(1));
+        let Poll::Ready(renewed) = expired.as_mut().poll(&mut context) else {
+            panic!("fresh observation must wake expired admission")
+        };
+        drop(renewed);
+        assert_eq!(gate.snapshot().active, 0);
+    }
+    use std::future::Future;
+    use std::task::Poll;
+
+    #[tokio::test]
+    async fn shrink_preserves_all_held_units_and_blocks_until_below_new_limit() {
+        let owner = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 3);
+        let first = owner.acquire().await;
+        let second = owner.acquire().await;
+        let third = owner.acquire().await;
+        owner.set_limit(1);
+        assert_eq!(owner.snapshot(), AdaptiveAdmissionSnapshot { limit: 1, active: 3 });
+        drop(first);
+        assert!(owner.try_acquire().is_none());
+        drop(second);
+        assert!(owner.try_acquire().is_none());
+        drop(third);
+        let fourth = owner.try_acquire().expect("last old permit returned to original owner");
+        assert_eq!(owner.snapshot(), AdaptiveAdmissionSnapshot { limit: 1, active: 1 });
+        drop(fourth);
+        assert_eq!(owner.snapshot().active, 0);
+    }
+
+    #[tokio::test]
+    async fn zero_capacity_and_cancelled_waiter_do_not_leak_or_bypass() {
+        let owner = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 0);
+        let mut waiting = Box::pin(owner.acquire());
+        std::future::poll_fn(|cx| {
+            assert!(waiting.as_mut().poll(cx).is_pending());
+            Poll::Ready(())
+        })
+        .await;
+        drop(waiting);
+        assert_eq!(owner.snapshot(), AdaptiveAdmissionSnapshot { limit: 0, active: 0 });
+        assert!(owner.try_acquire().is_none());
+        owner.set_limit(1);
+        let permit = owner.acquire().await;
+        assert!(owner.try_acquire().is_none());
+        drop(permit);
+        assert_eq!(owner.snapshot().active, 0);
+    }
+
+    #[tokio::test]
+    async fn resize_wakes_a_registered_waiter_without_an_unrelated_release() {
+        let owner = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 0);
+        let mut waiting = Box::pin(owner.acquire());
+        std::future::poll_fn(|cx| {
+            assert!(waiting.as_mut().poll(cx).is_pending());
+            Poll::Ready(())
+        })
+        .await;
+        owner.set_limit(1);
+        let permit = tokio::time::timeout(std::time::Duration::from_secs(1), waiting)
+            .await
+            .expect("resize notification");
+        assert_eq!(owner.snapshot().active, 1);
+        drop(permit);
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    async fn concurrent_resize_release_and_acquire_keep_the_owner_count_exact() {
+        let owner = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 8);
+        let mut tasks = Vec::new();
+        for _ in 0..16 {
+            let owner = owner.clone();
+            tasks.push(tokio::spawn(async move {
+                for _ in 0..100 {
+                    let permit = owner.acquire().await;
+                    tokio::task::yield_now().await;
+                    drop(permit);
+                }
+            }));
+        }
+        for limit in [1, 0, 4, 2, 8, 0, u32::MAX, 1] {
+            owner.set_limit(limit);
+            tokio::task::yield_now().await;
+        }
+        owner.set_limit(8);
+        tokio::time::timeout(std::time::Duration::from_secs(5), async {
+            for task in tasks {
+                task.await.expect("admission task");
+            }
+        })
+        .await
+        .expect("all waiters make progress");
+        assert_eq!(owner.snapshot(), AdaptiveAdmissionSnapshot { limit: 8, active: 0 });
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn expired_observation_blocks_new_work_without_revoking_held_permits() {
+        let owner = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 0);
+        owner.set_sampled_limit(2, Duration::from_secs(2));
+        let held = owner.acquire().await;
+        tokio::time::advance(Duration::from_secs(2)).await;
+        assert!(owner.try_acquire().is_none());
+        assert_eq!(owner.snapshot(), AdaptiveAdmissionSnapshot { limit: 0, active: 1 });
+        drop(held);
+        assert_eq!(owner.snapshot().active, 0);
+        owner.set_sampled_limit(1, Duration::from_secs(2));
+        let fresh = owner.try_acquire().expect("fresh observation reopens same owner");
+        owner.set_sampled_limit(8, Duration::ZERO);
+        assert!(owner.try_acquire().is_none());
+        drop(fresh);
+        assert_eq!(owner.snapshot().active, 0);
+    }
+
+    fn healthy(completed: u64) -> FeedbackObservation {
+        FeedbackObservation {
+            generation: 1,
+            max_concurrency: 8,
+            pressure: ResourcePressure::Stable,
+            completed_units: Some(completed),
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn controller_grows_one_unit_per_cooldown_and_cuts_pressure_immediately() {
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 0);
+        let mut controller = FeedbackController::new();
+        assert_eq!(controller.update(&gate, Some(healthy(0))).limit, 1);
+        for completed in 1..=25 {
+            tokio::time::advance(Duration::from_secs(1)).await;
+            let limit = controller.update(&gate, Some(healthy(completed))).limit;
+            assert_eq!(
+                limit,
+                if completed < 9 {
+                    1
+                } else if completed < 17 {
+                    2
+                } else if completed < 25 {
+                    3
+                } else {
+                    4
+                }
+            );
+        }
+        let held = gate.try_acquire().expect("existing work");
+        let mut pressure = healthy(26);
+        pressure.pressure = ResourcePressure::Busy;
+        assert_eq!(
+            controller.update(&gate, Some(pressure)),
+            FeedbackDecision {
+                limit: 2,
+                reason: FeedbackReason::Pressure
+            }
+        );
+        pressure.max_concurrency = 0;
+        assert_eq!(controller.update(&gate, Some(pressure)).limit, 0);
+        assert_eq!(gate.snapshot().active, 1);
+        assert!(gate.try_acquire().is_none());
+        drop(held);
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn controller_missing_low_sample_stalled_or_changed_sources_never_expand() {
+        for kind in 0..5 {
+            let gate = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 0);
+            let mut controller = FeedbackController::new();
+            for tick in 0..32 {
+                let mut observation = healthy(tick);
+                match kind {
+                    0 => observation.pressure = ResourcePressure::Unknown,
+                    1 => observation.completed_units = None,
+                    2 => observation.completed_units = Some(0),
+                    3 => observation.generation = tick,
+                    _ => {}
+                }
+                tokio::time::advance(Duration::from_secs(if kind == 4 { 3 } else { 1 })).await;
+                assert!(controller.update(&gate, Some(observation)).limit <= 1, "kind {kind}");
+            }
+            assert_eq!(
+                controller.update(&gate, None),
+                FeedbackDecision {
+                    limit: 0,
+                    reason: FeedbackReason::Unavailable
+                }
+            );
+            assert!(gate.try_acquire().is_none());
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn controller_resumes_after_zero_cap_without_requiring_impossible_progress() {
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 0);
+        let mut controller = FeedbackController::new();
+        let mut sample = healthy(0);
+        sample.max_concurrency = 0;
+        assert_eq!(controller.update(&gate, Some(sample)).limit, 0);
+        tokio::time::advance(Duration::from_secs(1)).await;
+        sample.max_concurrency = 8;
+        assert_eq!(controller.update(&gate, Some(sample)).limit, 1);
+        assert!(gate.try_acquire().is_some(), "minimum progress restarts inside the restored cap");
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn controller_applies_pressure_reduction_and_lower_cap_in_the_same_window() {
+        let gate = AdaptiveAdmission::new(NonZeroU16::new(8).expect("bounded test owner"), 0);
+        let mut controller = FeedbackController::new();
+        for completed in 0..=25 {
+            controller.update(&gate, Some(healthy(completed)));
+            tokio::time::advance(Duration::from_secs(1)).await;
+        }
+        assert_eq!(gate.snapshot().limit, 4);
+        let mut sample = healthy(26);
+        sample.max_concurrency = 3;
+        sample.pressure = ResourcePressure::Busy;
+        assert_eq!(controller.update(&gate, Some(sample)).limit, 2);
+    }
+}

crates/concurrency/src/foreground.rs

@@ -0,0 +1,568 @@
+// Copyright 2026 RustFS Team
+// Licensed under the Apache License, Version 2.0.
+
+//! Bounded foreground completion windows for background resource feedback.
+//! Recording uses fixed atomic storage, without an allocation, mutex or task
+//! per request. A single reader rotates banks and waits for the retired bank's
+//! writers before reading it. Delayed writers delay publication, not the
+//! recorded window boundary. Percentiles are intervals, never exact values.
+
+use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
+use std::time::{Duration, Instant};
+
+const SUB_BUCKETS: usize = 64;
+const FINITE_BUCKETS: usize = 27 * SUB_BUCKETS;
+const BUCKETS: usize = FINITE_BUCKETS + 1;
+const MAX_MICROS: u64 = u32::MAX as u64;
+
+/// Bounded foreground categories; no bucket, object or request identifiers.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ForegroundClass {
+    /// Object body reads.
+    Read,
+    /// Object writes, including multipart and copy operations.
+    Write,
+    /// Metadata and listing operations.
+    Metadata,
+    /// Other operations, including rejection before typed dispatch.
+    Other,
+}
+
+impl ForegroundClass {
+    /// Stable order shared by window summaries.
+    pub const ALL: [Self; 4] = [Self::Read, Self::Write, Self::Metadata, Self::Other];
+
+    /// Fixed metric label.
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Read => "read",
+            Self::Write => "write",
+            Self::Metadata => "metadata",
+            Self::Other => "other",
+        }
+    }
+
+    const fn index(self) -> usize {
+        match self {
+            Self::Read => 0,
+            Self::Write => 1,
+            Self::Metadata => 2,
+            Self::Other => 3,
+        }
+    }
+}
+
+/// Outcome at the observed response-body boundary, not a client ACK.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CompletionOutcome {
+    /// Successful response body completed.
+    Success,
+    /// Error response, service error, or body-stream failure.
+    Failed,
+    /// The request/body was dropped before completion.
+    Cancelled,
+}
+
+/// Inclusive bounds containing the observed percentile.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct LatencyBounds {
+    /// Inclusive lower bound in nanoseconds.
+    pub lower_nanos: u64,
+    /// Inclusive upper bound; absent for the overflow bucket.
+    pub upper_nanos: Option<u64>,
+}
+
+/// One class in a complete observation window.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ClassCompletions {
+    /// All finishes, including errors and cancellation.
+    pub finished: u64,
+    /// Error responses, service errors and body-stream failures.
+    pub failed: u64,
+    /// Censored observations; these must not be treated as successful latency.
+    pub cancelled: u64,
+    /// P99 of non-cancelled finishes, when at least 100 samples exist.
+    /// This count permits computing the rank; it is not statistical confidence.
+    pub p99: Option<LatencyBounds>,
+}
+
+/// Clock readings bracketing an atomic event-window cut. A scheduler pause
+/// between these readings is visible, rather than disguised as precise timing.
+#[derive(Clone, Copy, Debug)]
+pub struct WindowBoundary {
+    /// Read immediately before the event cut.
+    pub earliest: Instant,
+    /// Read immediately after the event cut.
+    pub latest: Instant,
+}
+
+/// Complete windows retain their actual cut brackets, even if publication waits.
+#[derive(Clone, Copy, Debug)]
+pub struct ForegroundWindow {
+    /// Start of this event window.
+    pub start: WindowBoundary,
+    /// Cut of the retired bank, possibly older than publication time.
+    pub end: WindowBoundary,
+    /// Request starts in this window, including pre-dispatch rejection.
+    pub started: Option<u64>,
+    /// Requests still alive at the cut; absent after accounting overflow.
+    pub in_flight: Option<u64>,
+    /// Per-class completions in ForegroundClass::ALL order.
+    pub classes: [Option<ClassCompletions>; 4],
+    /// False after a counter overflow or an inconsistent event count.
+    pub valid: bool,
+}
+
+struct ClassBank {
+    latencies: [AtomicU64; BUCKETS],
+    failed: AtomicU64,
+    cancelled: AtomicU64,
+}
+
+impl ClassBank {
+    fn new() -> Self {
+        Self {
+            latencies: std::array::from_fn(|_| AtomicU64::new(0)),
+            failed: AtomicU64::new(0),
+            cancelled: AtomicU64::new(0),
+        }
+    }
+}
+
+struct Bank {
+    writers: AtomicUsize,
+    started: AtomicU64,
+    overflowed: AtomicBool,
+    classes: [ClassBank; 4],
+}
+
+impl Bank {
+    fn new() -> Self {
+        Self {
+            writers: AtomicUsize::new(0),
+            started: AtomicU64::new(0),
+            overflowed: AtomicBool::new(false),
+            classes: std::array::from_fn(|_| ClassBank::new()),
+        }
+    }
+
+    fn increment(&self, counter: &AtomicU64) {
+        if counter.fetch_add(1, Ordering::Relaxed) == u64::MAX {
+            self.overflowed.store(true, Ordering::Relaxed);
+        }
+    }
+}
+
+struct Writer<'a>(&'a Bank);
+
+impl Drop for Writer<'_> {
+    fn drop(&mut self) {
+        self.0.writers.fetch_sub(1, Ordering::SeqCst);
+    }
+}
+
+/// One process-wide recorder. Its fixed storage is allocated with the owner.
+/// A request holds only a reference, timestamps and bounded enum state.
+pub struct ForegroundRecorder {
+    created_at: Instant,
+    epoch: AtomicU64,
+    reader_taken: AtomicBool,
+    banks: [Bank; 2],
+}
+
+impl Default for ForegroundRecorder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ForegroundRecorder {
+    /// Construct empty accounting for one lifetime of the owning process.
+    pub fn new() -> Self {
+        Self {
+            created_at: Instant::now(),
+            epoch: AtomicU64::new(0),
+            reader_taken: AtomicBool::new(false),
+            banks: std::array::from_fn(|_| Bank::new()),
+        }
+    }
+
+    fn writer(&self) -> Writer<'_> {
+        loop {
+            let epoch = self.epoch.load(Ordering::SeqCst);
+            let bank = &self.banks[usize::from(epoch & 1 != 0)];
+            bank.writers.fetch_add(1, Ordering::SeqCst);
+            let writer = Writer(bank);
+            // Sequential ordering joins registration, the reader's cut, and
+            // its zero-writer check. A late old-epoch registrant cannot write
+            // into a bank that the reader has begun draining or reusing.
+            if self.epoch.load(Ordering::SeqCst) == epoch {
+                return writer;
+            }
+        }
+    }
+
+    /// Begin at the external service-call boundary. Drop records cancellation
+    /// unless finish has already recorded a response-body outcome.
+    pub fn start(&self) -> ForegroundObservation<'_> {
+        let started_at = Instant::now();
+        let writer = self.writer();
+        writer.0.increment(&writer.0.started);
+        ForegroundObservation {
+            recorder: self,
+            started_at: Some(started_at),
+            class: ForegroundClass::Other,
+        }
+    }
+
+    fn finish(&self, class: ForegroundClass, elapsed: Duration, outcome: CompletionOutcome) {
+        let writer = self.writer();
+        let bank = writer.0;
+        let class = &bank.classes[class.index()];
+        if outcome == CompletionOutcome::Cancelled {
+            bank.increment(&class.cancelled);
+            return;
+        }
+        let bucket = latency_bucket(elapsed);
+        bank.increment(&class.latencies[bucket]);
+        if outcome == CompletionOutcome::Failed {
+            bank.increment(&class.failed);
+        }
+    }
+
+    /// Claim the sole reader. It cannot be replaced after being dropped:
+    /// resetting its carried in-flight count would falsify later windows.
+    pub fn take_reader(&self) -> Option<ForegroundReader<'_>> {
+        self.reader_taken
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .ok()?;
+        Some(ForegroundReader {
+            recorder: self,
+            start: WindowBoundary {
+                earliest: self.created_at,
+                latest: self.created_at,
+            },
+            retired: None,
+            in_flight: Some(0),
+        })
+    }
+}
+
+/// Non-cloneable request ownership, moved from the service future to its body.
+pub struct ForegroundObservation<'a> {
+    recorder: &'a ForegroundRecorder,
+    started_at: Option<Instant>,
+    class: ForegroundClass,
+}
+
+impl ForegroundObservation<'_> {
+    /// Set the first dispatched operation's bounded category.
+    pub fn set_class(&mut self, class: ForegroundClass) {
+        self.class = class;
+    }
+
+    /// Finish once. Later calls or Drop do not produce another observation.
+    pub fn finish(&mut self, outcome: CompletionOutcome) {
+        if let Some(started_at) = self.started_at.take() {
+            self.recorder.finish(self.class, started_at.elapsed(), outcome);
+        }
+    }
+}
+
+impl Drop for ForegroundObservation<'_> {
+    fn drop(&mut self) {
+        self.finish(CompletionOutcome::Cancelled);
+    }
+}
+
+/// Single-reader state; never acquired by a request path.
+pub struct ForegroundReader<'a> {
+    recorder: &'a ForegroundRecorder,
+    start: WindowBoundary,
+    retired: Option<(usize, WindowBoundary)>,
+    in_flight: Option<u64>,
+}
+
+impl ForegroundReader<'_> {
+    /// Cut a new window, or finish publishing an earlier cut. A live retired
+    /// writer returns None without blocking, discarding data or moving its cut.
+    pub fn sample(&mut self) -> Option<ForegroundWindow> {
+        if self.retired.is_none() {
+            let epoch = self.recorder.epoch.load(Ordering::SeqCst);
+            let next = epoch.checked_add(1)?;
+            let earliest = Instant::now();
+            self.recorder.epoch.store(next, Ordering::SeqCst);
+            let cut = WindowBoundary {
+                earliest,
+                latest: Instant::now(),
+            };
+            self.retired = Some((usize::from(epoch & 1 != 0), cut));
+        }
+        let (index, end) = self.retired?;
+        let bank = &self.recorder.banks[index];
+        if bank.writers.load(Ordering::SeqCst) != 0 {
+            return None;
+        }
+
+        let started = bank.started.swap(0, Ordering::Relaxed);
+        let overflowed = bank.overflowed.swap(false, Ordering::Relaxed);
+        let classes = std::array::from_fn(|index| {
+            let class = &bank.classes[index];
+            let failed = class.failed.swap(0, Ordering::Relaxed);
+            let cancelled = class.cancelled.swap(0, Ordering::Relaxed);
+            let buckets = std::array::from_fn::<_, BUCKETS, _>(|i| class.latencies[i].swap(0, Ordering::Relaxed));
+            let non_cancelled = buckets.iter().try_fold(0_u64, |sum, count| sum.checked_add(*count));
+            let finished = non_cancelled.and_then(|total| total.checked_add(cancelled));
+            let finished = finished.filter(|_| !overflowed && non_cancelled.is_some_and(|total| failed <= total))?;
+            Some(ClassCompletions {
+                finished,
+                failed,
+                cancelled,
+                p99: non_cancelled
+                    .filter(|total| *total >= 100)
+                    .and_then(|total| percentile_99(&buckets, total)),
+            })
+        });
+        let started = (!overflowed).then_some(started);
+        let finished = classes
+            .iter()
+            .try_fold(0_u64, |sum, class| sum.checked_add(class.as_ref()?.finished));
+        self.in_flight = self
+            .in_flight
+            .zip(finished)
+            .and_then(|(active, finished)| active.checked_add(started?)?.checked_sub(finished));
+        let window = ForegroundWindow {
+            start: self.start,
+            end,
+            started,
+            in_flight: self.in_flight,
+            classes,
+            valid: self.in_flight.is_some(),
+        };
+        self.start = end;
+        self.retired = None;
+        Some(window)
+    }
+}
+
+fn latency_bucket(elapsed: Duration) -> usize {
+    let micros = elapsed.as_nanos().div_ceil(1_000);
+    let Ok(micros) = u64::try_from(micros) else {
+        return FINITE_BUCKETS;
+    };
+    if micros > MAX_MICROS {
+        return FINITE_BUCKETS;
+    }
+    if micros < SUB_BUCKETS as u64 {
+        return usize::try_from(micros).unwrap_or(FINITE_BUCKETS);
+    }
+    let shift = 63 - micros.leading_zeros() - 6;
+    usize::try_from((u64::from(shift) + 1) * SUB_BUCKETS as u64 + (micros >> shift) - SUB_BUCKETS as u64)
+        .unwrap_or(FINITE_BUCKETS)
+}
+
+fn bucket_bounds(index: usize) -> LatencyBounds {
+    if index == FINITE_BUCKETS {
+        return LatencyBounds {
+            lower_nanos: MAX_MICROS * 1_000 + 1,
+            upper_nanos: None,
+        };
+    }
+    let (lower, upper) = if index < SUB_BUCKETS {
+        (index as u64, index as u64)
+    } else {
+        let shift = index / SUB_BUCKETS - 1;
+        let lower = (SUB_BUCKETS + index % SUB_BUCKETS) as u64 * (1_u64 << shift);
+        (lower, lower + (1_u64 << shift) - 1)
+    };
+    LatencyBounds {
+        lower_nanos: lower.saturating_sub(1) * 1_000 + u64::from(lower != 0),
+        upper_nanos: Some(upper * 1_000),
+    }
+}
+
+fn percentile_99(buckets: &[u64; BUCKETS], total: u64) -> Option<LatencyBounds> {
+    let rank = (u128::from(total) * 99).div_ceil(100);
+    let mut cumulative = 0_u128;
+    for (index, count) in buckets.iter().enumerate() {
+        cumulative += u128::from(*count);
+        if cumulative >= rank {
+            return Some(bucket_bounds(index));
+        }
+    }
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Arc;
+
+    #[test]
+    fn percentile_intervals_contain_each_bucket_edge_and_neighbour() {
+        for index in 0..BUCKETS {
+            let bounds = bucket_bounds(index);
+            assert_eq!(latency_bucket(Duration::from_nanos(bounds.lower_nanos)), index);
+            if let Some(upper) = bounds.upper_nanos {
+                assert!(upper >= bounds.lower_nanos);
+                assert_eq!(latency_bucket(Duration::from_nanos(upper)), index);
+                assert_eq!(latency_bucket(Duration::from_nanos(upper + 1)), index + 1);
+            }
+        }
+        assert_eq!(latency_bucket(Duration::MAX), FINITE_BUCKETS);
+    }
+
+    #[test]
+    fn body_ownership_carries_in_flight_counts_across_windows() {
+        let recorder = ForegroundRecorder::new();
+        let mut reader = recorder.take_reader().expect("first reader");
+        let mut request = recorder.start();
+        request.set_class(ForegroundClass::Read);
+        let first = reader.sample().expect("cut with a live request");
+        assert!(first.valid);
+        assert_eq!(first.started, Some(1));
+        assert_eq!(first.in_flight, Some(1));
+        assert_eq!(first.classes[0].expect("valid read count").finished, 0);
+
+        request.finish(CompletionOutcome::Success);
+        request.finish(CompletionOutcome::Failed);
+        drop(request);
+        let second = reader.sample().expect("body finished");
+        assert!(second.valid);
+        assert_eq!(second.started, Some(0));
+        assert_eq!(second.in_flight, Some(0));
+        let read = second.classes[0].expect("valid read summary");
+        assert_eq!((read.finished, read.failed, read.cancelled, read.p99), (1, 0, 0, None));
+        assert_eq!(first.end.earliest, second.start.earliest);
+        assert_eq!(first.end.latest, second.start.latest);
+    }
+
+    #[test]
+    fn cancellations_are_counted_without_fabricating_success_latencies() {
+        let recorder = ForegroundRecorder::new();
+        let mut reader = recorder.take_reader().expect("first reader");
+        for _ in 0..150 {
+            let mut request = recorder.start();
+            request.set_class(ForegroundClass::Write);
+        }
+        let window = reader.sample().expect("cancelled requests");
+        let write = window.classes[1].expect("known write count");
+        assert!(window.valid);
+        assert_eq!(window.in_flight, Some(0));
+        assert_eq!((write.finished, write.cancelled, write.failed, write.p99), (150, 150, 0, None));
+    }
+
+    #[test]
+    fn delayed_retired_writer_preserves_the_original_cut_and_next_bank() {
+        let recorder = ForegroundRecorder::new();
+        let mut reader = recorder.take_reader().expect("first reader");
+        let writer = recorder.writer();
+        assert!(reader.sample().is_none(), "never read a live writer's bank");
+        let original_cut = reader.retired.expect("pending cut").1;
+        let request = recorder.start(); // a start after the cut belongs to the new bank
+        writer.0.increment(&writer.0.started);
+        drop(writer);
+        let previous = reader.sample().expect("retired writer drained");
+        assert_eq!(previous.end.earliest, original_cut.earliest);
+        assert_eq!(previous.end.latest, original_cut.latest);
+        assert_eq!(previous.started, Some(1));
+        assert_eq!(previous.in_flight, Some(1));
+        drop(request);
+        let current = reader.sample().expect("next bank");
+        assert_eq!(current.started, Some(1));
+        assert_eq!(current.in_flight, Some(1));
+        assert_eq!(current.classes[3].expect("unclassified cancellation").cancelled, 1);
+    }
+
+    #[test]
+    fn completed_percentile_uses_rank_and_never_turns_maximum_into_p99() {
+        let recorder = ForegroundRecorder::new();
+        let mut reader = recorder.take_reader().expect("first reader");
+        for i in 0..100 {
+            let writer = recorder.writer();
+            writer.0.increment(&writer.0.started);
+            drop(writer);
+            recorder.finish(
+                ForegroundClass::Read,
+                if i == 99 {
+                    Duration::from_secs(60)
+                } else {
+                    Duration::from_millis(2)
+                },
+                if i == 99 {
+                    CompletionOutcome::Failed
+                } else {
+                    CompletionOutcome::Success
+                },
+            );
+        }
+        let window = reader.sample().expect("complete window");
+        let read = window.classes[0].expect("read summary");
+        assert_eq!((read.finished, read.failed, read.cancelled), (100, 1, 0));
+        let p99 = read.p99.expect("100 non-cancelled samples");
+        assert!(p99.lower_nanos <= 2_000_000);
+        assert!(p99.upper_nanos.is_some_and(|upper| (2_000_000..3_000_000).contains(&upper)));
+    }
+
+    #[test]
+    fn overflow_stays_unknown_and_reader_cannot_reset_event_accounting() {
+        let recorder = ForegroundRecorder::new();
+        {
+            let mut reader = recorder.take_reader().expect("first reader");
+            recorder.banks[0].started.store(u64::MAX, Ordering::Relaxed);
+            drop(recorder.start());
+            let invalid = reader.sample().expect("overflow window");
+            assert!(!invalid.valid);
+            assert_eq!(invalid.started, None);
+            assert_eq!(invalid.in_flight, None);
+            assert_eq!(invalid.classes, [None; 4]);
+            let later = reader.sample().expect("later empty window");
+            assert!(!later.valid, "a lost carried count cannot recover by inventing zero active work");
+        }
+        assert!(recorder.take_reader().is_none(), "reader replacement would lose live request ownership");
+    }
+
+    #[test]
+    fn concurrent_rotation_preserves_every_start_finish_and_cancellation() {
+        let recorder = Arc::new(ForegroundRecorder::new());
+        let mut reader = recorder.take_reader().expect("first reader");
+        let workers: Vec<_> = (0..4)
+            .map(|_| {
+                let recorder = Arc::clone(&recorder);
+                std::thread::spawn(move || {
+                    for index in 0..10_000 {
+                        let mut request = recorder.start();
+                        request.set_class(ForegroundClass::Read);
+                        if index % 10 != 0 {
+                            request.finish(CompletionOutcome::Success);
+                        }
+                    }
+                })
+            })
+            .collect();
+        let (mut started, mut finished, mut cancelled) = (0, 0, 0);
+        let mut add_window = |window: ForegroundWindow| {
+            assert!(window.valid, "concurrent event cuts must stay balanced");
+            started += window.started.expect("valid start count");
+            let reads = window.classes[0].expect("valid read count");
+            finished += reads.finished;
+            cancelled += reads.cancelled;
+        };
+        while workers.iter().any(|worker| !worker.is_finished()) {
+            if let Some(window) = reader.sample() {
+                add_window(window);
+            }
+            std::thread::yield_now();
+        }
+        for worker in workers {
+            worker.join().expect("writer must finish");
+        }
+        add_window(reader.sample().expect("drain after writers join"));
+        // A previously retired window may have been published by the last
+        // sample; cut once more to include the current, still open bank.
+        let final_window = reader.sample().expect("final open bank");
+        assert_eq!(final_window.in_flight, Some(0));
+        add_window(final_window);
+        assert_eq!((started, finished, cancelled), (40_000, 40_000, 4_000));
+    }
+}

crates/concurrency/src/lib.rs

@@ -36,8 +36,10 @@
 // Re-exported io-core type used by downstream timeout implementations.
 pub use rustfs_io_core::OperationProgress;
 
+pub mod adaptive;
 mod backpressure;
 mod deadlock;
+pub mod foreground;
 mod queue;
 pub mod workers;
 pub mod workload;

crates/config/README.md

@@ -116,6 +116,7 @@ when restoring `/rustfs/console` for a custom OEM build.
 - `RUSTFS_DATA_SCANNER_START_DELAY_SECS` (deprecated alias for compatibility)
 - `RUSTFS_SCANNER_IDLE_MODE` (canonical)
 - `RUSTFS_SCANNER_CACHE_SAVE_TIMEOUT_SECS` (canonical)
+- `RUSTFS_SCANNER_RECOVERY_BACKOFF_CAP_SECS` (canonical)
 - `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` (canonical)
 - `RUSTFS_SCANNER_CYCLE_MAX_OBJECTS` (canonical)
 - `RUSTFS_SCANNER_CYCLE_MAX_DIRECTORIES` (canonical)
@@ -127,6 +128,12 @@ Scanner cycle budget controls:
 
 - When `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` is unset, the finite default is 1800 seconds (30 minutes), matching the scanner benchmark guidance.
 - An explicit `0` preserves the compatibility behavior of an unbounded runtime budget. Object and directory budgets likewise remain unbounded when explicitly set to `0`.
+
+Scanner recovery retry controls:
+
+- `RUSTFS_SCANNER_RECOVERY_BACKOFF_CAP_SECS` caps the wait between automatic startup recovery retries. The persistent admin key is `scanner.recovery_backoff_cap`; the environment takes precedence over the persistent value, and the unset default remains 600 seconds (10 minutes). Values must be positive integer seconds within the platform timer range; `0`, malformed values, and overflow are rejected. A valid environment override does not hide an invalid persistent value from `admin config set` validation.
+- The cap bounds the existing exponential retry schedule. Updating the persistent value applies to the next computed retry; it does not reschedule a wait already in progress. Retryable observations continue retrying after the short retry budget. Admin scanner status reports the effective value and source at `runtime_config.recovery_backoff_cap_seconds`.
+
 Scanner walker controls:
 
 - `RUSTFS_SCANNER_WALKERS_PER_DISK` sets how many bucket walkers each local disk of an erasure set runs; the default `1` walks one bucket per disk at a time, which is the right value for rotational media. On flash, `2` to `4` lets one disk walk several buckets concurrently, which matters most for single-disk deployments with many buckets, where the walk is otherwise fully serial. Values outside `1` through `16` are rejected by `admin config set`; an out-of-range or non-numeric environment value is logged as a scanner runtime config error (`state = "startup_apply_failed"`) and the scanner keeps the default. The walkers of one disk share that disk's scanner admission, so peers still see one scan session per physical disk, and `RUSTFS_SCANNER_MAX_CONCURRENT_DISK_SCANS` still caps the total.

crates/config/src/constants/internode.rs

@@ -276,6 +276,9 @@ pub const DEFAULT_INTERNODE_BULK_CHANNELS: usize = 2;
 pub const ENV_INTERNODE_HTTP_TUNING_PROFILE: &str = "RUSTFS_INTERNODE_HTTP_TUNING_PROFILE";
 pub const DEFAULT_INTERNODE_HTTP_TUNING_PROFILE: &str = "legacy";
 
+/// Internode HTTP data-plane protocol: `http1` (default) or `auto` (TLS ALPN).
+pub const ENV_INTERNODE_HTTP_PROTOCOL: &str = "RUSTFS_INTERNODE_HTTP_PROTOCOL";
+
 /// Internode HTTP connection pool maximum idle connections per host.
 pub const ENV_INTERNODE_HTTP_POOL_MAX_IDLE_PER_HOST: &str = "RUSTFS_INTERNODE_HTTP_POOL_MAX_IDLE_PER_HOST";
 
@@ -287,8 +290,9 @@ pub const ENV_INTERNODE_HTTP_POOL_IDLE_TIMEOUT_SECS: &str = "RUSTFS_INTERNODE_HT
 /// NOTE (backlog#805-C3): all `RUSTFS_INTERNODE_HTTP2_*` tuning (window sizes,
 /// adaptive window, keepalive timeout) only takes effect when the internode
 /// connection actually negotiates HTTP/2, which happens via TLS-ALPN. Over
-/// plaintext internode transport the connection is HTTP/1.1 and these settings
-/// are silently inert — enable internode TLS to use them.
+/// plaintext internode transport or with the default `http1` protocol policy,
+/// these settings are inert. Select `RUSTFS_INTERNODE_HTTP_PROTOCOL=auto` and
+/// enable internode TLS to use them.
 pub const ENV_INTERNODE_HTTP2_INITIAL_STREAM_WINDOW_SIZE: &str = "RUSTFS_INTERNODE_HTTP2_INITIAL_STREAM_WINDOW_SIZE";
 
 /// Internode HTTP/2 initial connection window size in bytes.

crates/config/src/constants/scanner.rs

@@ -53,6 +53,9 @@ pub const SCANNER_IDLE_MODE: &str = "idle_mode";
 /// Scanner config key controlling scanner cache save timeout in seconds.
 pub const SCANNER_CACHE_SAVE_TIMEOUT: &str = "cache_save_timeout";
 
+/// Scanner config key capping automatic recovery retry waits in seconds.
+pub const SCANNER_RECOVERY_BACKOFF_CAP: &str = "recovery_backoff_cap";
+
 /// Scanner config key capping concurrent scanner set tasks.
 pub const SCANNER_MAX_CONCURRENT_SET_SCANS: &str = "max_concurrent_set_scans";
 
@@ -93,6 +96,7 @@ pub const SCANNER_KEYS: &[&str] = &[
     SCANNER_BITROT_CYCLE,
     SCANNER_IDLE_MODE,
     SCANNER_CACHE_SAVE_TIMEOUT,
+    SCANNER_RECOVERY_BACKOFF_CAP,
     SCANNER_MAX_CONCURRENT_SET_SCANS,
     SCANNER_MAX_CONCURRENT_DISK_SCANS,
     SCANNER_WALKERS_PER_DISK,
@@ -216,6 +220,14 @@ pub const ENV_SCANNER_CACHE_SAVE_TIMEOUT_SECS: &str = "RUSTFS_SCANNER_CACHE_SAVE
 /// Default scanner cache save timeout in seconds.
 pub const DEFAULT_SCANNER_CACHE_SAVE_TIMEOUT_SECS: u64 = 14;
 
+/// Environment variable that caps automatic scanner recovery retry waits.
+/// The value must be a positive integer number of seconds within the timer range.
+/// - Example: `export RUSTFS_SCANNER_RECOVERY_BACKOFF_CAP_SECS=600`
+pub const ENV_SCANNER_RECOVERY_BACKOFF_CAP_SECS: &str = "RUSTFS_SCANNER_RECOVERY_BACKOFF_CAP_SECS";
+
+/// Default maximum wait between automatic scanner recovery retries.
+pub const DEFAULT_SCANNER_RECOVERY_BACKOFF_CAP_SECS: u64 = 10 * 60;
+
 /// Environment variable that caps concurrent scanner set tasks.
 /// A value of `0` keeps the existing topology-based concurrency.
 /// - Example: `export RUSTFS_SCANNER_MAX_CONCURRENT_SET_SCANS=2`

crates/e2e_test/Cargo.toml

@@ -107,7 +107,7 @@ flate2.workspace = true
 http.workspace = true
 http-body-util.workspace = true
 hyper = { workspace = true, features = ["http2", "http1", "server"] }
-hyper-util = { workspace = true, features = ["tokio", "server-auto", "server-graceful", "tracing"] }
+hyper-util = { workspace = true, features = ["tokio", "server-auto", "server-graceful", "client-legacy", "tracing"] }
 reqwest = { workspace = true, features = ["json", "multipart", "stream"] }
 rustfs-signer.workspace = true
 
@@ -147,5 +147,6 @@ clap = { workspace = true, features = ["derive", "env"] }
 
 [dev-dependencies]
 aws-smithy-http-client = { workspace = true, default-features = false, features = ["test-util"] }
+rustfs-heal.workspace = true
 tempfile.workspace = true
 tokio = { workspace = true, features = ["test-util"] }

crates/e2e_test/README.md

@@ -200,10 +200,11 @@ python3 scripts/e2e_binary.py run --features e2e-test-hooks -- cargo nextest run
 python3 scripts/e2e_binary.py run --binary "$RUSTFS_E2E_STARTUP_CAS_BINARY" --features e2e-test-hooks -- cargo nextest run --profile e2e-full -p e2e_test
 python3 scripts/e2e_binary.py run --features e2e-test-hooks -- cargo nextest run --profile e2e-nightly -p e2e_test
 
-# Distributed 4-node 4-disk lane uses the default server.
+# Distributed 4-node 4-disk lane uses the fault-test hooks server; the
+# scanner_heal_topology_ fault cases fail closed without it.
 # Upgrade cases require RUSTFS_UPGRADE_SOURCE_BINARY and fail closed without it.
-python3 scripts/e2e_binary.py build
-python3 scripts/e2e_binary.py run -- cargo nextest run --profile e2e-distributed -p e2e_test
+python3 scripts/e2e_binary.py build --bins --features e2e-test-hooks
+python3 scripts/e2e_binary.py run --features e2e-test-hooks -- cargo nextest run --profile e2e-distributed -p e2e_test
 
 # Replication nightly uses the default server; awscurl is required for STS.
 python3 scripts/e2e_binary.py build

crates/e2e_test/src/anonymous_access_test.rs

@@ -17,7 +17,8 @@
 //! when PublicAccessBlock configuration is missing or explicitly set.
 
 use crate::common::{RustFSTestEnvironment, init_logging, local_http_client};
-use aws_sdk_s3::types::PublicAccessBlockConfiguration;
+use crate::sts_query_compat_test::{OPA_AUTH_TOKEN, OpaMock};
+use aws_sdk_s3::types::{PublicAccessBlockConfiguration, Tag, Tagging};
 use tracing::info;
 
 async fn setup_public_bucket(
@@ -69,6 +70,98 @@ async fn anonymous_get_object(
     local_http_client().get(&url).send().await
 }
 
+#[tokio::test]
+async fn test_plain_http_matches_secure_transport_false_bucket_policy() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    init_logging();
+
+    let mut env = RustFSTestEnvironment::new().await?;
+    env.start_rustfs_server(vec![]).await?;
+    assert!(env.url.starts_with("http://"), "fixture must exercise plaintext HTTP: {}", env.url);
+
+    let bucket = "secure-transport-policy";
+    let key = "plain-http.txt";
+    let admin = env.create_s3_client();
+    admin.create_bucket().bucket(bucket).send().await?;
+    admin
+        .put_object()
+        .bucket(bucket)
+        .key(key)
+        .body(aws_sdk_s3::primitives::ByteStream::from_static(b"plain http"))
+        .send()
+        .await?;
+    admin
+        .put_bucket_policy()
+        .bucket(bucket)
+        .policy(
+            serde_json::json!({
+                "Version": "2012-10-17",
+                "Statement": [{
+                    "Effect": "Allow",
+                    "Principal": "*",
+                    "Action": "s3:GetObject",
+                    "Resource": format!("arn:aws:s3:::{bucket}/*"),
+                    "Condition": {"Bool": {"aws:SecureTransport": "false"}}
+                }]
+            })
+            .to_string(),
+        )
+        .send()
+        .await?;
+
+    let response = anonymous_get_object(&env, bucket, key).await?;
+    assert_eq!(response.status().as_u16(), 200);
+    assert_eq!(response.bytes().await?.as_ref(), b"plain http");
+    Ok(())
+}
+
+/// Root credentials have no attached IAM policy, so these requests depend on
+/// the owner flag reaching policy evaluation unchanged.
+#[tokio::test]
+async fn test_root_requests_keep_policy_owner_flag() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    init_logging();
+
+    let opa = OpaMock::start().await?;
+    let mut env = RustFSTestEnvironment::new().await?;
+    env.start_rustfs_server_with_env(
+        vec![],
+        &[
+            ("RUSTFS_POLICY_PLUGIN_URL", opa.url.as_str()),
+            ("RUSTFS_POLICY_PLUGIN_AUTH_TOKEN", OPA_AUTH_TOKEN),
+        ],
+    )
+    .await?;
+
+    let bucket = "root-owner-flag";
+    let key = "owner.txt";
+    let client = env.create_s3_client();
+    client.create_bucket().bucket(bucket).send().await?;
+    client
+        .put_object()
+        .bucket(bucket)
+        .key(key)
+        .body(aws_sdk_s3::primitives::ByteStream::from_static(b"owner access"))
+        .send()
+        .await?;
+
+    // Duplicate stored tags are ambiguous. An owner request must not enter the
+    // OPA tag-loading path, which rejects this metadata before evaluation.
+    client
+        .put_bucket_tagging()
+        .bucket(bucket)
+        .tagging(
+            Tagging::builder()
+                .tag_set(Tag::builder().key("department").value("finance").build()?)
+                .tag_set(Tag::builder().key("department").value("engineering").build()?)
+                .build()?,
+        )
+        .send()
+        .await?;
+    let object = client.get_object().bucket(bucket).key(key).send().await?;
+
+    assert_eq!(object.body.collect().await?.into_bytes().as_ref(), b"owner access");
+    Ok(())
+}
+
 /// Issue #2036: Anonymous GetObject should succeed when bucket policy allows it
 /// and no PublicAccessBlock configuration exists (ConfigNotFound).
 #[tokio::test]

crates/e2e_test/src/common.rs

@@ -34,7 +34,7 @@ use rustfs_signer::sign_v4;
 use s3s::Body;
 use serde_json;
 use std::fs as stdfs;
-use std::io::ErrorKind;
+use std::io::{self, ErrorKind};
 use std::net::{Ipv6Addr, SocketAddr};
 use std::path::{Path, PathBuf};
 use std::process::{Child, Command, Stdio};
@@ -1272,6 +1272,7 @@ pub struct RustFSTestClusterEnvironment {
     /// Optional socket proxies used for the corresponding node's volume
     /// endpoints. Proxies must be installed before [`Self::start`].
     volume_proxy_addresses: Vec<Option<SocketAddr>>,
+    tls_ca_pem: Option<Vec<u8>>,
 }
 
 impl RustFSTestClusterEnvironment {
@@ -1312,7 +1313,10 @@ impl RustFSTestClusterEnvironment {
     pub async fn with_topology(topology: ClusterTopology) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
         topology.validate()?;
 
-        let temp_dir = format!("/tmp/rustfs_cluster_test_{}", Uuid::new_v4());
+        let temp_dir = std::env::temp_dir()
+            .join(format!("rustfs_cluster_test_{}", Uuid::new_v4()))
+            .to_string_lossy()
+            .into_owned();
         fs::create_dir_all(&temp_dir).await?;
 
         // Map every node to its owning pool index.
@@ -1374,9 +1378,35 @@ impl RustFSTestClusterEnvironment {
             node_capture_log_paths: vec![None; topology.node_count],
             topology,
             volume_proxy_addresses: vec![None; node_count],
+            tls_ca_pem: None,
         })
     }
 
+    /// Configure verified HTTPS for both volume endpoints and S3 clients.
+    /// The bundle must be generated before any node starts.
+    pub async fn enable_tls(&mut self, directory: &Path) -> std::io::Result<()> {
+        if self.nodes.iter().any(|node| node.process.is_some()) {
+            return Err(std::io::Error::new(
+                ErrorKind::InvalidInput,
+                "configure cluster TLS before starting nodes",
+            ));
+        }
+        let directory = fs::canonicalize(directory).await?;
+        let ca_pem = fs::read(directory.join("ca.crt")).await?;
+        reqwest::Certificate::from_pem(&ca_pem).map_err(|error| std::io::Error::new(ErrorKind::InvalidData, error))?;
+        self.set_env(
+            "RUSTFS_TLS_PATH",
+            directory
+                .to_str()
+                .ok_or_else(|| std::io::Error::new(ErrorKind::InvalidInput, "TLS directory is not UTF-8"))?,
+        );
+        for node in &mut self.nodes {
+            node.url = format!("https://{}", node.address);
+        }
+        self.tls_ca_pem = Some(ca_pem);
+        Ok(())
+    }
+
     /// Add an extra environment variable applied to every cluster node process.
     pub fn set_env<K, V>(&mut self, key: K, value: V)
     where
@@ -1467,6 +1497,29 @@ impl RustFSTestClusterEnvironment {
         Ok(proxy)
     }
 
+    /// Route internode traffic through a method-aware HTTP proxy.
+    pub(crate) async fn start_rpc_proxy_for_node(
+        &mut self,
+        node_idx: usize,
+    ) -> io::Result<crate::rpc_fault_proxy::RpcFaultProxy> {
+        self.ensure_node_index(node_idx)
+            .map_err(|error| io::Error::new(ErrorKind::InvalidInput, error))?;
+        if self.volume_proxy_addresses[node_idx].is_some() {
+            return Err(io::Error::new(
+                ErrorKind::AlreadyExists,
+                format!("a volume proxy is already configured for node {node_idx}"),
+            ));
+        }
+        let target = self.nodes[node_idx]
+            .address
+            .parse::<SocketAddr>()
+            .map_err(|error| io::Error::new(ErrorKind::InvalidInput, error))?;
+        let listen = SocketAddr::from((Ipv6Addr::LOCALHOST, target.port()));
+        let proxy = crate::rpc_fault_proxy::RpcFaultProxy::start_on(listen, target).await?;
+        self.volume_proxy_addresses[node_idx] = Some(proxy.local_addr());
+        Ok(proxy)
+    }
+
     fn volume_address(&self, node_idx: usize) -> String {
         self.volume_proxy_addresses[node_idx]
             .map(|address| address.to_string())
@@ -1475,6 +1528,7 @@ impl RustFSTestClusterEnvironment {
 
     fn build_volumes_arg(&self) -> String {
         let pools = self.topology.normalized_pools();
+        let scheme = if self.tls_ca_pem.is_some() { "https" } else { "http" };
 
         if pools.len() <= 1 {
             // Single pool: explicit enumeration of every drive on every node.
@@ -1484,7 +1538,7 @@ impl RustFSTestClusterEnvironment {
                 .enumerate()
                 .flat_map(|(node_idx, n)| {
                     let address = self.volume_address(node_idx);
-                    n.data_dirs.iter().map(move |dir| format!("http://{}{}", address, dir))
+                    n.data_dirs.iter().map(move |dir| format!("{scheme}://{address}{dir}"))
                 })
                 .collect::<Vec<_>>()
                 .join(" ");
@@ -1504,7 +1558,7 @@ impl RustFSTestClusterEnvironment {
                     .and_then(|d| d.rsplit_once('/').map(|(parent, _)| parent))
                     .unwrap_or(&node.data_dir);
                 format!(
-                    "http://{}{}/drive{{0...{}}}",
+                    "{scheme}://{}{}/drive{{0...{}}}",
                     self.volume_address(node_idx),
                     base,
                     self.topology.drives_per_node - 1
@@ -1693,13 +1747,20 @@ impl RustFSTestClusterEnvironment {
         if node_idx >= self.nodes.len() {
             return Err("node_idx is invalid".into());
         }
-        Ok(Client::from_conf(build_test_s3_config(
-            &self.nodes[node_idx].url,
-            &self.access_key,
-            &self.secret_key,
-            None,
-            "cluster-test",
-        )))
+        let mut config =
+            build_test_s3_config(&self.nodes[node_idx].url, &self.access_key, &self.secret_key, None, "cluster-test");
+        if let Some(ca_pem) = &self.tls_ca_pem {
+            use aws_smithy_http_client::tls::{Provider, TlsContext, TrustStore, rustls_provider::CryptoMode};
+            let tls = TlsContext::builder()
+                .with_trust_store(TrustStore::empty().with_pem_certificate(ca_pem.clone()))
+                .build()?;
+            let client = SmithyHttpClientBuilder::new()
+                .tls_provider(Provider::Rustls(CryptoMode::AwsLc))
+                .tls_context(tls)
+                .build_https();
+            config = config.to_builder().http_client(client).build();
+        }
+        Ok(Client::from_conf(config))
     }
 
     /// Create S3 clients for all nodes in the RustFS cluster and collect them into a vector.
@@ -1824,7 +1885,7 @@ impl RustFSTestClusterEnvironment {
         }
 
         self.nodes.push(ClusterNode {
-            url: format!("http://{address}"),
+            url: format!("{}://{address}", if self.tls_ca_pem.is_some() { "https" } else { "http" }),
             address,
             data_dir: data_dirs[0].clone(),
             data_dirs,
@@ -1846,6 +1907,47 @@ impl RustFSTestClusterEnvironment {
         Ok(new_idx)
     }
 
+    /// Remove retired single-node pools from a stopped multi-pool cluster.
+    ///
+    /// A decommissioned pool must leave the server command line before the
+    /// next start; the server refuses to start while it is still listed. The
+    /// remaining pools keep their node order and are renumbered from zero.
+    /// Data directories are left on disk for the owning harness to clean up.
+    pub fn remove_single_node_pools(&mut self, retired: &[usize]) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        if self.nodes.iter().any(|node| node.process.is_some()) {
+            return Err("stop the cluster before removing a pool".into());
+        }
+        let pools = self.topology.normalized_pools();
+        if pools.iter().any(|nodes| nodes.len() != 1) {
+            return Err("remove_single_node_pools requires one node per pool".into());
+        }
+        if retired.iter().any(|pool| *pool >= pools.len()) || retired.len() >= pools.len() {
+            return Err(format!("cannot remove pools {retired:?} from {} pools", pools.len()).into());
+        }
+        let keep: Vec<usize> = (0..self.nodes.len())
+            .filter(|node_idx| !retired.contains(&self.nodes[*node_idx].pool_idx))
+            .collect();
+        fn retain_indices<T>(values: &mut Vec<T>, keep: &[usize]) {
+            let old = std::mem::take(values);
+            *values = old
+                .into_iter()
+                .enumerate()
+                .filter(|(idx, _)| keep.contains(idx))
+                .map(|(_, value)| value)
+                .collect();
+        }
+        retain_indices(&mut self.nodes, &keep);
+        retain_indices(&mut self.node_extra_env, &keep);
+        retain_indices(&mut self.node_capture_log_paths, &keep);
+        retain_indices(&mut self.volume_proxy_addresses, &keep);
+        for (pool_idx, node) in self.nodes.iter_mut().enumerate() {
+            node.pool_idx = pool_idx;
+        }
+        self.topology.node_count = self.nodes.len();
+        self.topology.pools = (0..self.nodes.len()).map(|node_idx| vec![node_idx]).collect();
+        Ok(())
+    }
+
     /// Gracefully stop one cluster node and wait for its process to exit.
     ///
     /// This is intentionally separate from [`Self::stop_node`]: the latter is
@@ -2397,6 +2499,7 @@ mod tests {
             node_capture_log_paths: vec![None; topology.node_count],
             topology,
             volume_proxy_addresses: vec![None; node_count],
+            tls_ca_pem: None,
         }
     }
 
@@ -2414,8 +2517,8 @@ mod tests {
         );
     }
 
-    #[test]
-    fn volumes_single_pool_multidrive_enumerates_every_drive() {
+    #[tokio::test]
+    async fn volumes_single_pool_multidrive_enumerates_every_drive() {
         // 4 nodes x 2 drives -> 8 explicit endpoints, one legacy pool. No
         // ellipses, so the server parser keeps this as a single DistErasure pool.
         let env = fake_cluster(ClusterTopology::single_pool_multidrive(4, 2));
@@ -2427,6 +2530,25 @@ mod tests {
             .join(" ");
         assert_eq!(env.build_volumes_arg(), expected);
         assert_eq!(env.build_volumes_arg().split(' ').count(), 8);
+
+        let directory = tempfile::tempdir().expect("TLS fixture directory");
+        crate::tls_gen::run(crate::tls_gen::Args {
+            out_dir: directory.path().to_owned(),
+            days: 1,
+            force: false,
+        })
+        .expect("generate TLS bundle");
+        for topology in [
+            ClusterTopology::single_pool_multidrive(4, 4),
+            ClusterTopology::per_node_pools(4, vec![vec![0], vec![1]]),
+        ] {
+            let mut cluster = fake_cluster(topology);
+            let plaintext_volumes = cluster.build_volumes_arg();
+            cluster.enable_tls(directory.path()).await.expect("configure TLS");
+            assert_eq!(cluster.build_volumes_arg(), plaintext_volumes.replace("http://", "https://"));
+            assert!(cluster.nodes.iter().all(|node| node.url.starts_with("https://")));
+            assert!(cluster.create_s3_client(0).is_ok(), "trusted SDK client should build");
+        }
     }
 
     #[test]
@@ -2514,6 +2636,22 @@ mod tests {
         proxy.shutdown().await;
     }
 
+    #[tokio::test]
+    async fn cluster_data_dirs_use_os_temporary_directory() {
+        let cluster = RustFSTestClusterEnvironment::new(1).await.expect("allocate isolated cluster");
+        let root = PathBuf::from(&cluster.temp_dir);
+        assert!(
+            root.starts_with(std::env::temp_dir()),
+            "cluster must honor the selected temporary filesystem"
+        );
+        for node in &cluster.nodes {
+            assert!(Path::new(&node.data_dir).starts_with(&root));
+            assert!(node.data_dirs.iter().all(|drive| Path::new(drive).starts_with(&root)));
+        }
+        drop(cluster);
+        assert!(!root.exists(), "dropping the fixture must remove its owned directories");
+    }
+
     #[test]
     fn cluster_node_env_supports_per_node_overrides() {
         let mut env = fake_cluster(ClusterTopology::single_pool(4));

crates/e2e_test/src/data_usage_test.rs

@@ -14,6 +14,7 @@
 
 use aws_sdk_s3::primitives::ByteStream;
 use aws_sdk_s3::types::{BucketVersioningStatus, VersioningConfiguration};
+use futures::{StreamExt, TryStreamExt, stream};
 use rustfs_data_usage::DataUsageInfo;
 use tokio::time::{Duration, sleep};
 
@@ -74,16 +75,23 @@ async fn data_usage_reports_all_objects() -> Result<(), Box<dyn std::error::Erro
     // Create bucket and upload objects
     client.create_bucket().bucket(TEST_BUCKET).send().await?;
 
-    for i in 0..1000 {
-        let key = format!("obj-{i:04}");
-        client
-            .put_object()
-            .bucket(TEST_BUCKET)
-            .key(key)
-            .body(ByteStream::from_static(b"hello-world"))
-            .send()
-            .await?;
-    }
+    // Keep the full fixture and await every durable PUT before checking publication.
+    stream::iter(0..1000)
+        .map(Ok)
+        .try_for_each_concurrent(16, |i| {
+            let client = &client;
+            async move {
+                client
+                    .put_object()
+                    .bucket(TEST_BUCKET)
+                    .key(format!("obj-{i:04}"))
+                    .body(ByteStream::from_static(b"hello-world"))
+                    .send()
+                    .await
+                    .map(|_| ())
+            }
+        })
+        .await?;
 
     let usage = wait_for_bucket_usage(&env, TEST_BUCKET, |usage| {
         usage

crates/e2e_test/src/delete_objects_versioning_test.rs

@@ -24,6 +24,163 @@
 //! `xl.meta` immediately visible, and the old file-cache shortcut has been
 //! removed from the read path.
 
+use aws_sdk_s3::Client;
+use aws_sdk_s3::config::retry::RetryConfig;
+use aws_sdk_s3::types::{BucketVersioningStatus, Delete, ObjectIdentifier, VersioningConfiguration};
+use std::collections::BTreeMap;
+
+async fn delete_exact_marker_versions(
+    client: &Client,
+    bucket: &str,
+    key: &str,
+    versions: &[(String, bool)],
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let objects = versions
+        .iter()
+        .map(|(version, _)| ObjectIdentifier::builder().key(key).version_id(version).build())
+        .collect::<Result<Vec<_>, _>>()?;
+    let response = client
+        .delete_objects()
+        .bucket(bucket)
+        .delete(Delete::builder().set_objects(Some(objects)).build()?)
+        .send()
+        .await?;
+    assert!(response.errors().is_empty(), "explicit batch returned errors: {response:?}");
+    let mut actual = BTreeMap::new();
+    for deleted in response.deleted() {
+        assert_eq!(deleted.key(), Some(key));
+        *actual
+            .entry((
+                deleted.version_id().ok_or("Deleted entry omitted version ID")?.to_string(),
+                deleted.delete_marker().unwrap_or(false),
+                deleted.delete_marker_version_id().map(str::to_string),
+            ))
+            .or_insert(0_usize) += 1;
+    }
+    let mut expected = BTreeMap::new();
+    for (version, marker) in versions {
+        *expected
+            .entry((version.clone(), *marker, marker.then(|| version.clone())))
+            .or_insert(0_usize) += 1;
+    }
+    assert_eq!(actual, expected, "every requested occurrence must report its own version identity");
+    Ok(())
+}
+
+pub(crate) async fn assert_explicit_marker_batch_cleanup(
+    clients: &[Client],
+    bucket: &str,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    assert!(!clients.is_empty());
+    let clients: Vec<_> = clients
+        .iter()
+        .map(|client| {
+            Client::from_conf(
+                client
+                    .config()
+                    .to_builder()
+                    .retry_config(RetryConfig::standard().with_max_attempts(1))
+                    .build(),
+            )
+        })
+        .collect();
+    let writer = &clients[0];
+    let marker_writer = &clients[1 % clients.len()];
+    let deleter = &clients[2 % clients.len()];
+    let key = "same-key-history";
+    writer.create_bucket().bucket(bucket).send().await?;
+    writer
+        .put_bucket_versioning()
+        .bucket(bucket)
+        .versioning_configuration(
+            VersioningConfiguration::builder()
+                .status(BucketVersioningStatus::Enabled)
+                .build(),
+        )
+        .send()
+        .await?;
+    let mut data = Vec::new();
+    for byte in [41_u8, 73_u8] {
+        let body = vec![byte; 1024 * 1024];
+        let uploaded = writer
+            .put_object()
+            .bucket(bucket)
+            .key(key)
+            .body(body.clone().into())
+            .send()
+            .await?;
+        data.push((uploaded.version_id().ok_or("versioned PUT omitted ID")?.to_string(), body));
+    }
+    let mut markers = Vec::with_capacity(16);
+    for _ in 0..16 {
+        let deleted = marker_writer.delete_object().bucket(bucket).key(key).send().await?;
+        assert_eq!(deleted.delete_marker(), Some(true));
+        markers.push(deleted.version_id().ok_or("marker creation omitted ID")?.to_string());
+    }
+    let mut requested: Vec<_> = markers.iter().map(|id| (id.clone(), true)).collect();
+    requested.push((markers[0].clone(), true));
+    requested.push((markers[15].clone(), true));
+    delete_exact_marker_versions(deleter, bucket, key, &requested).await?;
+    for client in &clients {
+        let versions = client.list_object_versions().bucket(bucket).send().await?;
+        assert!(versions.delete_markers().is_empty(), "marker survived successful batch: {versions:?}");
+        let mut actual: Vec<_> = versions
+            .versions()
+            .iter()
+            .filter_map(|version| version.version_id())
+            .collect();
+        actual.sort_unstable();
+        let mut expected: Vec<_> = data.iter().map(|(id, _)| id.as_str()).collect();
+        expected.sort_unstable();
+        assert_eq!(actual, expected);
+        let current = client.get_object().bucket(bucket).key(key).send().await?;
+        assert_eq!(current.body.collect().await?.into_bytes().as_ref(), data[1].1.as_slice());
+        let historical = client
+            .get_object()
+            .bucket(bucket)
+            .key(key)
+            .version_id(&data[0].0)
+            .send()
+            .await?;
+        assert_eq!(historical.body.collect().await?.into_bytes().as_ref(), data[0].1.as_slice());
+    }
+    let uuid_marker = marker_writer.delete_object().bucket(bucket).key(key).send().await?;
+    let uuid_marker = uuid_marker.version_id().ok_or("marker creation omitted UUID")?.to_string();
+    writer
+        .put_bucket_versioning()
+        .bucket(bucket)
+        .versioning_configuration(
+            VersioningConfiguration::builder()
+                .status(BucketVersioningStatus::Suspended)
+                .build(),
+        )
+        .send()
+        .await?;
+    let null_marker = marker_writer.delete_object().bucket(bucket).key(key).send().await?;
+    assert_eq!(null_marker.delete_marker(), Some(true));
+    assert_eq!(null_marker.version_id(), Some("null"));
+    let requested = [
+        (uuid_marker.clone(), true),
+        (data[1].0.clone(), false),
+        ("null".to_string(), true),
+        (data[0].0.clone(), false),
+        (uuid_marker, true),
+    ];
+    delete_exact_marker_versions(deleter, bucket, key, &requested).await?;
+    for client in &clients {
+        let versions = client.list_object_versions().bucket(bucket).send().await?;
+        assert!(versions.versions().is_empty() && versions.delete_markers().is_empty(), "{versions:?}");
+    }
+    clients
+        .last()
+        .expect("nonempty clients")
+        .delete_bucket()
+        .bucket(bucket)
+        .send()
+        .await?;
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use crate::common::{RustFSTestEnvironment, init_logging};
@@ -35,6 +192,16 @@ mod tests {
         env.create_s3_client()
     }
 
+    #[tokio::test]
+    async fn test_explicit_delete_marker_batch_removes_versions_without_client_retries()
+    -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        init_logging();
+        let mut env = RustFSTestEnvironment::new().await?;
+        env.start_rustfs_server_with_env(vec![], &[("RUSTFS_CONSOLE_ENABLE", "false")])
+            .await?;
+        super::assert_explicit_marker_batch_cleanup(&[env.create_s3_client()], "explicit-marker-batch").await
+    }
+
     /// Regression test for Issue #1878.
     ///
     /// Verifies that after calling `delete_objects` (the batch plural API) on

crates/e2e_test/src/distributed/harness.rs

@@ -34,7 +34,7 @@ use crate::common::{
 };
 use crate::replication_extension_test::LOOPBACK_REPLICATION_TARGET_ENV;
 use aws_sdk_s3::Client;
-use aws_sdk_s3::config::retry::RetryConfig;
+use aws_sdk_s3::config::{Credentials, retry::RetryConfig};
 use aws_sdk_s3::error::{ProvideErrorMetadata, SdkError};
 use aws_sdk_s3::operation::{get_object::GetObjectError, put_object::PutObjectError};
 use aws_sdk_s3::primitives::ByteStream;
@@ -78,6 +78,7 @@ pub(crate) struct DistCluster {
     pub cluster: RustFSTestClusterEnvironment,
     pool_storage_roots: Option<Vec<PathBuf>>,
     owned_pool_dirs: Vec<PathBuf>,
+    capture_log_dir: Option<PathBuf>,
 }
 
 impl DistCluster {
@@ -129,11 +130,12 @@ impl DistCluster {
         for &(key, value) in extra_env {
             cluster.set_env(key, value);
         }
-        configure_node_logs(&mut cluster)?;
+        configure_node_logs(&mut cluster, None)?;
         Ok(Self {
             cluster,
             pool_storage_roots,
             owned_pool_dirs,
+            capture_log_dir: None,
         })
     }
 
@@ -171,17 +173,34 @@ impl DistCluster {
         Ok(())
     }
 
+    /// Append every node's stdout/stderr to `directory/node-<idx>.log`, including
+    /// nodes added by later pool expansion. Call before the first start so startup
+    /// events such as the resolved durability mode are captured.
+    pub fn capture_logs_under(&mut self, directory: &Path) -> TestResult {
+        self.capture_log_dir = Some(directory.to_path_buf());
+        configure_node_logs(&mut self.cluster, Some(directory))
+    }
+
     pub fn client_with_credentials(&self, node_idx: usize, access_key: &str, secret_key: &str) -> TestResult<Client> {
         if node_idx >= self.cluster.nodes.len() {
             return Err("node_idx is invalid".into());
         }
-        Ok(Client::from_conf(build_test_s3_config(
-            &self.cluster.nodes[node_idx].url,
-            access_key,
-            secret_key,
-            None,
-            "cluster-iam-test",
-        )))
+        let config = self.cluster.create_s3_client(node_idx)?.config().to_builder();
+        Ok(Client::from_conf(
+            config
+                .credentials_provider(Credentials::new(access_key, secret_key, None, None, "cluster-iam-test"))
+                .build(),
+        ))
+    }
+
+    /// Stop the fleet, drop retired pools from the command line, and restart
+    /// the remaining pools, which are renumbered from zero.
+    pub async fn remove_retired_pools_and_restart(&mut self, retired: &[usize]) -> TestResult {
+        self.stop_all_gracefully().await?;
+        self.cluster.remove_single_node_pools(retired)?;
+        self.cluster.start().await?;
+        wait_for_ready(&self.cluster).await?;
+        Ok(())
     }
 
     pub async fn append_pool_and_restart(&mut self) -> TestResult<usize> {
@@ -193,7 +212,7 @@ impl DistCluster {
             .ok_or("pool expansion requires configured isolated pool filesystems")?;
         self.owned_pool_dirs
             .push(relocate_pool_storage(&mut self.cluster, node_idx, roots)?);
-        configure_node_logs(&mut self.cluster)?;
+        configure_node_logs(&mut self.cluster, self.capture_log_dir.as_deref())?;
         self.cluster.start().await?;
         wait_for_ready(&self.cluster).await?;
         Ok(node_idx)
@@ -327,7 +346,19 @@ fn relocate_pool_storage(cluster: &mut RustFSTestClusterEnvironment, node_idx: u
     Ok(pool_run_root)
 }
 
-fn configure_node_logs(cluster: &mut RustFSTestClusterEnvironment) -> TestResult {
+pub(super) fn configure_node_logs(cluster: &mut RustFSTestClusterEnvironment, capture_dir: Option<&Path>) -> TestResult {
+    if let Some(directory) = capture_dir {
+        std::fs::create_dir_all(directory)?;
+        for node_idx in 0..cluster.nodes.len() {
+            // Overrides a path assigned from RUSTFS_E2E_LOG_DIR so every node of
+            // the run, including the seed node, logs into the same directory.
+            let path = directory.join(format!("node-{node_idx}.log"));
+            if cluster.node_capture_log_paths[node_idx].as_deref() != Some(path.to_string_lossy().as_ref()) {
+                cluster.set_node_capture_log_path(node_idx, path.to_string_lossy().into_owned())?;
+            }
+        }
+        return Ok(());
+    }
     let Some(log_dir) = std::env::var_os("RUSTFS_E2E_LOG_DIR") else {
         return Ok(());
     };
@@ -724,23 +755,44 @@ pub(crate) async fn set_bucket_quota(cluster: &RustFSTestClusterEnvironment, buc
     .await
 }
 
+/// The existing decommission cases wait up to 180 s for movement to finish; a
+/// start refused because a movement gate is busy is retried within the same budget.
+const DECOMMISSION_START_BUSY_BUDGET: Duration = Duration::from_secs(180);
+const DECOMMISSION_START_PROOF_BUDGET: Duration = Duration::from_secs(45);
+
 /// Start decommission and fail closed unless the admin API acknowledges it.
 pub(crate) async fn start_decommission(cluster: &RustFSTestClusterEnvironment, pool_id: usize) -> TestResult {
     let path = format!("/rustfs/admin/v3/pools/decommission?pool={pool_id}&by-id=true");
-    let deadline = Instant::now() + Duration::from_secs(45);
+    post_decommission_start(cluster, &path, DECOMMISSION_START_BUSY_BUDGET).await?;
+    Ok(())
+}
+
+/// POST a decommission start and return the response body. A start that meets
+/// a busy movement gate answers a retryable 503 and is retried within
+/// `busy_budget`; the init stage's missing fleet capability proof (500) is
+/// retried for 45 s. Every other status is fatal.
+pub(crate) async fn post_decommission_start(
+    cluster: &RustFSTestClusterEnvironment,
+    path: &str,
+    busy_budget: Duration,
+) -> TestResult<String> {
+    let started = Instant::now();
+    let mut delay = Duration::from_millis(250);
     loop {
-        let (status, response) = cluster_admin(cluster, Method::POST, &path, None).await?;
+        let (status, response) = cluster_admin(cluster, Method::POST, path, None).await?;
         if status.is_success() {
-            return Ok(());
+            return Ok(response);
         }
-        if status == StatusCode::INTERNAL_SERVER_ERROR
+        let elapsed = started.elapsed();
+        let busy = status == StatusCode::SERVICE_UNAVAILABLE && elapsed < busy_budget;
+        let awaiting_proof = status == StatusCode::INTERNAL_SERVER_ERROR
             && response.contains("requires a live fleet capability proof")
-            && Instant::now() < deadline
-        {
-            sleep(Duration::from_secs(1)).await;
-            continue;
+            && elapsed < DECOMMISSION_START_PROOF_BUDGET;
+        if !busy && !awaiting_proof {
+            return Err(format!("POST {path} did not start decommission: {status} {response}").into());
         }
-        return Err(format!("POST {path} did not start decommission: {status} {response}").into());
+        sleep(delay).await;
+        delay = (delay * 2).min(Duration::from_secs(2));
     }
 }
 
@@ -923,6 +975,21 @@ pub(crate) async fn rebalance_status_json(cluster: &RustFSTestClusterEnvironment
     Ok(serde_json::from_str(&body)?)
 }
 
+/// Mirrors `REBALANCE_DEFERRED_ENTRY_ERROR_PREFIX` in `crates/ecstore/src/services/rebalance`.
+const REBALANCE_DEFERRED_ENTRY_ERROR_PREFIX: &str = "deferred transient rebalance entry failure:";
+
+/// A transient entry failure (for example a write quorum miss on a busy
+/// target) is recorded as `lastError` and retried at the end of the run; the
+/// worker clears it when the pool completes. It is only acceptable while the
+/// pool is still started: a terminal pool keeping it is a real failure.
+fn is_retrying_deferred_rebalance_error(pool: &serde_json::Value, error: &str) -> bool {
+    error.starts_with(REBALANCE_DEFERRED_ENTRY_ERROR_PREFIX)
+        && pool
+            .get("status")
+            .and_then(serde_json::Value::as_str)
+            .is_some_and(|status| status.eq_ignore_ascii_case("started"))
+}
+
 fn validate_rebalance_status<'a>(status: &'a serde_json::Value, expected_id: &str) -> TestResult<&'a [serde_json::Value]> {
     let id = status
         .get("id")
@@ -950,7 +1017,7 @@ fn validate_rebalance_status<'a>(status: &'a serde_json::Value, expected_id: &st
         if pool
             .get("lastError")
             .and_then(serde_json::Value::as_str)
-            .is_some_and(|error| !error.is_empty())
+            .is_some_and(|error| !error.is_empty() && !is_retrying_deferred_rebalance_error(pool, error))
         {
             return Err(format!("rebalance reported lastError: {status}").into());
         }
@@ -1297,6 +1364,29 @@ async fn append_single_node_pool_extends_ellipses_volumes() {
     assert!(volumes.contains("/drive{0...1}"), "expanded layout must keep drive ellipses: {volumes}");
 }
 
+#[tokio::test]
+async fn remove_single_node_pools_drops_retired_pools_and_renumbers() {
+    let mut env =
+        RustFSTestClusterEnvironment::with_topology(ClusterTopology::per_node_pools(2, vec![vec![0], vec![1], vec![2], vec![3]]))
+            .await
+            .expect("four-pool topology");
+    let kept: Vec<String> = env.nodes[2..].iter().map(|node| node.address.clone()).collect();
+
+    env.remove_single_node_pools(&[0, 1]).expect("remove two retired pools");
+    assert_eq!(env.nodes.len(), 2);
+    assert_eq!(env.nodes.iter().map(|node| node.address.clone()).collect::<Vec<_>>(), kept);
+    assert_eq!(env.nodes.iter().map(|node| node.pool_idx).collect::<Vec<_>>(), vec![0, 1]);
+    let volumes = env.rustfs_volumes_arg();
+    assert_eq!(volumes.split(' ').count(), 2, "expected two pool arguments, got: {volumes}");
+    assert!(
+        volumes.contains(&kept[0]) && volumes.contains(&kept[1]),
+        "retired pools must leave the command line: {volumes}"
+    );
+
+    env.remove_single_node_pools(&[0, 1])
+        .expect_err("the last remaining pool cannot be removed");
+}
+
 #[tokio::test]
 async fn append_single_node_pool_rejects_striped_single_pool() {
     let mut env = RustFSTestClusterEnvironment::new(4).await.expect("four-node single pool");
@@ -1450,3 +1540,23 @@ fn rebalance_complete_accepts_non_participating_pools_but_requires_progress() {
     });
     assert!(!rebalance_complete(&no_movement, "run-1").unwrap());
 }
+
+#[test]
+fn rebalance_status_tolerates_deferred_entry_error_only_while_started() {
+    let deferred = "deferred transient rebalance entry failure: Storage resources are insufficient for the write operation: b/k";
+    let mut status = serde_json::json!({
+        "id": "run-1",
+        "pools": [{ "id": 0, "status": "Started", "stopping": false, "lastError": deferred, "progress": { "objects": 1, "bytes": 1 } }]
+    });
+    assert!(rebalance_active(&status, "run-1").expect("a retried deferral keeps the run active"));
+
+    status["pools"][0]["status"] = serde_json::json!("Completed");
+    assert!(
+        rebalance_complete(&status, "run-1").is_err(),
+        "a completed pool must have cleared its deferred entry error"
+    );
+
+    status["pools"][0]["status"] = serde_json::json!("Started");
+    status["pools"][0]["lastError"] = serde_json::json!("rebalance entry failed: Storage resources are insufficient");
+    assert!(rebalance_active(&status, "run-1").is_err(), "a non-deferred lastError stays fatal");
+}

crates/e2e_test/src/distributed/internode_tls_test.rs

@@ -0,0 +1,286 @@
+// Copyright 2026 RustFS Team
+// Licensed under the Apache License, Version 2.0.
+
+use super::harness::{DistCluster, DistLayout, TestResult, unique_bucket};
+use crate::tls_gen;
+use aws_sdk_s3::{Client, config::retry::RetryConfig, primitives::ByteStream};
+use rand::{Rng, SeedableRng, rngs::StdRng};
+use sha2::{Digest, Sha256};
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::task::JoinSet;
+
+const MIB: u64 = 1024 * 1024;
+const READ_TIMEOUT: Duration = Duration::from_secs(180);
+
+struct ExpectedRead {
+    range: Option<(u64, u64)>,
+    length: u64,
+    sha256: String,
+}
+
+struct ObjectFixture {
+    key: String,
+    path: PathBuf,
+    length: u64,
+    reads: Vec<ExpectedRead>,
+}
+
+fn fixture(directory: &Path, length: u64) -> TestResult<ObjectFixture> {
+    let key = format!("object-{length}");
+    let path = directory.join(&key);
+    let mut file = std::fs::File::create(&path)?;
+    let mut rng = StdRng::seed_from_u64(length);
+    let mut block = vec![0; usize::try_from(MIB)?];
+    let mut remaining = length;
+    let mut digest = Sha256::new();
+    while remaining != 0 {
+        let count = usize::try_from(remaining.min(MIB))?;
+        rng.fill_bytes(&mut block[..count]);
+        file.write_all(&block[..count])?;
+        digest.update(&block[..count]);
+        remaining -= u64::try_from(count)?;
+    }
+    drop(file);
+    let mut reads = vec![ExpectedRead {
+        range: None,
+        length,
+        sha256: hex_simd::encode_to_string(digest.finalize(), hex_simd::AsciiCase::Lower),
+    }];
+    // Unaligned ranges cross TLS frames and EC blocks; the tail detects
+    // truncation and incorrect range offsets independently of a full GET.
+    for (start, end) in [(17, (MIB + 31).min(length - 1)), (length.saturating_sub(65537), length - 1)] {
+        let mut input = std::fs::File::open(&path)?;
+        input.seek(SeekFrom::Start(start))?;
+        let range_length = end - start + 1;
+        let mut hasher = Sha256::new();
+        let mut input = input.take(range_length);
+        loop {
+            let count = input.read(&mut block)?;
+            if count == 0 {
+                break;
+            }
+            hasher.update(&block[..count]);
+        }
+        reads.push(ExpectedRead {
+            range: Some((start, end)),
+            length: range_length,
+            sha256: hex_simd::encode_to_string(hasher.finalize(), hex_simd::AsciiCase::Lower),
+        });
+    }
+    Ok(ObjectFixture {
+        key,
+        path,
+        length,
+        reads,
+    })
+}
+
+async fn verified_get(
+    client: &Client,
+    node: usize,
+    bucket: &str,
+    object: &ObjectFixture,
+    expected: &ExpectedRead,
+    concurrent: bool,
+) -> TestResult<serde_json::Value> {
+    let started = Instant::now();
+    let mut received = 0u64;
+    let mut stage = "response headers";
+    tokio::time::timeout(READ_TIMEOUT, async {
+        let mut request = client.get_object().bucket(bucket).key(&object.key);
+        if let Some((start, end)) = expected.range {
+            request = request.range(format!("bytes={start}-{end}"));
+        }
+        let mut output = request.send().await?;
+        assert_eq!(output.content_length(), Some(i64::try_from(expected.length)?));
+        if let Some((start, end)) = expected.range {
+            assert_eq!(output.content_range(), Some(format!("bytes {start}-{end}/{}", object.length).as_str()));
+        } else {
+            assert_eq!(output.content_range(), None);
+        }
+        stage = "response body";
+        let mut digest = Sha256::new();
+        while let Some(chunk) = output.body.next().await {
+            let chunk = chunk?;
+            received += u64::try_from(chunk.len())?;
+            assert!(received <= expected.length, "node {node}: GET exceeded the requested length");
+            digest.update(&chunk);
+        }
+        let actual_sha256 = hex_simd::encode_to_string(digest.finalize(), hex_simd::AsciiCase::Lower);
+        assert_eq!(received, expected.length, "node {node}: truncated GET {}", object.key);
+        assert_eq!(actual_sha256, expected.sha256, "node {node}: corrupt GET {}", object.key);
+        eprintln!(
+            "TLS acceptance: GET node={node}, key={}, range={:?}, concurrent={concurrent}, bytes={received}, elapsed={:?}",
+            object.key, expected.range, started.elapsed()
+        );
+        Ok(serde_json::json!({
+            "operation": "get", "node": node, "key": object.key,
+            "range": expected.range, "bytes": received, "sha256": actual_sha256,
+            "concurrent": concurrent, "elapsed_ms": started.elapsed().as_secs_f64() * 1000.0,
+        }))
+    })
+    .await
+    .map_err(|error| {
+        std::io::Error::new(
+            std::io::ErrorKind::TimedOut,
+            format!(
+                "TLS GET timed out: node={node}, key={}, range={:?}, concurrent={concurrent}, stage={stage}, received={received}/{}, elapsed={:?}: {error}",
+                object.key, expected.range, expected.length, started.elapsed()
+            ),
+        )
+    })?
+}
+
+/// This case always exercises the full acceptance sizes; do not substitute
+/// tiny objects and count that as a large distributed-read pass.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn four_node_tls_large_and_range_gets_preserve_bytes() -> TestResult {
+    let mode = std::env::var("RUSTFS_E2E_INTERNODE_HTTP_MODE").unwrap_or_else(|_| "http1".into());
+    let protocol = match mode.as_str() {
+        "http1" => "http1",
+        "auto" | "unpooled" => "auto",
+        _ => return Err("RUSTFS_E2E_INTERNODE_HTTP_MODE must be http1, auto or unpooled".into()),
+    };
+    let mut dist = DistCluster::new_stopped_with_env(
+        DistLayout::FourByFour,
+        &[
+            ("RUSTFS_INTERNODE_HTTP_PROTOCOL", protocol),
+            ("RUSTFS_SCANNER_ENABLED", "true"),
+            ("RUSTFS_SCANNER_START_DELAY_SECS", "0"),
+            ("RUSTFS_SCANNER_CYCLE", "1"),
+            ("RUSTFS_HEAL_ENABLED", "true"),
+            ("RUST_LOG", "warn"),
+        ],
+    )
+    .await?;
+    if mode == "unpooled" {
+        dist.cluster.set_env("RUSTFS_INTERNODE_HTTP_POOL_MAX_IDLE_PER_HOST", "0");
+    }
+    let directory = PathBuf::from(&dist.cluster.temp_dir);
+    let tls_directory = directory.join("tls");
+    tls_gen::run(tls_gen::Args {
+        out_dir: tls_directory.clone(),
+        days: 1,
+        force: false,
+    })?;
+    dist.cluster.enable_tls(&tls_directory).await?;
+    let report_path = std::env::var_os("RUSTFS_INTERNODE_ACCEPTANCE_REPORT").map(PathBuf::from);
+    if let Some(path) = &report_path
+        && (path.exists() || path.with_extension("pids.json").exists())
+    {
+        return Err("acceptance report paths must be unused".into());
+    }
+    let log_directory = report_path.as_ref().map_or_else(
+        || {
+            std::env::var_os("RUSTFS_E2E_LOG_DIR")
+                .map_or_else(|| directory.join("logs"), |root| PathBuf::from(root).join(unique_bucket("internode-tls")))
+        },
+        |path| path.with_extension("logs"),
+    );
+    std::fs::create_dir(&log_directory)?;
+    dist.capture_logs_under(&log_directory)?;
+    dist.cluster.start().await?;
+    let clients = dist
+        .clients()?
+        .into_iter()
+        .map(|client| Client::from_conf(client.config().to_builder().retry_config(RetryConfig::disabled()).build()))
+        .collect::<Vec<_>>();
+    let bucket = unique_bucket("internode-tls");
+    clients[0].create_bucket().bucket(&bucket).send().await?;
+    let pids = dist
+        .cluster
+        .nodes
+        .iter()
+        .map(|node| node.process.as_ref().map(std::process::Child::id))
+        .collect::<Vec<_>>();
+    if let Some(path) = &report_path {
+        std::fs::write(path.with_extension("pids.json"), serde_json::to_vec(&pids)?)?;
+    }
+
+    let mut results = Vec::new();
+    for length in [32 * 1024, 100 * MIB, 1024 * MIB] {
+        let fixture_directory = directory.clone();
+        let object = Arc::new(tokio::task::spawn_blocking(move || fixture(&fixture_directory, length)).await??);
+        eprintln!("TLS acceptance: fixture key={}, bytes={length}", object.key);
+        let started = Instant::now();
+        tokio::time::timeout(
+            READ_TIMEOUT,
+            clients[0]
+                .put_object()
+                .bucket(&bucket)
+                .key(&object.key)
+                .body(ByteStream::from_path(&object.path).await?)
+                .send(),
+        )
+        .await
+        .map_err(|error| {
+            std::io::Error::new(
+                std::io::ErrorKind::TimedOut,
+                format!(
+                    "TLS PUT timed out: key={}, bytes={length}, elapsed={:?}: {error}",
+                    object.key,
+                    started.elapsed()
+                ),
+            )
+        })??;
+        eprintln!("TLS acceptance: PUT key={}, bytes={length}, elapsed={:?}", object.key, started.elapsed());
+        results.push(
+            serde_json::json!({"operation": "put", "bytes": length, "elapsed_ms": started.elapsed().as_secs_f64() * 1000.0}),
+        );
+        if length == 32 * 1024 {
+            let alternate = dist.client_with_credentials(0, &dist.cluster.access_key, &dist.cluster.secret_key)?;
+            let alternate = Client::from_conf(alternate.config().to_builder().retry_config(RetryConfig::disabled()).build());
+            results.push(verified_get(&alternate, 0, &bucket, &object, &object.reads[0], false).await?);
+            let invalid = dist.client_with_credentials(0, "invalid-tls-user", "invalid-tls-secret-password")?;
+            let invalid = Client::from_conf(invalid.config().to_builder().retry_config(RetryConfig::disabled()).build());
+            let denied = invalid
+                .list_buckets()
+                .send()
+                .await
+                .expect_err("alternate credentials must not inherit the root identity");
+            assert_eq!(denied.raw_response().map(|response| response.status().as_u16()), Some(403));
+        }
+        for expected in &object.reads {
+            for (node, client) in clients.iter().enumerate() {
+                results.push(verified_get(client, node, &bucket, &object, expected, false).await?);
+            }
+        }
+        // Each reader owns a Tokio task and its cooperative budget. Polling
+        // every body and synchronous digest in one parent task can let an
+        // always-ready reader starve its siblings and their deadlines.
+        let mut readers = JoinSet::new();
+        for (node, client) in clients.iter().enumerate() {
+            let client = client.clone();
+            let bucket = bucket.clone();
+            let object = Arc::clone(&object);
+            readers.spawn(async move { verified_get(&client, node, &bucket, &object, &object.reads[0], true).await });
+        }
+        while let Some(result) = readers.join_next().await {
+            results.push(result??);
+        }
+        tokio::fs::remove_file(&object.path).await?;
+    }
+    for node in 0..clients.len() {
+        let log = tokio::fs::read_to_string(log_directory.join(format!("node-{node}.log"))).await?;
+        assert!(
+            !log.contains("internode body stalled"),
+            "node {node}: internode body stall during verified reads"
+        );
+    }
+    let report = serde_json::json!({
+        "schema": 1, "mode": mode, "tls_verified": true, "nodes": 4, "drives_per_node": 4,
+        "source_revision": env!("RUSTFS_E2E_BUILD_COMMIT"),
+        "source_dirty": env!("RUSTFS_E2E_BUILD_DIRTY"),
+        "scanner_enabled": true, "heal_enabled": true,
+        "scanner_progress_verified": false, "heal_progress_verified": false,
+        "results": results,
+    });
+    if let Some(path) = report_path {
+        std::fs::write(path, serde_json::to_vec_pretty(&report)?)?;
+    }
+    eprintln!("internode_tls_acceptance={report}");
+    Ok(())
+}

crates/e2e_test/src/distributed/mod.rs

@@ -26,12 +26,16 @@ mod expand_decommission_rebalance_test;
 mod extra_test;
 mod harness;
 mod heal_test;
+mod internode_tls_test;
+mod multipart_fence_acceptance_test;
 mod object_lock_test;
 mod observability_test;
 mod replication_delete_marker_test;
 mod replication_quota_test;
 mod s3_basic_test;
 mod s3_during_data_movement_test;
+mod scanner_heal_topology_fixture;
+mod scanner_heal_topology_test;
 mod site_replication_test;
 mod upgrade_test;
 mod versioning_test;

crates/e2e_test/src/distributed/multipart_fence_acceptance_test.rs

@@ -0,0 +1,780 @@
+// Copyright 2026 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 super::harness::{
+    TestResult, assert_object_bytes, cluster_admin_ok, configure_node_logs, payload_for, retrying_put, sha256_hex, unique_bucket,
+    wait_until,
+};
+use crate::common::{ClusterTopology, RustFSTestClusterEnvironment};
+use crate::rpc_fault_proxy::{RpcFaultProxy, RpcPause};
+use aws_sdk_s3::{
+    Client,
+    config::retry::RetryConfig,
+    error::{ProvideErrorMetadata, SdkError},
+    operation::create_multipart_upload::{CreateMultipartUploadError, CreateMultipartUploadOutput},
+    primitives::ByteStream,
+    types::{CompletedMultipartUpload, CompletedPart},
+};
+use futures::{StreamExt as _, TryStreamExt as _, stream};
+use std::time::{Duration, Instant};
+use tokio::task::JoinHandle;
+
+const DEADLINE: Duration = Duration::from_secs(45);
+
+async fn fixture(
+    drives_per_node: usize,
+    storage_class: &str,
+) -> TestResult<(RustFSTestClusterEnvironment, Vec<RpcFaultProxy>, Vec<Client>, String)> {
+    let mut cluster =
+        RustFSTestClusterEnvironment::with_topology(ClusterTopology::single_pool_multidrive(4, drives_per_node)).await?;
+    for (name, value) in [
+        ("RUSTFS_STORAGE_CLASS_STANDARD", storage_class),
+        ("RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT", "5"),
+        ("RUSTFS_OBJECT_LOCK_RPC_TIMEOUT_MS", "3000"),
+        ("RUSTFS_DRIVE_METADATA_TIMEOUT_SECS", "2"),
+        ("RUSTFS_DRIVE_MAX_TIMEOUT_DURATION", "5"),
+        // Keep disk-health ejection out of a method-specific quorum test.
+        ("RUSTFS_DRIVE_SUSPECT_FAILURE_THRESHOLD", "1000"),
+        ("RUSTFS_OBS_METRICS_EXPORT_ENABLED", "false"),
+        ("NO_PROXY", "127.0.0.1,::1,localhost"),
+        ("HTTP_PROXY", ""),
+        ("HTTPS_PROXY", ""),
+        ("RUST_LOG", "warn"),
+    ] {
+        cluster.set_env(name, value);
+    }
+    let mut proxies = Vec::new();
+    for node in 0..4 {
+        proxies.push(cluster.start_rpc_proxy_for_node(node).await?);
+    }
+    configure_node_logs(&mut cluster, None)?;
+    cluster.start().await?;
+    let clients = cluster
+        .create_all_clients()?
+        .into_iter()
+        .map(|client| {
+            Client::from_conf(
+                client
+                    .config()
+                    .to_builder()
+                    .retry_config(RetryConfig::standard().with_max_attempts(1))
+                    .build(),
+            )
+        })
+        .collect();
+    let bucket = unique_bucket("mpu-fence");
+    cluster.create_test_bucket(&bucket).await?;
+    Ok((cluster, proxies, clients, bucket))
+}
+
+fn create(
+    client: &Client,
+    bucket: &str,
+    key: &str,
+) -> JoinHandle<Result<CreateMultipartUploadOutput, SdkError<CreateMultipartUploadError>>> {
+    let request = client.create_multipart_upload().bucket(bucket).key(key);
+    tokio::spawn(async move { request.send().await })
+}
+
+async fn wait_for_faults(pauses: &[RpcPause], methods: &[&str]) -> TestResult {
+    if methods.iter().any(|method| matches!(*method, "Lock" | "LockBatch")) {
+        // Adaptive lock fan-out may not contact an unnecessary voter. All
+        // selected peers remain gated; require an actual scoped request hit.
+        let (result, _, _) = futures::future::select_all(pauses.iter().map(|pause| Box::pin(pause.wait_for_hits(1)))).await;
+        result?;
+    } else {
+        // Storage mutations fan out eagerly. Every selected peer must really
+        // receive this upload's RPC, so an unrelated failure cannot fake quorum.
+        for pause in pauses {
+            pause.wait_for_hits(1).await?;
+        }
+    }
+    Ok(())
+}
+
+fn assert_unavailable<E: std::fmt::Debug + ProvideErrorMetadata>(error: &SdkError<E>, cause: &str, retry: Option<&str>) {
+    let response = error.raw_response().expect("an S3 service response");
+    assert_eq!(response.status().as_u16(), 503, "{error:?}");
+    assert_eq!(error.as_service_error().and_then(|e| e.meta().code()), Some("ServiceUnavailable"));
+    assert_eq!(response.headers().get("x-rustfs-error-cause"), Some(cause));
+    assert_eq!(response.headers().get("retry-after"), retry);
+    assert!(
+        response
+            .headers()
+            .get("content-type")
+            .is_some_and(|v| v.starts_with("application/xml"))
+    );
+    let request_id = response.headers().get("x-amz-request-id").expect("request correlation ID");
+    assert!(!request_id.is_empty());
+    eprintln!("MPU acceptance: cause={cause}, retry={retry:?}, request_id={request_id}");
+}
+
+async fn abort(client: &Client, bucket: &str, key: &str, upload: &str) -> TestResult {
+    client
+        .abort_multipart_upload()
+        .bucket(bucket)
+        .key(key)
+        .upload_id(upload)
+        .send()
+        .await?;
+    let missing = client
+        .list_parts()
+        .bucket(bucket)
+        .key(key)
+        .upload_id(upload)
+        .send()
+        .await
+        .expect_err("an aborted upload must no longer admit ListParts");
+    assert_eq!(missing.as_service_error().and_then(|e| e.meta().code()), Some("NoSuchUpload"));
+    Ok(())
+}
+
+// Fault removal does not synchronously clear existing server leases or drive
+// health state. Keep the injected operation single-attempt, then require
+// bounded recovery of the exact cleanup API instead of assuming instant heal.
+async fn recover_after_fault<T, E, F, Fut>(operation: &str, mut call: F) -> TestResult<Result<T, SdkError<E>>>
+where
+    E: std::fmt::Debug + ProvideErrorMetadata,
+    F: FnMut() -> Fut,
+    Fut: std::future::Future<Output = Result<T, SdkError<E>>>,
+{
+    let started = Instant::now();
+    let mut attempts = 0;
+    let mut last_failure = String::new();
+    let outcome = tokio::time::timeout(DEADLINE, async {
+        loop {
+            attempts += 1;
+            let result = call().await;
+            let retry = result.as_ref().err().and_then(|error| {
+                let response = error.raw_response()?;
+                if response.status().as_u16() != 503
+                    || error.as_service_error()?.meta().code() != Some("ServiceUnavailable")
+                    || !matches!(
+                        response.headers().get("x-rustfs-error-cause"),
+                        Some("namespace_lock_timeout" | "namespace_lock_unavailable" | "storage_write_quorum")
+                    )
+                {
+                    return None;
+                }
+                let delay = match response.headers().get("retry-after") {
+                    Some("1") => Duration::from_secs(1),
+                    None => Duration::from_millis(100),
+                    Some(_) => return None,
+                };
+                last_failure = format!(
+                    "cause={:?}, request_id={:?}",
+                    response.headers().get("x-rustfs-error-cause"),
+                    response.headers().get("x-amz-request-id")
+                );
+                Some(delay)
+            });
+            match retry {
+                Some(delay) => tokio::time::sleep(delay).await,
+                None => return result,
+            }
+        }
+    })
+    .await;
+    eprintln!(
+        "MPU recovery: operation={operation}, attempts={attempts}, elapsed={:?}, last={last_failure}",
+        started.elapsed()
+    );
+    outcome.map_err(|_| format!("{operation} did not recover within {DEADLINE:?}: {last_failure}").into())
+}
+
+async fn abort_after_fault(client: &Client, bucket: &str, key: &str, upload: &str, allow_missing: bool) -> TestResult {
+    match recover_after_fault(&format!("Abort {key}"), || {
+        client
+            .abort_multipart_upload()
+            .bucket(bucket)
+            .key(key)
+            .upload_id(upload)
+            .send()
+    })
+    .await?
+    {
+        Ok(_) => {}
+        Err(error) if allow_missing && error.as_service_error().and_then(|e| e.meta().code()) == Some("NoSuchUpload") => {}
+        Err(error) => return Err(error.into()),
+    }
+    let missing = recover_after_fault(&format!("ListParts {key}"), || {
+        client.list_parts().bucket(bucket).key(key).upload_id(upload).send()
+    })
+    .await?
+    .expect_err("a recovered Abort must remove the upload");
+    assert_eq!(missing.as_service_error().and_then(|e| e.meta().code()), Some("NoSuchUpload"));
+    Ok(())
+}
+
+async fn round_trip(clients: &[Client], bucket: &str, key: &str, size: usize) -> TestResult {
+    let upload = clients[0].create_multipart_upload().bucket(bucket).key(key).send().await?;
+    let upload_id = upload.upload_id().ok_or("missing upload ID")?;
+    let body = payload_for(key, size);
+    let mut parts: Vec<_> = stream::iter(body.chunks(8 * 1024 * 1024).enumerate())
+        .map(|(part, bytes)| async move {
+            let number = i32::try_from(part + 1)?;
+            let result = clients[part % clients.len()]
+                .upload_part()
+                .bucket(bucket)
+                .key(key)
+                .upload_id(upload_id)
+                .part_number(number)
+                .body(ByteStream::from(bytes.to_vec()))
+                .send()
+                .await?;
+            Ok::<_, Box<dyn std::error::Error + Send + Sync>>(
+                CompletedPart::builder()
+                    .part_number(number)
+                    .e_tag(result.e_tag().ok_or("missing part ETag")?)
+                    .build(),
+            )
+        })
+        .buffer_unordered(4)
+        .try_collect()
+        .await?;
+    parts.sort_by_key(|part| part.part_number());
+    clients[1]
+        .complete_multipart_upload()
+        .bucket(bucket)
+        .key(key)
+        .upload_id(upload_id)
+        .multipart_upload(CompletedMultipartUpload::builder().set_parts(Some(parts)).build())
+        .send()
+        .await?;
+    for client in clients {
+        assert_object_bytes(client, bucket, key, &body).await?;
+    }
+    clients[0].delete_object().bucket(bucket).key(key).send().await?;
+    Ok(())
+}
+
+async fn assert_no_uploads(clients: &[Client], bucket: &str) -> TestResult {
+    for client in clients {
+        let uploads = client.list_multipart_uploads().bucket(bucket).send().await?;
+        assert!(uploads.uploads().is_empty(), "unexpected residual uploads: {:?}", uploads.uploads());
+    }
+    Ok(())
+}
+
+async fn assert_no_uploads_after_fault(clients: &[Client], bucket: &str) -> TestResult {
+    for client in clients {
+        let uploads = recover_after_fault("ListMultipartUploads after fault", || {
+            client.list_multipart_uploads().bucket(bucket).send()
+        })
+        .await??;
+        assert!(uploads.uploads().is_empty(), "unexpected residual uploads: {:?}", uploads.uploads());
+    }
+    Ok(())
+}
+
+async fn assert_object_bytes_after_fault(client: &Client, bucket: &str, key: &str, expected: &[u8]) -> TestResult {
+    let output = recover_after_fault(&format!("GetObject {key} after fault"), || {
+        client.get_object().bucket(bucket).key(key).send()
+    })
+    .await??;
+    // A successful response must have a complete, correct body. Streaming
+    // failures are not retried or converted into a successful comparison.
+    let bytes = output.body.collect().await?.into_bytes();
+    if bytes.as_ref() != expected {
+        return Err(format!("object {key} bytes differ: expected {} bytes, got {}", expected.len(), bytes.len()).into());
+    }
+    Ok(())
+}
+
+// This fixture inspects RustFS RPCs, so use the server-generated upload's
+// canonical suffix and fail explicitly if its encoding changes.
+fn upload_scope(upload_id: &str) -> TestResult<String> {
+    let decoded = String::from_utf8(base64_simd::URL_SAFE_NO_PAD.decode_to_vec(upload_id.as_bytes())?)?;
+    let (_, suffix) = decoded.split_once('.').ok_or("server upload ID lacks deployment delimiter")?;
+    if suffix.is_empty() {
+        return Err("server upload ID has an empty suffix".into());
+    }
+    Ok(suffix.to_owned())
+}
+
+fn upload_path_scope(bucket: &str, key: &str, upload_id: &str) -> TestResult<String> {
+    Ok(format!(
+        "{}/{}",
+        sha256_hex(format!("{bucket}/{key}").as_bytes()),
+        upload_scope(upload_id)?
+    ))
+}
+
+async fn with_paused_peers<T: Send + 'static>(
+    proxies: &[RpcFaultProxy],
+    methods: &[&'static str],
+    limits: &[usize],
+    scope: &str,
+    request: impl std::future::Future<Output = T> + Send + 'static,
+) -> TestResult<T> {
+    let pauses: Vec<_> = proxies[1..=limits.len()]
+        .iter()
+        .zip(limits)
+        .map(|(proxy, limit)| proxy.pause(methods, *limit, Some(scope)))
+        .collect::<Result<_, _>>()?;
+    let task = tokio::spawn(request);
+    wait_for_faults(&pauses, methods).await?;
+    let result = tokio::time::timeout(DEADLINE, task).await??;
+    for pause in &pauses {
+        pause.discard_pending();
+    }
+    drop(pauses);
+    Ok(result)
+}
+
+fn quorum_outcome<T: std::fmt::Debug, E: std::fmt::Debug + ProvideErrorMetadata>(
+    result: Result<T, SdkError<E>>,
+    at_quorum: bool,
+    locks: bool,
+) -> TestResult<Option<T>> {
+    if at_quorum {
+        Ok(Some(result.map_err(|error| format!("exactly quorum must succeed: {error:?}"))?))
+    } else {
+        assert_unavailable(
+            &result.expect_err("quorum-minus-one must fail"),
+            if locks {
+                "namespace_lock_timeout"
+            } else {
+                "storage_write_quorum"
+            },
+            if locks { Some("1") } else { None },
+        );
+        Ok(None)
+    }
+}
+
+async fn wait_for_lock_peer_recovery(proxies: &[RpcFaultProxy], client: &Client, bucket: &str) -> TestResult {
+    let key = unique_bucket("peer-recovery");
+    let observers = proxies[1..]
+        .iter()
+        .map(|proxy| proxy.pause(&["Lock", "LockBatch"], usize::MAX, Some(&key)))
+        .collect::<Result<Vec<_>, _>>()?;
+    for observer in &observers {
+        observer.release();
+    }
+    wait_until(
+        DEADLINE,
+        || async {
+            retrying_put(client, bucket, &key, vec![0x42; 1024], DEADLINE).await?;
+            // Quorum success alone can leave one peer's request breaker open.
+            // Two replies require a half-open peer to finish its first probe
+            // before admitting another RPC; every peer must rejoin the matrix.
+            Ok(observers.iter().all(|observer| observer.forwarded() >= 2))
+        },
+        "all lock peers recover after fault retirement",
+    )
+    .await
+}
+
+async fn phase_quorum_matrix(
+    proxies: &[RpcFaultProxy],
+    clients: &[Client],
+    bucket: &str,
+    locks: bool,
+    drives_per_node: usize,
+) -> TestResult {
+    for phase in ["create", "part", "complete", "abort"] {
+        // Ordinary Create holds only the shared bucket lifecycle fence.
+        // Four-node read quorum is two; commit/write quorum is three.
+        let unavailable_at_quorum = if locks && phase == "create" { 2 } else { 1 };
+        for unavailable in [unavailable_at_quorum, unavailable_at_quorum + 1] {
+            let key = format!("{locks}-{phase}-{unavailable}");
+            let mut limits = vec![usize::MAX; unavailable];
+            // EC12+4: one peer contributes four shards; one packet on the
+            // second peer moves exactly twelve available shards to eleven.
+            if !locks && drives_per_node == 4 && unavailable > 1 {
+                limits[unavailable - 1] = 1;
+            }
+            let available_votes = if locks {
+                4 - unavailable
+            } else {
+                4 * drives_per_node - limits.iter().map(|limit| drives_per_node.min(*limit)).sum::<usize>()
+            };
+            let methods: &[&'static str] = if locks {
+                &["Lock", "LockBatch"]
+            } else {
+                match phase {
+                    "create" => &["WriteMetadata"],
+                    "part" => &["PreparePartTransaction"],
+                    "complete" => &["RenameData", "RenameDataAtIncarnation", "RenameDataWithQuotaFence"],
+                    "abort" => &["Delete"],
+                    _ => unreachable!(),
+                }
+            };
+            eprintln!("MPU quorum acceptance: phase={phase}, lock_fault={locks}, available_votes={available_votes}");
+            if phase == "create" {
+                let request = clients[0].create_multipart_upload().bucket(bucket).key(&key);
+                let result = with_paused_peers(proxies, methods, &limits, bucket, async move { request.send().await }).await?;
+                if let Some(upload) = quorum_outcome(result, unavailable == unavailable_at_quorum, locks)? {
+                    abort_after_fault(&clients[0], bucket, &key, upload.upload_id().ok_or("missing upload ID")?, false).await?;
+                }
+            } else {
+                let upload = clients[0]
+                    .create_multipart_upload()
+                    .bucket(bucket)
+                    .key(&key)
+                    .send()
+                    .await
+                    .map_err(|error| format!("setup Create failed for {key}: {error:?}"))?;
+                let upload_id = upload.upload_id().ok_or("missing upload ID")?;
+                let scope = if !locks && phase == "abort" {
+                    upload_path_scope(bucket, &key, upload_id)?
+                } else {
+                    upload_scope(upload_id)?
+                };
+                let body = payload_for(&key, if drives_per_node == 4 { 9 * 1024 * 1024 } else { 1024 * 1024 });
+                let initial = if phase != "part" {
+                    Some(
+                        clients[0]
+                            .upload_part()
+                            .bucket(bucket)
+                            .key(&key)
+                            .upload_id(upload_id)
+                            .part_number(1)
+                            .body(ByteStream::from(body.clone()))
+                            .send()
+                            .await?,
+                    )
+                } else {
+                    None
+                };
+                match phase {
+                    "part" => {
+                        let request = clients[0]
+                            .upload_part()
+                            .bucket(bucket)
+                            .key(&key)
+                            .upload_id(upload_id)
+                            .part_number(1)
+                            .body(ByteStream::from(body.clone()));
+                        let result =
+                            with_paused_peers(proxies, methods, &limits, &scope, async move { request.send().await }).await?;
+                        if let Some(part) = quorum_outcome(result, unavailable == unavailable_at_quorum, locks)? {
+                            let completion = clients[0]
+                                .complete_multipart_upload()
+                                .bucket(bucket)
+                                .key(&key)
+                                .upload_id(upload_id)
+                                .multipart_upload(
+                                    CompletedMultipartUpload::builder()
+                                        .parts(
+                                            CompletedPart::builder()
+                                                .part_number(1)
+                                                .e_tag(part.e_tag().ok_or("missing ETag")?)
+                                                .build(),
+                                        )
+                                        .build(),
+                                );
+                            recover_after_fault(&format!("Complete {key} after part fault"), || completion.clone().send())
+                                .await??;
+                            for reader in clients {
+                                assert_object_bytes_after_fault(reader, bucket, &key, &body).await?;
+                            }
+                        }
+                    }
+                    "complete" => {
+                        let part = initial.as_ref().expect("complete fixture has one part");
+                        let request = clients[0]
+                            .complete_multipart_upload()
+                            .bucket(bucket)
+                            .key(&key)
+                            .upload_id(upload_id)
+                            .multipart_upload(
+                                CompletedMultipartUpload::builder()
+                                    .parts(
+                                        CompletedPart::builder()
+                                            .part_number(1)
+                                            .e_tag(part.e_tag().ok_or("missing ETag")?)
+                                            .build(),
+                                    )
+                                    .build(),
+                            );
+                        let result =
+                            with_paused_peers(proxies, methods, &limits, &scope, async move { request.send().await }).await?;
+                        if quorum_outcome(result, unavailable == unavailable_at_quorum, locks)?.is_some() {
+                            for reader in clients {
+                                assert_object_bytes_after_fault(reader, bucket, &key, &body).await?;
+                            }
+                        }
+                    }
+                    "abort" => {
+                        let request = clients[0]
+                            .abort_multipart_upload()
+                            .bucket(bucket)
+                            .key(&key)
+                            .upload_id(upload_id);
+                        let result =
+                            with_paused_peers(proxies, methods, &limits, &scope, async move { request.send().await }).await?;
+                        quorum_outcome(result, unavailable == unavailable_at_quorum, locks)?;
+                    }
+                    _ => unreachable!(),
+                }
+                // Cleanup must recover even after a below-quorum mutation;
+                // only an already retired session may return NoSuchUpload.
+                abort_after_fault(&clients[0], bucket, &key, upload_id, true).await?;
+                recover_after_fault(&format!("DeleteObject {key} after {phase}"), || {
+                    clients[0].delete_object().bucket(bucket).key(&key).send()
+                })
+                .await??;
+            }
+            wait_for_lock_peer_recovery(proxies, &clients[0], bucket).await?;
+            round_trip(clients, bucket, "recovered", 9 * 1024 * 1024).await?;
+            assert_no_uploads_after_fault(clients, bucket).await?;
+        }
+    }
+    Ok(())
+}
+
+#[tokio::test]
+async fn metadata_delay_preserves_write_quorum_and_rejects_quorum_minus_one() -> TestResult {
+    let (_cluster, proxies, clients, bucket) = fixture(1, "EC:2").await?;
+    phase_quorum_matrix(&proxies, &clients, &bucket, false, 1).await
+}
+
+#[tokio::test]
+async fn lock_delay_preserves_admission_quorum_and_reports_timeout() -> TestResult {
+    let (_cluster, proxies, clients, bucket) = fixture(1, "EC:2").await?;
+    phase_quorum_matrix(&proxies, &clients, &bucket, true, 1).await
+}
+
+#[tokio::test]
+async fn sixteen_shard_multipart_metadata_requires_twelve_votes() -> TestResult {
+    let (cluster, proxies, clients, bucket) = fixture(4, "EC:4").await?;
+    let storage = cluster_admin_ok(&cluster, http::Method::GET, "/rustfs/admin/v3/storageinfo", None).await?;
+    let storage: serde_json::Value = serde_json::from_str(&storage)?;
+    let storage: rustfs_madmin::StorageInfo = serde_json::from_value(storage["info"].clone())?;
+    assert_eq!(storage.disks.len(), 16);
+    assert_eq!(storage.backend.total_sets, vec![1]);
+    assert_eq!(storage.backend.drives_per_set, vec![16]);
+    assert_eq!(storage.backend.standard_sc_parity, Some(4));
+    phase_quorum_matrix(&proxies, &clients, &bucket, false, 4).await
+}
+
+#[tokio::test]
+async fn cancelled_metadata_wait_releases_fence_for_bucket_recreation() -> TestResult {
+    let (_cluster, proxies, clients, bucket) = fixture(1, "EC:2").await?;
+    let pauses: Vec<_> = proxies[1..]
+        .iter()
+        .map(|proxy| proxy.pause(&["WriteMetadata"], usize::MAX, Some(&bucket)))
+        .collect::<Result<_, _>>()?;
+    let task = create(&clients[0], &bucket, "cancelled");
+    wait_for_faults(&pauses, &["WriteMetadata"]).await?;
+    task.abort();
+    assert!(task.await.expect_err("cancelled S3 future").is_cancelled());
+    drop(pauses);
+    // Deletion must wait for admitted server work to finish, then erase its
+    // generation. Client cancellation alone does not prove server cancellation.
+    tokio::time::timeout(DEADLINE, clients[1].delete_bucket().bucket(&bucket).send()).await??;
+    clients[2].create_bucket().bucket(&bucket).send().await?;
+    assert_no_uploads(&clients, &bucket).await?;
+    round_trip(&clients, &bucket, "new-generation", 9 * 1024 * 1024).await?;
+    assert_no_uploads(&clients, &bucket).await
+}
+
+/// Same logical geometry as the incident: one pool, four 16-shard sets,
+/// EC12+4, 45 MiB files, 8 MiB parts, two files and four parts in flight.
+#[tokio::test]
+async fn eight_node_eight_drive_multipart_load_leaves_no_residual_uploads() -> TestResult {
+    let rounds = std::env::var("RUSTFS_E2E_MPU_LOAD_ROUNDS")
+        .unwrap_or_else(|_| "3".into())
+        .parse::<usize>()?;
+    if !(1..=256).contains(&rounds) {
+        return Err("RUSTFS_E2E_MPU_LOAD_ROUNDS must be in 1..=256".into());
+    }
+    let mut cluster = RustFSTestClusterEnvironment::with_topology(ClusterTopology::single_pool_multidrive(8, 8)).await?;
+    for (name, value) in [
+        ("RUSTFS_STORAGE_CLASS_STANDARD", "EC:4"),
+        ("TOKIO_WORKER_THREADS", "2"),
+        ("RAYON_NUM_THREADS", "2"),
+        ("RUSTFS_OBS_METRICS_EXPORT_ENABLED", "false"),
+        ("NO_PROXY", "127.0.0.1,::1,localhost"),
+        ("HTTP_PROXY", ""),
+        ("HTTPS_PROXY", ""),
+        ("RUST_LOG", "warn"),
+    ] {
+        cluster.set_env(name, value);
+    }
+    configure_node_logs(&mut cluster, None)?;
+    cluster.start().await?;
+    let clients: Vec<_> = cluster
+        .create_all_clients()?
+        .into_iter()
+        .map(|client| {
+            Client::from_conf(
+                client
+                    .config()
+                    .to_builder()
+                    .retry_config(RetryConfig::standard().with_max_attempts(1))
+                    .build(),
+            )
+        })
+        .collect();
+    let storage = cluster_admin_ok(&cluster, http::Method::GET, "/rustfs/admin/v3/storageinfo", None).await?;
+    let storage: serde_json::Value = serde_json::from_str(&storage)?;
+    let storage: rustfs_madmin::StorageInfo = serde_json::from_value(storage["info"].clone())?;
+    assert_eq!(storage.disks.len(), 64);
+    assert_eq!(storage.backend.total_sets, vec![4]);
+    assert_eq!(storage.backend.drives_per_set, vec![16]);
+    assert_eq!(storage.backend.standard_sc_parity, Some(4));
+    let bucket = unique_bucket("mpu-8x8");
+    cluster.create_test_bucket(&bucket).await?;
+    let started = Instant::now();
+    for round in 0..rounds {
+        let first = format!("round-{round}-first");
+        let second = format!("round-{round}-second");
+        tokio::try_join!(
+            round_trip(&clients, &bucket, &first, 45 * 1024 * 1024),
+            round_trip(&clients, &bucket, &second, 45 * 1024 * 1024),
+        )?;
+        let aborted = clients[round % clients.len()]
+            .create_multipart_upload()
+            .bucket(&bucket)
+            .key("aborted")
+            .send()
+            .await?;
+        let upload_id = aborted.upload_id().ok_or("missing upload ID")?;
+        clients[(round + 1) % clients.len()]
+            .upload_part()
+            .bucket(&bucket)
+            .key("aborted")
+            .upload_id(upload_id)
+            .part_number(1)
+            .body(ByteStream::from(vec![0xa5; 8 * 1024 * 1024]))
+            .send()
+            .await?;
+        abort(&clients[(round + 2) % clients.len()], &bucket, "aborted", upload_id).await?;
+        assert_no_uploads(&clients, &bucket).await?;
+        eprintln!(
+            "MPU 8x8 acceptance: round={}/{rounds}, completed={}, aborted={}, elapsed={:?}",
+            round + 1,
+            2 * (round + 1),
+            round + 1,
+            started.elapsed()
+        );
+    }
+    Ok(())
+}
+
+async fn resume_at_rpc<T: Send + 'static>(
+    proxies: &[RpcFaultProxy],
+    methods: &[&'static str],
+    scope: &str,
+    request: impl std::future::Future<Output = TestResult<T>> + Send + 'static,
+) -> TestResult<T> {
+    let pauses: Vec<_> = proxies[1..]
+        .iter()
+        .map(|proxy| proxy.pause(methods, usize::MAX, Some(scope)))
+        .collect::<Result<_, _>>()?;
+    eprintln!("MPU delay acceptance: methods={methods:?}, scope={scope}");
+    let task = tokio::spawn(request);
+    wait_for_faults(&pauses, methods).await?;
+    assert!(
+        !task.is_finished(),
+        "the selected commit must wait while only one shard/voter is available"
+    );
+    drop(pauses);
+    tokio::time::timeout(DEADLINE, task).await??
+}
+
+#[tokio::test]
+async fn each_multipart_phase_resumes_after_metadata_and_lock_delays() -> TestResult {
+    let (_cluster, proxies, clients, bucket) = fixture(1, "EC:2").await?;
+    for locks in [false, true] {
+        let key = format!("phase-{locks}");
+        let client = clients[0].clone();
+        let create = client.create_multipart_upload().bucket(&bucket).key(&key);
+        let upload = resume_at_rpc(
+            &proxies,
+            if locks { &["Lock", "LockBatch"] } else { &["WriteMetadata"] },
+            bucket.as_str(),
+            async move { Ok(create.send().await?) },
+        )
+        .await?;
+        let upload_id = upload.upload_id().ok_or("missing upload ID")?;
+        let scope = upload_scope(upload_id)?;
+        let body = payload_for(&key, 1024 * 1024);
+        let part = client
+            .upload_part()
+            .bucket(&bucket)
+            .key(&key)
+            .upload_id(upload_id)
+            .part_number(1)
+            .body(ByteStream::from(body.clone()));
+        let part = resume_at_rpc(
+            &proxies,
+            if locks {
+                &["Lock", "LockBatch"]
+            } else {
+                &["PreparePartTransaction"]
+            },
+            &scope,
+            async move { Ok(part.send().await?) },
+        )
+        .await?;
+        let complete = client
+            .complete_multipart_upload()
+            .bucket(&bucket)
+            .key(&key)
+            .upload_id(upload_id)
+            .multipart_upload(
+                CompletedMultipartUpload::builder()
+                    .parts(
+                        CompletedPart::builder()
+                            .part_number(1)
+                            .e_tag(part.e_tag().ok_or("missing ETag")?)
+                            .build(),
+                    )
+                    .build(),
+            );
+        resume_at_rpc(
+            &proxies,
+            if locks {
+                &["Lock", "LockBatch"]
+            } else {
+                &["RenameData", "RenameDataAtIncarnation", "RenameDataWithQuotaFence"]
+            },
+            &scope,
+            async move { Ok(complete.send().await?) },
+        )
+        .await?;
+        for reader in &clients {
+            assert_object_bytes(reader, &bucket, &key, &body).await?;
+        }
+        client.delete_object().bucket(&bucket).key(&key).send().await?;
+        let upload = client.create_multipart_upload().bucket(&bucket).key(&key).send().await?;
+        let upload_id = upload.upload_id().ok_or("missing upload ID")?;
+        let scope = upload_scope(upload_id)?;
+        let scope = if locks {
+            scope
+        } else {
+            upload_path_scope(&bucket, &key, upload_id)?
+        };
+        let request = client.abort_multipart_upload().bucket(&bucket).key(&key).upload_id(upload_id);
+        resume_at_rpc(&proxies, if locks { &["Lock", "LockBatch"] } else { &["Delete"] }, &scope, async move {
+            Ok(request.send().await?)
+        })
+        .await?;
+        let missing = client
+            .list_parts()
+            .bucket(&bucket)
+            .key(&key)
+            .upload_id(upload_id)
+            .send()
+            .await
+            .expect_err("delayed Abort must remove the upload");
+        assert_eq!(missing.as_service_error().and_then(|e| e.meta().code()), Some("NoSuchUpload"));
+        assert_no_uploads(&clients, &bucket).await?;
+    }
+    Ok(())
+}

crates/e2e_test/src/distributed/scanner_heal_topology_test.rs

@@ -0,0 +1,761 @@
+// Copyright 2026 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.
+
+//! `scanner_heal_topology_` protection matrix (backlog#2873, S00).
+//!
+//! Every case seeds the deterministic inventory from the fixture into one
+//! pool, then drives expansion, rebalance or decommission while re-verifying
+//! the recorded versions through every node and the physical pool placement
+//! from `xl.meta`. Fault cases hold the mover at a proven window through the
+//! `e2e-test-hooks` barriers before injecting a kill or a commit failure. The
+//! gate mapping is documented in `docs/testing/scanner-heal-topology-gates.md`.
+
+use super::harness::unique_bucket;
+use super::harness::{
+    DECOMMISSION_POOL_ID, TestResult, decommission_status_json, rebalance_complete, rebalance_status_json, start_decommission,
+    start_rebalance, wait_for_decommission_active, wait_for_decommission_complete, wait_for_decommission_running_with_progress,
+    wait_for_rebalance_active, wait_for_rebalance_complete,
+};
+use super::scanner_heal_topology_fixture::{
+    LiveWorkload, MOVEMENT_ACTIVE_TIMEOUT, MOVEMENT_COMPLETE_TIMEOUT, MovementOperation, SEED_POOL,
+    STAGE_AFTER_RESPONSIBILITY_PERSISTED, STAGE_BEFORE_SOURCE_CLEANUP, STAGE_BEFORE_TARGET_COMMIT, TopologyManifest, TopologyRun,
+    assert_bucket_durability_strict, assert_every_node_serves, assert_probe_objects, assert_process_durability_strict,
+    assert_seed_pool_census_unchanged, assert_single_pool_placement, cancel_decommission, capture_seed_pool_census,
+    clear_decommission, expect_decommission_rejected, expected_live_state, incarnation_sidecar_census, pool_count, pools_holding,
+    put_probe_objects, rebalance_stopped, require_test_hooks, run_live_workload, seed_manifest, start_decommission_targets,
+    stop_rebalance, verify_from_every_node, verify_live_state, verify_manifest, wait_for_decommission_flag,
+};
+use crate::common::{admin_request, init_logging};
+use http::Method;
+use serde_json::{Value, json};
+use std::collections::BTreeSet;
+use std::time::Duration;
+use tokio::time::{Instant, sleep};
+
+const ALL_POOLS: [usize; 4] = [0, 1, 2, 3];
+const TARGET_POOLS: [usize; 3] = [1, 2, 3];
+const LIVE_WRITERS: usize = 6;
+const LIVE_ROUNDS: usize = 6;
+/// Locally the decommission start reaches its durable save in about a second
+/// (POST to response ~0.8 s); 60 s separates a stalled start path from slow I/O.
+const PRE_ACK_REACH_TIMEOUT: Duration = Duration::from_secs(60);
+/// Cancel and stop are acknowledged before every in-flight entry finishes its
+/// cleanup; terminal state and placement are polled within this budget.
+const TERMINAL_TRANSITION_TIMEOUT: Duration = Duration::from_secs(90);
+/// Recovery includes the fleet-proof retry before migration can resume. A
+/// healthy CI restart completed after 253 s while still making progress; keep
+/// this recovery budget below the distributed profile's 720 s process limit.
+const DECOMMISSION_RESUME_COMPLETE_TIMEOUT: Duration = Duration::from_secs(360);
+
+fn pools(ids: &[usize]) -> BTreeSet<usize> {
+    ids.iter().copied().collect()
+}
+
+fn seed_pool_sidecars(
+    census: &std::collections::BTreeMap<String, crate::chaos::VersionShardCensus>,
+) -> Vec<(&String, &crate::chaos::VersionShardCensus)> {
+    census
+        .iter()
+        .filter(|(location, _)| location.starts_with(&format!("{SEED_POOL}/")))
+        .collect()
+}
+
+/// Expansion and restart must leave the seed pool's sidecar census unchanged.
+fn assert_seed_sidecars_unchanged(run: &TopologyRun, manifest: &TopologyManifest, label: &str) -> TestResult {
+    for bucket in manifest.buckets() {
+        let now = incarnation_sidecar_census(&run.dist, bucket)?;
+        let before = &manifest.incarnation_sidecars[bucket];
+        if seed_pool_sidecars(&now) != seed_pool_sidecars(before) {
+            return Err(format!(
+                "{label}: bucket incarnation sidecar of {bucket} changed on the seed pool: before {before:?} now {now:?}"
+            )
+            .into());
+        }
+    }
+    Ok(())
+}
+
+/// After the seed pool is retired every bucket must keep its incarnation
+/// sidecar on at least one target pool.
+fn assert_sidecars_survive_on_targets(
+    run: &TopologyRun,
+    manifest: &TopologyManifest,
+    targets: &BTreeSet<usize>,
+    label: &str,
+) -> TestResult<Value> {
+    let mut summary = serde_json::Map::new();
+    for bucket in manifest.buckets() {
+        let now = incarnation_sidecar_census(&run.dist, bucket)?;
+        let on_targets: Vec<&String> = now
+            .keys()
+            .filter(|location| {
+                location
+                    .split('/')
+                    .next()
+                    .and_then(|pool| pool.parse::<usize>().ok())
+                    .is_some_and(|pool| targets.contains(&pool))
+            })
+            .collect();
+        if on_targets.is_empty() {
+            return Err(
+                format!("{label}: bucket {bucket} has no incarnation sidecar on target pools {targets:?}: {now:?}").into(),
+            );
+        }
+        summary.insert(bucket.to_string(), json!(on_targets));
+    }
+    Ok(Value::Object(summary))
+}
+
+fn manifest_summary(manifest: &TopologyManifest) -> Value {
+    let mut shapes = std::collections::BTreeMap::new();
+    for entry in &manifest.entries {
+        *shapes.entry(entry.shape).or_insert(0usize) += 1;
+    }
+    json!({
+        "buckets": manifest.buckets(),
+        "entries": manifest.entries.len(),
+        "keys": manifest.entries.iter().map(|entry| format!("{}/{}", entry.bucket, entry.key)).collect::<BTreeSet<_>>().len(),
+        "shapes": shapes,
+        "bytes": manifest.entries.iter().map(|entry| entry.length).sum::<u64>(),
+    })
+}
+
+fn timeouts() -> Value {
+    json!({
+        "movement_active_secs": MOVEMENT_ACTIVE_TIMEOUT.as_secs(),
+        "movement_complete_secs": MOVEMENT_COMPLETE_TIMEOUT.as_secs(),
+        "decommission_resume_complete_secs": DECOMMISSION_RESUME_COMPLETE_TIMEOUT.as_secs(),
+        "barrier_reach_secs": MOVEMENT_COMPLETE_TIMEOUT.as_secs(),
+        "terminal_transition_secs": TERMINAL_TRANSITION_TIMEOUT.as_secs(),
+    })
+}
+
+/// Cancel and stop acknowledge before every in-flight entry has finished its
+/// cleanup, so placement is polled until it settles within the terminal budget.
+async fn wait_for_single_pool_placement(
+    run: &TopologyRun,
+    manifest: &TopologyManifest,
+    allowed: &BTreeSet<usize>,
+    label: &str,
+) -> TestResult<std::collections::BTreeMap<String, usize>> {
+    let deadline = Instant::now() + TERMINAL_TRANSITION_TIMEOUT;
+    loop {
+        match assert_single_pool_placement(&run.dist, manifest, allowed, label) {
+            Ok(placement) => return Ok(placement),
+            Err(error) if Instant::now() < deadline => {
+                tracing::info!("{label}: placement not settled yet: {error}");
+                sleep(Duration::from_secs(1)).await;
+            }
+            Err(error) => return Err(error),
+        }
+    }
+}
+
+/// A stopped run may leave a committed target beside its retained source.
+/// Every version must still be held by at least one pool; returns the
+/// versions held by more than one.
+fn assert_held_by_some_pool(run: &TopologyRun, manifest: &TopologyManifest, label: &str) -> TestResult<Vec<String>> {
+    let mut duplicated = Vec::new();
+    for entry in &manifest.entries {
+        let held = pools_holding(&run.dist, &entry.bucket, &entry.key, entry.version_id.as_deref())?;
+        if held.is_empty() {
+            return Err(format!(
+                "{label}: {}/{} version {:?} is held by no pool",
+                entry.bucket, entry.key, entry.version_id
+            )
+            .into());
+        }
+        if held.len() > 1 {
+            duplicated.push(format!("{}/{}@{} {held:?}", entry.bucket, entry.key, entry.listed_version_id()));
+        }
+    }
+    Ok(duplicated)
+}
+
+async fn expand_and_verify(run: &mut TopologyRun, manifest: &TopologyManifest) -> TestResult {
+    run.dist.expand_to_four_pools().await?;
+    assert_eq!(pool_count(&run.dist.cluster).await?, 4, "expected four pools after expansion");
+    verify_from_every_node(&run.dist, manifest, "after expansion to four pools").await?;
+    assert_single_pool_placement(&run.dist, manifest, &pools(&[SEED_POOL]), "before data movement")?;
+    Ok(())
+}
+
+/// G-EXP: 1→2→4 pools with scanner and heal enabled; old versions intact on
+/// every node, seed-pool shards and set placement untouched, new writes land
+/// in exactly one pool, and the pool map survives a full restart.
+#[tokio::test]
+async fn scanner_heal_topology_expand_one_to_four_pools_preserves_versions_and_placement() -> TestResult {
+    init_logging();
+    let mut run = TopologyRun::start("expand").await?;
+    let manifest = seed_manifest(&run).await?;
+    let bucket_durability = assert_bucket_durability_strict(&run.dist.cluster, &manifest.buckets()).await?;
+    verify_from_every_node(&run.dist, &manifest, "seeded").await?;
+    let seed_census = capture_seed_pool_census(&run.dist, &manifest)?;
+    let scratch = unique_bucket("sht-scratch");
+    run.dist.create_bucket(&scratch).await?;
+
+    let mut steps = Vec::new();
+    for expected_pools in 2..=4 {
+        let new_node = run.dist.append_pool_and_restart().await?;
+        if new_node + 1 != expected_pools {
+            return Err(format!("appended node index {new_node} does not match pool count {expected_pools}").into());
+        }
+        let label = format!("after expanding to {expected_pools} pools");
+        assert_eq!(pool_count(&run.dist.cluster).await?, expected_pools, "{label}: pool list");
+        verify_from_every_node(&run.dist, &manifest, &label).await?;
+        assert_seed_pool_census_unchanged(&run.dist, &manifest, &seed_census, &label)?;
+        assert_seed_sidecars_unchanged(&run, &manifest, &label)?;
+        steps.push(json!({ "pools": expected_pools, "verified_nodes": run.dist.cluster.nodes.len() }));
+    }
+
+    let probes = put_probe_objects(&run.dist, &scratch, "post-expand", 8).await?;
+    let probe_placement = assert_probe_objects(&run.dist, &scratch, &probes, &pools(&ALL_POOLS), "post-expand probes").await?;
+
+    run.dist.restart_current_binary_gracefully().await?;
+    assert_eq!(pool_count(&run.dist.cluster).await?, 4, "pool map after restart");
+    verify_from_every_node(&run.dist, &manifest, "after full restart").await?;
+    assert_seed_pool_census_unchanged(&run.dist, &manifest, &seed_census, "after full restart")?;
+    assert_seed_sidecars_unchanged(&run, &manifest, "after full restart")?;
+    assert_probe_objects(&run.dist, &scratch, &probes, &pools(&ALL_POOLS), "post-expand probes after restart").await?;
+    assert_bucket_durability_strict(&run.dist.cluster, &manifest.buckets()).await?;
+    let strict_nodes = assert_process_durability_strict(&run.node_log_paths())?;
+
+    run.write_evidence(
+        "g-exp-expand",
+        &json!({
+            "gate": "G-EXP",
+            "manifest": manifest_summary(&manifest),
+            "bucket_durability": bucket_durability,
+            "process_durability_strict_nodes": strict_nodes,
+            "expansion_steps": steps,
+            "probe_placement": probe_placement,
+            "timeouts": timeouts(),
+        }),
+    )?;
+    Ok(())
+}
+
+/// Wait for the first rebalance run to report either `stopped` (the expected
+/// outcome) or `completed` (the inventory moved before the stop arrived).
+async fn wait_for_rebalance_stopped_or_completed(run: &TopologyRun, rebalance_id: &str) -> TestResult<(&'static str, Value)> {
+    let deadline = Instant::now() + TERMINAL_TRANSITION_TIMEOUT;
+    loop {
+        let status = rebalance_status_json(&run.dist.cluster).await?;
+        if rebalance_stopped(&status, rebalance_id)? {
+            return Ok(("stopped", status));
+        }
+        if rebalance_complete(&status, rebalance_id).unwrap_or(false) {
+            return Ok(("completed_before_stop", status));
+        }
+        if Instant::now() >= deadline {
+            return Err(format!(
+                "rebalance {rebalance_id} reached neither stopped nor completed within {TERMINAL_TRANSITION_TIMEOUT:?}: {status}"
+            )
+            .into());
+        }
+        sleep(Duration::from_millis(500)).await;
+    }
+}
+
+/// G-REB: rebalance with concurrent PUT/GET/DELETE and the scanner running;
+/// stop mid-run, verify no content error and no lost acknowledged version,
+/// restart the cluster, then rebalance to completion.
+#[tokio::test]
+async fn scanner_heal_topology_rebalance_survives_live_writes_stop_and_restart() -> TestResult {
+    init_logging();
+    let mut run = TopologyRun::start("rebalance").await?;
+    let manifest = seed_manifest(&run).await?;
+    assert_bucket_durability_strict(&run.dist.cluster, &manifest.buckets()).await?;
+    verify_from_every_node(&run.dist, &manifest, "seeded").await?;
+    let scratch = unique_bucket("sht-scratch");
+    run.dist.create_bucket(&scratch).await?;
+    expand_and_verify(&mut run, &manifest).await?;
+
+    let baseline: Vec<(String, String)> = manifest
+        .plain_entries()
+        .filter(|entry| matches!(entry.shape, "inline" | "external" | "special"))
+        .map(|entry| (entry.key.clone(), entry.sha256.clone()))
+        .collect();
+
+    let first_id = start_rebalance(&run.dist.cluster).await?;
+    wait_for_rebalance_active(&run.dist.cluster, &first_id, MOVEMENT_ACTIVE_TIMEOUT).await?;
+    let during_rebalance = put_probe_objects(&run.dist, &scratch, "during-rebalance", 4).await?;
+    let workload = tokio::spawn(run_live_workload(LiveWorkload {
+        clients: run.dist.clients()?,
+        bucket: scratch.clone(),
+        prefix: "live".to_string(),
+        writers: LIVE_WRITERS,
+        rounds: LIVE_ROUNDS,
+        baseline_bucket: manifest.plain_bucket.clone(),
+        baseline: baseline.clone(),
+        pause: Duration::from_millis(100),
+    }));
+    sleep(Duration::from_secs(2)).await;
+    stop_rebalance(&run.dist.cluster).await?;
+    let (first_outcome, first_status) = wait_for_rebalance_stopped_or_completed(&run, &first_id).await?;
+    let ops = workload.await??;
+    let live_state = expected_live_state(&ops);
+
+    for node_idx in 0..run.dist.cluster.nodes.len() {
+        let client = run.dist.client(node_idx)?;
+        verify_manifest(&client, &manifest, &format!("after rebalance {first_outcome} via node {node_idx}")).await?;
+        verify_live_state(
+            &client,
+            &scratch,
+            &live_state,
+            &format!("after rebalance {first_outcome} via node {node_idx}"),
+        )
+        .await?;
+    }
+    let retained_after_stop = assert_held_by_some_pool(&run, &manifest, &format!("after rebalance {first_outcome}"))?;
+    let during_placement = assert_probe_objects(
+        &run.dist,
+        &scratch,
+        &during_rebalance,
+        &pools(&TARGET_POOLS),
+        "writes issued while the seed pool was rebalancing must avoid it",
+    )
+    .await?;
+
+    run.dist.restart_current_binary_gracefully().await?;
+    assert_every_node_serves(&run.dist, &scratch, "after-stop-restart").await?;
+    verify_from_every_node(&run.dist, &manifest, "after restart following the stop").await?;
+    verify_live_state(&run.dist.client(0)?, &scratch, &live_state, "after restart following the stop").await?;
+
+    let second_id = start_rebalance(&run.dist.cluster).await?;
+    wait_for_rebalance_active(&run.dist.cluster, &second_id, MOVEMENT_ACTIVE_TIMEOUT).await?;
+    wait_for_rebalance_complete(&run.dist.cluster, &second_id, MOVEMENT_COMPLETE_TIMEOUT).await?;
+    verify_from_every_node(&run.dist, &manifest, "after the second rebalance completed").await?;
+    verify_live_state(&run.dist.client(3)?, &scratch, &live_state, "after the second rebalance completed").await?;
+    let final_placement =
+        assert_single_pool_placement(&run.dist, &manifest, &pools(&ALL_POOLS), "after the second rebalance completed")?;
+    let moved = final_placement.values().filter(|pool| **pool != SEED_POOL).count();
+    if moved == 0 {
+        return Err("rebalance completed without moving any manifest version off the seed pool".into());
+    }
+    let strict_nodes = assert_process_durability_strict(&run.node_log_paths())?;
+
+    run.write_evidence(
+        "g-reb-rebalance",
+        &json!({
+            "gate": "G-REB",
+            "manifest": manifest_summary(&manifest),
+            "first_run": { "id": first_id, "outcome": first_outcome, "status": first_status, "versions_held_by_two_pools_after_stop": retained_after_stop },
+            "second_run": { "id": second_id, "versions_off_seed_pool": moved },
+            "live_ops": ops,
+            "probe_placement_during_rebalance": during_placement,
+            "process_durability_strict_nodes": strict_nodes,
+            "timeouts": timeouts(),
+        }),
+    )?;
+    Ok(())
+}
+
+/// G-DEC: cancel an active decommission and keep every version; queue two
+/// pools, retire them in order, reject retiring the last active pools, and
+/// keep listings, history, markers and locks correct across a restart.
+#[tokio::test]
+async fn scanner_heal_topology_decommission_queue_cancel_resume_and_last_pool_guard() -> TestResult {
+    init_logging();
+    let mut run = TopologyRun::start("decommission").await?;
+    let manifest = seed_manifest(&run).await?;
+    assert_bucket_durability_strict(&run.dist.cluster, &manifest.buckets()).await?;
+    verify_from_every_node(&run.dist, &manifest, "seeded").await?;
+    let scratch = unique_bucket("sht-scratch");
+    run.dist.create_bucket(&scratch).await?;
+    expand_and_verify(&mut run, &manifest).await?;
+
+    start_decommission(&run.dist.cluster, DECOMMISSION_POOL_ID).await?;
+    wait_for_decommission_running_with_progress(&run.dist.cluster, DECOMMISSION_POOL_ID, MOVEMENT_ACTIVE_TIMEOUT).await?;
+    cancel_decommission(&run.dist.cluster, DECOMMISSION_POOL_ID).await?;
+    let canceled =
+        wait_for_decommission_flag(&run.dist.cluster, DECOMMISSION_POOL_ID, "canceled", TERMINAL_TRANSITION_TIMEOUT).await?;
+    let after_cancel = wait_for_single_pool_placement(&run, &manifest, &pools(&ALL_POOLS), "after cancel").await?;
+    verify_from_every_node(&run.dist, &manifest, "after cancel").await?;
+    clear_decommission(&run.dist.cluster, DECOMMISSION_POOL_ID).await?;
+
+    start_decommission_targets(&run.dist.cluster, "0,1").await?;
+    let queued = wait_for_decommission_flag(&run.dist.cluster, 1, "queued", Duration::from_secs(5)).await?;
+    wait_for_decommission_active(&run.dist.cluster, 0, MOVEMENT_ACTIVE_TIMEOUT).await?;
+    let during = put_probe_objects(&run.dist, &scratch, "during-decommission", 4).await?;
+    wait_for_decommission_complete(&run.dist.cluster, 0, MOVEMENT_COMPLETE_TIMEOUT).await?;
+    wait_for_decommission_complete(&run.dist.cluster, 1, MOVEMENT_COMPLETE_TIMEOUT).await?;
+    let (rejected_status, rejected_body) = expect_decommission_rejected(&run.dist.cluster, "2,3").await?;
+    verify_from_every_node(&run.dist, &manifest, "after retiring pools 0 and 1").await?;
+    let final_placement = assert_single_pool_placement(&run.dist, &manifest, &pools(&[2, 3]), "after retiring pools 0 and 1")?;
+    assert_probe_objects(&run.dist, &scratch, &during, &pools(&[2, 3]), "writes issued during decommission").await?;
+    let sidecars = assert_sidecars_survive_on_targets(&run, &manifest, &pools(&[2, 3]), "after retiring pools 0 and 1")?;
+
+    // A decommissioned pool must leave the command line; the server refuses to
+    // start while it is still listed. Pools 2 and 3 are renumbered to 0 and 1.
+    run.dist.remove_retired_pools_and_restart(&[0, 1]).await?;
+    let pools_after_restart = pool_count(&run.dist.cluster).await?;
+    if pools_after_restart != 2 {
+        return Err(format!("expected two pools after removing the retired pools, found {pools_after_restart}").into());
+    }
+    verify_from_every_node(&run.dist, &manifest, "after restart without the retired pools").await?;
+    assert_single_pool_placement(&run.dist, &manifest, &pools(&[0, 1]), "after restart without the retired pools")?;
+    let status_after_restart = decommission_status_json(&run.dist.cluster).await?;
+    let strict_nodes = assert_process_durability_strict(&run.node_log_paths())?;
+
+    run.write_evidence(
+        "g-dec-decommission",
+        &json!({
+            "gate": "G-DEC",
+            "manifest": manifest_summary(&manifest),
+            "cancel": canceled,
+            "placement_after_cancel_pools": after_cancel.values().collect::<BTreeSet<_>>(),
+            "queued_pool_1": queued,
+            "final_placement_pools": final_placement.values().collect::<BTreeSet<_>>(),
+            "sidecars_on_targets": sidecars,
+            "last_pool_rejection": { "status": rejected_status.as_u16(), "body": rejected_body },
+            "status_after_restart": status_after_restart,
+            "process_durability_strict_nodes": strict_nodes,
+            "timeouts": timeouts(),
+        }),
+    )?;
+    Ok(())
+}
+
+/// Outcome of a fault case: the worker result and the data verdict are
+/// reported separately so a fail-closed worker and a lost version never hide
+/// each other.
+async fn settle_decommission(
+    run: &TopologyRun,
+    manifest: &TopologyManifest,
+    label: &str,
+    completion_timeout: Duration,
+) -> TestResult<Value> {
+    let completion = wait_for_decommission_complete(&run.dist.cluster, DECOMMISSION_POOL_ID, completion_timeout).await;
+    let allowed = if completion.is_ok() {
+        pools(&TARGET_POOLS)
+    } else {
+        pools(&ALL_POOLS)
+    };
+    let integrity = async {
+        verify_from_every_node(&run.dist, manifest, label).await?;
+        wait_for_single_pool_placement(run, manifest, &allowed, label).await
+    }
+    .await;
+    let status = decommission_status_json(&run.dist.cluster).await.unwrap_or(Value::Null);
+    settle(label, completion, integrity, status)
+}
+
+async fn settle_rebalance(run: &TopologyRun, manifest: &TopologyManifest, rebalance_id: &str, label: &str) -> TestResult<Value> {
+    let completion = wait_for_rebalance_complete(&run.dist.cluster, rebalance_id, MOVEMENT_COMPLETE_TIMEOUT).await;
+    let integrity = async {
+        verify_from_every_node(&run.dist, manifest, label).await?;
+        wait_for_single_pool_placement(run, manifest, &pools(&ALL_POOLS), label).await
+    }
+    .await;
+    let status = rebalance_status_json(&run.dist.cluster).await.unwrap_or(Value::Null);
+    settle(label, completion, integrity, status)
+}
+
+fn settle(
+    label: &str,
+    completion: TestResult,
+    integrity: TestResult<std::collections::BTreeMap<String, usize>>,
+    status: Value,
+) -> TestResult<Value> {
+    match (completion, integrity) {
+        (Ok(()), Ok(placement)) => {
+            Ok(json!({ "worker": "completed", "placement_pools": placement.values().collect::<BTreeSet<_>>(), "status": status }))
+        }
+        (Err(worker), Ok(_)) => {
+            Err(format!("{label}: data stayed intact but the worker did not complete: {worker}; status {status}").into())
+        }
+        (Ok(()), Err(data)) => Err(format!("{label}: worker completed but data diverged: {data}").into()),
+        (Err(worker), Err(data)) => {
+            Err(format!("{label}: worker did not complete: {worker}; and data diverged: {data}; status {status}").into())
+        }
+    }
+}
+
+fn record(run: &TopologyRun, case: &str, outcome: &TestResult<Value>, mut evidence: Value) -> TestResult {
+    evidence["outcome"] = match outcome {
+        Ok(detail) => detail.clone(),
+        Err(error) => json!({ "error": error.to_string() }),
+    };
+    run.write_evidence(case, &evidence)?;
+    Ok(())
+}
+
+/// G-DEC fault: SIGKILL the decommission leader while an entry is held after
+/// its target commit and before source cleanup; the resumed worker must
+/// finish without losing or duplicating the version.
+#[tokio::test]
+async fn scanner_heal_topology_decommission_kill_before_source_cleanup_resumes_without_loss() -> TestResult {
+    init_logging();
+    require_test_hooks();
+    let mut run = TopologyRun::start("decom-kill").await?;
+    let manifest = seed_manifest(&run).await?;
+    verify_from_every_node(&run.dist, &manifest, "seeded").await?;
+    expand_and_verify(&mut run, &manifest).await?;
+
+    let key = manifest.plain_key("external", 3)?;
+    run.movement_barrier
+        .arm_movement("decommission", &manifest.plain_bucket, &key, STAGE_BEFORE_SOURCE_CLEANUP)?;
+    start_decommission(&run.dist.cluster, DECOMMISSION_POOL_ID).await?;
+    let reached = run
+        .movement_barrier
+        .wait_reached_during(
+            &run.dist.cluster,
+            MovementOperation::Decommission(DECOMMISSION_POOL_ID),
+            MOVEMENT_COMPLETE_TIMEOUT,
+        )
+        .await?;
+    let window = pools_holding(&run.dist, &manifest.plain_bucket, &key, None)?;
+    if !window.contains(&SEED_POOL) || window.len() < 2 {
+        return Err(format!(
+            "barrier window did not show a committed target beside the retained source for {key}: pools {window:?}"
+        )
+        .into());
+    }
+
+    let killed_pid = run.kill_node(SEED_POOL)?;
+    run.movement_barrier.disarm()?;
+    let restarted_pid = run.restart_killed_node(SEED_POOL).await?;
+    let label = "after the killed leader resumed decommission";
+    let outcome = settle_decommission(&run, &manifest, label, DECOMMISSION_RESUME_COMPLETE_TIMEOUT).await;
+    let strict_nodes = assert_process_durability_strict(&run.node_log_paths());
+    record(
+        &run,
+        "g-dec-kill-before-source-cleanup",
+        &outcome,
+        json!({
+            "gate": "G-DEC",
+            "window": STAGE_BEFORE_SOURCE_CLEANUP,
+            "nonce": run.movement_barrier.nonce(),
+            "object": key,
+            "reached": reached,
+            "pools_holding_at_window": window,
+            "killed_pid": killed_pid,
+            "restarted_pid": restarted_pid,
+            "process_durability_strict_nodes": strict_nodes.as_ref().ok(),
+            "timeouts": timeouts(),
+        }),
+    )?;
+    outcome?;
+    strict_nodes?;
+    Ok(())
+}
+
+/// G-DEC fault: inject a target commit failure after the multipart copy is
+/// staged; the source must stay authoritative and a later attempt completes.
+#[tokio::test]
+async fn scanner_heal_topology_decommission_target_commit_failure_retains_source() -> TestResult {
+    init_logging();
+    require_test_hooks();
+    let mut run = TopologyRun::start("decom-target-fail").await?;
+    let manifest = seed_manifest(&run).await?;
+    verify_from_every_node(&run.dist, &manifest, "seeded").await?;
+    expand_and_verify(&mut run, &manifest).await?;
+
+    let key = manifest.plain_key("multipart", 0)?;
+    run.movement_barrier
+        .arm_movement("decommission", &manifest.plain_bucket, &key, STAGE_BEFORE_TARGET_COMMIT)?;
+    start_decommission(&run.dist.cluster, DECOMMISSION_POOL_ID).await?;
+    let reached = run
+        .movement_barrier
+        .wait_reached_during(
+            &run.dist.cluster,
+            MovementOperation::Decommission(DECOMMISSION_POOL_ID),
+            MOVEMENT_COMPLETE_TIMEOUT,
+        )
+        .await?;
+    let window = pools_holding(&run.dist, &manifest.plain_bucket, &key, None)?;
+    if window != pools(&[SEED_POOL]) {
+        return Err(format!("the target must not be published before its commit; {key} is held by {window:?}").into());
+    }
+    run.movement_barrier.disarm()?;
+    run.movement_barrier.release_movement_with_io_error()?;
+
+    let label = "after the failed target commit was retried";
+    let outcome = settle_decommission(&run, &manifest, label, MOVEMENT_COMPLETE_TIMEOUT).await;
+    let strict_nodes = assert_process_durability_strict(&run.node_log_paths());
+    record(
+        &run,
+        "g-dec-target-commit-failure",
+        &outcome,
+        json!({
+            "gate": "G-DEC",
+            "window": STAGE_BEFORE_TARGET_COMMIT,
+            "nonce": run.movement_barrier.nonce(),
+            "object": key,
+            "reached": reached,
+            "injection": "io_error",
+            "process_durability_strict_nodes": strict_nodes.as_ref().ok(),
+            "timeouts": timeouts(),
+        }),
+    )?;
+    outcome?;
+    strict_nodes?;
+    Ok(())
+}
+
+/// G-DEC fault: kill the leader after the decommission start transaction is
+/// durable in `pool.bin` but before the admin request is acknowledged and
+/// before any worker starts; the persisted responsibility must resume on restart.
+#[tokio::test]
+async fn scanner_heal_topology_decommission_kill_after_responsibility_persisted_before_ack_resumes() -> TestResult {
+    init_logging();
+    require_test_hooks();
+    let mut run = TopologyRun::start("decom-ack").await?;
+    let manifest = seed_manifest(&run).await?;
+    verify_from_every_node(&run.dist, &manifest, "seeded").await?;
+    expand_and_verify(&mut run, &manifest).await?;
+
+    run.movement_barrier
+        .arm_movement("decommission_start", ".rustfs.sys", "pool.bin", STAGE_AFTER_RESPONSIBILITY_PERSISTED)?;
+    let leader_url = run.dist.cluster.nodes[SEED_POOL].url.clone();
+    let access_key = run.dist.cluster.access_key.clone();
+    let secret_key = run.dist.cluster.secret_key.clone();
+    let start_request = tokio::spawn(async move {
+        // Mirror start_decommission: the init stage answers 500 with the fleet
+        // proof marker until the fleet has proven its capability.
+        let path = format!("/rustfs/admin/v3/pools/decommission?pool={DECOMMISSION_POOL_ID}&by-id=true");
+        // A busy movement gate answers a retryable 503; keep retrying within
+        // the window budget so a refused start is never read as a reached window.
+        let deadline = Instant::now() + PRE_ACK_REACH_TIMEOUT;
+        loop {
+            match admin_request(&leader_url, Method::POST, &path, None, &access_key, &secret_key).await {
+                Ok((status, body))
+                    if (status.as_u16() == 503
+                        || (status.as_u16() == 500 && body.contains("requires a live fleet capability proof")))
+                        && Instant::now() < deadline =>
+                {
+                    sleep(Duration::from_secs(1)).await;
+                }
+                Ok((status, body)) => return Ok(format!("{status} {body}")),
+                Err(error) => return Err(error.to_string()),
+            }
+        }
+    });
+    // The start request normally reaches the durable save within about a
+    // second. If it returns first the window was never entered; if it stays in
+    // flight past the budget, the start path itself stalled before the save.
+    let requested_at = Instant::now();
+    let mut start_request = start_request;
+    let reached = tokio::select! {
+        reached = run.movement_barrier.wait_reached(PRE_ACK_REACH_TIMEOUT) => match reached {
+            Ok(reached) => reached,
+            Err(error) => {
+                return Err(format!(
+                    "the decommission start stayed in flight for {PRE_ACK_REACH_TIMEOUT:?} without reaching the durable start save: {error}"
+                )
+                .into());
+            }
+        },
+        finished = &mut start_request => {
+            return Err(format!("the decommission start returned before the pre-ACK window was reached: {:?}", finished?).into());
+        }
+    };
+    let reach_elapsed = requested_at.elapsed();
+    let killed_pid = run.kill_node(SEED_POOL)?;
+    let start_outcome = start_request.await?;
+    if let Ok(response) = &start_outcome {
+        return Err(format!(
+            "the decommission start was acknowledged ({response}) although the leader was killed in the pre-ACK window"
+        )
+        .into());
+    }
+    run.movement_barrier.disarm()?;
+    let restarted_pid = run.restart_killed_node(SEED_POOL).await?;
+
+    let label = "after the persisted decommission resumed";
+    let resumed = wait_for_decommission_active(&run.dist.cluster, DECOMMISSION_POOL_ID, Duration::from_secs(60)).await;
+    let outcome = match resumed {
+        Ok(()) => settle_decommission(&run, &manifest, label, DECOMMISSION_RESUME_COMPLETE_TIMEOUT).await,
+        Err(error) => Err(format!("{label}: the persisted decommission did not become active after the restart: {error}").into()),
+    };
+    let strict_nodes = assert_process_durability_strict(&run.node_log_paths());
+    record(
+        &run,
+        "g-dec-kill-before-ack",
+        &outcome,
+        json!({
+            "gate": "G-DEC",
+            "window": STAGE_AFTER_RESPONSIBILITY_PERSISTED,
+            "nonce": run.movement_barrier.nonce(),
+            "reached": reached,
+            "reach_elapsed_ms": reach_elapsed.as_millis() as u64,
+            "start_request": { "outcome": "uncertain", "error": start_outcome.err() },
+            "killed_pid": killed_pid,
+            "restarted_pid": restarted_pid,
+            "process_durability_strict_nodes": strict_nodes.as_ref().ok(),
+            "timeouts": timeouts(),
+        }),
+    )?;
+    outcome?;
+    strict_nodes?;
+    Ok(())
+}
+
+/// G-REB fault: SIGKILL the rebalancing node while an entry is held after its
+/// target commit and before source cleanup; the resumed run must complete
+/// without losing or duplicating the version.
+#[tokio::test]
+async fn scanner_heal_topology_rebalance_kill_before_source_cleanup_resumes_without_loss() -> TestResult {
+    init_logging();
+    require_test_hooks();
+    let mut run = TopologyRun::start("rebal-kill").await?;
+    let manifest = seed_manifest(&run).await?;
+    verify_from_every_node(&run.dist, &manifest, "seeded").await?;
+    expand_and_verify(&mut run, &manifest).await?;
+
+    let key = manifest.plain_key("empty", 0)?;
+    run.movement_barrier
+        .arm_movement("rebalance", &manifest.plain_bucket, &key, STAGE_BEFORE_SOURCE_CLEANUP)?;
+    let rebalance_id = start_rebalance(&run.dist.cluster).await?;
+    let reached = run
+        .movement_barrier
+        .wait_reached_during(&run.dist.cluster, MovementOperation::Rebalance(&rebalance_id), MOVEMENT_COMPLETE_TIMEOUT)
+        .await?;
+    let window = pools_holding(&run.dist, &manifest.plain_bucket, &key, None)?;
+    if !window.contains(&SEED_POOL) || window.len() < 2 {
+        return Err(format!(
+            "barrier window did not show a committed target beside the retained source for {key}: pools {window:?}"
+        )
+        .into());
+    }
+
+    let killed_pid = run.kill_node(SEED_POOL)?;
+    run.movement_barrier.disarm()?;
+    let restarted_pid = run.restart_killed_node(SEED_POOL).await?;
+    let label = "after the killed node resumed rebalance";
+    let outcome = settle_rebalance(&run, &manifest, &rebalance_id, label).await;
+    let strict_nodes = assert_process_durability_strict(&run.node_log_paths());
+    record(
+        &run,
+        "g-reb-kill-before-source-cleanup",
+        &outcome,
+        json!({
+            "gate": "G-REB",
+            "window": STAGE_BEFORE_SOURCE_CLEANUP,
+            "nonce": run.movement_barrier.nonce(),
+            "object": key,
+            "reached": reached,
+            "pools_holding_at_window": window,
+            "rebalance_id": rebalance_id,
+            "killed_pid": killed_pid,
+            "restarted_pid": restarted_pid,
+            "process_durability_strict_nodes": strict_nodes.as_ref().ok(),
+            "timeouts": timeouts(),
+        }),
+    )?;
+    outcome?;
+    strict_nodes?;
+    Ok(())
+}

crates/e2e_test/src/distributed/versioning_test.rs

@@ -17,6 +17,14 @@ use crate::common::init_logging;
 use aws_sdk_s3::error::ProvideErrorMetadata;
 use aws_sdk_s3::types::{BucketVersioningStatus, VersioningConfiguration};
 
+#[tokio::test]
+async fn four_node_explicit_delete_marker_batch_is_immediately_visible() -> TestResult {
+    init_logging();
+    let dist = DistCluster::start(DistLayout::FourByFour).await?;
+    let bucket = unique_bucket("explicit-marker-batch");
+    crate::delete_objects_versioning_test::assert_explicit_marker_batch_cleanup(&dist.clients()?, &bucket).await
+}
+
 #[tokio::test]
 async fn four_node_four_drive_versioning_put_list_get_delete_marker() -> TestResult {
     init_logging();

crates/e2e_test/src/dual_stack_differential/compare.rs

@@ -0,0 +1,512 @@
+// 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.
+
+//! What one stack answered, and how two answers are compared.
+//!
+//! An [`Observation`] keeps only what a client acts on: the HTTP status, the S3 error code, the
+//! allowlisted response headers and a few typed fields decoded from the response. The error
+//! message is kept for diagnostics and never compared: message wording is judged by the wire
+//! corpus, not here. The comparator is pure so it can be tested without a server.
+
+use serde::Serialize;
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::{Path, PathBuf};
+
+/// Response headers compared exactly (after [`normalized_header_value`]).
+const HEADER_ALLOWLIST: [&str; 7] = [
+    "content-type",
+    "x-amz-version-id",
+    "etag",
+    "x-amz-delete-marker",
+    "content-range",
+    "accept-ranges",
+    "x-amz-request-charged",
+];
+
+/// Every response header with this prefix is compared as well.
+const HEADER_ALLOWLIST_PREFIX: &str = "x-amz-server-side-encryption";
+
+/// Placeholder for a field one side did not send.
+const ABSENT: &str = "<absent>";
+
+/// The lowercase header name if the comparator looks at this header.
+pub(crate) fn compared_header(name: &str) -> Option<String> {
+    let name = name.to_ascii_lowercase();
+    (HEADER_ALLOWLIST.contains(&name.as_str()) || name.starts_with(HEADER_ALLOWLIST_PREFIX)).then_some(name)
+}
+
+/// A version ID is minted per process, so its value never matches across two servers; only
+/// whether it is the literal `null` (an unversioned write) carries meaning.
+fn normalized_header_value(name: &str, value: &str) -> String {
+    if name == "x-amz-version-id" && value != "null" {
+        "<version-id>".to_owned()
+    } else {
+        value.to_owned()
+    }
+}
+
+/// One request's outcome as a client sees it.
+#[derive(Clone, Debug, Serialize)]
+pub(crate) struct Observation {
+    /// The S3 operation, named as in the `s3s::S3` trait (`GetObject`).
+    pub op: &'static str,
+    /// Which request of the script this was (`normal`, `negative`, or a setup label).
+    pub case: &'static str,
+    /// HTTP status; 0 when no response arrived.
+    pub status: u16,
+    /// The S3 error code, or the SDK's error kind when there was no service error.
+    pub error_code: Option<String>,
+    /// Allowlisted headers only, lowercase names, normalized values.
+    pub headers: BTreeMap<String, String>,
+    /// Typed values decoded from the response body, never free text.
+    pub fields: BTreeMap<String, String>,
+    /// Diagnostic only; never compared.
+    #[serde(skip)]
+    pub message: Option<String>,
+}
+
+impl Observation {
+    /// Builds an observation, keeping only the allowlisted headers.
+    pub(crate) fn new<'h>(
+        op: &'static str,
+        case: &'static str,
+        status: u16,
+        error_code: Option<String>,
+        headers: impl IntoIterator<Item = (&'h str, &'h str)>,
+    ) -> Self {
+        let headers = headers
+            .into_iter()
+            .filter_map(|(name, value)| compared_header(name).map(|name| (name, value)))
+            .map(|(name, value)| {
+                let value = normalized_header_value(&name, value);
+                (name, value)
+            })
+            .collect();
+        Self {
+            op,
+            case,
+            status,
+            error_code,
+            headers,
+            fields: BTreeMap::new(),
+            message: None,
+        }
+    }
+
+    pub(crate) fn with_field(mut self, name: &str, value: impl Into<String>) -> Self {
+        self.fields.insert(name.to_owned(), value.into());
+        self
+    }
+
+    pub(crate) fn is_success(&self) -> bool {
+        (200..300).contains(&self.status)
+    }
+}
+
+/// One field on which the two stacks answered differently.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+pub(crate) struct Difference {
+    pub op: String,
+    pub case: String,
+    pub field: String,
+    pub a: String,
+    pub b: String,
+}
+
+/// Every difference between two transcripts of the same script, matched by `(op, case)`.
+pub(crate) fn compare(a: &[Observation], b: &[Observation]) -> Vec<Difference> {
+    let mut differences = Vec::new();
+    let (index_a, duplicates_a) = index(a);
+    let (index_b, duplicates_b) = index(b);
+    for (op, case) in duplicates_a.union(&duplicates_b) {
+        let count = |side: &[Observation]| {
+            side.iter()
+                .filter(|observation| (observation.op, observation.case) == (*op, *case))
+                .count()
+                .to_string()
+        };
+        differences.push(difference(op, case, "duplicate_case", count(a), count(b)));
+    }
+    let keys: BTreeSet<_> = index_a.keys().chain(index_b.keys()).copied().collect();
+    for key @ (op, case) in keys {
+        match (index_a.get(&key), index_b.get(&key)) {
+            (Some(a), Some(b)) => compare_one(a, b, &mut differences),
+            (a, b) => {
+                let presence = |side: Option<&&Observation>| if side.is_some() { "present" } else { ABSENT }.to_owned();
+                differences.push(difference(op, case, "observation", presence(a), presence(b)));
+            }
+        }
+    }
+    differences
+}
+
+type Key = (&'static str, &'static str);
+
+fn index(side: &[Observation]) -> (BTreeMap<Key, &Observation>, BTreeSet<Key>) {
+    let mut index = BTreeMap::new();
+    let mut duplicates = BTreeSet::new();
+    for observation in side {
+        let key = (observation.op, observation.case);
+        if index.insert(key, observation).is_some() {
+            duplicates.insert(key);
+        }
+    }
+    (index, duplicates)
+}
+
+fn difference(op: &str, case: &str, field: &str, a: String, b: String) -> Difference {
+    Difference {
+        op: op.to_owned(),
+        case: case.to_owned(),
+        field: field.to_owned(),
+        a,
+        b,
+    }
+}
+
+fn compare_one(a: &Observation, b: &Observation, differences: &mut Vec<Difference>) {
+    let mut field = |name: String, value_a: Option<&str>, value_b: Option<&str>| {
+        if value_a != value_b {
+            let show = |value: Option<&str>| value.unwrap_or(ABSENT).to_owned();
+            differences.push(difference(a.op, a.case, &name, show(value_a), show(value_b)));
+        }
+    };
+    field(
+        "status".to_owned(),
+        Some(a.status.to_string().as_str()),
+        Some(b.status.to_string().as_str()),
+    );
+    field("error_code".to_owned(), a.error_code.as_deref(), b.error_code.as_deref());
+    let headers: BTreeSet<_> = a.headers.keys().chain(b.headers.keys()).collect();
+    for name in headers {
+        field(
+            format!("header.{name}"),
+            a.headers.get(name).map(String::as_str),
+            b.headers.get(name).map(String::as_str),
+        );
+    }
+    let fields: BTreeSet<_> = a.fields.keys().chain(b.fields.keys()).collect();
+    for name in fields {
+        field(
+            format!("body.{name}"),
+            a.fields.get(name).map(String::as_str),
+            b.fields.get(name).map(String::as_str),
+        );
+    }
+}
+
+/// Operations observed on both sides.
+pub(crate) fn compared_ops(a: &[Observation], b: &[Observation]) -> BTreeSet<&'static str> {
+    let ops_b: BTreeSet<_> = b.iter().map(|observation| observation.op).collect();
+    a.iter()
+        .map(|observation| observation.op)
+        .filter(|op| ops_b.contains(op))
+        .collect()
+}
+
+/// `(op, case)` pairs observed on both sides.
+pub(crate) fn compared_cases(a: &[Observation], b: &[Observation]) -> usize {
+    let cases_b: BTreeSet<_> = b.iter().map(|observation| (observation.op, observation.case)).collect();
+    a.iter()
+        .map(|observation| (observation.op, observation.case))
+        .collect::<BTreeSet<_>>()
+        .intersection(&cases_b)
+        .count()
+}
+
+/// The JSON report written for every run.
+#[derive(Debug, Serialize)]
+pub(crate) struct Report {
+    pub schema: u32,
+    pub run: String,
+    pub stack_a: String,
+    pub stack_b: String,
+    pub region_a: Option<String>,
+    pub region_b: Option<String>,
+    pub compared_ops: usize,
+    pub compared_cases: usize,
+    pub differences: Vec<Difference>,
+}
+
+impl Report {
+    /// Writes the report as `<directory>/<run>.json` and returns its path.
+    pub(crate) fn write_to(&self, directory: &Path) -> std::io::Result<PathBuf> {
+        std::fs::create_dir_all(directory)?;
+        let path = directory.join(format!("{}.json", self.run));
+        let json = serde_json::to_vec_pretty(self).map_err(std::io::Error::other)?;
+        std::fs::write(&path, json)?;
+        Ok(path)
+    }
+}
+
+/// One line per difference, for a failing assertion.
+pub(crate) fn render(differences: &[Difference]) -> String {
+    differences
+        .iter()
+        .map(|d| format!("({}, {}, {}, a={:?}, b={:?})", d.op, d.case, d.field, d.a, d.b))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ok(op: &'static str) -> Observation {
+        Observation::new(op, "normal", 200, None, [("content-type", "application/xml")])
+    }
+
+    fn fields(differences: &[Difference]) -> Vec<&str> {
+        differences.iter().map(|d| d.field.as_str()).collect()
+    }
+
+    #[test]
+    fn identical_transcripts_have_no_difference() {
+        let a = vec![
+            ok("HeadBucket"),
+            ok("GetBucketLocation").with_field("location_constraint", "us-east-1"),
+        ];
+        let b = a.clone();
+        assert_eq!(compare(&a, &b), Vec::new());
+        assert_eq!(compared_ops(&a, &b).len(), 2);
+    }
+
+    #[test]
+    fn a_status_difference_is_reported() {
+        let a = vec![ok("PutBucketAcl")];
+        let b = vec![Observation::new(
+            "PutBucketAcl",
+            "normal",
+            403,
+            None,
+            [("content-type", "application/xml")],
+        )];
+        assert_eq!(
+            compare(&a, &b),
+            vec![Difference {
+                op: "PutBucketAcl".into(),
+                case: "normal".into(),
+                field: "status".into(),
+                a: "200".into(),
+                b: "403".into(),
+            }]
+        );
+    }
+
+    #[test]
+    fn an_error_code_difference_is_reported() {
+        let a = vec![Observation::new("GetObject", "negative", 404, Some("NoSuchKey".into()), [])];
+        let b = vec![Observation::new(
+            "GetObject",
+            "negative",
+            404,
+            Some("NoSuchBucket".into()),
+            [],
+        )];
+        let differences = compare(&a, &b);
+        assert_eq!(fields(&differences), ["error_code"]);
+        assert_eq!((differences[0].a.as_str(), differences[0].b.as_str()), ("NoSuchKey", "NoSuchBucket"));
+    }
+
+    #[test]
+    fn an_error_code_on_one_side_only_is_reported() {
+        let a = vec![Observation::new("HeadBucket", "negative", 404, Some("NotFound".into()), [])];
+        let b = vec![Observation::new("HeadBucket", "negative", 404, None, [])];
+        let differences = compare(&a, &b);
+        assert_eq!(fields(&differences), ["error_code"]);
+        assert_eq!(differences[0].b, ABSENT);
+    }
+
+    #[test]
+    fn an_allowlisted_header_difference_is_reported() {
+        let a = vec![Observation::new("HeadObject", "normal", 200, None, [("ETag", "\"aa\"")])];
+        let b = vec![Observation::new("HeadObject", "normal", 200, None, [("etag", "\"bb\"")])];
+        assert_eq!(fields(&compare(&a, &b)), ["header.etag"]);
+    }
+
+    #[test]
+    fn a_header_sent_by_one_side_only_is_reported() {
+        let a = vec![Observation::new(
+            "DeleteObject",
+            "normal",
+            204,
+            None,
+            [("x-amz-delete-marker", "true")],
+        )];
+        let b = vec![Observation::new("DeleteObject", "normal", 204, None, [])];
+        let differences = compare(&a, &b);
+        assert_eq!(fields(&differences), ["header.x-amz-delete-marker"]);
+        assert_eq!((differences[0].a.as_str(), differences[0].b.as_str()), ("true", ABSENT));
+    }
+
+    #[test]
+    fn every_server_side_encryption_header_is_compared() {
+        let header = "x-amz-server-side-encryption-customer-key-md5";
+        let a = vec![Observation::new("PutObject", "sse-c", 200, None, [(header, "one")])];
+        let b = vec![Observation::new("PutObject", "sse-c", 200, None, [(header, "two")])];
+        assert_eq!(fields(&compare(&a, &b)), [format!("header.{header}")]);
+    }
+
+    #[test]
+    fn headers_outside_the_allowlist_are_not_compared() {
+        let a = vec![Observation::new(
+            "ListBuckets",
+            "normal",
+            200,
+            None,
+            [
+                ("date", "Mon"),
+                ("x-amz-request-id", "1"),
+                ("server", "a"),
+                ("content-length", "10"),
+            ],
+        )];
+        let b = vec![Observation::new(
+            "ListBuckets",
+            "normal",
+            200,
+            None,
+            [
+                ("date", "Tue"),
+                ("x-amz-request-id", "2"),
+                ("server", "b"),
+                ("content-length", "11"),
+            ],
+        )];
+        assert_eq!(compare(&a, &b), Vec::new());
+        assert!(a[0].headers.is_empty(), "non-allowlisted headers were kept: {:?}", a[0].headers);
+    }
+
+    #[test]
+    fn distinct_version_ids_are_not_a_difference() {
+        let a = vec![Observation::new(
+            "PutObject",
+            "normal",
+            200,
+            None,
+            [("x-amz-version-id", "0b1c")],
+        )];
+        let b = vec![Observation::new(
+            "PutObject",
+            "normal",
+            200,
+            None,
+            [("x-amz-version-id", "9f8e")],
+        )];
+        assert_eq!(compare(&a, &b), Vec::new());
+    }
+
+    #[test]
+    fn a_null_version_id_against_a_real_one_is_reported() {
+        let a = vec![Observation::new(
+            "PutObject",
+            "normal",
+            200,
+            None,
+            [("x-amz-version-id", "null")],
+        )];
+        let b = vec![Observation::new(
+            "PutObject",
+            "normal",
+            200,
+            None,
+            [("x-amz-version-id", "9f8e")],
+        )];
+        assert_eq!(fields(&compare(&a, &b)), ["header.x-amz-version-id"]);
+    }
+
+    #[test]
+    fn a_body_field_difference_is_reported() {
+        let a = vec![ok("GetBucketLocation").with_field("location_constraint", "us-east-1")];
+        let b = vec![ok("GetBucketLocation").with_field("location_constraint", "eu-west-1")];
+        let differences = compare(&a, &b);
+        assert_eq!(fields(&differences), ["body.location_constraint"]);
+        assert_eq!((differences[0].a.as_str(), differences[0].b.as_str()), ("us-east-1", "eu-west-1"));
+    }
+
+    #[test]
+    fn a_body_field_on_one_side_only_is_reported() {
+        let a = vec![ok("ListObjectsV2").with_field("keys", "[]")];
+        let b = vec![ok("ListObjectsV2")];
+        assert_eq!(fields(&compare(&a, &b)), ["body.keys"]);
+    }
+
+    #[test]
+    fn error_messages_are_never_compared() {
+        let mut a = Observation::new("GetObject", "negative", 404, Some("NoSuchKey".into()), []);
+        let mut b = a.clone();
+        a.message = Some("The specified key does not exist.".into());
+        b.message = Some("Object not found".into());
+        assert_eq!(compare(&[a], &[b]), Vec::new());
+    }
+
+    #[test]
+    fn a_case_observed_on_one_side_only_is_reported() {
+        let a = vec![ok("HeadBucket"), ok("ListBuckets")];
+        let b = vec![ok("HeadBucket")];
+        let differences = compare(&a, &b);
+        assert_eq!(fields(&differences), ["observation"]);
+        assert_eq!(differences[0].op, "ListBuckets");
+        assert_eq!(compared_ops(&a, &b).into_iter().collect::<Vec<_>>(), ["HeadBucket"]);
+    }
+
+    #[test]
+    fn a_case_recorded_twice_is_reported() {
+        let a = vec![ok("HeadBucket"), ok("HeadBucket")];
+        let b = vec![ok("HeadBucket")];
+        assert_eq!(fields(&compare(&a, &b)), ["duplicate_case"]);
+    }
+
+    #[test]
+    fn compared_ops_counts_operations_not_cases() {
+        let negative = Observation::new("HeadBucket", "negative", 404, Some("NotFound".into()), []);
+        let a = vec![ok("HeadBucket"), negative, ok("ListBuckets")];
+        let b = a.clone();
+        assert_eq!(compared_ops(&a, &b).len(), 2);
+    }
+
+    #[test]
+    fn the_report_lists_each_difference_as_op_field_a_b() {
+        let directory = std::env::temp_dir().join(format!("dual-stack-report-{}", uuid::Uuid::new_v4()));
+        let report = Report {
+            schema: 1,
+            run: "unit".into(),
+            stack_a: "legacy".into(),
+            stack_b: "legacy".into(),
+            region_a: None,
+            region_b: Some("eu-west-1".into()),
+            compared_ops: 1,
+            compared_cases: 1,
+            differences: compare(
+                &[ok("GetBucketLocation").with_field("location_constraint", "us-east-1")],
+                &[ok("GetBucketLocation").with_field("location_constraint", "eu-west-1")],
+            ),
+        };
+        let path = report.write_to(&directory).expect("write the report");
+        let json: serde_json::Value = serde_json::from_slice(&std::fs::read(&path).expect("read the report")).expect("parse");
+        let _ = std::fs::remove_dir_all(&directory);
+        assert_eq!(path.file_name().and_then(|name| name.to_str()), Some("unit.json"));
+        assert_eq!(json["compared_ops"], 1);
+        assert_eq!(
+            json["differences"],
+            serde_json::json!([{
+                "op": "GetBucketLocation",
+                "case": "normal",
+                "field": "body.location_constraint",
+                "a": "us-east-1",
+                "b": "eu-west-1",
+            }])
+        );
+    }
+}

crates/e2e_test/src/dual_stack_differential/mod.rs

@@ -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.
+
+//! Dual-stack differential: one `rustfs` binary, two processes, one SDK script (rustfs/backlog#2740).
+//!
+//! Stack A always runs `RUSTFS_S3_STACK=legacy`. Stack B runs the value of `RUSTFS_E2E_STACK_B`
+//! (default `legacy` until the gateway stack is assembled), and `RUSTFS_E2E_STACK_B_REGION`, when
+//! set, starts B in another region so that a difference can be injected by hand. Both servers
+//! answer the script in `scenarios`, which covers every operation of `impl S3 for FS`; `compare`
+//! reports each `(op, field, a, b)` on which the answers differ, and every run writes its report
+//! to `<target>/dual-stack/<run>.json`. Two processes, not two embedded servers: bucket metadata
+//! is process-global, so two stacks in one process would read each other's buckets.
+
+mod compare;
+mod scenarios;
+
+use crate::common::{RustFSTestEnvironment, init_logging, workspace_root};
+use compare::{Difference, Observation, Report, compare, compared_cases, compared_ops, render};
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+type BoxError = Box<dyn std::error::Error + Send + Sync>;
+
+const STACK_A: &str = "legacy";
+const ENV_STACK_B: &str = "RUSTFS_E2E_STACK_B";
+const ENV_STACK_B_REGION: &str = "RUSTFS_E2E_STACK_B_REGION";
+/// Becomes `gateway` once rustfs/backlog#2734 T2.5 assembles the gateway stack.
+const DEFAULT_STACK_B: &str = "legacy";
+/// The region the negative control gives stack A explicitly, so an inherited `RUSTFS_REGION`
+/// cannot erase the injected difference. Not `us-east-1`: that region answers GetBucketLocation
+/// with an empty LocationConstraint and re-creating an owned bucket with 200, so it would not
+/// report its own name and would add CreateBucket differences to the control.
+const CONTROL_REGION_A: &str = "us-west-2";
+const CONTROL_REGION_B: &str = "eu-west-1";
+/// `normal` cases the legacy stack must answer with a 2xx. The comparison alone cannot tell a
+/// script that exercises real behavior from one in which both stacks fail the same way. Five of
+/// the 73 fail on legacy by design of this script: PutBucketReplication (no registered remote
+/// target), GetBucketReplication (so no configuration), PutBucketNotificationConfiguration (no
+/// notification target configured), RestoreObject (the object is not archived) and
+/// GetObjectTorrent (legacy answers `NoSuchKey`).
+const MIN_NORMAL_SUCCESSES: usize = 68;
+
+struct PairConfig {
+    stack_b: String,
+    region_a: Option<String>,
+    region_b: Option<String>,
+}
+
+impl PairConfig {
+    fn from_env() -> Self {
+        Self {
+            stack_b: std::env::var(ENV_STACK_B).unwrap_or_else(|_| DEFAULT_STACK_B.to_owned()),
+            region_a: None,
+            region_b: std::env::var(ENV_STACK_B_REGION).ok(),
+        }
+    }
+}
+
+/// Starts one server on `stack`, overriding its region only when asked.
+async fn start_stack(stack: &str, region: Option<&str>) -> Result<RustFSTestEnvironment, BoxError> {
+    let mut env = RustFSTestEnvironment::new().await?;
+    let mut vars = vec![("RUSTFS_S3_STACK", stack)];
+    if let Some(region) = region {
+        vars.push(("RUSTFS_REGION", region));
+    }
+    env.start_rustfs_server_without_cleanup_with_env(&vars).await?;
+    Ok(env)
+}
+
+/// Starts stack A and stack B side by side, each with its own port and data directory.
+async fn spawn_pair(config: &PairConfig) -> Result<(RustFSTestEnvironment, RustFSTestEnvironment), BoxError> {
+    tokio::try_join!(
+        start_stack(STACK_A, config.region_a.as_deref()),
+        start_stack(&config.stack_b, config.region_b.as_deref())
+    )
+}
+
+fn report_directory() -> PathBuf {
+    let target = std::env::var_os("CARGO_TARGET_DIR").map_or_else(|| PathBuf::from("target"), PathBuf::from);
+    let target = if target.is_absolute() {
+        target
+    } else {
+        workspace_root().join(target)
+    };
+    target.join("dual-stack")
+}
+
+struct Run {
+    report: Report,
+    path: PathBuf,
+    a: Vec<Observation>,
+}
+
+/// Runs the script against both stacks concurrently and writes the report.
+async fn run_differential(label: &str, config: &PairConfig) -> Run {
+    let (server_a, server_b) = spawn_pair(config).await.expect("start stack A and stack B");
+    let (a, b) = tokio::join!(Box::pin(scenarios::run(&server_a)), Box::pin(scenarios::run(&server_b)));
+    let millis = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_or(0, |elapsed| elapsed.as_millis());
+    let report = Report {
+        schema: 1,
+        run: format!("{label}-{millis}-{}", std::process::id()),
+        stack_a: STACK_A.to_owned(),
+        stack_b: config.stack_b.clone(),
+        region_a: config.region_a.clone(),
+        region_b: config.region_b.clone(),
+        compared_ops: compared_ops(&a, &b).len(),
+        compared_cases: compared_cases(&a, &b),
+        differences: compare(&a, &b),
+    };
+    let path = report.write_to(&report_directory()).expect("write the dual-stack report");
+    Run { report, path, a }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn both_stacks_answer_every_operation_identically() {
+        init_logging();
+        let config = PairConfig::from_env();
+        let run = run_differential("self-comparison", &config).await;
+        let report = &run.report;
+
+        let mut observed: Vec<_> = run.a.iter().map(|observation| observation.op).collect();
+        observed.sort_unstable();
+        observed.dedup();
+        assert_eq!(
+            observed,
+            scenarios::OPERATIONS,
+            "the script must drive exactly the operations of impl S3 for FS"
+        );
+        assert_eq!(report.compared_ops, scenarios::OPERATIONS.len(), "report: {}", run.path.display());
+        assert!(
+            report.differences.is_empty(),
+            "stack {} and stack {} differ on {} of {} cases (report: {}):\n{}",
+            report.stack_a,
+            report.stack_b,
+            report.differences.len(),
+            report.compared_cases,
+            run.path.display(),
+            render(&report.differences)
+        );
+
+        let not_4xx: Vec<_> = run
+            .a
+            .iter()
+            .filter(|observation| observation.case == "negative" && !(400..500).contains(&observation.status))
+            .collect();
+        assert!(not_4xx.is_empty(), "negative cases must fail with a 4xx on {STACK_A}: {not_4xx:#?}");
+        let successes = run
+            .a
+            .iter()
+            .filter(|observation| observation.case == "normal" && observation.is_success())
+            .count();
+        assert!(
+            successes >= MIN_NORMAL_SUCCESSES,
+            "only {successes} normal cases succeeded on {STACK_A}: {:#?}",
+            run.a
+        );
+    }
+
+    #[tokio::test]
+    async fn differential_detects_an_injected_difference() {
+        init_logging();
+        let config = PairConfig {
+            stack_b: STACK_A.to_owned(),
+            region_a: Some(CONTROL_REGION_A.to_owned()),
+            region_b: Some(CONTROL_REGION_B.to_owned()),
+        };
+        let run = run_differential("injected-region", &config).await;
+        let expected = Difference {
+            op: "GetBucketLocation".to_owned(),
+            case: "normal".to_owned(),
+            field: "body.location_constraint".to_owned(),
+            a: CONTROL_REGION_A.to_owned(),
+            b: CONTROL_REGION_B.to_owned(),
+        };
+        assert!(
+            run.report.differences.contains(&expected),
+            "B started in {CONTROL_REGION_B} but GetBucketLocation was not reported (report: {}):\n{}",
+            run.path.display(),
+            render(&run.report.differences)
+        );
+    }
+}

crates/e2e_test/src/lib.rs

@@ -31,6 +31,12 @@ pub mod chaos;
 #[cfg(test)]
 pub mod fake_s3_target;
 
+// Dual-stack differential (rustfs/backlog#2740): one binary, two processes on
+// different RUSTFS_S3_STACK values, the same SDK script for every S3 operation,
+// compared on status, error code, allowlisted headers and typed body fields.
+#[cfg(test)]
+mod dual_stack_differential;
+
 // On-demand migration (backlog#2147): shared two-server environment, admin
 // wrappers, and the harness self-test (backlog#2151). Behavior scenarios are
 // added by later ODM tasks.
@@ -45,6 +51,9 @@ pub mod on_demand_migration;
 #[cfg(test)]
 pub mod fault_proxy;
 
+#[cfg(test)]
+mod rpc_fault_proxy;
+
 // Reliability tests built on the fault-injection harness
 #[cfg(test)]
 mod reliability_disk_fault_test;

crates/e2e_test/src/multipart_copy_readiness_test.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! Harbor / Docker Distribution multipart staging to CopyObject regressions.
+//! Multipart completion validation, staging preservation, and CopyObject readiness.
 
 use crate::common::{RustFSTestEnvironment, init_logging};
 use aws_sdk_s3::error::ProvideErrorMetadata;
@@ -39,6 +39,132 @@ fn list_contains_key(output: &aws_sdk_s3::operation::list_objects_v2::ListObject
         .any(|object| object.key().is_some_and(|candidate| candidate == key))
 }
 
+#[tokio::test]
+async fn multipart_complete_invalid_etag_returns_400_and_preserves_retry() -> Result<(), Box<dyn Error + Send + Sync>> {
+    init_logging();
+    let mut env = RustFSTestEnvironment::new().await?;
+    env.start_rustfs_server(vec![]).await?;
+    let client = env.create_s3_client();
+    let bucket = "multipart-invalid-etag";
+    let key = "object";
+    env.create_test_bucket(bucket).await?;
+    let original = b"original object";
+    client
+        .put_object()
+        .bucket(bucket)
+        .key(key)
+        .body(ByteStream::from_static(original))
+        .send()
+        .await?;
+    let upload = client.create_multipart_upload().bucket(bucket).key(key).send().await?;
+    let upload_id = upload.upload_id().ok_or("missing upload id")?;
+    let payload = b"completed multipart payload";
+    let mut uploaded_etag = None;
+
+    // The first case reproduces #8771's Create -> Complete sequence without UploadPart.
+    for (upload_first, part_number, etag) in [
+        (false, 1, Some("unknown-etag")),
+        (true, 1, Some("unknown-etag")),
+        (true, 1, Some("\"unknown-etag\"")),
+        (true, 1, Some("00000000000000000000000000000000")),
+        (true, 1, None),
+        (true, 2, Some("unknown-etag")),
+    ] {
+        if upload_first && uploaded_etag.is_none() {
+            let part = client
+                .upload_part()
+                .bucket(bucket)
+                .key(key)
+                .upload_id(upload_id)
+                .part_number(1)
+                .body(ByteStream::from_static(payload))
+                .send()
+                .await?;
+            uploaded_etag = Some(part.e_tag().ok_or("missing part ETag")?.to_owned());
+        }
+        let error = client
+            .complete_multipart_upload()
+            .bucket(bucket)
+            .key(key)
+            .upload_id(upload_id)
+            .multipart_upload(
+                CompletedMultipartUpload::builder()
+                    .parts(
+                        CompletedPart::builder()
+                            .part_number(part_number)
+                            .set_e_tag(etag.map(str::to_owned))
+                            .build(),
+                    )
+                    .build(),
+            )
+            .send()
+            .await
+            .expect_err("missing or mismatched parts must not complete the upload");
+        assert_eq!(error.raw_response().map(|response| response.status().as_u16()), Some(400), "{error:?}");
+        assert_eq!(
+            error.as_service_error().and_then(ProvideErrorMetadata::code),
+            Some("InvalidPart"),
+            "{error:?}"
+        );
+
+        let staged = client
+            .list_parts()
+            .bucket(bucket)
+            .key(key)
+            .upload_id(upload_id)
+            .send()
+            .await?;
+        assert_eq!(staged.parts().len(), usize::from(uploaded_etag.is_some()));
+        if let Some(etag) = uploaded_etag.as_deref() {
+            assert_eq!(staged.parts()[0].part_number(), Some(1));
+            assert_eq!(staged.parts()[0].e_tag(), Some(etag));
+        }
+        let current = client
+            .get_object()
+            .bucket(bucket)
+            .key(key)
+            .send()
+            .await?
+            .body
+            .collect()
+            .await?
+            .into_bytes();
+        assert_eq!(current.as_ref(), original, "rejected completion must preserve the original object");
+    }
+
+    let etag = uploaded_etag.ok_or("part was not uploaded")?;
+    // Accept the unquoted value, then replay with the quoted UploadPart response.
+    for etag in [etag.trim_matches('"'), etag.as_str()] {
+        client
+            .complete_multipart_upload()
+            .bucket(bucket)
+            .key(key)
+            .upload_id(upload_id)
+            .multipart_upload(
+                CompletedMultipartUpload::builder()
+                    .parts(CompletedPart::builder().part_number(1).e_tag(etag).build())
+                    .build(),
+            )
+            .send()
+            .await?;
+    }
+    let current = client
+        .get_object()
+        .bucket(bucket)
+        .key(key)
+        .send()
+        .await?
+        .body
+        .collect()
+        .await?
+        .into_bytes();
+    assert_eq!(current.as_ref(), payload, "a valid retry must publish the exact uploaded bytes");
+    client.delete_object().bucket(bucket).key(key).send().await?;
+    env.delete_test_bucket(bucket).await?;
+    env.stop_server();
+    Ok(())
+}
+
 async fn upload_one_part_mpu(
     client: &aws_sdk_s3::Client,
     bucket: &str,

crates/e2e_test/src/negative_sigv4_test.rs

@@ -230,6 +230,302 @@ fn encode_unsigned_aws_chunked_with_sha256_trailer(decoded: &[u8]) -> Vec<u8> {
     encoded
 }
 
+/// Sign the data and terminating chunks independently of the server decoder.
+fn encode_signed_aws_chunked(signer: &SigV4, headers: &SignedHeaders, decoded: &[u8], trailer: bool) -> Vec<u8> {
+    let mut previous = headers
+        .authorization
+        .rsplit_once("Signature=")
+        .expect("seed signature")
+        .1
+        .to_string();
+    let mut encoded = Vec::new();
+    for chunk in [decoded, b"".as_slice()] {
+        let string_to_sign = format!(
+            "AWS4-HMAC-SHA256-PAYLOAD\n{}\n{}\n{previous}\n{}\n{}",
+            headers.amz_date,
+            get_scope(REGION, signer.time, "s3"),
+            sha256_hex(b""),
+            sha256_hex(chunk),
+        );
+        previous = get_signature(get_signing_key(&signer.secret_key, REGION, signer.time, "s3"), &string_to_sign);
+        encoded.extend_from_slice(format!("{:x};chunk-signature={previous}\r\n", chunk.len()).as_bytes());
+        encoded.extend_from_slice(chunk);
+        encoded.extend_from_slice(b"\r\n");
+    }
+    if trailer {
+        let checksum = sha256_base64(decoded);
+        let canonical = format!("x-amz-checksum-sha256:{checksum}\n");
+        let string_to_sign = format!(
+            "AWS4-HMAC-SHA256-TRAILER\n{}\n{}\n{previous}\n{}",
+            headers.amz_date,
+            get_scope(REGION, signer.time, "s3"),
+            sha256_hex(canonical.as_bytes()),
+        );
+        let signature = get_signature(get_signing_key(&signer.secret_key, REGION, signer.time, "s3"), &string_to_sign);
+        encoded.extend_from_slice(
+            format!("x-amz-checksum-sha256:{checksum}\r\nx-amz-trailer-signature:{signature}\r\n\r\n").as_bytes(),
+        );
+    }
+    encoded
+}
+
+/// Exercise decoder failures through both storage publication boundaries.
+#[tokio::test]
+async fn aws_chunked_named_errors_reject_put_and_upload_part() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let mut env = RustFSTestEnvironment::new().await?;
+    setup(&mut env).await?;
+    let client = env.create_s3_client();
+    let decoded = b"private-chunked-fixture-body";
+    let mut failures = Vec::new();
+    for multipart in [false, true] {
+        for (case, expected_status, expected_code) in [
+            ("signature", 403, "SignatureDoesNotMatch"),
+            ("final-signature", 403, "SignatureDoesNotMatch"),
+            ("format", 400, "IncompleteBody"),
+            ("metadata-at-limit", 400, "IncompleteBody"),
+            ("metadata-over-limit", 400, "EntityTooLarge"),
+            ("chunk-over-limit", 400, "EntityTooLarge"),
+            ("trailers-over-limit", 400, "IncompleteBody"),
+            ("too-many-trailers", 400, "IncompleteBody"),
+        ] {
+            let key = format!("chunked-{case}-{multipart}.bin");
+            let upload_id = if multipart {
+                Some(
+                    client
+                        .create_multipart_upload()
+                        .bucket(BUCKET)
+                        .key(&key)
+                        .send()
+                        .await?
+                        .upload_id()
+                        .ok_or("missing upload ID")?
+                        .to_owned(),
+                )
+            } else {
+                None
+            };
+            let query = upload_id
+                .as_ref()
+                .map(|id| format!("partNumber=1&uploadId={}", urlencoding::encode(id)))
+                .unwrap_or_default();
+            let path = format!("/{BUCKET}/{key}");
+            let target = if query.is_empty() {
+                path.clone()
+            } else {
+                format!("{path}?{query}")
+            };
+            let signer = SigV4::new(&env);
+            let unsigned = matches!(case, "trailers-over-limit" | "too-many-trailers");
+            let mode = if unsigned {
+                UNSIGNED_PAYLOAD_TRAILER
+            } else {
+                "STREAMING-AWS4-HMAC-SHA256-PAYLOAD"
+            };
+            let length = decoded.len().to_string();
+            let mut extra = vec![
+                ("content-encoding", "aws-chunked"),
+                ("x-amz-decoded-content-length", length.as_str()),
+            ];
+            if unsigned {
+                extra.push(("x-amz-trailer", "x-amz-checksum-sha256"));
+            }
+            let headers = signer.sign_with_extra_headers("PUT", &path, &query, mode, &extra);
+            let encoded = match case {
+                "signature" | "final-signature" => {
+                    let mut body = encode_signed_aws_chunked(&signer, &headers, decoded, false);
+                    let offset = if case == "signature" {
+                        body.windows(2).position(|w| w == b"\r\n").expect("chunk header") + 2
+                    } else {
+                        body.len() - 5
+                    };
+                    body[offset] = if body[offset] == b'a' { b'b' } else { b'a' };
+                    body
+                }
+                "format" => b"invalid-chunk-size\r\n".to_vec(),
+                "metadata-at-limit" | "metadata-over-limit" => {
+                    let size = if case == "metadata-at-limit" { 1024 } else { 1025 };
+                    let mut body = vec![b'z'; size - 2];
+                    body.extend_from_slice(b"\r\n");
+                    body
+                }
+                "chunk-over-limit" => format!("10000001;chunk-signature={}\r\n", "0".repeat(64)).into_bytes(),
+                "trailers-over-limit" | "too-many-trailers" => {
+                    let mut body = format!("{:x}\r\n", decoded.len()).into_bytes();
+                    body.extend_from_slice(decoded);
+                    body.extend_from_slice(b"\r\n0\r\n");
+                    if case == "trailers-over-limit" {
+                        body.extend_from_slice(format!("x-private:{}\r\n\r\n", "v".repeat(16385 - 14)).as_bytes());
+                    } else {
+                        body.extend_from_slice("x-private:v\r\n".repeat(101).as_bytes());
+                        body.extend_from_slice(b"\r\n");
+                    }
+                    body
+                }
+                _ => unreachable!("all fixtures are enumerated"),
+            };
+            let mut request = local_http_client()
+                .put(format!("{}{target}", env.url))
+                .header("authorization", &headers.authorization)
+                .header("x-amz-content-sha256", &headers.content_sha256)
+                .header("x-amz-date", &headers.amz_date);
+            for (name, value) in extra {
+                request = request.header(name, value);
+            }
+            let response = request
+                .body(encoded)
+                .timeout(std::time::Duration::from_secs(20))
+                .send()
+                .await?;
+            let status = response.status().as_u16();
+            let body = response.text().await?;
+            eprintln!("aws-chunked {case} multipart={multipart}: HTTP {status}, {body}");
+            if status != expected_status || !body.contains(&format!("<Code>{expected_code}</Code>")) {
+                failures.push(format!(
+                    "{case} multipart={multipart}: expected {expected_status} {expected_code}, got {status} {body}"
+                ));
+            }
+            for private in [
+                "private-chunked-fixture-body",
+                "chunk-signature=",
+                "AwsChunkedStreamError",
+                "x-private",
+            ] {
+                if body.contains(private) {
+                    failures.push(format!("{case}: response exposed {private}"));
+                }
+            }
+            if let Some(id) = upload_id {
+                let parts = client.list_parts().bucket(BUCKET).key(&key).upload_id(&id).send().await?;
+                assert!(parts.parts().is_empty(), "{case}: rejected UploadPart published a part");
+                client
+                    .abort_multipart_upload()
+                    .bucket(BUCKET)
+                    .key(&key)
+                    .upload_id(id)
+                    .send()
+                    .await?;
+            }
+            let absent = client
+                .get_object()
+                .bucket(BUCKET)
+                .key(&key)
+                .send()
+                .await
+                .expect_err("a rejected body must not publish an object");
+            assert_eq!(absent.as_service_error().and_then(ProvideErrorMetadata::code), Some("NoSuchKey"));
+        }
+    }
+    assert!(failures.is_empty(), "{}", failures.join("\n"));
+    Ok(())
+}
+
+#[tokio::test]
+async fn aws_chunked_valid_signed_and_trailer_boundaries_succeed() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let mut env = RustFSTestEnvironment::new().await?;
+    setup(&mut env).await?;
+    let client = env.create_s3_client();
+    let decoded = b"valid-chunked-control";
+    for (case, multipart) in ["signed", "signed-trailer", "trailer-size-limit", "trailer-count-limit"]
+        .into_iter()
+        .flat_map(|case| [false, true].map(|multipart| (case, multipart)))
+    {
+        let key = format!("{case}-{multipart}");
+        let upload_id = if multipart {
+            Some(
+                client
+                    .create_multipart_upload()
+                    .bucket(BUCKET)
+                    .key(&key)
+                    .send()
+                    .await?
+                    .upload_id()
+                    .ok_or("missing upload ID")?
+                    .to_owned(),
+            )
+        } else {
+            None
+        };
+        let query = upload_id
+            .as_ref()
+            .map(|id| format!("partNumber=1&uploadId={}", urlencoding::encode(id)))
+            .unwrap_or_default();
+        let signer = SigV4::new(&env);
+        let path = format!("/{BUCKET}/{key}");
+        let target = if query.is_empty() {
+            path.clone()
+        } else {
+            format!("{path}?{query}")
+        };
+        let length = decoded.len().to_string();
+        let mode = match case {
+            "signed" => "STREAMING-AWS4-HMAC-SHA256-PAYLOAD",
+            "signed-trailer" => "STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER",
+            _ => UNSIGNED_PAYLOAD_TRAILER,
+        };
+        let mut extra = vec![
+            ("content-encoding", "aws-chunked"),
+            ("x-amz-decoded-content-length", length.as_str()),
+        ];
+        if case != "signed" {
+            extra.push(("x-amz-trailer", "x-amz-checksum-sha256"));
+        }
+        let headers = signer.sign_with_extra_headers("PUT", &path, &query, mode, &extra);
+        let mut encoded = if case.starts_with("signed") {
+            encode_signed_aws_chunked(&signer, &headers, decoded, case == "signed-trailer")
+        } else {
+            encode_unsigned_aws_chunked_with_sha256_trailer(decoded)
+        };
+        if !case.starts_with("signed") {
+            encoded.truncate(encoded.len() - 2);
+            if case == "trailer-size-limit" {
+                let checksum_line_size = format!("x-amz-checksum-sha256:{}\r\n", sha256_base64(decoded)).len();
+                encoded.extend_from_slice(format!("x-padding:{}\r\n", "v".repeat(16384 - checksum_line_size - 14)).as_bytes());
+            } else {
+                encoded.extend_from_slice("x-padding:v\r\n".repeat(99).as_bytes());
+            }
+            encoded.extend_from_slice(b"\r\n");
+        }
+        let mut request = local_http_client()
+            .put(format!("{}{target}", env.url))
+            .header("authorization", &headers.authorization)
+            .header("x-amz-content-sha256", &headers.content_sha256)
+            .header("x-amz-date", &headers.amz_date);
+        for (name, value) in extra {
+            request = request.header(name, value);
+        }
+        let response = request
+            .body(encoded)
+            .timeout(std::time::Duration::from_secs(20))
+            .send()
+            .await?;
+        let status = response.status();
+        let etag = response
+            .headers()
+            .get("etag")
+            .and_then(|value| value.to_str().ok())
+            .map(str::to_owned);
+        let body = response.text().await?;
+        assert_eq!(status.as_u16(), 200, "{case}: {body}");
+        if let Some(id) = upload_id {
+            let part = aws_sdk_s3::types::CompletedPart::builder()
+                .part_number(1)
+                .e_tag(etag.ok_or("successful UploadPart omitted ETag")?)
+                .build();
+            client
+                .complete_multipart_upload()
+                .bucket(BUCKET)
+                .key(&key)
+                .upload_id(id)
+                .multipart_upload(aws_sdk_s3::types::CompletedMultipartUpload::builder().parts(part).build())
+                .send()
+                .await?;
+        }
+        let object = client.get_object().bucket(BUCKET).key(&key).send().await?;
+        assert_eq!(object.body.collect().await?.into_bytes().as_ref(), decoded, "{case}");
+    }
+    Ok(())
+}
+
 /// Positive control: a correctly hand-signed request must succeed. Without
 /// this, every negative assertion below could pass for the wrong reason (a
 /// broken signer that never produces a valid signature).
@@ -566,47 +862,54 @@ async fn tampered_payload_is_rejected() -> Result<(), Box<dyn std::error::Error
     let mut env = RustFSTestEnvironment::new().await?;
     setup(&mut env).await?;
 
-    let key = "tampered-payload.txt";
-    let path = format!("/{BUCKET}/{key}");
-    let claimed_body = b"the-body-i-claim-to-send";
-    let actual_body = b"the-body-i-really-send!!";
-    assert_eq!(claimed_body.len(), actual_body.len(), "keep content-length stable for the mismatch");
+    use md5::{Digest, Md5};
 
     let signer = SigV4::new(&env);
-    // Sign over the hash of the CLAIMED body (single-chunk payload hash), then
-    // send a different body of equal length.
-    let headers = signer.sign("PUT", &path, "", &sha256_hex(claimed_body));
-
-    let result = send_signed(&env, reqwest::Method::PUT, &path, &headers, Some(actual_body.to_vec())).await;
-    match result {
-        Ok(resp) => {
-            let status = resp.status();
-            let body = resp.text().await.unwrap_or_default();
+    let client = env.create_s3_client();
+    // Empty, small-eager, zero-copy, and streaming PUTs must share the error contract.
+    for size in [0, 24, 2 * 1024 * 1024, 17 * 1024 * 1024] {
+        let actual_body = vec![b'a'; size];
+        let wrong_hash = sha256_hex(b"a different payload");
+        let content_md5 = base64_simd::STANDARD.encode_to_string(Md5::digest(&actual_body));
+        for with_md5 in [false, true] {
+            let key = format!("tampered-payload-{size}-{with_md5}.txt");
+            let path = format!("/{BUCKET}/{key}");
+            let extra = if with_md5 {
+                vec![("content-md5", content_md5.as_str())]
+            } else {
+                vec![]
+            };
+            let headers = signer.sign_with_extra_headers("PUT", &path, "", &wrong_hash, &extra);
+            let mut request = local_http_client()
+                .put(format!("{}{}", env.url, path))
+                .header("x-amz-date", &headers.amz_date)
+                .header("x-amz-content-sha256", &headers.content_sha256)
+                .header("authorization", &headers.authorization);
+            for (name, value) in extra {
+                request = request.header(name, value);
+            }
+            let response = request.body(actual_body.clone()).send().await?;
+            let status = response.status();
+            let body = response.text().await?;
+            assert_eq!(status, reqwest::StatusCode::BAD_REQUEST, "payload mismatch: {body}");
+            assert_error_code(&body, "XAmzContentSHA256Mismatch");
             assert!(
-                status.is_client_error(),
-                "payload mismatch must be rejected with a client error, got {status}, body:\n{body}"
+                body.replace("&apos;", "'")
+                    .contains("<Message>The provided 'x-amz-content-sha256' header does not match what was computed.</Message>"),
+                "wrong message: {body}"
             );
-            info!(%status, "tampered payload rejected with error status");
-        }
-        // A mid-stream hash-mismatch abort surfacing as a transport error is
-        // also a valid rejection (definitely not a 200 success).
-        Err(err) => {
-            assert!(!err.is_connect(), "connection failure is not proof of payload rejection: {err}");
-            assert!(!err.is_timeout(), "request timeout is not proof of payload rejection: {err}");
-            info!(%err, "tampered payload rejected via mid-stream transport error");
+
+            let absent = client
+                .get_object()
+                .bucket(BUCKET)
+                .key(&key)
+                .send()
+                .await
+                .expect_err("a tampered payload must not publish an object");
+            assert_eq!(absent.raw_response().map(|response| response.status().as_u16()), Some(404));
+            assert_eq!(absent.as_service_error().and_then(ProvideErrorMetadata::code), Some("NoSuchKey"));
         }
     }
-
-    let absent = env
-        .create_s3_client()
-        .get_object()
-        .bucket(BUCKET)
-        .key(key)
-        .send()
-        .await
-        .expect_err("a tampered payload must not publish an object");
-    assert_eq!(absent.raw_response().map(|response| response.status().as_u16()), Some(404));
-    assert_eq!(absent.as_service_error().and_then(ProvideErrorMetadata::code), Some("NoSuchKey"));
     Ok(())
 }
 
@@ -638,9 +941,9 @@ async fn tampered_upload_part_payload_is_rejected() -> Result<(), Box<dyn std::e
     assert_eq!(
         status,
         reqwest::StatusCode::BAD_REQUEST,
-        "multipart payload mismatch must be rejected as BadDigest, body:\n{body}"
+        "multipart payload mismatch must be rejected as XAmzContentSHA256Mismatch, body:\n{body}"
     );
-    assert_error_code(&body, "BadDigest");
+    assert_error_code(&body, "XAmzContentSHA256Mismatch");
 
     let parts = client
         .list_parts()

crates/e2e_test/src/protocols/webdav_core.rs

@@ -32,7 +32,9 @@
 //! Advisory: <https://github.com/rustfs/rustfs/security/advisories/GHSA-3p3x-734c-h5vx>
 
 use crate::common::rustfs_binary_path_with_features;
-use crate::common::{AdminTransport, admin_add_canned_policy_via, admin_attach_user_policy_via, admin_create_user_via};
+use crate::common::{
+    AdminTransport, admin_add_canned_policy_via, admin_attach_user_policy_via, admin_create_user_via, signed_s3_request,
+};
 use crate::common::{FAST_DATA_USAGE_SCANNER_ENV, admin_request};
 use crate::protocols::test_env::{DEFAULT_ACCESS_KEY, DEFAULT_SECRET_KEY, ProtocolTestEnvironment};
 use anyhow::Result;
@@ -774,6 +776,81 @@ async fn test_webdav_core_operations_direct() -> Result<()> {
     test_webdav_core_operations().await
 }
 
+#[tokio::test]
+async fn test_webdav_content_type_directory_marker() -> Result<()> {
+    let env = ProtocolTestEnvironment::new().map_err(|e| anyhow::anyhow!("{}", e))?;
+    let admin_base_url = format!("http://{}", S3_TEST_ADDRESS);
+    let binary_path = rustfs_binary_path_with_features(Some("webdav"));
+    let mut server_process = Command::new(&binary_path)
+        .arg("--address")
+        .arg(S3_TEST_ADDRESS)
+        .env("RUSTFS_CONSOLE_ENABLE", "false")
+        .env("RUSTFS_WEBDAV_ENABLE", "true")
+        .env("RUSTFS_WEBDAV_ADDRESS", WEBDAV_ADDRESS)
+        .env("RUSTFS_WEBDAV_TLS_ENABLED", "false")
+        .arg(&env.temp_dir)
+        .spawn()?;
+
+    let result = async {
+        ProtocolTestEnvironment::wait_for_port_ready(WEBDAV_PORT, 30)
+            .await
+            .map_err(|e| anyhow::anyhow!("{}", e))?;
+
+        let client = create_client();
+        let bucket_name = "webdav-content-type-bucket";
+        let directory_name = "content-type-directory";
+        let webdav_base_url = format!("http://{}", WEBDAV_ADDRESS);
+        let mkcol_bucket = client
+            .request(
+                reqwest::Method::from_bytes(b"MKCOL").expect("MKCOL is a valid HTTP method"),
+                format!("{}/{}", webdav_base_url, bucket_name),
+            )
+            .header("Authorization", basic_auth_header())
+            .send()
+            .await?;
+        anyhow::ensure!(
+            mkcol_bucket.status().is_success() || mkcol_bucket.status().as_u16() == 201,
+            "MKCOL bucket should succeed, got: {}",
+            mkcol_bucket.status()
+        );
+
+        let mkcol_directory = client
+            .request(
+                reqwest::Method::from_bytes(b"MKCOL").expect("MKCOL is a valid HTTP method"),
+                format!("{}/{}/{}", webdav_base_url, bucket_name, directory_name),
+            )
+            .header("Authorization", basic_auth_header())
+            .send()
+            .await?;
+        anyhow::ensure!(
+            mkcol_directory.status().is_success() || mkcol_directory.status().as_u16() == 201,
+            "MKCOL directory should succeed, got: {}",
+            mkcol_directory.status()
+        );
+
+        let head_url = format!("{}/{}/{}/", admin_base_url, bucket_name, directory_name);
+        let head = signed_s3_request(http::Method::HEAD, &head_url, None, None, DEFAULT_ACCESS_KEY, DEFAULT_SECRET_KEY)
+            .await
+            .map_err(|error| anyhow::anyhow!("{error}"))?;
+        anyhow::ensure!(head.status().is_success(), "HEAD directory marker should succeed, got: {}", head.status());
+        let content_type = head
+            .headers()
+            .get("content-type")
+            .and_then(|value| value.to_str().ok())
+            .unwrap_or_default();
+        anyhow::ensure!(
+            content_type == "application/x-directory",
+            "WebDAV directory marker must preserve its content type, got: {content_type}"
+        );
+        Ok(())
+    }
+    .await;
+
+    let _ = server_process.kill().await;
+    let _ = server_process.wait().await;
+    result
+}
+
 /// Extract the numeric value of the first occurrence of a DAV property in a
 /// PROPFIND multistatus body. Namespace-prefix agnostic; a self-closing
 /// (unreported) property yields None.

crates/e2e_test/src/replication_extension_test.rs

@@ -10109,6 +10109,45 @@ async fn test_scanner_compensates_existing_objects_across_write_paths() -> TestR
         .send()
         .await?;
 
+    // Multipart null-version cell: a one-part upload already carries a
+    // multipart ETag, so its replica travels the target's multipart path,
+    // whose completion must keep the null version too.
+    let multipart_null_key = "pre-versioning-null-multipart.txt";
+    let multipart_null_payload = "multipart null version payload";
+    let upload = source_client
+        .create_multipart_upload()
+        .bucket(source_bucket)
+        .key(multipart_null_key)
+        .send()
+        .await?;
+    let upload_id = upload.upload_id().ok_or("multipart upload id missing")?;
+    let part = source_client
+        .upload_part()
+        .bucket(source_bucket)
+        .key(multipart_null_key)
+        .upload_id(upload_id)
+        .part_number(1)
+        .body(ByteStream::from_static(multipart_null_payload.as_bytes()))
+        .send()
+        .await?;
+    source_client
+        .complete_multipart_upload()
+        .bucket(source_bucket)
+        .key(multipart_null_key)
+        .upload_id(upload_id)
+        .multipart_upload(
+            CompletedMultipartUpload::builder()
+                .parts(
+                    CompletedPart::builder()
+                        .part_number(1)
+                        .set_e_tag(part.e_tag().map(str::to_string))
+                        .build(),
+                )
+                .build(),
+        )
+        .send()
+        .await?;
+
     enable_bucket_versioning(&source_env, source_bucket).await?;
     enable_bucket_versioning(&target_env, target_bucket).await?;
 
@@ -10193,19 +10232,22 @@ async fn test_scanner_compensates_existing_objects_across_write_paths() -> TestR
     wait_for_replicated_object(&target_client, target_bucket, copy_key, plain_payload).await?;
     wait_for_replicated_object(&target_client, target_bucket, member_key, std::str::from_utf8(member_payload)?).await?;
 
-    // The null version converges too, and keeps its identity: the replica is
-    // the target's null version, not a freshly minted one.
-    wait_for_replicated_object(&target_client, target_bucket, null_key, null_payload).await?;
-    let null_replica = target_client
-        .get_object()
-        .bucket(target_bucket)
-        .key(null_key)
-        .version_id("null")
-        .send()
-        .await?;
-    assert_eq!(null_replica.version_id(), Some("null"));
-    let null_replica_body = null_replica.body.collect().await?.into_bytes();
-    assert_eq!(null_replica_body.as_ref(), null_payload.as_bytes());
+    // The null versions converge too, and keep their identity whichever path
+    // carried them: each replica is the target's null version, not a freshly
+    // minted one.
+    for (key, payload) in [(null_key, null_payload), (multipart_null_key, multipart_null_payload)] {
+        wait_for_replicated_object(&target_client, target_bucket, key, payload).await?;
+        let null_replica = target_client
+            .get_object()
+            .bucket(target_bucket)
+            .key(key)
+            .version_id("null")
+            .send()
+            .await?;
+        assert_eq!(null_replica.version_id(), Some("null"), "{key} must replicate as the null version");
+        let null_replica_body = null_replica.body.collect().await?.into_bytes();
+        assert_eq!(null_replica_body.as_ref(), payload.as_bytes());
+    }
 
     Ok(())
 }

crates/e2e_test/src/rpc_fault_proxy.rs

@@ -0,0 +1,572 @@
+// Copyright 2026 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.
+
+//! Method-selective faults without changing the server or gRPC body/trailers.
+
+use bytes::Bytes;
+use http_body_util::{BodyExt as _, Full, Limited, combinators::BoxBody};
+use hyper::{Request, body::Incoming, service::service_fn};
+use hyper_util::{
+    client::legacy::{Client, connect::HttpConnector},
+    rt::{TokioExecutor, TokioIo},
+    server::conn::auto,
+};
+use prost::Message as _;
+use rustfs_protos::proto_gen::node_service::DeleteRequest;
+use std::{
+    io,
+    net::SocketAddr,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicUsize, Ordering},
+    },
+    time::Duration,
+};
+use tokio::{
+    net::TcpListener,
+    sync::{Notify, watch},
+    task::{JoinHandle, JoinSet},
+};
+
+type ProxyBody = BoxBody<Bytes, io::Error>;
+type ProxyClient = Client<HttpConnector, ProxyBody>;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Disposition {
+    Hold,
+    Forward,
+    Discard,
+}
+
+struct PauseState {
+    methods: Vec<&'static str>,
+    scope: Option<Vec<u8>>,
+    limit: usize,
+    matched: AtomicUsize,
+    blocked: AtomicUsize,
+    forwarded: AtomicUsize,
+    reached: Notify,
+    release: watch::Sender<Disposition>,
+}
+
+type PauseSlot = Arc<Mutex<Option<Arc<PauseState>>>>;
+
+pub(crate) struct RpcPause {
+    state: Arc<PauseState>,
+    slot: PauseSlot,
+}
+
+impl RpcPause {
+    pub(crate) fn hits(&self) -> usize {
+        self.state.blocked.load(Ordering::SeqCst)
+    }
+
+    /// Selected RPCs whose backend returned a response, excluding discarded packets.
+    pub(crate) fn forwarded(&self) -> usize {
+        self.state.forwarded.load(Ordering::SeqCst)
+    }
+
+    pub(crate) async fn wait_for_hits(&self, count: usize) -> io::Result<()> {
+        tokio::time::timeout(Duration::from_secs(20), async {
+            loop {
+                let notified = self.state.reached.notified();
+                if self.hits() >= count {
+                    return;
+                }
+                notified.await;
+            }
+        })
+        .await
+        .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "the selected RPC fault was not reached"))
+    }
+
+    pub(crate) fn release(&self) {
+        self.settle(Disposition::Forward);
+    }
+
+    /// Retire packets that outlived the caller's operation budget. A later
+    /// healthy request must not replay an expired lock grant or mutation.
+    pub(crate) fn discard_pending(&self) {
+        self.settle(Disposition::Discard);
+    }
+
+    fn settle(&self, disposition: Disposition) {
+        self.state.release.send_if_modified(|current| {
+            if *current == Disposition::Hold {
+                *current = disposition;
+                true
+            } else {
+                false
+            }
+        });
+    }
+}
+
+impl Drop for RpcPause {
+    fn drop(&mut self) {
+        self.release();
+        let mut slot = self.slot.lock().expect("RPC pause slot");
+        if slot.as_ref().is_some_and(|current| Arc::ptr_eq(current, &self.state)) {
+            *slot = None;
+        }
+    }
+}
+
+pub(crate) struct RpcFaultProxy {
+    address: SocketAddr,
+    slot: PauseSlot,
+    task: JoinHandle<()>,
+}
+
+impl RpcFaultProxy {
+    pub(crate) async fn start_on(address: SocketAddr, target: SocketAddr) -> io::Result<Self> {
+        let listener = TcpListener::bind(address).await?;
+        let address = listener.local_addr()?;
+        let slot: PauseSlot = Arc::new(Mutex::new(None));
+        let active = slot.clone();
+        let task = tokio::spawn(async move {
+            let h1: ProxyClient = Client::builder(TokioExecutor::new()).build_http();
+            let h2: ProxyClient = Client::builder(TokioExecutor::new()).http2_only(true).build_http();
+            let mut connections = JoinSet::new();
+            loop {
+                tokio::select! {
+                    accepted = listener.accept() => {
+                        let Ok((socket, _)) = accepted else { break };
+                        let h1 = h1.clone();
+                        let h2 = h2.clone();
+                        let active = active.clone();
+                        connections.spawn(async move {
+                            let service = service_fn(move |request: Request<Incoming>| {
+                                let client = if request.version() == http::Version::HTTP_2 { h2.clone() } else { h1.clone() };
+                                let pause = active.lock().expect("RPC pause slot").clone();
+                                forward_request(request, client, target, pause)
+
+                            });
+                            let _ = auto::Builder::new(TokioExecutor::new())
+                                .serve_connection(TokioIo::new(socket), service).await;
+                        });
+                    }
+                    _ = connections.join_next(), if !connections.is_empty() => {}
+                }
+            }
+        });
+        Ok(Self { address, slot, task })
+    }
+
+    pub(crate) fn local_addr(&self) -> SocketAddr {
+        self.address
+    }
+
+    /// Pause at most limit requests to the named unary methods; other streams
+    /// on the same HTTP/2 connection continue forwarding.
+    pub(crate) fn pause(&self, methods: &[&'static str], limit: usize, scope: Option<&str>) -> io::Result<RpcPause> {
+        let mut slot = self.slot.lock().expect("RPC pause slot");
+        if slot.is_some() || methods.is_empty() || limit == 0 || scope.is_some_and(str::is_empty) {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "RPC pause needs an empty slot, methods and a positive limit",
+            ));
+        }
+        let (release, _) = watch::channel(Disposition::Hold);
+        let state = Arc::new(PauseState {
+            methods: methods.to_vec(),
+            scope: scope.map(|scope| scope.as_bytes().to_vec()),
+            limit,
+            matched: AtomicUsize::new(0),
+            blocked: AtomicUsize::new(0),
+            forwarded: AtomicUsize::new(0),
+            reached: Notify::new(),
+            release,
+        });
+        *slot = Some(state.clone());
+        Ok(RpcPause {
+            state,
+            slot: self.slot.clone(),
+        })
+    }
+}
+
+fn scope_matches(method: &str, body: &[u8], scope: &[u8]) -> io::Result<bool> {
+    if method != "Delete" {
+        return Ok(body.windows(scope.len()).any(|window| window == scope));
+    }
+    // Abort's recursive root delete must not be confused with transaction or
+    // part cleanup below that root. This is a unary, uncompressed gRPC frame.
+    if body.len() < 5 || body[0] != 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "scoped Delete needs an uncompressed unary frame",
+        ));
+    }
+    let mut encoded_length = [0; 4];
+    encoded_length.copy_from_slice(&body[1..5]);
+    if u32::try_from(body.len() - 5).ok() != Some(u32::from_be_bytes(encoded_length)) {
+        return Err(io::Error::new(io::ErrorKind::InvalidData, "scoped Delete frame length mismatch"));
+    }
+    let request = DeleteRequest::decode(&body[5..]).map_err(io::Error::other)?;
+    let options: serde_json::Value = serde_json::from_str(&request.options).map_err(io::Error::other)?;
+    Ok(request.volume == ".rustfs.sys/multipart"
+        && request.path.trim_end_matches('/').as_bytes() == scope
+        && options.get("recursive").and_then(serde_json::Value::as_bool) == Some(true))
+}
+
+async fn forward_request(
+    request: Request<Incoming>,
+    client: ProxyClient,
+    target: SocketAddr,
+    pause: Option<Arc<PauseState>>,
+) -> io::Result<hyper::Response<Incoming>> {
+    let (mut parts, body) = request.into_parts();
+    let mut body = body.map_err(io::Error::other).boxed();
+    let mut observed = None;
+    if let Some(pause) = pause {
+        let method = parts.uri.path().strip_prefix("/node_service.NodeService/");
+        if let Some(method) = method.filter(|name| pause.methods.contains(name)) {
+            let matches = if let Some(scope) = pause.scope.as_deref() {
+                // Inspect bounded routing data while retaining the exact
+                // original bytes covered by the RPC signature.
+                let collected = Limited::new(body, 1024 * 1024).collect().await.map_err(io::Error::other)?;
+                let trailers = collected.trailers().cloned();
+                let bytes = collected.to_bytes();
+                let matches = scope_matches(method, &bytes, scope)?;
+                body = Full::new(bytes)
+                    .map_err(|never| match never {})
+                    .with_trailers(async move { trailers.map(Ok::<_, io::Error>) })
+                    .boxed();
+                matches
+            } else {
+                true
+            };
+            if matches && pause.matched.fetch_add(1, Ordering::SeqCst) < pause.limit {
+                let mut released = pause.release.subscribe();
+                pause.blocked.fetch_add(1, Ordering::SeqCst);
+                pause.reached.notify_one();
+                let disposition = loop {
+                    let disposition = *released.borrow_and_update();
+                    if disposition != Disposition::Hold {
+                        break disposition;
+                    }
+                    if released.changed().await.is_err() {
+                        break Disposition::Discard;
+                    }
+                };
+                if disposition == Disposition::Discard {
+                    return Err(io::Error::new(io::ErrorKind::ConnectionAborted, "injected RPC packet loss"));
+                }
+                observed = Some(pause);
+            }
+        }
+    }
+    if !parts.headers.contains_key(http::header::HOST)
+        && let Some(authority) = parts.uri.authority()
+    {
+        parts.headers.insert(
+            http::header::HOST,
+            http::HeaderValue::from_str(authority.as_str()).map_err(io::Error::other)?,
+        );
+    }
+    parts.uri = http::Uri::builder()
+        .scheme("http")
+        .authority(target.to_string())
+        .path_and_query(parts.uri.path_and_query().map_or("/", |value| value.as_str()))
+        .build()
+        .map_err(io::Error::other)?;
+    let response = client
+        .request(Request::from_parts(parts, body))
+        .await
+        .map_err(io::Error::other)?;
+    if let Some(pause) = observed
+        && response.status().is_success()
+        && response.headers().get("grpc-status").is_none_or(|status| status == "0")
+    {
+        pause.forwarded.fetch_add(1, Ordering::SeqCst);
+    }
+    Ok(response)
+}
+
+impl Drop for RpcFaultProxy {
+    fn drop(&mut self) {
+        self.task.abort();
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http_body_util::{Full, StreamBody};
+    use hyper::{Response, body::Frame};
+    use std::convert::Infallible;
+
+    struct Backend {
+        received: Arc<AtomicUsize>,
+        address: SocketAddr,
+        task: JoinHandle<()>,
+    }
+
+    impl Drop for Backend {
+        fn drop(&mut self) {
+            self.task.abort();
+        }
+    }
+
+    async fn backend() -> io::Result<Backend> {
+        let listener = TcpListener::bind("127.0.0.1:0").await?;
+        let address = listener.local_addr()?;
+        let received = Arc::new(AtomicUsize::new(0));
+        let received_task = received.clone();
+        let task = tokio::spawn(async move {
+            let mut children = JoinSet::new();
+            loop {
+                tokio::select! {
+                    accepted = listener.accept() => {
+                        let Ok((socket, _)) = accepted else { break };
+                        let received = received_task.clone();
+                        children.spawn(async move {
+                            let service = service_fn(move |request: Request<Incoming>| {
+                                let received = received.clone();
+                                async move {
+                                received.fetch_add(1, Ordering::SeqCst);
+                                let authority = request.headers().get(http::header::HOST).cloned();
+                                let body = request.into_body().collect().await?.to_bytes();
+                                let mut trailers = http::HeaderMap::new();
+                                trailers.insert("grpc-status", http::HeaderValue::from_static("0"));
+                                trailers.insert("x-proof", http::HeaderValue::from_static("unchanged-proof"));
+                                let stream = futures::stream::iter([
+                                    Ok::<_, Infallible>(Frame::data(body)),
+                                    Ok(Frame::trailers(trailers)),
+                                ]);
+                                let mut response = Response::new(StreamBody::new(stream));
+                                response.headers_mut().insert(http::header::TRAILER, http::HeaderValue::from_static("grpc-status, x-proof"));
+                                if let Some(authority) = authority { response.headers_mut().insert("x-original-authority", authority); }
+                                Ok::<_, hyper::Error>(response)
+                            }});
+                            let _ = auto::Builder::new(TokioExecutor::new()).serve_connection(TokioIo::new(socket), service).await;
+                        });
+                    }
+                    _ = children.join_next(), if !children.is_empty() => {}
+                }
+            }
+        });
+        Ok(Backend { received, address, task })
+    }
+
+    async fn call(client: &ProxyClient, address: SocketAddr, method: &str) -> io::Result<hyper::Response<Incoming>> {
+        call_body(client, address, method, Bytes::from_static(b"opaque signed protobuf")).await
+    }
+
+    async fn call_body(
+        client: &ProxyClient,
+        address: SocketAddr,
+        method: &str,
+        bytes: Bytes,
+    ) -> io::Result<hyper::Response<Incoming>> {
+        let body: ProxyBody = Full::new(bytes).map_err(|never| match never {}).boxed();
+        let request = Request::builder()
+            .method("POST")
+            .uri(format!("http://{address}/node_service.NodeService/{method}"))
+            .header(http::header::TE, "trailers")
+            .body(body)
+            .map_err(io::Error::other)?;
+        client.request(request).await.map_err(io::Error::other)
+    }
+
+    #[tokio::test]
+    async fn preserves_protocol_authority_payload_and_grpc_trailers() {
+        tokio::time::timeout(Duration::from_secs(10), async {
+            let backend = backend().await.expect("backend listener");
+            let proxy = RpcFaultProxy::start_on("127.0.0.1:0".parse().expect("loopback address"), backend.address)
+                .await
+                .expect("proxy");
+            for h2 in [false, true] {
+                let client: ProxyClient = Client::builder(TokioExecutor::new()).http2_only(h2).build_http();
+                let response = call(&client, proxy.local_addr(), "ReadVersion")
+                    .await
+                    .expect("transparent request");
+                assert_eq!(response.version(), if h2 { http::Version::HTTP_2 } else { http::Version::HTTP_11 });
+                assert_eq!(response.headers()["x-original-authority"], proxy.local_addr().to_string());
+                let collected = response.into_body().collect().await.expect("complete body and trailers");
+                let trailers = collected.trailers().expect("gRPC trailers must survive both proxy hops");
+                assert_eq!(trailers["grpc-status"], "0");
+                assert_eq!(trailers["x-proof"], "unchanged-proof");
+                assert_eq!(collected.to_bytes(), Bytes::from_static(b"opaque signed protobuf"));
+            }
+        })
+        .await
+        .expect("transparent proxy deadline");
+    }
+
+    #[tokio::test]
+    async fn isolates_rpc_methods_limits_injection_and_releases_on_drop() {
+        tokio::time::timeout(Duration::from_secs(10), async {
+            let backend = backend().await.expect("backend listener");
+            let proxy = RpcFaultProxy::start_on("127.0.0.1:0".parse().expect("loopback address"), backend.address)
+                .await
+                .expect("proxy");
+            let client: ProxyClient = Client::builder(TokioExecutor::new()).http2_only(true).build_http();
+            let pause = proxy.pause(&["WriteMetadata"], 1, None).expect("arm one metadata request");
+            let task_client = client.clone();
+            let address = proxy.local_addr();
+            let blocked = tokio::spawn(async move { call(&task_client, address, "WriteMetadata").await });
+            pause.wait_for_hits(1).await.expect("metadata barrier reached");
+            for method in ["Lock", "WriteMetadata"] {
+                let response = call(&client, address, method)
+                    .await
+                    .expect("unselected or over-limit request must progress");
+                assert_eq!(
+                    response.into_body().collect().await.expect("forwarded body").to_bytes(),
+                    Bytes::from_static(b"opaque signed protobuf")
+                );
+            }
+            assert_eq!(pause.hits(), 1);
+            assert!(!blocked.is_finished(), "the selected request must still be held");
+            drop(pause);
+            assert_eq!(
+                blocked
+                    .await
+                    .expect("blocked request task")
+                    .expect("released request")
+                    .into_body()
+                    .collect()
+                    .await
+                    .expect("released body")
+                    .to_bytes(),
+                Bytes::from_static(b"opaque signed protobuf")
+            );
+        })
+        .await
+        .expect("selective fault deadline");
+    }
+    #[tokio::test]
+    async fn released_observer_requires_a_selected_backend_response() {
+        tokio::time::timeout(Duration::from_secs(10), async {
+            let backend = backend().await.expect("backend listener");
+            let proxy = RpcFaultProxy::start_on("127.0.0.1:0".parse().expect("loopback"), backend.address)
+                .await
+                .expect("proxy listener");
+            let client: ProxyClient = Client::builder(TokioExecutor::new()).http2_only(true).build_http();
+            let observer = proxy
+                .pause(&["Lock"], usize::MAX, Some("recovery-bucket"))
+                .expect("RPC observer");
+            let unrelated = call_body(&client, proxy.local_addr(), "Lock", Bytes::from_static(b"other-bucket"))
+                .await
+                .expect("unrelated request");
+            unrelated.into_body().collect().await.expect("unrelated body");
+            assert_eq!(observer.forwarded(), 0, "unrelated traffic cannot prove recovery");
+            let task_client = client.clone();
+            let address = proxy.local_addr();
+            let request =
+                tokio::spawn(
+                    async move { call_body(&task_client, address, "Lock", Bytes::from_static(b"recovery-bucket")).await },
+                );
+            observer.wait_for_hits(1).await.expect("selected request arrived");
+            assert_eq!(observer.forwarded(), 0, "an intercepted request has not reached its backend");
+            observer.release();
+            let body = request
+                .await
+                .expect("request task")
+                .expect("forwarded request")
+                .into_body()
+                .collect()
+                .await
+                .expect("forwarded body");
+            assert_eq!(body.trailers().expect("preserved trailers")["x-proof"], "unchanged-proof");
+            assert_eq!(body.to_bytes(), Bytes::from_static(b"recovery-bucket"));
+            assert_eq!(observer.forwarded(), 1);
+            let another = call_body(&client, address, "Lock", Bytes::from_static(b"recovery-bucket"))
+                .await
+                .expect("observer forwards without pausing");
+            another.into_body().collect().await.expect("second body");
+            assert_eq!(observer.forwarded(), 2);
+        })
+        .await
+        .expect("passive observer deadline");
+    }
+
+    #[tokio::test]
+    async fn scoped_fault_discards_expired_packets_without_replaying_them() {
+        tokio::time::timeout(Duration::from_secs(10), async {
+            let backend = backend().await.expect("backend listener");
+            let proxy = RpcFaultProxy::start_on("127.0.0.1:0".parse().expect("loopback"), backend.address)
+                .await
+                .expect("proxy listener");
+            let client: ProxyClient = Client::builder(TokioExecutor::new()).http2_only(true).build_http();
+            assert!(proxy.pause(&["Lock"], 1, Some("")).is_err(), "empty scope must not match every body");
+            let pause = proxy
+                .pause(&["Lock"], usize::MAX, Some("specific-bucket"))
+                .expect("bucket-scoped lock fault");
+            let unrelated = call_body(&client, proxy.local_addr(), "Lock", Bytes::from_static(b"other-bucket"))
+                .await
+                .expect("unrelated bucket must progress");
+            let unrelated = unrelated.into_body().collect().await.expect("unrelated response");
+            assert_eq!(unrelated.trailers().expect("unchanged trailers")["x-proof"], "unchanged-proof");
+            assert_eq!(unrelated.to_bytes(), Bytes::from_static(b"other-bucket"));
+            assert_eq!(pause.hits(), 0);
+            let task_client = client.clone();
+            let address = proxy.local_addr();
+            let blocked =
+                tokio::spawn(
+                    async move { call_body(&task_client, address, "Lock", Bytes::from_static(b"specific-bucket")).await },
+                );
+            pause.wait_for_hits(1).await.expect("selected bucket reached");
+            assert!(!blocked.is_finished());
+            pause.discard_pending();
+            drop(pause); // Drop must not replace Discard with Forward.
+            assert!(blocked.await.expect("request task").is_err());
+            assert_eq!(backend.received.load(Ordering::SeqCst), 1, "discard must never execute at the peer");
+            let recovered = call(&client, address, "Lock").await.expect("future requests recover");
+            recovered.into_body().collect().await.expect("recovered response");
+            assert_eq!(backend.received.load(Ordering::SeqCst), 2);
+        })
+        .await
+        .expect("scoped discard deadline");
+    }
+    #[test]
+    fn delete_scope_matches_only_the_upload_root() {
+        let frame = |volume: &str, path: &str| {
+            let message = DeleteRequest {
+                volume: volume.to_owned(),
+                path: path.to_owned(),
+                options: r#"{"recursive":true}"#.to_owned(),
+                ..Default::default()
+            };
+            let payload = message.encode_to_vec();
+            let length = u32::try_from(payload.len()).expect("small control packet");
+            let mut bytes = vec![0];
+            bytes.extend_from_slice(&length.to_be_bytes());
+            bytes.extend_from_slice(&payload);
+            bytes
+        };
+        let root = b"hash/upload";
+        assert!(scope_matches("Delete", &frame(".rustfs.sys/multipart", "hash/upload"), root).expect("root frame"));
+        assert!(scope_matches("Delete", &frame(".rustfs.sys/multipart", "hash/upload/"), root).expect("directory frame"));
+        for path in ["hash/upload/part.1", "hash/upload-other"] {
+            assert!(!scope_matches("Delete", &frame(".rustfs.sys/multipart", path), root).expect("other path"));
+        }
+        assert!(!scope_matches("Delete", &frame(".rustfs.sys/tmp", "hash/upload"), root).expect("other volume"));
+        let non_recursive = DeleteRequest {
+            volume: ".rustfs.sys/multipart".to_owned(),
+            path: "hash/upload".to_owned(),
+            options: r#"{"recursive":false}"#.to_owned(),
+            ..Default::default()
+        }
+        .encode_to_vec();
+        let mut non_recursive_frame = vec![0];
+        non_recursive_frame.extend_from_slice(&u32::try_from(non_recursive.len()).expect("small frame").to_be_bytes());
+        non_recursive_frame.extend_from_slice(&non_recursive);
+        assert!(!scope_matches("Delete", &non_recursive_frame, root).expect("non-recursive frame"));
+        assert!(
+            scope_matches("Delete", &[0, 0, 0, 0, 1], root).is_err(),
+            "truncation must not become a match"
+        );
+    }
+}

crates/e2e_test/src/storage_api.rs

@@ -15,7 +15,7 @@
 #[cfg(test)]
 pub(crate) use rustfs_ecstore::api::bucket::bucket_target_sys::BucketTargetSys;
 #[cfg(test)]
-pub(crate) use rustfs_ecstore::api::disk::{Endpoint, RUSTFS_META_BUCKET, VolumeInfo, WalkDirOptions};
+pub(crate) use rustfs_ecstore::api::disk::{DiskOption, Endpoint, RUSTFS_META_BUCKET, VolumeInfo, WalkDirOptions, new_disk};
 pub(crate) use rustfs_ecstore::api::rpc::{AuthenticatedChannel, TonicInterceptor, node_service_time_out_client_no_auth};
 #[cfg(test)]
 pub(crate) use rustfs_ecstore::api::rpc::{
@@ -52,3 +52,8 @@ pub(crate) mod internode_rpc_signature {
 pub(crate) mod replication_extension {
     pub(crate) use super::BucketTargetSys;
 }
+
+#[cfg(test)]
+pub(crate) mod upgrade_compatibility {
+    pub(crate) use super::{DiskOption, Endpoint, new_disk};
+}

crates/e2e_test/src/upgrade_compatibility_test.rs

@@ -14,7 +14,7 @@
 
 use crate::common::{
     RustFSTestClusterEnvironment, RustFSTestEnvironment, admin_request, init_logging, replication_fast_env, rustfs_binary_path,
-    signed_request,
+    signal_process, signed_request,
 };
 use crate::fake_s3_target::{BucketMode, FAKE_ACCESS_KEY, FAKE_SECRET_KEY, FakeS3Target, Operation as FakeTargetOperation};
 use crate::on_demand_migration::common::{ODM_SERVER_ENV, OdmTestEnv, SeedObject, fake_source_client};
@@ -1372,6 +1372,353 @@ async fn rc5_rollback_requires_restoring_odm_configuration() -> TestResult {
     Ok(())
 }
 
+struct Rc5CheckpointCapture {
+    disk: PathBuf,
+    path: PathBuf,
+    task_id: String,
+    bytes: Vec<u8>,
+}
+
+async fn capture_rc5_checkpoint(drives: &[PathBuf], writer_pid: u32) -> Result<Rc5CheckpointCapture, BoxError> {
+    let has_signed_progress = |value: &Value| {
+        value["schema_version"].as_u64() == Some(6)
+            && value["successful_objects"].as_u64().is_some_and(|count| count > 0)
+            && value["processed_objects"]
+                .as_array()
+                .is_some_and(|objects| !objects.is_empty())
+            && value["integrity_digest"].as_str().is_some_and(|digest| !digest.is_empty())
+    };
+    tokio::time::timeout(Duration::from_secs(60), async {
+        loop {
+            for drive in drives {
+                let mut entries = match tokio::fs::read_dir(drive.join(".rustfs.sys/buckets")).await {
+                    Ok(entries) => entries,
+                    Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue,
+                    Err(error) => return Err(error.into()),
+                };
+                while let Some(entry) = entries.next_entry().await? {
+                    if !entry.file_name().to_string_lossy().ends_with("_ahm_checkpoint.json") {
+                        continue;
+                    }
+                    let metadata = entry.metadata().await?;
+                    if !metadata.is_file() || metadata.len() > 1024 * 1024 {
+                        return Err("the old checkpoint is not a bounded regular file".into());
+                    }
+                    let bytes = match tokio::fs::read(entry.path()).await {
+                        Ok(bytes) => bytes,
+                        Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue,
+                        Err(error) => return Err(error.into()),
+                    };
+                    let Ok(value) = serde_json::from_slice::<Value>(&bytes) else {
+                        continue;
+                    };
+                    if !has_signed_progress(&value) {
+                        continue;
+                    }
+
+                    // Freeze only this fixture's writer before copying its actual
+                    // bytes. The environment's normal stop path kills a stopped child.
+                    signal_process(writer_pid, "STOP")?;
+                    let bytes = tokio::fs::read(entry.path()).await?;
+                    let value: Value = serde_json::from_slice(&bytes)?;
+                    if !has_signed_progress(&value) {
+                        return Err("the stopped rc.5 writer did not retain signed checkpoint progress".into());
+                    }
+                    let task_id = value["task_id"].as_str().ok_or("the old checkpoint has no task id")?;
+                    uuid::Uuid::parse_str(task_id)?;
+                    if entry.file_name() != std::ffi::OsStr::new(&format!("{task_id}_ahm_checkpoint.json")) {
+                        return Err("the old checkpoint task id does not match its filename".into());
+                    }
+                    return Ok(Rc5CheckpointCapture {
+                        disk: drive.clone(),
+                        path: entry.path(),
+                        task_id: task_id.to_owned(),
+                        bytes,
+                    });
+                }
+            }
+            sleep(Duration::from_millis(5)).await;
+        }
+    })
+    .await
+    .map_err(|_| "rc.5 did not produce a signed checkpoint with progress within 60 seconds")?
+}
+
+fn rc5_checkpoint_object(index: usize) -> (String, Vec<u8>) {
+    (
+        format!("object-{index:05}.bin"),
+        format!("rc.5 checkpoint upgrade object {index:05}\n")
+            .repeat(256)
+            .into_bytes(),
+    )
+}
+
+fn checkpoint_binary_sha256(path: &Path) -> Result<String, BoxError> {
+    use sha2::Digest;
+    use std::io::Read;
+
+    let mut input = std::fs::File::open(path)?;
+    let mut digest = sha2::Sha256::new();
+    let mut buffer = [0_u8; 64 * 1024];
+    loop {
+        let count = input.read(&mut buffer)?;
+        if count == 0 {
+            break;
+        }
+        digest.update(&buffer[..count]);
+    }
+    Ok(hex_simd::encode_to_string(digest.finalize(), hex_simd::AsciiCase::Lower))
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[ignore = "requires the pinned 1.0.0-rc.5 release binary"]
+async fn rc5_checkpoint_upgrade_rewinds_signed_progress_without_losing_objects() -> TestResult {
+    use crate::storage_api::upgrade_compatibility::{DiskOption, Endpoint, new_disk};
+    use futures::{StreamExt, TryStreamExt, stream};
+    use rustfs_heal::heal::CheckpointManager;
+
+    const BUCKET: &str = "upgrade-rc5-checkpoint";
+    const OBJECTS: usize = 1600;
+
+    init_logging();
+    let previous_binary = source_binary()?;
+    assert_eq!(binary_source_revision(&previous_binary).await?, RC5_COMMIT);
+    let current_binary = rustfs_binary_path();
+    let evidence_dir = std::env::var_os(G09_EVIDENCE_DIR_ENV)
+        .map(|root| PathBuf::from(root).join(format!("rc5-checkpoint-upgrade-{}", uuid::Uuid::new_v4())));
+    if let Some(directory) = &evidence_dir {
+        std::fs::create_dir_all(directory)?;
+    }
+
+    // Declare the server after its extra drives so error unwinding stops it
+    // before the fixture directories are removed.
+    let fixture = tempfile::TempDir::new()?;
+    let extra_drives = (0..3)
+        .map(|index| {
+            let path = fixture.path().join(format!("drive-{index}"));
+            std::fs::create_dir(&path)?;
+            Ok(path.to_str().ok_or("fixture drive path is not UTF-8")?.to_owned())
+        })
+        .collect::<Result<Vec<_>, BoxError>>()?;
+    let mut env = RustFSTestEnvironment::new().await?;
+    let log_path = evidence_dir.as_deref().unwrap_or(fixture.path()).join("server.log");
+    env.capture_log_path = Some(log_path.to_str().ok_or("fixture log path is not UTF-8")?.to_owned());
+    let server_env = [
+        ("RUSTFS_UNSAFE_BYPASS_DISK_CHECK", "true"),
+        ("RUSTFS_DURABILITY_MODE", "strict"),
+        ("RUSTFS_NEW_BUCKET_DURABILITY_MODE", "strict"),
+        ("RUST_LOG", "warn,rustfs::heal=debug"),
+    ];
+    env.start_rustfs_server_from_binary(&previous_binary, extra_drives.iter().map(String::as_str).collect(), &server_env)
+        .await?;
+    env.create_test_bucket(BUCKET).await?;
+    let (status, durability) = admin_request(
+        &env.url,
+        Method::GET,
+        &format!("/rustfs/admin/v3/bucket-durability/{BUCKET}"),
+        None,
+        &env.access_key,
+        &env.secret_key,
+    )
+    .await?;
+    assert_eq!(status, StatusCode::OK, "old bucket durability: {durability}");
+    assert_eq!(serde_json::from_str::<Value>(&durability)?["mode"], "strict");
+
+    let old_client = env.create_s3_client();
+    let manifest = stream::iter(0..OBJECTS)
+        .map(|index| {
+            let client = old_client.clone();
+            async move {
+                let (key, body) = rc5_checkpoint_object(index);
+                let entry = serde_json::json!({
+                    "bucket": BUCKET,
+                    "key": key,
+                    "length": body.len(),
+                    "sha256": rustfs_utils::hex_sha256(&body, str::to_owned),
+                });
+                client
+                    .put_object()
+                    .bucket(BUCKET)
+                    .key(&key)
+                    .body(ByteStream::from(body))
+                    .send()
+                    .await?;
+                Ok::<_, BoxError>(entry)
+            }
+        })
+        .buffered(4)
+        .try_collect::<Vec<_>>()
+        .await?;
+    let drives = extra_drives
+        .iter()
+        .map(PathBuf::from)
+        .chain(std::iter::once(PathBuf::from(&env.temp_dir)))
+        .collect::<Vec<_>>();
+    let writer_pid = env.process.as_ref().ok_or("rc.5 writer is not running")?.id();
+    let start_heal = async {
+        let (status, body) = tokio::time::timeout(
+            Duration::from_secs(15),
+            admin_request(
+                &env.url,
+                Method::POST,
+                "/rustfs/admin/v3/heal/",
+                Some(
+                    serde_json::json!({
+                        "recursive": true, "dryRun": false, "remove": false, "recreate": false,
+                        "scanMode": 2, "updateParity": false, "nolock": false, "pool": 0, "set": 0,
+                    })
+                    .to_string(),
+                ),
+                &env.access_key,
+                &env.secret_key,
+            ),
+        )
+        .await??;
+        if status != StatusCode::OK {
+            return Err(format!("rc.5 root heal was not accepted: {status} {body}").into());
+        }
+        Ok::<_, BoxError>(body)
+    };
+    let (capture, heal_start) = tokio::try_join!(capture_rc5_checkpoint(&drives, writer_pid), start_heal)?;
+    env.stop_server();
+    assert_eq!(
+        std::fs::read(&capture.path)?,
+        capture.bytes,
+        "stopping the old writer must preserve captured bytes"
+    );
+    let checkpoint_dir = capture.disk.join(".rustfs.sys/buckets");
+    let resume_path = checkpoint_dir.join(format!("{}_ahm_resume_state.json", capture.task_id));
+    let resume_bytes = std::fs::read(&resume_path)?;
+    let old_checkpoint: Value = serde_json::from_slice(&capture.bytes)?;
+    if let Some(directory) = &evidence_dir {
+        std::fs::write(directory.join("checkpoint.rc5.json"), &capture.bytes)?;
+        std::fs::write(directory.join("resume.rc5.json"), &resume_bytes)?;
+        std::fs::write(directory.join("manifest.json"), serde_json::to_vec_pretty(&manifest)?)?;
+        std::fs::write(
+            directory.join("source.json"),
+            serde_json::to_vec_pretty(&serde_json::json!({
+                "kind": "old-release-checkpoint-reader-upgrade",
+                "scope": "schema-6 reader authentication, safe rewind and object reads; not full G09 qualification",
+                "writer_revision": RC5_COMMIT,
+                "writer_binary_sha256": checkpoint_binary_sha256(&previous_binary)?,
+                "candidate_revision": current_source_revision()?,
+                "candidate_binary_sha256": checkpoint_binary_sha256(&current_binary)?,
+                "layout": "one process and four logical drives; not physical fault qualification",
+                "task_id": capture.task_id,
+                "checkpoint_sha256": rustfs_utils::hex_sha256(&capture.bytes, str::to_owned),
+                "resume_sha256": rustfs_utils::hex_sha256(&resume_bytes, str::to_owned),
+                "acknowledged_objects": manifest.len(),
+                "bucket_durability": serde_json::from_str::<Value>(&durability)?,
+                "heal_start": serde_json::from_str::<Value>(&heal_start)?,
+            }))?,
+        )?;
+    }
+
+    let blocked_path = checkpoint_dir.join(format!("{}_ahm_checkpoint.blocked", capture.task_id));
+    assert!(!blocked_path.try_exists()?, "the original checkpoint must not already be blocked");
+    let disk_options = DiskOption {
+        cleanup: false,
+        health_check: false,
+    };
+    // Reopen with the same member order passed to the old writer.
+    let disk_index = drives
+        .iter()
+        .position(|drive| drive == &capture.disk)
+        .ok_or("captured disk is not a fixture member")?;
+    let mut endpoint = Endpoint::try_from(capture.disk.to_str().ok_or("captured drive path is not UTF-8")?)?;
+    endpoint.set_pool_index(0);
+    endpoint.set_set_index(0);
+    endpoint.set_disk_index(disk_index);
+    let disk = new_disk(&endpoint, &disk_options).await?;
+    let manager = CheckpointManager::load_from_disk(disk.clone(), &capture.task_id).await?;
+    let rewound = manager.get_checkpoint().await;
+    assert_eq!(rewound.schema_version, 7);
+    assert_eq!(rewound.task_id, capture.task_id);
+    assert_eq!((rewound.current_bucket_index, rewound.current_object_index), (0, 0));
+    assert!(rewound.processed_objects.is_empty() && rewound.failed_objects.is_empty() && rewound.skipped_objects.is_empty());
+    assert_eq!(rewound.successful_objects, 0);
+    assert_eq!(rewound.failed_object_count, 0);
+    assert_eq!(rewound.skipped_object_count, 0);
+    assert_eq!(rewound.processed_bytes, 0);
+    assert_eq!((rewound.total_objects, rewound.total_bytes), (0, 0));
+    assert!(rewound.baseline_generation.is_none() && !rewound.baseline_known && !rewound.counter_unknown);
+    assert!(!blocked_path.try_exists()?, "an authentic old checkpoint must not be quarantined");
+    assert_eq!(
+        std::fs::read(&capture.path)?,
+        capture.bytes,
+        "the reader must not rewrite the old checkpoint"
+    );
+    assert_eq!(std::fs::read(&resume_path)?, resume_bytes, "the reader must not take over the old task");
+    drop(manager);
+    drop(disk);
+
+    // A separate copy with one digest byte changed proves that successful
+    // rewind above did not bypass authentication of the original wire bytes.
+    let corrupt_root = fixture.path().join("corrupt-reader-control");
+    let corrupt_metadata = corrupt_root.join(".rustfs.sys/buckets");
+    std::fs::create_dir_all(&corrupt_metadata)?;
+    let mut corrupted = capture.bytes.clone();
+    let digest = old_checkpoint["integrity_digest"]
+        .as_str()
+        .ok_or("old checkpoint digest is not a string")?;
+    let offset = corrupted
+        .windows(digest.len())
+        .position(|bytes| bytes == digest.as_bytes())
+        .ok_or("the digest is absent from the captured bytes")?;
+    corrupted[offset] = if corrupted[offset] == b'A' { b'B' } else { b'A' };
+    let corrupt_path = corrupt_metadata.join(format!("{}_ahm_checkpoint.json", capture.task_id));
+    std::fs::write(&corrupt_path, &corrupted)?;
+    let endpoint = Endpoint::try_from(corrupt_root.to_str().ok_or("control disk path is not UTF-8")?)?;
+    let corrupt_disk = new_disk(&endpoint, &disk_options).await?;
+    let Err(error) = CheckpointManager::load_from_disk(corrupt_disk.clone(), &capture.task_id).await else {
+        return Err("the current checkpoint reader accepted a corrupted signature".into());
+    };
+    assert!(matches!(error, rustfs_heal::Error::InvalidCheckpoint(ref reason) if reason.contains("digest")));
+    let corrupt_blocked = corrupt_metadata.join(format!("{}_ahm_checkpoint.blocked", capture.task_id));
+    assert!(corrupt_blocked.try_exists()?, "the corrupted copy must retain a blocked marker");
+    assert_eq!(std::fs::read(&corrupt_path)?, corrupted, "quarantine must preserve the invalid bytes");
+    if let Some(directory) = &evidence_dir {
+        std::fs::write(directory.join("checkpoint.corrupted.json"), &corrupted)?;
+        std::fs::copy(&corrupt_blocked, directory.join("checkpoint.corrupted.blocked"))?;
+    }
+    drop(corrupt_disk);
+
+    env.restart_server_preserving_data(extra_drives.iter().map(String::as_str).collect(), &server_env)
+        .await?;
+    let current_client = env.create_s3_client();
+    stream::iter(0..OBJECTS)
+        .map(|index| {
+            let client = current_client.clone();
+            async move {
+                let (key, expected) = rc5_checkpoint_object(index);
+                let (_, actual) = read_object(&client, BUCKET, &key, None).await?;
+                assert_eq!(actual, expected, "old object {key} changed during the upgrade");
+                Ok::<_, BoxError>(())
+            }
+        })
+        .buffer_unordered(4)
+        .try_collect::<Vec<_>>()
+        .await?;
+    env.stop_server();
+    if let Some(directory) = &evidence_dir {
+        std::fs::write(
+            directory.join("result.json"),
+            serde_json::to_vec_pretty(&serde_json::json!({
+                "status": "passed",
+                "scope": "old-release checkpoint reader and object-data upgrade only",
+                "authenticated_original_bytes": true,
+                "original_checkpoint_unchanged_after_read": true,
+                "old_successful_objects": old_checkpoint["successful_objects"],
+                "rewound_schema": rewound.schema_version,
+                "rewound_successful_objects": rewound.successful_objects,
+                "corrupt_digest_rejected_and_retained": true,
+                "verified_objects": OBJECTS,
+            }))?,
+        )?;
+    }
+    Ok(())
+}
+
 #[tokio::test]
 #[ignore = "requires a pinned previous RustFS release binary"]
 async fn direct_upgrade_from_previous_release_preserves_object_contracts() -> TestResult {

crates/ecstore/Cargo.toml

@@ -142,6 +142,7 @@ rustfs-lifecycle.workspace = true
 rustfs-s3-client = { workspace = true }
 rustfs-s3-types = { workspace = true }
 rustfs-data-usage.workspace = true
+rustfs-gateway-types.workspace = true
 rustfs-object-capacity.workspace = true
 rustfs-object-data-cache = { workspace = true, features = ["runtime-memory"] }
 arc-swap.workspace = true
@@ -160,7 +161,6 @@ serde = { workspace = true, features = ["derive"] }
 time = { workspace = true, features = ["parsing", "formatting", "macros", "serde"] }
 bytesize.workspace = true
 serde_json = { workspace = true, features = ["raw_value"] }
-s3s = { workspace = true, features = ["minio"] }
 http.workspace = true
 opentelemetry.workspace = true
 http-body = { workspace = true }
@@ -249,6 +249,7 @@ windows-sys = { workspace = true, features = [
 windows-sys = { workspace = true, features = ["Win32_System_Ioctl"] }
 
 [dev-dependencies]
+s3s = { workspace = true, features = ["minio"] }
 aws-smithy-async.workspace = true
 rustfs-s3-ops.workspace = true
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "test-util", "fs"] }
@@ -278,10 +279,6 @@ harness = false
 name = "comparison_benchmark"
 harness = false
 
-[[bench]]
-name = "rename_data_meta_benchmark"
-harness = false
-
 [[bench]]
 name = "single_block_non_inline_benchmark"
 harness = false
@@ -290,5 +287,9 @@ harness = false
 name = "multipart_read_parts_benchmark"
 harness = false
 
+[[bench]]
+name = "local_walk_dir_benchmark"
+harness = false
+
 [lib]
 doctest = false

crates/ecstore/benches/local_walk_dir_benchmark.rs

@@ -0,0 +1,85 @@
+// 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 criterion::{Criterion, Throughput, criterion_group, criterion_main};
+use rustfs_filemeta::{MetaCacheEntry, MetacacheReader, test_data::create_real_xlmeta};
+use std::hint::black_box;
+
+mod storage_api;
+use storage_api::local_walk_dir::{Disk, DiskAPI, DiskOption, Endpoint, WalkDirOptions, new_disk};
+
+const OBJECTS: usize = 1000;
+
+async fn walk_page(disk: &Disk, recursive: bool) -> Vec<MetaCacheEntry> {
+    let opts = WalkDirOptions {
+        bucket: "bench-bucket".to_string(),
+        base_dir: "prefix".to_string(),
+        recursive,
+        limit: i32::try_from(OBJECTS).expect("page limit fits"),
+        ..Default::default()
+    };
+    let (reader, mut writer) = tokio::io::duplex(4096);
+    let produce = async move { disk.walk_dir(opts, &mut writer).await };
+    let consume = async { MetacacheReader::new(reader).read_all().await.expect("decode listing stream") };
+    let (result, entries) = tokio::join!(produce, consume);
+    result.expect("production walk_dir must succeed");
+    entries
+}
+
+fn bench_local_walk_dir(c: &mut Criterion) {
+    let root = tempfile::tempdir().expect("create benchmark disk");
+    let metadata = create_real_xlmeta().expect("create object metadata");
+    let decoded = rustfs_filemeta::FileMeta::load(&metadata).expect("decode fixture");
+    let data_dirs = decoded.get_data_dirs().expect("fixture data directories");
+    for i in 0..OBJECTS {
+        let object_dir = root.path().join("bench-bucket/prefix").join(format!("object-{i:04}"));
+        std::fs::create_dir_all(&object_dir).expect("create object directory");
+        for data_dir in data_dirs.iter().flatten() {
+            std::fs::create_dir_all(object_dir.join(data_dir.to_string())).expect("create data directory");
+        }
+        std::fs::write(object_dir.join("xl.meta"), &metadata).expect("write object metadata");
+    }
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(4)
+        .enable_all()
+        .build()
+        .expect("build benchmark runtime");
+    let endpoint = Endpoint::try_from(root.path().to_str().expect("UTF-8 disk path")).expect("disk endpoint");
+    let disk = runtime
+        .block_on(new_disk(
+            &endpoint,
+            &DiskOption {
+                cleanup: false,
+                health_check: false,
+            },
+        ))
+        .expect("open local disk");
+    let mut group = c.benchmark_group("local_walk_dir");
+    group.throughput(Throughput::Elements(u64::try_from(OBJECTS).expect("object count fits")));
+    for (name, recursive) in [("recursive_1000_objects", true), ("non_recursive_1000_objects", false)] {
+        let entries = runtime.block_on(walk_page(&disk, recursive));
+        let objects: Vec<_> = entries.iter().filter(|entry| !entry.metadata.is_empty()).collect();
+        assert_eq!(objects.len(), OBJECTS);
+        for (i, entry) in objects.iter().enumerate() {
+            assert_eq!(entry.name, format!("prefix/object-{i:04}"));
+        }
+        group.bench_function(name, |b| {
+            b.iter(|| black_box(runtime.block_on(walk_page(&disk, recursive))));
+        });
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench_local_walk_dir);
+criterion_main!(benches);

crates/ecstore/benches/storage_api/mod.rs

@@ -33,3 +33,7 @@ pub(crate) mod single_block_non_inline {
 pub(crate) mod multipart {
     pub(crate) use rustfs_ecstore::api::disk::{DiskAPI, DiskOption, Endpoint, new_disk};
 }
+
+pub(crate) mod local_walk_dir {
+    pub(crate) use rustfs_ecstore::api::disk::{Disk, DiskAPI, DiskOption, Endpoint, WalkDirOptions, new_disk};
+}

crates/ecstore/src/api/mod.rs

@@ -17,8 +17,8 @@
 #[cfg(feature = "diagnostic-read-version-caller")]
 pub mod diagnostic {
     pub use crate::cluster::rpc::runtime_sources::{
-        current_read_version_entry_source, observe_read_version_context_boundary, with_read_version_entry,
-        with_read_version_spawn_context,
+        current_read_version_entry_source, observe_read_version_context_boundary, with_captured_read_version_context,
+        with_read_version_entry, with_read_version_spawn_context,
     };
     pub use rustfs_io_metrics::internode_metrics::{ReadVersionContextBoundary, ReadVersionEntrySource};
 }
@@ -62,6 +62,8 @@ pub mod bucket {
         }
 
         pub mod bucket_lifecycle_ops {
+            pub use rustfs_lifecycle::{RestoreOutputLocation, RestoreRequest, RestoreS3Location, RestoreTag, RestoreTagging};
+
             pub use crate::bucket::lifecycle::bucket_lifecycle_ops::{
                 ExpiryState, LifecycleOps, ManualTransitionCancelCheck, ManualTransitionProgressSink,
                 ManualTransitionQueueSnapshot, ManualTransitionRunExecution, ManualTransitionRunOptions,
@@ -133,7 +135,7 @@ pub mod bucket {
             pub use crate::bucket::lifecycle::lifecycle::{
                 Event, ExpirationOptions, IlmAction, LIFECYCLE_MALFORMED_XML_ERROR_KIND, Lifecycle, LifecycleCalculate,
                 ObjectOpts, RuleValidate, TRANSITION_COMPLETE, TRANSITION_PENDING, TransitionOptions, expected_expiry_time,
-                object_opts_from_object_info,
+                format_lifecycle_date, object_opts_from_object_info, parse_lifecycle_date,
             };
         }
 
@@ -225,7 +227,7 @@ pub mod bucket {
     }
 
     pub mod object_lock {
-        pub use crate::bucket::object_lock::{ObjectLockApi, ObjectLockStatusExt};
+        pub use crate::bucket::object_lock::ObjectLockApi;
 
         pub mod types {
             pub use crate::bucket::object_lock::types::{
@@ -320,9 +322,9 @@ pub mod bucket {
 
     pub mod utils {
         pub use crate::bucket::utils::{
-            check_bucket_and_object_names, check_list_objs_args, check_object_name_for_length_and_slash,
-            check_valid_bucket_name_strict, deserialize, has_bad_path_component, is_meta_bucketname, is_valid_object_prefix,
-            serialize,
+            BucketConfigXml, BucketConfigXmlError, check_bucket_and_object_names, check_list_objs_args,
+            check_object_name_for_length_and_slash, check_valid_bucket_name_strict, deserialize, has_bad_path_component,
+            is_meta_bucketname, is_valid_object_prefix, serialize,
         };
     }
 
@@ -349,7 +351,7 @@ pub mod capacity {
 }
 
 pub mod object_api_utils {
-    pub use crate::object_api::object_api_utils::{ObjReaderFn, PutObjReader, get_raw_etag, new_getobjectreader, to_s3s_etag};
+    pub use crate::object_api::object_api_utils::{ObjReaderFn, PutObjReader, get_raw_etag, new_getobjectreader};
 }
 
 pub mod cluster {
@@ -491,6 +493,8 @@ pub mod global {
 }
 
 pub mod runtime {
+    #[cfg(any(test, feature = "test-util"))]
+    pub use crate::runtime::global::set_object_store_resolver;
     pub use crate::runtime::instance::{InstanceContext, bootstrap_ctx};
     pub use crate::runtime::sources::{
         boot_time, bucket_monitor, deployment_id, endpoint_pools, expiry_state_handle, first_cluster_node_is_local,
@@ -587,12 +591,14 @@ pub mod rpc {
         decode_heal_bucket_rpc_options, encode_heal_bucket_rpc_options, gen_signature_headers, gen_tonic_replay_scope_headers,
         gen_tonic_signature_headers, gen_tonic_signature_interceptor, node_service_time_out_client,
         node_service_time_out_client_no_auth, normalize_tonic_rpc_audience, set_tonic_canonical_body_digest,
-        sign_ns_scanner_capability, sign_ns_scanner_capability_with_tier_registry_generation, 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_ns_scanner_capability_with_tier_registry_generation,
-        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_mutation_body_digest_reject_unsigned,
-        verify_tonic_rpc_response_proof, verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
+        sign_ns_scanner_capability, sign_ns_scanner_capability_with_checkpoint_coverage,
+        sign_ns_scanner_capability_with_tier_registry_generation, 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_ns_scanner_capability_with_checkpoint_coverage,
+        verify_ns_scanner_capability_with_tier_registry_generation, 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_mutation_body_digest_reject_unsigned, verify_tonic_rpc_response_proof,
+        verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
     };
 }
 

crates/ecstore/src/bucket/bucket_target_sys.rs

@@ -2012,7 +2012,7 @@ impl TargetClient {
             .head_object()
             .bucket(bucket)
             .key(object)
-            .set_version_id(version_id)
+            .set_version_id(resolve_read_api_version_id(version_id))
             .customize()
             .map_request(move |mut req| {
                 for (k, v) in headers.clone().into_iter() {
@@ -4170,6 +4170,34 @@ mod tests {
         );
     }
 
+    /// The worker's convergence HEAD addresses a source null version (nil
+    /// UUID) as `versionId=null`, the spelling every S3 target understands,
+    /// like the proxy and audit reads do.
+    #[tokio::test]
+    async fn head_object_addresses_nil_source_version_as_null() {
+        let (client, request_uris) = recording_target_client();
+        let versioned = Uuid::new_v4().to_string();
+        // Only the request URI matters here; the canned empty response may or
+        // may not parse as a HEAD result.
+        let _ = client
+            .head_object("target-bucket", "object", Some(Uuid::nil().to_string()))
+            .await;
+        let _ = client.head_object("target-bucket", "object", Some(versioned.clone())).await;
+
+        let request_uris = request_uris.lock().expect("recorded request lock should not be poisoned");
+        assert_eq!(request_uris.len(), 2);
+        assert!(
+            request_uris[0].contains("versionId=null") && !request_uris[0].contains(&Uuid::nil().to_string()),
+            "a nil source version must be addressed as the null version: {}",
+            request_uris[0]
+        );
+        assert!(
+            request_uris[1].contains(&format!("versionId={versioned}")),
+            "a concrete source version must pass through unchanged: {}",
+            request_uris[1]
+        );
+    }
+
     #[tokio::test]
     async fn put_object_sends_source_version_id_query_to_target() {
         // MinIO reads the replicated version only from the `versionId` query

crates/ecstore/src/bucket/lifecycle/bucket_lifecycle_ops.rs

@@ -87,12 +87,14 @@ use rustfs_filemeta::{
     FileInfo, FileInfoOpts, NULL_VERSION_ID, RestoreStatus, RestoreStatusOps, TRANSITION_COMPLETE, get_file_info,
     is_restored_object_on_disk,
 };
+use rustfs_gateway_types::persistence::PersistedLifecycleConfiguration;
+use rustfs_gateway_types::persistence::PersistedObjectLockConfiguration as ObjectLockConfiguration;
+use rustfs_lifecycle::{RestoreRequest, RestoreS3Location};
 use rustfs_lock::{NamespaceLockGuard, error::LockError};
 use rustfs_scanner_metrics::metrics::{
     IlmAction, Metrics, ScannerLifecycleExpiryStateUpdate, ScannerLifecycleTransitionStateUpdate, global_metrics,
 };
 use rustfs_utils::{get_env_i64, get_env_usize, path::encode_dir_object, string::parse_bool};
-use s3s::dto::{BucketLifecycleConfiguration, ExpirationStatus, ObjectLockConfiguration, RestoreRequest, RestoreRequestType};
 use sha2::{Digest, Sha256};
 use std::any::Any;
 use std::collections::{BTreeMap, HashMap, HashSet};
@@ -298,7 +300,7 @@ impl LifecycleSys {
         Arc::new(Self)
     }
 
-    pub async fn get(&self, bucket: &str) -> Option<BucketLifecycleConfiguration> {
+    pub async fn get(&self, bucket: &str) -> Option<PersistedLifecycleConfiguration> {
         match metadata_boundary::get_lifecycle_config(bucket).await {
             Ok((lc, _)) => Some(lc),
             Err(Error::ConfigNotFound) => None,
@@ -879,7 +881,11 @@ fn free_version_cleanup_fences_current(
         && free_version_physical_topology_generation(api) == topology_generation
 }
 
-async fn cleanup_free_version_exact(api: Arc<ECStore>, oi: &ObjectInfo, cancel: &CancellationToken) -> std::io::Result<bool> {
+pub(crate) async fn cleanup_free_version_exact(
+    api: Arc<ECStore>,
+    oi: &ObjectInfo,
+    cancel: &CancellationToken,
+) -> std::io::Result<bool> {
     const FREE_VERSION_REMOTE_DEADLINE: StdDuration = StdDuration::from_secs(30);
 
     let topology_generation = free_version_physical_topology_generation(&api);
@@ -1058,10 +1064,6 @@ impl HeldExpiryQueue {
         Self { state, previous }
     }
 
-    pub(crate) async fn pending_tasks(&self) -> usize {
-        self.state.read().await.pending_tasks()
-    }
-
     /// Drops the held tasks unrun and restores the previous expiry state.
     pub(crate) async fn release(self) {
         *self.state.write().await = self.previous;
@@ -3042,14 +3044,7 @@ fn spawn_tier_free_version_recovery_once_with_options(
                         move |bucket_marker, object_marker, recovery_cancel| {
                             let api = Arc::clone(&api);
                             async move {
-                                recover_tier_free_versions_with_cancel(
-                                    api,
-                                    DEFAULT_FREE_VERSION_RECOVERY_LIMIT,
-                                    bucket_marker,
-                                    object_marker,
-                                    recovery_cancel,
-                                )
-                                .await
+                                recover_configured_tier_free_versions(api, bucket_marker, object_marker, recovery_cancel).await
                             }
                         },
                     )
@@ -3061,6 +3056,39 @@ fn spawn_tier_free_version_recovery_once_with_options(
     }))
 }
 
+async fn recover_configured_tier_free_versions(
+    api: Arc<ECStore>,
+    bucket_marker: Option<String>,
+    object_marker: Option<String>,
+    cancel_token: CancellationToken,
+) -> crate::error::Result<FreeVersionRecoveryStats> {
+    let tier_config_mgr = api.tier_config_mgr();
+    let has_tiers = select! {
+        biased;
+        _ = cancel_token.cancelled() => {
+            return Err(std::io::Error::new(std::io::ErrorKind::Interrupted, "tier free-version recovery cancelled").into());
+        }
+        manager = tier_config_mgr.read() => !manager.empty(),
+    };
+    // Startup can launch recovery before tier configuration is loaded. Keep
+    // polling, but release the manager lock before any namespace I/O.
+    if !has_tiers {
+        return Ok(FreeVersionRecoveryStats {
+            scanned: 0,
+            enqueued: 0,
+            failed: 0,
+            next_bucket_marker: None,
+            next_object_marker: None,
+            scanned_entries: 0,
+            buckets_scanned: 0,
+            truncated: false,
+        });
+    }
+
+    recover_tier_free_versions_with_cancel(api, DEFAULT_FREE_VERSION_RECOVERY_LIMIT, bucket_marker, object_marker, cancel_token)
+        .await
+}
+
 fn tier_free_version_recovery_leader_retry_delay() -> StdDuration {
     StdDuration::from_secs(rand::rng().random_range(15..=30))
 }
@@ -3908,7 +3936,7 @@ pub fn init_background_stale_multipart_upload_cleanup(api: Arc<ECStore>) {
     });
 }
 
-pub async fn validate_transition_tier(lc: &BucketLifecycleConfiguration) -> Result<(), std::io::Error> {
+pub async fn validate_transition_tier(lc: &PersistedLifecycleConfiguration) -> Result<(), std::io::Error> {
     for rule in &lc.rules {
         if let Some(transitions) = &rule.transitions {
             for transition in transitions {
@@ -4025,8 +4053,9 @@ pub(crate) async fn enqueue_immediate_expiry(api: Arc<ECStore>, oi: &ObjectInfo,
         .map(lifecycle::object_opts_from_object_info)
         .collect::<Vec<ObjectOpts>>();
     let lock_config = configs.object_lock;
+    let evaluator_lock_config = lock_config.clone();
     let events = match Evaluator::new(lifecycle)
-        .with_lock_retention(lock_config.clone())
+        .with_lock_retention(evaluator_lock_config)
         .eval(&object_opts)
         .await
     {
@@ -4506,19 +4535,26 @@ pub async fn enqueue_transition_for_existing_objects_scoped(
     }
 }
 
-fn lifecycle_rule_has_date_expiration(lc: &BucketLifecycleConfiguration, rule_id: &str) -> bool {
+fn lifecycle_rule_has_date_expiration(lc: &PersistedLifecycleConfiguration, rule_id: &str) -> bool {
     lc.rules.iter().any(|rule| {
-        rule.status == ExpirationStatus::from_static(ExpirationStatus::ENABLED)
+        rule.status == "Enabled"
             && rule.id.as_deref() == Some(rule_id)
             && rule.expiration.as_ref().is_some_and(|expiration| expiration.date.is_some())
     })
 }
 
-fn should_defer_date_expiry_for_recent_config_update(lc: &BucketLifecycleConfiguration, now: OffsetDateTime) -> bool {
-    lc.expiry_updated_at.as_ref().is_some_and(|updated_at| {
-        let updated_at = OffsetDateTime::from(updated_at.clone());
-        now.unix_timestamp().saturating_sub(updated_at.unix_timestamp()) < DATE_EXPIRY_EXISTING_OBJECTS_GRACE_SECS
-    })
+fn should_defer_date_expiry_for_recent_config_update(lc: &PersistedLifecycleConfiguration, now: OffsetDateTime) -> bool {
+    lc.expiry_updated_at
+        .as_ref()
+        .is_some_and(|updated_at| match rustfs_lifecycle::parse_lifecycle_date(updated_at) {
+            Ok(updated_at) => {
+                now.unix_timestamp().saturating_sub(updated_at.unix_timestamp()) < DATE_EXPIRY_EXISTING_OBJECTS_GRACE_SECS
+            }
+            Err(error) => {
+                warn!(error = %error, "Deferring date expiry with an unreadable update timestamp");
+                true
+            }
+        })
 }
 
 async fn apply_existing_object_expiry(
@@ -4538,7 +4574,7 @@ async fn apply_existing_object_expiry(
 struct ExistingObjectExpiryContext<'a> {
     api: Arc<ECStore>,
     bucket: &'a str,
-    lc: Arc<BucketLifecycleConfiguration>,
+    lc: Arc<PersistedLifecycleConfiguration>,
     lock_config: Option<Arc<ObjectLockConfiguration>>,
     bucket_incarnation_id: Uuid,
     src: &'a LcEventSrc,
@@ -4558,8 +4594,9 @@ async fn enqueue_expiry_for_existing_object_group(
         .iter()
         .map(lifecycle::object_opts_from_object_info)
         .collect::<Vec<ObjectOpts>>();
+    let evaluator_lock_config = context.lock_config.clone();
     let events = match Evaluator::new(context.lc.clone())
-        .with_lock_retention(context.lock_config.clone())
+        .with_lock_retention(evaluator_lock_config)
         .eval(&object_opts)
         .await
     {
@@ -4753,7 +4790,7 @@ fn manual_transition_version_marker(oi: &ObjectInfo) -> String {
 async fn enqueue_transition_with_lifecycle_report(
     api: Option<Arc<ECStore>>,
     oi: &ObjectInfo,
-    lc: &BucketLifecycleConfiguration,
+    lc: &PersistedLifecycleConfiguration,
     src: &LcEventSrc,
     options: &ManualTransitionRunOptions,
     report: &mut ManualTransitionRunReport,
@@ -4819,7 +4856,7 @@ async fn enqueue_transition_with_lifecycle_report(
     false
 }
 
-async fn enqueue_transition_with_lifecycle(oi: &ObjectInfo, lc: &BucketLifecycleConfiguration, src: &LcEventSrc) -> bool {
+async fn enqueue_transition_with_lifecycle(oi: &ObjectInfo, lc: &PersistedLifecycleConfiguration, src: &LcEventSrc) -> bool {
     let event = lc.eval(&oi.to_lifecycle_opts()).await;
     match event.action {
         IlmAction::TransitionAction | IlmAction::TransitionVersionAction => {
@@ -5333,12 +5370,8 @@ pub async fn post_restore_opts(version_id: &str, bucket: &str, object: &str) ->
     })
 }
 
-fn select_restore_s3_location(rreq: &RestoreRequest) -> Result<Option<&s3s::dto::S3Location>, std::io::Error> {
-    if rreq
-        .type_
-        .as_ref()
-        .is_none_or(|type_| type_.as_str() != RestoreRequestType::SELECT)
-    {
+fn select_restore_s3_location(rreq: &RestoreRequest) -> Result<Option<&RestoreS3Location>, std::io::Error> {
+    if rreq.type_.as_ref().is_none_or(|type_| type_.as_str() != "SELECT") {
         return Ok(None);
     }
     let output_location = rreq
@@ -5380,27 +5413,25 @@ pub async fn put_restore_opts(
     // the OutputLocation metadata instead of a write to `OutputLocation.S3`
     // (backlog#1341). RestoreObject rejects SELECT at the API boundary; this
     // is the fail-closed backstop for any other caller.
-    if rreq
-        .type_
-        .as_ref()
-        .is_some_and(|type_| type_.as_str() == RestoreRequestType::SELECT)
-    {
+    if rreq.type_.as_ref().is_some_and(|type_| type_.as_str() == "SELECT") {
         return Err(std::io::Error::other("SELECT restore requests are not supported"));
     }
     for (k, v) in oi.user_defined.iter() {
         meta.insert(k.to_string(), v.clone());
     }
+    // The fleet capability gate guarantees physical copy-back support. Keep
+    // the completed transition identity for orphan recovery and remote cleanup.
     rustfs_utils::http::metadata_compat::remove_str(&mut meta, rustfs_utils::http::metadata_compat::SUFFIX_RESTORE_OPERATION_ID);
-    rustfs_utils::http::metadata_compat::remove_str(&mut meta, rustfs_utils::http::metadata_compat::SUFFIX_RESTORE_WORKER_LOCK);
     if !oi.user_tags.is_empty() {
         meta.insert(AMZ_OBJECT_TAGGING.to_string(), (*oi.user_tags).clone());
     }
-    let restore_expiry = lifecycle::expected_expiry_time(OffsetDateTime::now_utc(), rreq.days.unwrap_or(1));
+    // Finalization publishes completion and its expiry under the object lock.
+    // The local copy-back commit must not make unfinished work eligible for expiry.
     meta.insert(
         metadata_keys::RESTORE.to_string(),
         RestoreStatus {
-            is_restore_in_progress: Some(false),
-            restore_expiry_date: Some(restore_expiry),
+            is_restore_in_progress: Some(true),
+            restore_expiry_date: None,
         }
         .to_string(),
     );
@@ -5414,6 +5445,7 @@ pub async fn put_restore_opts(
         // computed MD5 is not the object's public plaintext ETag.
         preserve_etag: oi.etag.clone(),
         shard_integrity_write_mode: Some(oi.shard_integrity_write_mode()),
+        restore_copyback: true,
         //expires:           oi.expires,
         ..Default::default()
     })
@@ -5433,6 +5465,18 @@ impl LifecycleOps for ObjectInfo {
         if self.transitioned_object.status != lifecycle::TRANSITION_COMPLETE {
             return false;
         }
+        if rustfs_utils::http::metadata_compat::get_consistent_str(
+            &self.user_defined,
+            rustfs_utils::http::metadata_compat::SUFFIX_RESTORE_COPYBACK,
+        ) == Some(rustfs_utils::http::metadata_compat::RESTORE_COPYBACK_PROTOCOL_V1)
+            && self
+                .user_defined
+                .get(metadata_keys::RESTORE)
+                .and_then(|value| rustfs_filemeta::parse_restore_obj_status(value).ok())
+                .is_some_and(|status| status.is_restore_in_progress == Some(true))
+        {
+            return false;
+        }
         !is_restored_object_on_disk(&self.user_defined)
     }
 }
@@ -5444,25 +5488,25 @@ pub trait RestoreRequestOps {
 impl RestoreRequestOps for RestoreRequest {
     fn validate(&self, _api: Arc<ECStore>) -> Result<(), std::io::Error> {
         // SELECT type requires select_parameters, and vice versa
-        if self.type_.as_ref().is_none_or(|t| t.as_str() != RestoreRequestType::SELECT) && self.select_parameters.is_some() {
+        if self.type_.as_ref().is_none_or(|t| t.as_str() != "SELECT") && self.select_parameters.is_some() {
             return Err(std::io::Error::other("Select parameters can only be specified with SELECT request type"));
         }
         if let Some(type_) = &self.type_
-            && type_.as_str() == RestoreRequestType::SELECT
+            && type_.as_str() == "SELECT"
             && self.select_parameters.is_none()
         {
             return Err(std::io::Error::other("SELECT restore request requires select parameters to be specified"));
         }
 
         // OutputLocation is only valid for SELECT requests
-        if self.type_.as_ref().is_none_or(|t| t.as_str() != RestoreRequestType::SELECT) && self.output_location.is_some() {
+        if self.type_.as_ref().is_none_or(|t| t.as_str() != "SELECT") && self.output_location.is_some() {
             return Err(std::io::Error::other("OutputLocation can only be specified with SELECT request type"));
         }
         select_restore_s3_location(self)?;
 
         // Days must not be specified with SELECT requests
         if let Some(type_) = &self.type_
-            && type_.as_str() == RestoreRequestType::SELECT
+            && type_.as_str() == "SELECT"
             && self.days.is_some_and(|d| d > 0)
         {
             return Err(std::io::Error::other("Days cannot be specified with SELECT restore request"));
@@ -5504,7 +5548,7 @@ pub fn lifecycle_version_delete_target(oi: &ObjectInfo) -> Option<ObjectToDelete
 }
 
 pub async fn eval_action_from_lifecycle(
-    lc: &BucketLifecycleConfiguration,
+    lc: &PersistedLifecycleConfiguration,
     lock_config: Option<&ObjectLockConfiguration>,
     oi: &ObjectInfo,
 ) -> lifecycle::Event {
@@ -6209,14 +6253,19 @@ mod tests {
     use rustfs_data_usage::TierStats;
     use rustfs_filemeta::metadata_keys;
     use rustfs_filemeta::{FileInfo, FileMeta};
+    use rustfs_gateway_types::dto::MetadataEntry;
+    use rustfs_gateway_types::persistence::{
+        PersistedDefaultRetention as DefaultRetention, PersistedObjectLockConfiguration as ObjectLockConfiguration,
+        PersistedObjectLockRule as ObjectLockRule,
+    };
+    use rustfs_gateway_types::persistence::{
+        PersistedLifecycleConfiguration, PersistedLifecycleExpiration, PersistedLifecycleRule,
+        PersistedNoncurrentVersionExpiration, PersistedTransition,
+    };
+    use rustfs_lifecycle::{RestoreOutputLocation as OutputLocation, RestoreRequest, RestoreS3Location as S3Location};
     #[cfg(feature = "test-util")]
     use rustfs_s3_client::transition_api::ReaderImpl;
     use rustfs_scanner_metrics::metrics::{IlmAction, global_metrics};
-    use s3s::dto::{
-        BucketLifecycleConfiguration, DefaultRetention, ExpirationStatus, LifecycleExpiration, LifecycleRule, MetadataEntry,
-        NoncurrentVersionExpiration, ObjectLockConfiguration, ObjectLockEnabled, ObjectLockRetentionMode, ObjectLockRule,
-        OutputLocation, RestoreRequest, RestoreRequestType, S3Location, Timestamp, Transition, TransitionStorageClass,
-    };
     use serial_test::serial;
     use sha2::{Digest, Sha256};
     use std::collections::HashMap;
@@ -9223,7 +9272,7 @@ mod tests {
             output_location,
             select_parameters: None,
             tier: None,
-            type_: Some(RestoreRequestType::from_static(RestoreRequestType::SELECT)),
+            type_: Some("SELECT".to_owned()),
         }
     }
 
@@ -9540,12 +9589,12 @@ mod tests {
 
     #[test]
     fn lifecycle_rule_has_date_expiration_detects_enabled_date_rule() {
-        let lc = BucketLifecycleConfiguration {
+        let lc = PersistedLifecycleConfiguration {
             expiry_updated_at: None,
-            rules: vec![LifecycleRule {
-                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
-                expiration: Some(LifecycleExpiration {
-                    date: Some(Timestamp::from(OffsetDateTime::now_utc())),
+            rules: vec![PersistedLifecycleRule {
+                status: "Enabled".to_owned(),
+                expiration: Some(PersistedLifecycleExpiration {
+                    date: Some(lifecycle::format_lifecycle_date(OffsetDateTime::now_utc()).unwrap()),
                     ..Default::default()
                 }),
                 id: Some("rule-date".to_string()),
@@ -10062,14 +10111,15 @@ mod tests {
     #[test]
     fn should_defer_date_expiry_for_recent_config_update_respects_grace_window() {
         let now = OffsetDateTime::now_utc();
-        let recent = BucketLifecycleConfiguration {
-            expiry_updated_at: Some(Timestamp::from(now - time::Duration::seconds(1))),
+        let recent = PersistedLifecycleConfiguration {
+            expiry_updated_at: Some(lifecycle::format_lifecycle_date(now - time::Duration::seconds(1)).unwrap()),
             rules: Vec::new(),
         };
-        let stale = BucketLifecycleConfiguration {
-            expiry_updated_at: Some(Timestamp::from(
-                now - time::Duration::seconds(DATE_EXPIRY_EXISTING_OBJECTS_GRACE_SECS + 1),
-            )),
+        let stale = PersistedLifecycleConfiguration {
+            expiry_updated_at: Some(
+                lifecycle::format_lifecycle_date(now - time::Duration::seconds(DATE_EXPIRY_EXISTING_OBJECTS_GRACE_SECS + 1))
+                    .unwrap(),
+            ),
             rules: Vec::new(),
         };
 
@@ -10197,12 +10247,12 @@ mod tests {
         assert_eq!(deleted.version_id, None);
     }
 
-    fn expired_delete_marker_lifecycle() -> BucketLifecycleConfiguration {
-        BucketLifecycleConfiguration {
+    fn expired_delete_marker_lifecycle() -> PersistedLifecycleConfiguration {
+        PersistedLifecycleConfiguration {
             expiry_updated_at: None,
-            rules: vec![LifecycleRule {
-                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
-                expiration: Some(LifecycleExpiration {
+            rules: vec![PersistedLifecycleRule {
+                status: "Enabled".to_owned(),
+                expiration: Some(PersistedLifecycleExpiration {
                     expired_object_delete_marker: Some(true),
                     ..Default::default()
                 }),
@@ -10218,12 +10268,12 @@ mod tests {
         }
     }
 
-    fn latest_expiration_lifecycle() -> BucketLifecycleConfiguration {
-        BucketLifecycleConfiguration {
+    fn latest_expiration_lifecycle() -> PersistedLifecycleConfiguration {
+        PersistedLifecycleConfiguration {
             expiry_updated_at: None,
-            rules: vec![LifecycleRule {
-                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
-                expiration: Some(LifecycleExpiration {
+            rules: vec![PersistedLifecycleRule {
+                status: "Enabled".to_owned(),
+                expiration: Some(PersistedLifecycleExpiration {
                     days: Some(1),
                     ..Default::default()
                 }),
@@ -10239,12 +10289,12 @@ mod tests {
         }
     }
 
-    fn current_and_noncurrent_expiration_lifecycle() -> BucketLifecycleConfiguration {
-        BucketLifecycleConfiguration {
+    fn current_and_noncurrent_expiration_lifecycle() -> PersistedLifecycleConfiguration {
+        PersistedLifecycleConfiguration {
             expiry_updated_at: None,
-            rules: vec![LifecycleRule {
-                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
-                expiration: Some(LifecycleExpiration {
+            rules: vec![PersistedLifecycleRule {
+                status: "Enabled".to_owned(),
+                expiration: Some(PersistedLifecycleExpiration {
                     days: Some(30),
                     ..Default::default()
                 }),
@@ -10252,7 +10302,7 @@ mod tests {
                 del_marker_expiration: None,
                 filter: None,
                 id: Some("expire-current-and-noncurrent".to_string()),
-                noncurrent_version_expiration: Some(NoncurrentVersionExpiration {
+                noncurrent_version_expiration: Some(PersistedNoncurrentVersionExpiration {
                     noncurrent_days: Some(1),
                     newer_noncurrent_versions: None,
                 }),
@@ -10263,12 +10313,12 @@ mod tests {
         }
     }
 
-    fn all_versions_expiration_lifecycle() -> BucketLifecycleConfiguration {
-        BucketLifecycleConfiguration {
+    fn all_versions_expiration_lifecycle() -> PersistedLifecycleConfiguration {
+        PersistedLifecycleConfiguration {
             expiry_updated_at: None,
-            rules: vec![LifecycleRule {
-                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
-                expiration: Some(LifecycleExpiration {
+            rules: vec![PersistedLifecycleRule {
+                status: "Enabled".to_owned(),
+                expiration: Some(PersistedLifecycleExpiration {
                     days: Some(1),
                     expired_object_all_versions: Some(true),
                     ..Default::default()
@@ -10287,29 +10337,29 @@ mod tests {
 
     fn lock_enabled_without_default_retention() -> ObjectLockConfiguration {
         ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+            object_lock_enabled: Some("Enabled".to_owned()),
             rule: None,
         }
     }
 
     fn lock_enabled_with_default_retention() -> ObjectLockConfiguration {
         ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+            object_lock_enabled: Some("Enabled".to_owned()),
             rule: Some(ObjectLockRule {
                 default_retention: Some(DefaultRetention {
                     days: Some(30),
-                    mode: Some(ObjectLockRetentionMode::from_static(ObjectLockRetentionMode::COMPLIANCE)),
+                    mode: Some("COMPLIANCE".to_owned()),
                     years: None,
                 }),
             }),
         }
     }
 
-    fn latest_transition_lifecycle() -> BucketLifecycleConfiguration {
-        BucketLifecycleConfiguration {
+    fn latest_transition_lifecycle() -> PersistedLifecycleConfiguration {
+        PersistedLifecycleConfiguration {
             expiry_updated_at: None,
-            rules: vec![LifecycleRule {
-                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
+            rules: vec![PersistedLifecycleRule {
+                status: "Enabled".to_owned(),
                 expiration: None,
                 abort_incomplete_multipart_upload: None,
                 del_marker_expiration: None,
@@ -10318,10 +10368,10 @@ mod tests {
                 noncurrent_version_expiration: None,
                 noncurrent_version_transitions: None,
                 prefix: None,
-                transitions: Some(vec![Transition {
+                transitions: Some(vec![PersistedTransition {
                     days: Some(1),
                     date: None,
-                    storage_class: Some(TransitionStorageClass::from_static("WARM")),
+                    storage_class: Some("WARM".to_owned()),
                 }]),
             }],
         }
@@ -12864,8 +12914,9 @@ mod tests {
 
         for (name, object, lock_config, expected) in cases {
             let object_opts = lifecycle::object_opts_from_object_info(&object);
+            let evaluator_lock_config = lock_config.clone().map(Arc::new);
             let batch_event = Evaluator::new(Arc::new(lifecycle.clone()))
-                .with_lock_retention(lock_config.clone().map(Arc::new))
+                .with_lock_retention(evaluator_lock_config)
                 .eval(&[object_opts])
                 .await
                 .expect("batch lifecycle evaluation should succeed")
@@ -14122,10 +14173,7 @@ mod tests {
         let object = current_object_with_metadata(
             ReplicationStatusType::Completed,
             HashMap::from([
-                (
-                    metadata_keys::OBJECT_LOCK_MODE.to_string(),
-                    s3s::dto::ObjectLockRetentionMode::COMPLIANCE.to_string(),
-                ),
+                (metadata_keys::OBJECT_LOCK_MODE.to_string(), "COMPLIANCE".to_string()),
                 (metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE.to_string(), retain_until),
             ]),
         );
@@ -14137,7 +14185,7 @@ mod tests {
 
     #[tokio::test]
     async fn restored_copy_expiry_is_not_blocked_by_retention() {
-        let lifecycle = BucketLifecycleConfiguration {
+        let lifecycle = PersistedLifecycleConfiguration {
             expiry_updated_at: None,
             rules: Vec::new(),
         };
@@ -14147,10 +14195,7 @@ mod tests {
         let mut object = current_object_with_metadata(
             ReplicationStatusType::Completed,
             HashMap::from([
-                (
-                    metadata_keys::OBJECT_LOCK_MODE.to_string(),
-                    ObjectLockRetentionMode::COMPLIANCE.to_string(),
-                ),
+                (metadata_keys::OBJECT_LOCK_MODE.to_string(), "COMPLIANCE".to_string()),
                 (metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE.to_string(), retain_until),
             ]),
         );
@@ -14250,9 +14295,14 @@ mod tests {
 
         crate::store::init_local_disks(endpoint_pools.clone()).await.unwrap();
 
-        let ecstore = ECStore::new("127.0.0.1:0".parse().unwrap(), endpoint_pools, CancellationToken::new())
-            .await
-            .unwrap();
+        // Tests start the recovery loop they observe. An automatic startup loop
+        // would race that loop for the same unconsumed worker queue.
+        let ecstore = temp_env::async_with_vars(
+            [(super::ENV_TIER_FREE_VERSION_RECOVERY_ENABLED, Some("false"))],
+            ECStore::new("127.0.0.1:0".parse().unwrap(), endpoint_pools, CancellationToken::new()),
+        )
+        .await
+        .unwrap();
 
         let buckets = ecstore
             .list_bucket(&BucketOptions {
@@ -14362,7 +14412,7 @@ mod tests {
                 "removed" => {
                     metadata_sys::delete(&bucket, BUCKET_LIFECYCLE_CONFIG).await.unwrap();
                 }
-                "disabled" => changed.rules[0].status = ExpirationStatus::from_static(ExpirationStatus::DISABLED),
+                "disabled" => changed.rules[0].status = "Disabled".to_owned(),
                 "longer-days" => {
                     changed.rules[0]
                         .noncurrent_version_expiration
@@ -14478,7 +14528,7 @@ mod tests {
         );
     }
 
-    async fn install_test_expiry_policy(ecstore: &Arc<ECStore>, bucket: &str) -> Arc<BucketLifecycleConfiguration> {
+    async fn install_test_expiry_policy(ecstore: &Arc<ECStore>, bucket: &str) -> Arc<PersistedLifecycleConfiguration> {
         let xml = br#"<LifecycleConfiguration><Rule><ID>expire</ID><Status>Enabled</Status><Filter><Prefix></Prefix></Filter><Expiration><Days>0</Days></Expiration><NoncurrentVersionExpiration><NoncurrentDays>0</NoncurrentDays></NoncurrentVersionExpiration></Rule></LifecycleConfiguration>"#;
         metadata_sys::update_in(&ecstore.ctx, bucket, BUCKET_LIFECYCLE_CONFIG, xml.to_vec())
             .await
@@ -14730,8 +14780,234 @@ mod tests {
 
     #[tokio::test]
     #[serial]
-    async fn tier_free_version_recovery_production_entrypoint_enqueues_seeded_item() {
+    async fn tier_free_version_recovery_without_tiers_skips_listing_and_resets_cursor() {
         let (disk_paths, ecstore) = setup_test_env().await;
+        let manager = ecstore.tier_config_mgr();
+        let saved_tiers = std::mem::take(&mut manager.write().await.tiers);
+        let runtime_state = install_unconsumed_runtime_expiry_worker(&ecstore, 1).await;
+        let recovery_rx = Arc::clone(&runtime_state.read().await.tasks_rx[0]);
+        let bucket = format!("recovery-no-tiers-{}", Uuid::new_v4());
+        let object = "free-version";
+        create_test_bucket(&ecstore, &bucket).await;
+        seed_recoverable_free_version(&disk_paths, &bucket, object, None, None).await;
+        let metadata_path = disk_paths[0].join(&bucket).join(object).join(STORAGE_FORMAT_FILE);
+        let metadata_before = fs::read(&metadata_path).await.expect("seeded metadata should be readable");
+
+        let list_started = Arc::new(tokio::sync::Notify::new());
+        let list_wait = set_recovery_bucket_list_wait_hook(Arc::clone(&list_started));
+        let walk_calls = Arc::new(AtomicUsize::new(0));
+        let counted_walks = Arc::clone(&walk_calls);
+        let walk_hook = set_recovery_walk_test_hook(move |_| {
+            counted_walks.fetch_add(1, Ordering::SeqCst);
+            None
+        });
+        let mut schedule = super::TierFreeVersionRecoverySchedule::default();
+        schedule.record_success(&free_version_recovery_stats(1, 0, true));
+        let stats = tokio::select! {
+            biased;
+            _ = list_started.notified() => panic!("empty tier configuration must not list buckets"),
+            result = super::recover_configured_tier_free_versions(
+                Arc::clone(&ecstore),
+                schedule.bucket_marker.clone(),
+                schedule.object_marker.clone(),
+                CancellationToken::new(),
+            ) => result.expect("empty tier configuration should be an idle recovery result"),
+        };
+        assert_eq!(
+            stats,
+            FreeVersionRecoveryStats {
+                scanned: 0,
+                enqueued: 0,
+                failed: 0,
+                next_bucket_marker: None,
+                next_object_marker: None,
+                scanned_entries: 0,
+                buckets_scanned: 0,
+                truncated: false,
+            }
+        );
+        schedule.record_success(&stats);
+        assert!(schedule.bucket_marker.is_none());
+        assert!(schedule.object_marker.is_none());
+        assert!(!schedule.follow_up_sweep);
+        assert_eq!(walk_calls.load(Ordering::SeqCst), 0);
+        assert!(matches!(
+            recovery_rx.lock().await.try_recv(),
+            Err(tokio::sync::mpsc::error::TryRecvError::Empty)
+        ));
+        assert_eq!(
+            fs::read(&metadata_path).await.expect("paused recovery must retain metadata"),
+            metadata_before
+        );
+        drop(list_wait);
+        drop(walk_hook);
+
+        remove_seeded_free_version(&disk_paths, &bucket, object).await;
+        ecstore
+            .delete_bucket(&bucket, &DeleteBucketOptions::default())
+            .await
+            .expect("test bucket should be removed");
+        manager.write().await.tiers = saved_tiers;
+        reset_runtime_expiry_state(&ecstore).await;
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn tier_free_version_recovery_tier_snapshot_wait_is_cancellable() {
+        let (_disk_paths, ecstore) = setup_test_env().await;
+        let manager = ecstore.tier_config_mgr();
+        let _write_guard = manager.write().await;
+        let cancel = CancellationToken::new();
+        let recovery = super::recover_configured_tier_free_versions(ecstore, None, None, cancel.clone());
+        tokio::pin!(recovery);
+        assert!(
+            futures::poll!(&mut recovery).is_pending(),
+            "recovery should wait for the tier manager lock"
+        );
+        cancel.cancel();
+        let err = recovery
+            .await
+            .expect_err("cancellation must not wait for the tier manager writer");
+        assert!(matches!(err, crate::error::Error::Io(ref err) if err.kind() == std::io::ErrorKind::Interrupted));
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn tier_free_version_recovery_loop_observes_tier_configuration_changes() {
+        let automatic_recovery_started = super::TIER_FREE_VERSION_RECOVERY_STARTED.get().copied();
+        let (disk_paths, ecstore) = setup_test_env().await;
+        assert_eq!(
+            super::TIER_FREE_VERSION_RECOVERY_STARTED.get().copied(),
+            automatic_recovery_started,
+            "fixture must not start an unowned automatic recovery loop"
+        );
+        let manager = ecstore.tier_config_mgr();
+        let saved_tiers = std::mem::take(&mut manager.write().await.tiers);
+        let runtime_state = install_unconsumed_runtime_expiry_worker(&ecstore, 1).await;
+        let recovery_rx = Arc::clone(&runtime_state.read().await.tasks_rx[0]);
+        let bucket = format!("recovery-dynamic-tier-{}", Uuid::new_v4());
+        let object = "free-version";
+        create_test_bucket(&ecstore, &bucket).await;
+        seed_recoverable_free_version(&disk_paths, &bucket, object, None, None).await;
+
+        let page_permits = Arc::new(tokio::sync::Semaphore::new(1));
+        let worker_permits = Arc::clone(&page_permits);
+        let (page_tx, mut page_rx) = tokio::sync::mpsc::unbounded_channel();
+        let cancel = CancellationToken::new();
+        let loop_cancel = cancel.clone();
+        let recovery_store = Arc::clone(&ecstore);
+        let worker = tokio::spawn(async move {
+            run_tier_free_version_recovery_loop(
+                loop_cancel,
+                runtime_state,
+                std::convert::identity,
+                move |bucket, object, cancel| {
+                    let api = Arc::clone(&recovery_store);
+                    let page_tx = page_tx.clone();
+                    let page_permits = Arc::clone(&worker_permits);
+                    async move {
+                        // Advance the scheduler clock only while real disk I/O is
+                        // parked. Otherwise its timeout can win while the blocking
+                        // filesystem operation is still running on wall-clock time.
+                        let permit = tokio::select! {
+                            _ = cancel.cancelled() => return Err(crate::error::Error::other("test recovery canceled")),
+                            permit = page_permits.acquire() => permit.expect("test controls page admission"),
+                        };
+                        permit.forget();
+                        let stats =
+                            super::recover_configured_tier_free_versions(api, bucket.clone(), object.clone(), cancel).await?;
+                        page_tx
+                            .send((bucket, object, stats.clone()))
+                            .expect("test should observe each recovery result");
+                        Ok(stats)
+                    }
+                },
+            )
+            .await;
+        });
+        let (_, _, idle) = page_rx
+            .recv()
+            .await
+            .expect("worker should check the initially empty configuration");
+        assert_eq!(idle.buckets_scanned, 0);
+        assert!(matches!(
+            recovery_rx.lock().await.try_recv(),
+            Err(tokio::sync::mpsc::error::TryRecvError::Empty)
+        ));
+
+        let tier = format!("RECOVERY{}", Uuid::new_v4().simple()).to_uppercase();
+        crate::services::tier::test_util::register_mock_tier(&manager, &tier).await;
+        tokio::time::pause();
+        tokio::task::yield_now().await;
+        tokio::time::advance(TIER_FREE_VERSION_RECOVERY_BASE_INTERVAL).await;
+        tokio::time::resume();
+        page_permits.add_permits(1);
+        let (bucket_marker, object_marker, active) = tokio::time::timeout(StdDuration::from_secs(30), page_rx.recv())
+            .await
+            .expect("new tier should enable the next recovery page")
+            .expect("worker should remain running");
+        assert!(bucket_marker.is_none());
+        assert!(object_marker.is_none());
+        assert_eq!(active.enqueued, 1, "recovery page: {active:?}");
+        let task = recovery_rx
+            .lock()
+            .await
+            .try_recv()
+            .expect("new tier should enable discovery")
+            .expect("queue item should exist");
+        let recovered = task
+            .as_any()
+            .downcast_ref::<FreeVersionTask>()
+            .expect("seeded free version should be queued");
+        assert_eq!(recovered.0.bucket, bucket);
+        assert_eq!(recovered.0.name, object);
+
+        // Simulate a historical or temporarily missing configuration without
+        // bypassing the admin removal path's persisted-reference proof.
+        let configured_tiers = std::mem::take(&mut manager.write().await.tiers);
+        tokio::time::pause();
+        tokio::task::yield_now().await;
+        tokio::time::advance(TIER_FREE_VERSION_RECOVERY_BASE_INTERVAL).await;
+        tokio::time::resume();
+        page_permits.add_permits(1);
+        let (_, _, idle_again) = tokio::time::timeout(StdDuration::from_secs(30), page_rx.recv())
+            .await
+            .expect("empty configuration should still produce an idle check")
+            .expect("worker should remain running");
+        assert_eq!(idle_again.buckets_scanned, 0);
+        assert_eq!(idle_again.enqueued, 0);
+        assert!(matches!(
+            recovery_rx.lock().await.try_recv(),
+            Err(tokio::sync::mpsc::error::TryRecvError::Empty)
+        ));
+        cancel.cancel();
+        worker.await.expect("worker should exit on cancellation");
+        manager.write().await.tiers = configured_tiers;
+        manager
+            .write()
+            .await
+            .remove(&tier, true)
+            .await
+            .expect("mock tier should be removed");
+        manager.write().await.tiers = saved_tiers;
+        remove_seeded_free_version(&disk_paths, &bucket, object).await;
+        ecstore
+            .delete_bucket(&bucket, &DeleteBucketOptions::default())
+            .await
+            .expect("test bucket should be removed");
+        reset_runtime_expiry_state(&ecstore).await;
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn tier_free_version_recovery_production_entrypoint_enqueues_seeded_item() {
+        let (disk_paths, ecstore) =
+            temp_env::async_with_vars([(super::ENV_TIER_FREE_VERSION_RECOVERY_ENABLED, Some("false"))], async {
+                setup_test_env().await
+            })
+            .await;
+        let tier = format!("RECOVERY{}", Uuid::new_v4().simple()).to_uppercase();
+        crate::services::tier::test_util::register_mock_tier(&ecstore.tier_config_mgr(), &tier).await;
         let runtime_state = install_unconsumed_runtime_expiry_worker(&ecstore, 1).await;
         let recovery_rx = {
             let state = runtime_state.read().await;
@@ -14767,6 +15043,13 @@ mod tests {
             .await
             .expect_err("aborted production recovery task should report cancellation");
         assert!(join_error.is_cancelled());
+        ecstore
+            .tier_config_mgr()
+            .write()
+            .await
+            .remove(&tier, true)
+            .await
+            .expect("mock tier should be removed");
         remove_seeded_free_version(&disk_paths, &bucket, object).await;
         ecstore
             .delete_bucket(&bucket, &DeleteBucketOptions::default())

crates/ecstore/src/bucket/lifecycle/core.rs

@@ -17,7 +17,7 @@ use crate::object_api::ObjectInfo;
 pub use rustfs_lifecycle::{
     Event, ExpirationOptions, IlmAction, LIFECYCLE_MALFORMED_XML_ERROR_KIND, Lifecycle, LifecycleCalculate, ObjectOpts,
     RuleValidate, TRANSITION_COMPLETE, TRANSITION_PENDING, TransitionOptions, abort_incomplete_multipart_upload_due,
-    expected_expiry_time, expiration_action_has_valid_target,
+    expected_expiry_time, expiration_action_has_valid_target, format_lifecycle_date, parse_lifecycle_date,
 };
 
 pub fn object_opts_from_object_info(oi: &ObjectInfo) -> ObjectOpts {

crates/ecstore/src/bucket/lifecycle/metadata_boundary.rs

@@ -14,7 +14,8 @@
 
 use std::sync::Arc;
 
-use s3s::dto::{BucketLifecycleConfiguration, ObjectLockConfiguration};
+use rustfs_gateway_types::persistence::PersistedLifecycleConfiguration;
+use rustfs_gateway_types::persistence::PersistedObjectLockConfiguration as ObjectLockConfiguration;
 use time::OffsetDateTime;
 use uuid::Uuid;
 
@@ -24,7 +25,7 @@ use crate::error::{Error, Result};
 
 #[derive(Debug)]
 pub(crate) struct LifecycleExpiryConfigs {
-    pub(crate) lifecycle: Option<Arc<BucketLifecycleConfiguration>>,
+    pub(crate) lifecycle: Option<Arc<PersistedLifecycleConfiguration>>,
     pub(crate) object_lock: Option<Arc<ObjectLockConfiguration>>,
     pub(crate) bucket_incarnation_id: Uuid,
     pub(crate) table_bucket_enabled: bool,
@@ -63,7 +64,14 @@ pub(crate) async fn get_expiry_configs_for_options(
     bucket: &str,
     opts: &crate::object_api::ObjectOptions,
 ) -> Result<LifecycleExpiryConfigs> {
-    let bucket_incarnation_id = metadata_sys::get_bucket_incarnation_id_for_options_in(&api.ctx, bucket, opts).await?;
+    let bucket_incarnation_id = match opts
+        .object_lock_config_snapshot
+        .as_ref()
+        .and_then(|snapshot| snapshot.validated_bucket_incarnation_for(api.id, bucket, opts.expected_bucket_incarnation_id))
+    {
+        Some(incarnation_id) => incarnation_id,
+        None => metadata_sys::get_bucket_incarnation_id_for_options_in(&api.ctx, bucket, opts).await?,
+    };
     let metadata = get_authoritative_metadata(api, bucket, bucket_incarnation_id).await?;
     let table_bucket_enabled = metadata.table_bucket_enabled();
 
@@ -100,7 +108,7 @@ pub(crate) async fn get_expiry_configs_for_options(
     })
 }
 
-pub(crate) async fn get_lifecycle_config(bucket: &str) -> Result<(BucketLifecycleConfiguration, OffsetDateTime)> {
+pub(crate) async fn get_lifecycle_config(bucket: &str) -> Result<(PersistedLifecycleConfiguration, OffsetDateTime)> {
     metadata_sys::get_lifecycle_config(bucket).await
 }
 
@@ -110,15 +118,15 @@ mod tests {
     use crate::bucket::metadata::BucketMetadata;
     use crate::bucket::metadata_sys::{self, test_support::isolated_store_over_temp_disks};
     use crate::storage_api_contracts::bucket::MakeBucketOptions;
-    use s3s::dto::{ExpirationStatus, LifecycleExpiration, LifecycleRule};
+    use rustfs_gateway_types::persistence::{PersistedLifecycleExpiration, PersistedLifecycleRule};
     use serial_test::serial;
 
-    fn lifecycle_config() -> BucketLifecycleConfiguration {
-        BucketLifecycleConfiguration {
+    fn lifecycle_config() -> PersistedLifecycleConfiguration {
+        PersistedLifecycleConfiguration {
             expiry_updated_at: None,
-            rules: vec![LifecycleRule {
-                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
-                expiration: Some(LifecycleExpiration {
+            rules: vec![PersistedLifecycleRule {
+                status: "Enabled".to_owned(),
+                expiration: Some(PersistedLifecycleExpiration {
                     days: Some(1),
                     ..Default::default()
                 }),
@@ -174,5 +182,36 @@ mod tests {
                 .unwrap()
         );
         assert!(get_expiry_configs(&store_b, bucket).await.unwrap().lifecycle.is_none());
+
+        let snapshot = store_a.object_lock_config_snapshot(bucket).await.unwrap();
+        assert_eq!(
+            snapshot.validated_bucket_incarnation_for(store_a.id, bucket, Some(configs.bucket_incarnation_id)),
+            Some(configs.bucket_incarnation_id)
+        );
+        assert_eq!(
+            snapshot.validated_bucket_incarnation_for(store_a.id, bucket, Some(uuid::Uuid::new_v4())),
+            None
+        );
+        assert_eq!(snapshot.validated_bucket_incarnation_for(store_b.id, bucket, None), None);
+        let opts = crate::object_api::ObjectOptions {
+            object_lock_config_snapshot: Some(snapshot.clone()),
+            expected_bucket_incarnation_id: Some(configs.bucket_incarnation_id),
+            ..Default::default()
+        };
+        assert_eq!(
+            get_expiry_configs_for_options(&store_a, bucket, &opts)
+                .await
+                .unwrap()
+                .bucket_incarnation_id,
+            configs.bucket_incarnation_id
+        );
+        let unguarded = crate::object_api::ObjectLockConfigSnapshot::for_store_bucket(
+            store_a.id,
+            bucket,
+            configs.bucket_incarnation_id,
+            time::OffsetDateTime::UNIX_EPOCH,
+            metadata_sys::ObjectLockConfigState::ConfirmedAbsent,
+        );
+        assert_eq!(unguarded.validated_bucket_incarnation_for(store_a.id, bucket, None), None);
     }
 }

crates/ecstore/src/bucket/lifecycle/object_lock_boundary.rs

@@ -22,7 +22,7 @@ pub(crate) fn is_object_locked_by_metadata(user_defined: &HashMap<String, String
 }
 
 pub(crate) fn check_object_lock_for_deletion_with_config(
-    config: Option<&s3s::dto::ObjectLockConfiguration>,
+    config: Option<&rustfs_gateway_types::persistence::PersistedObjectLockConfiguration>,
     obj_info: &ObjectInfo,
     bypass_governance: bool,
 ) -> crate::error::Result<Option<ObjectLockBlockReason>> {

crates/ecstore/src/bucket/lifecycle/replication_sink.rs

@@ -82,12 +82,13 @@ mod tests {
     use crate::bucket::replication::{DeleteReplicationConfigSnapshot, ReplicationObjectBridge};
     use crate::object_api::{ObjectInfo, ObjectOptions};
     use crate::storage_api_contracts::object::ObjectToDelete;
-    use rustfs_scanner_metrics::metrics::IlmAction;
-    use s3s::dto::{
-        BucketVersioningStatus, DeleteMarkerReplication, DeleteMarkerReplicationStatus, DeleteReplication,
-        DeleteReplicationStatus, Destination, ReplicationConfiguration, ReplicationRule, ReplicationRuleStatus,
-        VersioningConfiguration,
+    use rustfs_gateway_types::dto::Status;
+    use rustfs_gateway_types::persistence::PersistedVersioningConfiguration as VersioningConfiguration;
+    use rustfs_gateway_types::persistence::{
+        PersistedOptionalReplicationStatus, PersistedReplicationConfiguration, PersistedReplicationDestination,
+        PersistedReplicationRule, PersistedReplicationStatus,
     };
+    use rustfs_scanner_metrics::metrics::IlmAction;
     use uuid::Uuid;
 
     use super::*;
@@ -160,27 +161,27 @@ mod tests {
             for purge_enabled in [false, true] {
                 let snapshot = DeleteReplicationConfigSnapshot::from_configs_for_test(
                     VersioningConfiguration {
-                        status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
+                        status: Some("Enabled".to_owned()),
                         ..Default::default()
                     },
-                    Some(ReplicationConfiguration {
+                    Some(PersistedReplicationConfiguration {
                         role: String::new(),
-                        rules: vec![ReplicationRule {
-                            delete_marker_replication: Some(DeleteMarkerReplication {
+                        rules: vec![PersistedReplicationRule {
+                            delete_marker_replication: Some(PersistedOptionalReplicationStatus {
                                 status: Some(if marker_enabled {
-                                    DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::ENABLED)
+                                    Status::ENABLED.to_string()
                                 } else {
-                                    DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::DISABLED)
+                                    Status::DISABLED.to_string()
                                 }),
                             }),
-                            delete_replication: Some(DeleteReplication {
+                            delete_replication: Some(PersistedReplicationStatus {
                                 status: if purge_enabled {
-                                    DeleteReplicationStatus::from_static(DeleteReplicationStatus::ENABLED)
+                                    Status::ENABLED.to_string()
                                 } else {
-                                    DeleteReplicationStatus::from_static(DeleteReplicationStatus::DISABLED)
+                                    Status::DISABLED.to_string()
                                 },
                             }),
-                            destination: Destination {
+                            destination: PersistedReplicationDestination {
                                 bucket: "arn:rustfs:replication:target".to_string(),
                                 ..Default::default()
                             },
@@ -190,7 +191,7 @@ mod tests {
                             prefix: Some(String::new()),
                             priority: Some(1),
                             source_selection_criteria: None,
-                            status: ReplicationRuleStatus::from_static(ReplicationRuleStatus::ENABLED),
+                            status: Status::ENABLED.to_string(),
                         }],
                     }),
                 );

crates/ecstore/src/bucket/lifecycle/runtime_boundary.rs

@@ -14,7 +14,7 @@
 
 use std::sync::Arc;
 
-use s3s::dto::BucketLifecycleConfiguration;
+use rustfs_gateway_types::persistence::PersistedLifecycleConfiguration;
 use tokio::sync::RwLock;
 use tokio_util::sync::CancellationToken;
 
@@ -52,7 +52,7 @@ pub(crate) fn deployment_id() -> Option<String> {
     sources::deployment_id()
 }
 
-pub(crate) async fn bucket_lifecycle_config(bucket: &str) -> Option<BucketLifecycleConfiguration> {
+pub(crate) async fn bucket_lifecycle_config(bucket: &str) -> Option<PersistedLifecycleConfiguration> {
     sources::bucket_lifecycle_config(bucket).await
 }
 

crates/ecstore/src/bucket/metadata.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use super::msgp_decode::{read_msgp_ext8_time, skip_msgp_value, write_msgp_time};
-use super::object_lock::{ObjectLockApi, ObjectLockStatusExt};
+use super::object_lock::ObjectLockApi;
 use super::versioning::VersioningApi;
 use super::{quota::BucketQuota, target::BucketTargets};
 use crate::bucket::replication::invalid_replication_config_status_field;
@@ -25,12 +25,17 @@ use crate::object_api::WriteCompletion;
 use crate::runtime::sources as runtime_sources;
 use crate::store::ECStore;
 use byteorder::{BigEndian, ByteOrder, LittleEndian};
-use rustfs_policy::policy::BucketPolicy;
-use s3s::dto::{
-    AccelerateConfiguration, BucketLifecycleConfiguration, BucketLoggingStatus, BucketVersioningStatus, CORSConfiguration,
-    NotificationConfiguration, ObjectLockConfiguration, PublicAccessBlockConfiguration, ReplicationConfiguration,
-    RequestPaymentConfiguration, ServerSideEncryptionConfiguration, Tagging, VersioningConfiguration, WebsiteConfiguration,
+use rustfs_gateway_types::cors_tagging::{PersistedCorsConfiguration as CORSConfiguration, PersistedTagging as Tagging};
+use rustfs_gateway_types::persistence::{
+    PersistedAccelerateConfiguration as AccelerateConfiguration,
+    PersistedBucketEncryptionConfiguration as ServerSideEncryptionConfiguration,
+    PersistedBucketLoggingStatus as BucketLoggingStatus, PersistedLifecycleConfiguration,
+    PersistedNotificationConfiguration as NotificationConfiguration, PersistedObjectLockConfiguration as ObjectLockConfiguration,
+    PersistedPublicAccessBlockConfiguration as PublicAccessBlockConfiguration, PersistedReplicationConfiguration,
+    PersistedRequestPaymentConfiguration as RequestPaymentConfiguration,
+    PersistedVersioningConfiguration as VersioningConfiguration, PersistedWebsiteConfiguration as WebsiteConfiguration,
 };
+use rustfs_policy::policy::BucketPolicy;
 use serde::Serializer;
 use sha2::{Digest, Sha256};
 use std::collections::HashMap;
@@ -40,23 +45,11 @@ use time::{Date, OffsetDateTime, PrimitiveDateTime, Time as CivilTime, UtcOffset
 use tracing::error;
 use uuid::Uuid;
 
-// The serving-layer DTO impls for the storage-level Object Lock traits live
-// here because this module owns the persisted `ObjectLockConfiguration`
-// during the s3s ratchet migration (rustfs/backlog#1842).
+// The persisted Object Lock configuration answers the storage-level trait
+// here because this module owns the persisted `ObjectLockConfiguration`.
 impl ObjectLockApi for ObjectLockConfiguration {
     fn enabled(&self) -> bool {
-        self.object_lock_enabled
-            .as_ref()
-            .is_some_and(|v| v.as_str() == s3s::dto::ObjectLockEnabled::ENABLED)
-    }
-}
-
-impl ObjectLockStatusExt for s3s::dto::ObjectLockLegalHoldStatus {
-    fn valid(&self) -> bool {
-        matches!(
-            self.as_str(),
-            s3s::dto::ObjectLockLegalHoldStatus::ON | s3s::dto::ObjectLockLegalHoldStatus::OFF
-        )
+        self.object_lock_enabled.as_deref() == Some("Enabled")
     }
 }
 
@@ -439,6 +432,8 @@ pub struct BucketMetadata {
     pub bucket_incarnation_id: Uuid,
     pub(crate) bucket_incarnation_sidecar: bool,
     pub(crate) bucket_creation_committed: bool,
+    // A legacy default is not proof of an interrupted creation.
+    pub(crate) bucket_creation_commit_record_present: bool,
     pub policy_config_json: Vec<u8>,
     pub notification_config_xml: Vec<u8>,
     pub lifecycle_config_xml: Vec<u8>,
@@ -487,13 +482,13 @@ pub struct BucketMetadata {
 
     pub policy_config: Option<BucketPolicy>,
     pub notification_config: Option<NotificationConfiguration>,
-    pub lifecycle_config: Option<BucketLifecycleConfiguration>,
+    pub lifecycle_config: Option<PersistedLifecycleConfiguration>,
     pub object_lock_config: Option<ObjectLockConfiguration>,
     pub versioning_config: Option<VersioningConfiguration>,
     pub sse_config: Option<ServerSideEncryptionConfiguration>,
     pub tagging_config: Option<Tagging>,
     pub quota_config: Option<BucketQuota>,
-    pub replication_config: Option<ReplicationConfiguration>,
+    pub replication_config: Option<PersistedReplicationConfiguration>,
     pub bucket_target_config: Option<BucketTargets>,
     pub bucket_target_config_meta: Option<HashMap<String, String>>,
     pub cors_config: Option<CORSConfiguration>,
@@ -514,6 +509,7 @@ impl Default for BucketMetadata {
             bucket_incarnation_id: Uuid::nil(),
             bucket_incarnation_sidecar: false,
             bucket_creation_committed: false,
+            bucket_creation_commit_record_present: false,
             policy_config_json: Default::default(),
             notification_config_xml: Default::default(),
             lifecycle_config_xml: Default::default(),
@@ -752,7 +748,10 @@ impl BucketMetadata {
                 "TableBucketConfigUpdatedAt" => self.table_bucket_config_updated_at = read_msgp_time_value(rd)?,
                 "DurabilityConfigUpdatedAt" => self.durability_config_updated_at = read_msgp_time_value(rd)?,
                 "OnDemandMigrationConfigUpdatedAt" => self.on_demand_migration_config_updated_at = read_msgp_time_value(rd)?,
-                "BucketCreationCommitted" => self.bucket_creation_committed = read_msgp_bool(rd)?,
+                "BucketCreationCommitted" => {
+                    self.bucket_creation_committed = read_msgp_bool(rd)?;
+                    self.bucket_creation_commit_record_present = true;
+                }
                 other => {
                     tracing::debug!(field = %other, "BucketMetadata decode_from: skipping unknown field");
                     skip_msgp_value(rd)?;
@@ -765,8 +764,10 @@ impl BucketMetadata {
 
     /// Encode to msgp bytes. Field order follows MinIO BucketMetadata for compatibility.
     pub fn encode_to<W: Write>(&self, wr: &mut W) -> Result<()> {
-        // Map size: MinIO fields (25) + RustFS extensions (22)
-        let map_len: u32 = 47;
+        // Preserve the absence of a legacy commit record across config rewrites.
+        let commit_record_present = self.bucket_creation_commit_record_present || self.bucket_creation_committed;
+        // Map size: MinIO fields (25) + RustFS extensions (21) + optional commit record.
+        let map_len: u32 = 46 + u32::from(commit_record_present);
         rmp::encode::write_map_len(wr, map_len)?;
 
         // MinIO field order (same as Go struct)
@@ -847,8 +848,10 @@ impl BucketMetadata {
         write_msgp_time(wr, self.durability_config_updated_at)?;
         rmp::encode::write_str(wr, "OnDemandMigrationConfigUpdatedAt")?;
         write_msgp_time(wr, self.on_demand_migration_config_updated_at)?;
-        rmp::encode::write_str(wr, "BucketCreationCommitted")?;
-        rmp::encode::write_bool(wr, self.bucket_creation_committed)?;
+        if commit_record_present {
+            rmp::encode::write_str(wr, "BucketCreationCommitted")?;
+            rmp::encode::write_bool(wr, self.bucket_creation_committed)?;
+        }
 
         Ok(())
     }
@@ -1018,9 +1021,11 @@ impl BucketMetadata {
                     None
                 } else {
                     let config = deserialize::<VersioningConfiguration>(&data)?;
-                    if config.status.as_ref().is_some_and(|status| {
-                        !matches!(status.as_str(), BucketVersioningStatus::ENABLED | BucketVersioningStatus::SUSPENDED)
-                    }) {
+                    if config
+                        .status
+                        .as_ref()
+                        .is_some_and(|status| !matches!(status.as_str(), "Enabled" | "Suspended"))
+                    {
                         return Err(Error::other("bucket versioning configuration has an invalid status"));
                     }
                     Some(config)
@@ -1033,7 +1038,7 @@ impl BucketMetadata {
                 let config = if data.is_empty() {
                     None
                 } else {
-                    let config = deserialize::<ReplicationConfiguration>(&data)?;
+                    let config = deserialize::<PersistedReplicationConfiguration>(&data)?;
                     if let Some(field) = invalid_replication_config_status_field(&config) {
                         return Err(Error::other(format!("replication field {field} has an invalid status")));
                     }
@@ -1227,8 +1232,8 @@ impl BucketMetadata {
         }
         self.lifecycle_config = None;
         if !self.lifecycle_config_xml.is_empty()
-            && let Err(e) =
-                deserialize::<BucketLifecycleConfiguration>(&self.lifecycle_config_xml).map(|c| self.lifecycle_config = Some(c))
+            && let Err(e) = deserialize::<PersistedLifecycleConfiguration>(&self.lifecycle_config_xml)
+                .map(|c| self.lifecycle_config = Some(c))
         {
             tracing::warn!(
                 event = "bucket_metadata_parse_failed",
@@ -1314,8 +1319,8 @@ impl BucketMetadata {
         }
         self.replication_config = None;
         if !self.replication_config_xml.is_empty()
-            && let Err(e) =
-                deserialize::<ReplicationConfiguration>(&self.replication_config_xml).map(|c| self.replication_config = Some(c))
+            && let Err(e) = deserialize::<PersistedReplicationConfiguration>(&self.replication_config_xml)
+                .map(|c| self.replication_config = Some(c))
         {
             tracing::warn!(
                 event = "bucket_metadata_parse_failed",
@@ -1691,6 +1696,13 @@ mod test {
         let mut bm = BucketMetadata::unmarshal(&body[4..]).expect("unmarshal recovered blob");
         assert_eq!(bm.name, "interop");
         assert!(!bm.bucket_creation_committed, "legacy metadata must default to uncommitted");
+        assert!(!bm.bucket_creation_commit_record_present, "legacy metadata has no creation-commit record");
+        let rewritten = BucketMetadata::unmarshal(&bm.marshal_msg().expect("rewrite legacy metadata"))
+            .expect("read rewritten legacy metadata");
+        assert!(
+            !rewritten.bucket_creation_commit_record_present,
+            "rewriting legacy metadata must not fabricate a creation intent"
+        );
         bm.parse_all_configs().expect("parse recovered configs");
         assert!(bm.lifecycle_config.is_some());
     }
@@ -1708,6 +1720,7 @@ mod test {
 
         assert_eq!(bm.name, new.name);
         assert!(new.bucket_creation_committed);
+        assert!(new.bucket_creation_commit_record_present);
         assert!(!bm.bucket_incarnation_id.is_nil());
         assert_eq!(bm.bucket_incarnation_id, new.bucket_incarnation_id);
     }
@@ -1812,17 +1825,15 @@ mod test {
 
     #[test]
     fn object_locking_requires_lock_metadata_not_plain_versioning() {
-        use s3s::dto::ObjectLockEnabled;
-
         let mut bm = BucketMetadata::new("test-bucket");
         bm.versioning_config = Some(VersioningConfiguration {
-            status: Some(s3s::dto::BucketVersioningStatus::from_static("Enabled")),
+            status: Some("Enabled".to_owned()),
             ..Default::default()
         });
         assert!(!bm.object_locking());
 
         bm.object_lock_config = Some(ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+            object_lock_enabled: Some("Enabled".to_owned()),
             ..Default::default()
         });
         assert!(bm.object_locking());

crates/ecstore/src/bucket/metadata_sys.rs

@@ -30,14 +30,18 @@ use crate::storage_api_contracts::heal::HealOperations as _;
 use crate::storage_api_contracts::namespace::NamespaceLocking as _;
 use crate::store::{ECStore, await_bucket_namespace_operation};
 use futures::future::join_all;
+use rustfs_gateway_types::cors_tagging::{PersistedCorsConfiguration as CORSConfiguration, PersistedTagging as Tagging};
+use rustfs_gateway_types::persistence::{
+    PersistedAccelerateConfiguration as AccelerateConfiguration,
+    PersistedBucketEncryptionConfiguration as ServerSideEncryptionConfiguration,
+    PersistedBucketLoggingStatus as BucketLoggingStatus, PersistedLifecycleConfiguration,
+    PersistedNotificationConfiguration as NotificationConfiguration, PersistedObjectLockConfiguration as ObjectLockConfiguration,
+    PersistedPublicAccessBlockConfiguration as PublicAccessBlockConfiguration, PersistedReplicationConfiguration,
+    PersistedRequestPaymentConfiguration as RequestPaymentConfiguration,
+    PersistedVersioningConfiguration as VersioningConfiguration, PersistedWebsiteConfiguration as WebsiteConfiguration,
+};
 use rustfs_heal_contracts::heal_channel::HealOpts;
 use rustfs_policy::policy::BucketPolicy;
-use s3s::dto::ReplicationConfiguration;
-use s3s::dto::{
-    AccelerateConfiguration, BucketLifecycleConfiguration, BucketLoggingStatus, CORSConfiguration, NotificationConfiguration,
-    ObjectLockConfiguration, ObjectLockEnabled, ObjectLockRetentionMode, PublicAccessBlockConfiguration,
-    RequestPaymentConfiguration, ServerSideEncryptionConfiguration, Tagging, VersioningConfiguration, WebsiteConfiguration,
-};
 use std::collections::HashSet;
 use std::time::Duration;
 use std::{
@@ -168,7 +172,7 @@ pub(crate) fn object_lock_config_state_from_authoritative_metadata(bm: &BucketMe
     if bm.lock_enabled {
         return Ok(ObjectLockConfigState::Configured {
             config: ObjectLockConfiguration {
-                object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+                object_lock_enabled: Some("Enabled".to_owned()),
                 rule: None,
             },
             updated_at: bm.object_lock_config_updated_at,
@@ -212,17 +216,10 @@ pub(crate) fn configured_object_lock_state_for_tests(
 ) -> ObjectLockConfigState {
     ObjectLockConfigState::Configured {
         config: ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
-            rule: Some(s3s::dto::ObjectLockRule {
-                default_retention: Some(s3s::dto::DefaultRetention {
-                    mode: Some(s3s::dto::ObjectLockRetentionMode::from_static(match mode {
-                        crate::bucket::object_lock::types::RetentionMode::Governance => {
-                            s3s::dto::ObjectLockRetentionMode::GOVERNANCE
-                        }
-                        crate::bucket::object_lock::types::RetentionMode::Compliance => {
-                            s3s::dto::ObjectLockRetentionMode::COMPLIANCE
-                        }
-                    })),
+            object_lock_enabled: Some("Enabled".to_owned()),
+            rule: Some(rustfs_gateway_types::persistence::PersistedObjectLockRule {
+                default_retention: Some(rustfs_gateway_types::persistence::PersistedDefaultRetention {
+                    mode: Some(mode.as_str().to_owned()),
                     days: Some(days),
                     years: None,
                 }),
@@ -233,7 +230,7 @@ pub(crate) fn configured_object_lock_state_for_tests(
 }
 
 fn validate_authoritative_object_lock_config(config: &ObjectLockConfiguration) -> Result<()> {
-    if config.object_lock_enabled.as_ref().map(ObjectLockEnabled::as_str) != Some(ObjectLockEnabled::ENABLED) {
+    if config.object_lock_enabled.as_deref() != Some("Enabled") {
         return Err(Error::other("persisted bucket Object Lock enabled state is invalid"));
     }
 
@@ -246,7 +243,7 @@ fn validate_authoritative_object_lock_config(config: &ObjectLockConfiguration) -
     if !retention
         .mode
         .as_ref()
-        .is_some_and(|mode| matches!(mode.as_str(), ObjectLockRetentionMode::COMPLIANCE | ObjectLockRetentionMode::GOVERNANCE))
+        .is_some_and(|mode| matches!(mode.as_str(), "COMPLIANCE" | "GOVERNANCE"))
     {
         return Err(Error::other("persisted bucket Object Lock retention mode is invalid"));
     }
@@ -1368,7 +1365,7 @@ pub async fn get_public_access_block_config(bucket: &str) -> Result<(PublicAcces
     bucket_meta_sys.get_public_access_block_config(bucket).await
 }
 
-pub async fn get_lifecycle_config(bucket: &str) -> Result<(BucketLifecycleConfiguration, OffsetDateTime)> {
+pub async fn get_lifecycle_config(bucket: &str) -> Result<(PersistedLifecycleConfiguration, OffsetDateTime)> {
     let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
     let bucket_meta_sys = bucket_meta_sys_lock.read().await;
 
@@ -1587,7 +1584,7 @@ pub(crate) async fn get_cached_quota_config_and_incarnation_in(
     bucket_meta_sys.cached_quota_config_and_incarnation(bucket).await
 }
 
-pub async fn get_replication_config(bucket: &str) -> Result<(ReplicationConfiguration, OffsetDateTime)> {
+pub async fn get_replication_config(bucket: &str) -> Result<(PersistedReplicationConfiguration, OffsetDateTime)> {
     let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
     let bucket_meta_sys = bucket_meta_sys_lock.read().await;
 
@@ -1597,7 +1594,7 @@ pub async fn get_replication_config(bucket: &str) -> Result<(ReplicationConfigur
 pub(crate) async fn get_replication_config_in(
     ctx: &crate::runtime::instance::InstanceContext,
     bucket: &str,
-) -> Result<(ReplicationConfiguration, OffsetDateTime)> {
+) -> Result<(PersistedReplicationConfiguration, OffsetDateTime)> {
     let bucket_meta_sys_lock = bucket_metadata_sys_of(ctx)?;
     let bucket_meta_sys = bucket_meta_sys_lock.read().await;
 
@@ -1723,9 +1720,27 @@ struct MetadataPublishGuard {
     _guard: tokio::sync::OwnedMutexGuard<MetadataPublishLockState>,
 }
 
+#[derive(Debug, Clone)]
+pub(crate) struct PendingBucketCreationProof {
+    pub(crate) generation: Uuid,
+    pub(crate) intent: Vec<u8>,
+    pub(crate) versioning_requested: bool,
+    pub(crate) witnesses: Vec<crate::disk::os::NativeBucketCreationWitness>,
+}
+
+impl PendingBucketCreationProof {
+    pub(crate) fn matches_metadata(&self, metadata: &BucketMetadata) -> Result<bool> {
+        Ok(!metadata.bucket_creation_committed
+            && metadata.bucket_incarnation_sidecar
+            && metadata.bucket_incarnation_id == self.generation
+            && metadata.marshal_msg()? == self.intent)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct BucketMetadataSys {
     metadata_map: Arc<RwLock<HashMap<String, Arc<BucketMetadata>>>>,
+    pending_bucket_creations: Arc<RwLock<HashMap<String, PendingBucketCreationProof>>>,
     /// Serializes metadata-map commits and their derived cache updates for one
     /// bucket. Namespace locks, when present, are acquired before this lock.
     metadata_publish_locks: Arc<MetadataPublishLockRegistry>,
@@ -1769,6 +1784,7 @@ impl BucketMetadataSys {
     pub fn new(api: Arc<ECStore>) -> Self {
         Self {
             metadata_map: Arc::new(RwLock::new(HashMap::new())),
+            pending_bucket_creations: Arc::new(RwLock::new(HashMap::new())),
             metadata_publish_locks: Arc::new(MetadataPublishLockRegistry {
                 locks: StdMutex::new(HashMap::new()),
             }),
@@ -1799,6 +1815,81 @@ impl BucketMetadataSys {
             .expect("bucket metadata object store should still be live")
     }
 
+    pub(crate) async fn pending_bucket_creation(&self, bucket: &str) -> Option<PendingBucketCreationProof> {
+        self.pending_bucket_creations.read().await.get(bucket).cloned()
+    }
+
+    pub(crate) async fn grant_pending_bucket_creation(&self, bucket: &str, proof: PendingBucketCreationProof) {
+        self.pending_bucket_creations.write().await.insert(bucket.to_owned(), proof);
+    }
+
+    pub(crate) async fn revoke_pending_bucket_creation(&self, bucket: &str) {
+        self.pending_bucket_creations.write().await.remove(bucket);
+    }
+
+    pub(crate) async fn consume_pending_bucket_creation(
+        &self,
+        bucket: &str,
+        metadata: &BucketMetadata,
+        witnesses: &[crate::disk::os::NativeBucketCreationWitness],
+    ) -> Result<bool> {
+        let mut pending = self.pending_bucket_creations.write().await;
+        let Some(proof) = pending.get(bucket) else {
+            return Ok(false);
+        };
+        if !proof.matches_metadata(metadata)?
+            || proof.witnesses.len() != witnesses.len()
+            || !proof
+                .witnesses
+                .iter()
+                .zip(witnesses)
+                .all(|(old, current)| old.matches(current))
+            || !crate::disk::os::consume_native_creation_witnesses(witnesses)
+        {
+            return Ok(false);
+        }
+        pending.remove(bucket);
+        Ok(true)
+    }
+
+    #[cfg(test)]
+    pub(crate) async fn refresh_bucket_for_test(&self, bucket: &str) -> Result<()> {
+        let expected = self.metadata_map.read().await.get(bucket).cloned();
+        let lock = self.object_store().new_ns_lock(bucket, bucket).await?;
+        let guard = lock.get_read_lock(crate::set_disk::get_lock_acquire_timeout()).await?;
+        self.load_bucket_under_namespace(bucket, MetadataLoadMode::Refresh, expected.as_ref(), &guard)
+            .await
+    }
+
+    #[cfg(test)]
+    pub(crate) async fn publish_persisted_metadata_for_test(&self, bucket: &str) -> Result<()> {
+        let expected = self.metadata_map.read().await.get(bucket).cloned();
+        let lock = self.object_store().new_ns_lock(bucket, bucket).await?;
+        let guard = lock.get_read_lock(crate::set_disk::get_lock_acquire_timeout()).await?;
+        let (metadata, persisted) = await_bucket_namespace_operation(
+            Some(&guard),
+            bucket,
+            "test cached metadata load",
+            load_bucket_metadata_parse_with_presence(self.object_store(), bucket, true),
+        )
+        .await?;
+        self.publish_if_unchanged(bucket, expected.as_ref(), metadata, persisted, &guard)
+            .await
+    }
+
+    #[cfg(test)]
+    pub(crate) async fn migrate_bucket_creation_commit_for_test(&self, bucket: &str) -> Result<()> {
+        self.migrate_bucket_creation_commit(bucket).await.map(|_| ())
+    }
+
+    #[cfg(test)]
+    pub(crate) async fn legacy_migration_reports_missing_bucket_for_test(&self, bucket: &str) -> Result<bool> {
+        Ok(matches!(
+            self.migrate_legacy_metadata(bucket).await?,
+            BucketMetadataAuthority::MissingBucket
+        ))
+    }
+
     fn object_store_if_live(&self) -> Option<Arc<ECStore>> {
         self.api.upgrade()
     }
@@ -1989,6 +2080,7 @@ impl BucketMetadataSys {
         expected: Option<&Arc<BucketMetadata>>,
         namespace_guard: &rustfs_lock::NamespaceLockGuard,
     ) -> Result<()> {
+        self.revoke_pending_bucket_creation(bucket).await;
         if !await_bucket_namespace_operation(
             Some(namespace_guard),
             bucket,
@@ -2072,6 +2164,7 @@ impl BucketMetadataSys {
         persisted: bool,
         namespace_guard: &rustfs_lock::NamespaceLockGuard,
     ) -> Result<()> {
+        self.revoke_pending_bucket_creation(bucket).await;
         if !persisted {
             let _publish_guard = self
                 .lock_metadata_publish(bucket, namespace_guard, "refreshed bucket metadata absence publish")
@@ -2133,6 +2226,7 @@ impl BucketMetadataSys {
     }
 
     pub async fn set(&self, bucket: String, bm: Arc<BucketMetadata>) {
+        self.revoke_pending_bucket_creation(&bucket).await;
         if !is_meta_bucketname(&bucket) {
             let publish_lock = self.metadata_publish_lock(&bucket);
             let _publish_guard = publish_lock.lock().await;
@@ -2154,6 +2248,7 @@ impl BucketMetadataSys {
         if is_meta_bucketname(bucket) {
             return false;
         }
+        self.revoke_pending_bucket_creation(bucket).await;
         let publish_lock = self.metadata_publish_lock(bucket);
         let _publish_guard = publish_lock.lock().await;
         let mut map = self.metadata_map.write().await;
@@ -2171,6 +2266,7 @@ impl BucketMetadataSys {
     }
 
     async fn _reset(&mut self) {
+        self.pending_bucket_creations.write().await.clear();
         let mut map = self.metadata_map.write().await;
         map.clear();
         drop(map);
@@ -2309,6 +2405,7 @@ impl BucketMetadataSys {
     /// server's metadata never leaks into the ambient (first) instance.
     pub(crate) async fn persist_and_set(&self, bm: BucketMetadata) -> Result<()> {
         let mut bm = bm;
+        self.revoke_pending_bucket_creation(&bm.name).await;
         bm.save_with_store(self.object_store()).await?;
 
         self.set(bm.name.clone(), Arc::new(bm)).await;
@@ -2317,6 +2414,7 @@ impl BucketMetadataSys {
     }
 
     async fn persist_new_and_set(&self, mut bm: BucketMetadata) -> Result<()> {
+        self.revoke_pending_bucket_creation(&bm.name).await;
         bm.bucket_creation_committed = true;
         bm.save_with_store_committed(self.object_store()).await?;
         save_bucket_incarnation(self.object_store(), &bm.name, bm.bucket_incarnation_id).await?;
@@ -2326,7 +2424,9 @@ impl BucketMetadataSys {
     }
 
     async fn persist_new_bucket_metadata_intent(&self, mut bm: BucketMetadata) -> Result<()> {
+        self.revoke_pending_bucket_creation(&bm.name).await;
         bm.bucket_creation_committed = false;
+        bm.bucket_creation_commit_record_present = true;
         bm.save_with_store(self.object_store()).await?;
         save_bucket_incarnation(self.object_store(), &bm.name, bm.bucket_incarnation_id).await?;
         bm.bucket_incarnation_sidecar = true;
@@ -2336,6 +2436,7 @@ impl BucketMetadataSys {
     }
 
     async fn commit_bucket_metadata(&self, mut bm: BucketMetadata) -> Result<()> {
+        self.revoke_pending_bucket_creation(&bm.name).await;
         bm.parse_all_configs()?;
         bm.bucket_incarnation_sidecar = true;
         // The caller holds the full bucket creation fence (lifecycle, metadata
@@ -2384,6 +2485,7 @@ impl BucketMetadataSys {
         bucket: &str,
         namespace_guard: &rustfs_lock::NamespaceLockGuard,
     ) -> Result<()> {
+        self.revoke_pending_bucket_creation(bucket).await;
         let expected = self.metadata_map.read().await.get(bucket).cloned();
         if !self
             .bucket_exists(bucket, namespace_guard, "peer bucket metadata existence check")
@@ -2440,6 +2542,7 @@ impl BucketMetadataSys {
             #[cfg(test)]
             self.lazy_disk_loads.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
 
+            self.revoke_pending_bucket_creation(bucket).await;
             let lock = self.object_store().new_ns_lock(bucket, bucket).await?;
             let guard = lock.get_read_lock(crate::set_disk::get_lock_acquire_timeout()).await?;
             #[cfg(test)]
@@ -2765,6 +2868,7 @@ impl BucketMetadataSys {
     /// revalidated at write quorum, so a stale snapshot can neither revert an
     /// acknowledged configuration update nor outlive a delete/recreate.
     async fn migrate_bucket_creation_commit(&self, bucket: &str) -> Result<BucketMetadataAuthority> {
+        self.revoke_pending_bucket_creation(bucket).await;
         let transaction_lock = self
             .object_store()
             .new_ns_lock(RUSTFS_META_BUCKET, &bucket_metadata_transaction_lock_key(bucket))
@@ -2842,6 +2946,7 @@ impl BucketMetadataSys {
         &self,
         bucket: &str,
     ) -> Result<BucketMetadataAuthority> {
+        self.revoke_pending_bucket_creation(bucket).await;
         #[cfg(test)]
         if self.object_lock_disk_read_errors.write().await.remove(bucket) {
             return Err(Error::other(format!("injected Object Lock metadata disk read failure: {bucket}")));
@@ -3017,7 +3122,7 @@ impl BucketMetadataSys {
         }
     }
 
-    pub async fn get_lifecycle_config(&self, bucket: &str) -> Result<(BucketLifecycleConfiguration, OffsetDateTime)> {
+    pub async fn get_lifecycle_config(&self, bucket: &str) -> Result<(PersistedLifecycleConfiguration, OffsetDateTime)> {
         let (bm, _) = self.get_config(bucket).await?;
 
         match ConfigState::of(&bm.lifecycle_config_xml, &bm.lifecycle_config).require(bucket, BUCKET_LIFECYCLE_CONFIG)? {
@@ -3140,7 +3245,7 @@ impl BucketMetadataSys {
         }))
     }
 
-    pub async fn get_replication_config(&self, bucket: &str) -> Result<(ReplicationConfiguration, OffsetDateTime)> {
+    pub async fn get_replication_config(&self, bucket: &str) -> Result<(PersistedReplicationConfiguration, OffsetDateTime)> {
         let (bm, _) = self.get_config(bucket).await?;
 
         if !bm.replication_config_xml.is_empty() && bm.replication_config.is_none() {
@@ -3234,6 +3339,7 @@ mod tests {
     };
     use crate::bucket::target::{BucketTarget, BucketTargetType, Credentials};
     use crate::config::com::read_config;
+    use crate::disk::{DiskAPI as _, RUSTFS_META_TMP_BUCKET};
     use crate::storage_api_contracts::bucket::{BucketOperations as _, DeleteBucketOptions, MakeBucketOptions};
     use byteorder::{ByteOrder as _, LittleEndian};
     use serial_test::serial;
@@ -3288,6 +3394,180 @@ mod tests {
         ),
     ];
 
+    #[tokio::test]
+    #[serial(storage_class_env)]
+    async fn persistence_entry_failures_revoke_pending_creation_before_cache_publish() {
+        let (dirs, store) = isolated_store_over_temp_disks().await;
+        init_bucket_metadata_sys(store.clone(), Vec::new()).await;
+        let sys = bucket_metadata_sys_of(&store.ctx).expect("instance metadata system");
+        let sys = sys.read().await.clone();
+        let options = MakeBucketOptions {
+            lock_enabled: true,
+            ..Default::default()
+        };
+        for entry in ["save", "persist", "persist-new", "commit"] {
+            let bucket = format!("revoke-{entry}-{}", Uuid::new_v4());
+            store.fail_next_bucket_creation_after_intent_for_test(&bucket);
+            store
+                .make_bucket(&bucket, &options)
+                .await
+                .expect_err("stop the real producer before physical publication");
+            sys.pending_bucket_creation(&bucket)
+                .await
+                .expect("the producer must leave a real live creation permission");
+            let (intent, persisted) = get_config_from_disk_with_presence_in(&store.ctx, &bucket)
+                .await
+                .expect("read the original producer intent");
+            assert!(persisted, "{entry}: the complete original intent must be persisted");
+            let original_intent = intent.marshal_msg().expect("encode the original intent");
+
+            // Keep the creation fence order used by the real producer.
+            let lifecycle_guard = store
+                .acquire_bucket_lifecycle_write_lock(&bucket)
+                .await
+                .expect("hold the bucket lifecycle fence");
+            let transaction_guard = acquire_bucket_metadata_transaction_lock_in(&store.ctx, &bucket)
+                .await
+                .expect("hold the metadata transaction fence");
+            let namespace_lock = store
+                .new_ns_lock(&bucket, &bucket)
+                .await
+                .expect("create the exact bucket namespace lock");
+            let namespace_guard = namespace_lock
+                .get_write_lock(crate::set_disk::get_lock_acquire_timeout())
+                .await
+                .expect("hold the exact bucket namespace fence");
+
+            // A file at each native staging root causes actual IO to fail before
+            // metadata can reach the cache-publishing set call. Preserve the
+            // original staging directories so no fixture data is discarded.
+            for dir in &dirs {
+                let staging = dir.path().join(RUSTFS_META_TMP_BUCKET);
+                let saved = dir.path().join(".rustfs.sys/revocation-saved-tmp");
+                std::fs::rename(&staging, &saved).expect("preserve the native staging directory");
+                std::fs::write(&staging, b"block metadata staging with a non-directory")
+                    .expect("install an actual non-directory IO obstruction");
+            }
+            let result = match entry {
+                "save" => sys.save(intent).await,
+                "persist" => sys.persist_and_set(intent).await,
+                "persist-new" => sys.persist_new_and_set(intent).await,
+                "commit" => sys.commit_bucket_metadata(intent).await,
+                _ => unreachable!(),
+            };
+            for dir in &dirs {
+                let staging = dir.path().join(RUSTFS_META_TMP_BUCKET);
+                let saved = dir.path().join(".rustfs.sys/revocation-saved-tmp");
+                std::fs::remove_file(&staging).expect("remove only the fixture's staging obstruction");
+                std::fs::rename(&saved, &staging).expect("restore the complete original staging directory");
+            }
+            drop((namespace_guard, transaction_guard, lifecycle_guard));
+            result.expect_err("native persistence must fail before its downstream cache set");
+            assert!(
+                sys.pending_bucket_creation(&bucket).await.is_none(),
+                "{entry}: the entry revoker must retire live permission even when persistence fails"
+            );
+            let (after_failure, present) = get_config_from_disk_with_presence_in(&store.ctx, &bucket)
+                .await
+                .expect("read the intent after the failed persistence entry");
+            assert!(present, "{entry}: a failed persistence entry must retain the original metadata");
+            assert_eq!(
+                after_failure
+                    .marshal_msg()
+                    .expect("encode the original intent after persistence failure"),
+                original_intent,
+                "{entry}: native IO failure must not change the original generation or complete intent"
+            );
+            let error = store
+                .make_bucket(&bucket, &options)
+                .await
+                .expect_err("a failed ordinary persistence entry cannot preserve creation permission");
+            assert!(error.to_string().contains("administrator recovery"), "{entry}: {error}");
+            let (after_retry, _) = get_config_from_disk_with_presence_in(&store.ctx, &bucket)
+                .await
+                .expect("read the original intent after the rejected retry");
+            assert_eq!(
+                after_retry.marshal_msg().expect("encode the intent after the rejected retry"),
+                original_intent,
+                "{entry}: the rejected retry must preserve the complete original intent"
+            );
+            for disk in store.pools[0].disk_set[0].disks.read().await.iter() {
+                assert!(
+                    matches!(
+                        disk.as_ref().expect("native disk").stat_volume(&bucket).await,
+                        Err(crate::disk::error::DiskError::VolumeNotFound)
+                    ),
+                    "{entry}: failed persistence and the rejected retry must not publish a physical volume"
+                );
+            }
+        }
+    }
+
+    #[tokio::test]
+    #[serial(storage_class_env)]
+    async fn metadata_reset_revokes_real_pending_creation_without_changing_persisted_intent() {
+        let (_dirs, store) = isolated_store_over_temp_disks().await;
+        init_bucket_metadata_sys(store.clone(), Vec::new()).await;
+        let bucket = format!("revoke-reset-{}", Uuid::new_v4());
+        let options = MakeBucketOptions {
+            lock_enabled: true,
+            ..Default::default()
+        };
+        store.fail_next_bucket_creation_after_intent_for_test(&bucket);
+        store
+            .make_bucket(&bucket, &options)
+            .await
+            .expect_err("stop the real producer before physical publication");
+        let sys = bucket_metadata_sys_of(&store.ctx).expect("instance metadata system");
+        let mut sys = sys.read().await.clone();
+        sys.pending_bucket_creation(&bucket)
+            .await
+            .expect("the real producer must leave live creation permission before reset");
+        let (intent, persisted) = get_config_from_disk_with_presence_in(&store.ctx, &bucket)
+            .await
+            .expect("read the original intent before cache reset");
+        assert!(persisted, "cache reset starts from a complete real persisted intent");
+        let original_intent = intent.marshal_msg().expect("encode the original reset intent");
+        sys._reset().await;
+        assert!(
+            sys.pending_bucket_creation(&bucket).await.is_none(),
+            "reset must revoke the producer-issued permission shared with the instance metadata system"
+        );
+        let (after_reset, present) = get_config_from_disk_with_presence_in(&store.ctx, &bucket)
+            .await
+            .expect("read the original intent after cache reset");
+        assert!(present, "cache reset must retain the persisted intent");
+        assert_eq!(
+            after_reset.marshal_msg().expect("encode the intent after cache reset"),
+            original_intent,
+            "cache reset must leave the original generation and complete persisted intent unchanged"
+        );
+        let error = store
+            .make_bucket(&bucket, &options)
+            .await
+            .expect_err("reset cannot regrant the producer's old creation permission");
+        assert!(error.to_string().contains("administrator recovery"), "{error}");
+        let (after_retry, _) = get_config_from_disk_with_presence_in(&store.ctx, &bucket)
+            .await
+            .expect("read the intent after the reset-induced retry rejection");
+        assert_eq!(
+            after_retry
+                .marshal_msg()
+                .expect("encode the intent after the rejected reset retry"),
+            original_intent,
+            "the reset-induced rejection must preserve the original complete intent"
+        );
+        for disk in store.pools[0].disk_set[0].disks.read().await.iter() {
+            assert!(
+                matches!(
+                    disk.as_ref().expect("native disk").stat_volume(&bucket).await,
+                    Err(crate::disk::error::DiskError::VolumeNotFound)
+                ),
+                "cache reset and the rejected retry must not publish a physical volume"
+            );
+        }
+    }
+
     #[tokio::test]
     async fn g_d3_003_new_writer_replication_loads_without_fail_closed_state() {
         let (dirs, store) = isolated_store_over_temp_disks().await;
@@ -3476,7 +3756,7 @@ mod tests {
         let mut versioned = BucketMetadata::new("authoritative-versioned");
         versioned.versioning_config_xml = b"<VersioningConfiguration><Status>Enabled</Status></VersioningConfiguration>".to_vec();
         versioned.versioning_config = Some(VersioningConfiguration {
-            status: Some(s3s::dto::BucketVersioningStatus::from_static(s3s::dto::BucketVersioningStatus::ENABLED)),
+            status: Some("Enabled".to_owned()),
             ..Default::default()
         });
         sys.set("authoritative-versioned".to_string(), Arc::new(versioned)).await;
@@ -3599,25 +3879,24 @@ mod tests {
         else {
             panic!("legacy lock-enabled metadata must remain configured");
         };
-        assert_eq!(
-            config.object_lock_enabled.as_ref().map(|value| value.as_str()),
-            Some(ObjectLockEnabled::ENABLED)
-        );
+        assert_eq!(config.object_lock_enabled.as_deref(), Some("Enabled"));
         assert!(config.rule.is_none());
     }
 
     #[test]
     fn authoritative_object_lock_state_rejects_invalid_retention_periods() {
-        use s3s::dto::{DefaultRetention, ObjectLockRule};
+        use rustfs_gateway_types::persistence::{
+            PersistedDefaultRetention as DefaultRetention, PersistedObjectLockRule as ObjectLockRule,
+        };
 
         for (days, years) in [(Some(0), None), (Some(-1), None), (Some(1), Some(1)), (None, None)] {
             let mut metadata = BucketMetadata::new("invalid-object-lock");
             metadata.object_lock_config = Some(ObjectLockConfiguration {
-                object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+                object_lock_enabled: Some("Enabled".to_owned()),
                 rule: Some(ObjectLockRule {
                     default_retention: Some(DefaultRetention {
                         days,
-                        mode: Some(ObjectLockRetentionMode::from_static(ObjectLockRetentionMode::COMPLIANCE)),
+                        mode: Some("COMPLIANCE".to_owned()),
                         years,
                     }),
                 }),
@@ -3632,9 +3911,11 @@ mod tests {
 
     #[test]
     fn authoritative_object_lock_state_rejects_invalid_enabled_mode_and_rule() {
-        use s3s::dto::{DefaultRetention, ObjectLockRule};
+        use rustfs_gateway_types::persistence::{
+            PersistedDefaultRetention as DefaultRetention, PersistedObjectLockRule as ObjectLockRule,
+        };
 
-        for enabled in [None, Some(ObjectLockEnabled::from("Disabled".to_string()))] {
+        for enabled in [None, Some("Disabled".to_string())] {
             let mut metadata = BucketMetadata::new("invalid-object-lock-enabled");
             metadata.lock_enabled = true;
             metadata.object_lock_config = Some(ObjectLockConfiguration {
@@ -3646,11 +3927,11 @@ mod tests {
 
         let mut invalid_mode = BucketMetadata::new("invalid-object-lock-mode");
         invalid_mode.object_lock_config = Some(ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+            object_lock_enabled: Some("Enabled".to_owned()),
             rule: Some(ObjectLockRule {
                 default_retention: Some(DefaultRetention {
                     days: Some(1),
-                    mode: Some(ObjectLockRetentionMode::from("invalid".to_string())),
+                    mode: Some("invalid".to_string()),
                     years: None,
                 }),
             }),
@@ -3659,7 +3940,7 @@ mod tests {
 
         let mut missing_retention = BucketMetadata::new("missing-object-lock-retention");
         missing_retention.object_lock_config = Some(ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+            object_lock_enabled: Some("Enabled".to_owned()),
             rule: Some(ObjectLockRule { default_retention: None }),
         });
         assert!(object_lock_config_state_from_authoritative_metadata(&missing_retention).is_err());
@@ -3669,7 +3950,7 @@ mod tests {
     fn object_lock_ever_enabled_marker_survives_config_removal() {
         let mut metadata = BucketMetadata::new("lock-config-removed");
         let config = ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+            object_lock_enabled: Some("Enabled".to_owned()),
             rule: None,
         };
         metadata
@@ -3687,10 +3968,7 @@ mod tests {
         else {
             panic!("an ever-enabled bucket must remain Object Lock configured");
         };
-        assert_eq!(
-            config.object_lock_enabled.as_ref().map(ObjectLockEnabled::as_str),
-            Some(ObjectLockEnabled::ENABLED)
-        );
+        assert_eq!(config.object_lock_enabled.as_deref(), Some("Enabled"));
     }
 
     #[tokio::test]
@@ -3706,7 +3984,7 @@ mod tests {
 
         let node = Arc::new(RwLock::new(BucketMetadataSys::new(ecstore.clone())));
         let config = ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+            object_lock_enabled: Some("Enabled".to_owned()),
             rule: None,
         };
         update_with_sys(
@@ -4687,7 +4965,7 @@ mod tests {
     #[tokio::test]
     async fn update_config_with_persists_tagging_rewrite_across_disk_reload() {
         use crate::bucket::metadata::BUCKET_TAGGING_CONFIG;
-        use s3s::dto::Tag;
+        use rustfs_gateway_types::cors_tagging::PersistedTag as Tag;
 
         let (dirs, ecstore) = isolated_store_over_temp_disks().await;
 
@@ -4851,7 +5129,7 @@ mod tests {
     #[tokio::test]
     async fn concurrent_update_config_with_calls_do_not_lose_writes() {
         use crate::bucket::metadata::BUCKET_TAGGING_CONFIG;
-        use s3s::dto::Tag;
+        use rustfs_gateway_types::cors_tagging::PersistedTag as Tag;
 
         let (dirs, ecstore) = isolated_store_over_temp_disks().await;
         let sys = Arc::new(RwLock::new(BucketMetadataSys::new(ecstore)));
@@ -4951,7 +5229,7 @@ mod tests {
         let mut persisted = BucketMetadata::new("reload-bucket");
         persisted.policy_config_json = b"persisted-marker".to_vec();
         let lock_config = ObjectLockConfiguration {
-            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
+            object_lock_enabled: Some("Enabled".to_owned()),
             rule: None,
         };
         persisted
@@ -5230,7 +5508,7 @@ mod tests {
     #[serial]
     async fn bucket_delete_waits_for_config_mutation_fence() {
         use crate::bucket::metadata::BUCKET_TAGGING_CONFIG;
-        use s3s::dto::Tag;
+        use rustfs_gateway_types::cors_tagging::PersistedTag as Tag;
 
         let (_dirs, store) = isolated_store_over_temp_disks().await;
         init_bucket_metadata_sys(store.clone(), Vec::new()).await;

crates/ecstore/src/bucket/object_lock/mod.rs

@@ -17,15 +17,8 @@ pub mod objectlock_sys;
 pub mod types;
 
 /// Whether a bucket Object Lock configuration has locking enabled. The
-/// serving-layer `ObjectLockConfiguration` DTO implements this in
-/// the bucket-metadata module, which owns the persisted configuration type
-/// during the s3s ratchet migration (rustfs/backlog#1842).
+/// persisted `ObjectLockConfiguration` implements this in the bucket-metadata
+/// module, which owns the persisted configuration type.
 pub trait ObjectLockApi {
     fn enabled(&self) -> bool;
 }
-
-/// Whether a legal-hold status value is one of the two valid wire values.
-/// Implemented for the serving-layer DTO in the bucket-metadata module.
-pub trait ObjectLockStatusExt {
-    fn valid(&self) -> bool;
-}

crates/ecstore/src/bucket/quota/checker.rs

@@ -254,27 +254,23 @@ impl QuotaChecker {
     }
 
     /// Scanner usage for a bucket the reservation ledger admits is reporting
-    /// input only, so a failed lookup degrades to "unknown" and is counted
+    /// input only, so unavailable memory usage is reported as "unknown" and counted
     /// instead of becoming an error the write path would fail on.
     async fn report_only_usage(&self, bucket: &str) -> Option<u64> {
         // The plain lookup: a report must not wait for an early snapshot reload.
         let usage = get_bucket_usage_memory(bucket).await;
-        match self.usage_or_degraded_baseline(bucket, usage).await {
-            Ok(usage) => Some(usage),
-            Err(err) => {
-                metrics::counter!(METRIC_QUOTA_USAGE_REPORT_UNAVAILABLE_TOTAL).increment(1);
-                debug!(
-                    event = EVENT_QUOTA_USAGE_REPORT,
-                    component = LOG_COMPONENT_ECSTORE,
-                    subsystem = LOG_SUBSYSTEM_QUOTA,
-                    state = "usage_unknown",
-                    bucket = %bucket,
-                    error = %err,
-                    "durable quota usage report degraded"
-                );
-                None
-            }
+        if usage.is_none() {
+            metrics::counter!(METRIC_QUOTA_USAGE_REPORT_UNAVAILABLE_TOTAL).increment(1);
+            debug!(
+                event = EVENT_QUOTA_USAGE_REPORT,
+                component = LOG_COMPONENT_ECSTORE,
+                subsystem = LOG_SUBSYSTEM_QUOTA,
+                state = "usage_unknown",
+                bucket = %bucket,
+                "durable quota usage report degraded"
+            );
         }
+        usage
     }
 
     /// Re-save `bucket`'s quota under the sharded durable reservation
@@ -544,6 +540,8 @@ mod tests {
     use serial_test::serial;
     use uuid::Uuid;
 
+    mod reporting_retirement;
+
     /// Regression (PR #5307 / s3-tests `test_100_continue_error_retry`): a
     /// bucket with no persisted metadata has no quota, so the admission check
     /// must pass and let the request reach its NoSuchBucket answer. With the

crates/ecstore/src/bucket/quota/checker/tests/reporting_retirement.rs

@@ -0,0 +1,247 @@
+// 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 super::*;
+use crate::disk::DiskAPI as _;
+use crate::object_api::{ObjectOptions, PutObjReader};
+use crate::storage_api_contracts::object::ObjectIO as _;
+use crate::test_metrics::CapturingRecorder;
+use rustfs_data_usage::{BucketUsageInfo, DataUsageInfo};
+use std::time::SystemTime;
+
+async fn stop_reporting_fixture(store: &crate::store::ECStore) {
+    if let Some(cancel) = store.ctx.background_cancel_token() {
+        cancel.cancel();
+    }
+    for pool in &store.pools {
+        for set in &pool.disk_set {
+            let disks = set.disks.read().await.clone();
+            for disk in disks.iter().flatten() {
+                disk.close().await.expect("stop fixture disk monitoring");
+            }
+        }
+    }
+}
+
+async fn install_reporting_snapshot(
+    store: Arc<crate::store::ECStore>,
+    bucket: &str,
+    source: &str,
+    size: u64,
+) -> Option<(String, Vec<u8>)> {
+    if source == "missing" {
+        return None;
+    }
+    let mut info = DataUsageInfo {
+        last_update: Some(SystemTime::now()),
+        scanner_epoch: Some(1),
+        scanner_cycle: Some(1),
+        buckets_count: 1,
+        ..Default::default()
+    };
+    info.buckets_usage.insert(
+        bucket.to_owned(),
+        BucketUsageInfo {
+            size,
+            objects_count: 1,
+            versions_count: 1,
+            ..Default::default()
+        },
+    );
+    info.bucket_sizes.insert(bucket.to_owned(), size);
+    info.calculate_totals();
+    let object = match source {
+        "legacy" => rustfs_data_usage::LEGACY_DATA_USAGE_OBJECT_NAME,
+        "incomplete" => rustfs_data_usage::DATA_USAGE_OBJECT_NAME,
+        "complete" => {
+            info.usage_snapshot_complete = true;
+            rustfs_data_usage::DATA_USAGE_OBJECT_NAME
+        }
+        "observed" => {
+            info.usage_snapshot_complete = true;
+            info.usage_snapshot_converged = Some(false);
+            info.usage_snapshot_authoritative_baseline = Some(DataUsageInfo::default().snapshot_identity());
+            rustfs_data_usage::DATA_USAGE_OBSERVED_OBJECT_NAME
+        }
+        _ => panic!("unknown scanner fixture source"),
+    };
+    let path = format!("{}/{object}", crate::disk::BUCKET_META_PREFIX);
+    let bytes = serde_json::to_vec(&info).expect("scanner fixture encoding");
+    crate::config::com::save_config(store, &path, bytes.clone())
+        .await
+        .expect("persist scanner fixture");
+    if source == "complete" {
+        crate::data_usage::replace_bucket_usage_memory_from_info(&info).await;
+    }
+    Some((path, bytes))
+}
+
+#[tokio::test(flavor = "current_thread")]
+#[serial]
+async fn durable_quota_reporting_retires_degraded_floors_without_changing_ledger_admission() {
+    let recorder = CapturingRecorder::default();
+    let _recorder = metrics::set_default_local_recorder(&recorder);
+    for protocol in [1, 2] {
+        for source in ["missing", "legacy", "incomplete", "observed", "complete"] {
+            let (_dirs, store, sys) = isolated_durable_quota_store().await;
+            let checker = QuotaChecker::new(sys);
+            let bucket = format!("quota-report-{protocol}-{}", Uuid::new_v4().simple());
+            let quota = if protocol == 1 {
+                BucketQuota::new(Some(4096))
+            } else {
+                BucketQuota::new_sharded(4096)
+            };
+            create_bucket_with_quota_json(&store, &bucket, serde_json::to_vec(&quota).expect("quota fixture encoding")).await;
+            let snapshot = install_reporting_snapshot(store.clone(), &bucket, source, 1_000_000).await;
+            crate::data_usage::invalidate_data_usage_snapshot_cache().await;
+            let unavailable_before = recorder.counter_value(METRIC_QUOTA_USAGE_REPORT_UNAVAILABLE_TOTAL, &[]);
+            let check = checker
+                .check_quota(&bucket, QuotaOperation::PutObject, 512)
+                .await
+                .expect("reporting cannot fail ledger admission");
+            let (_, usage) = checker.get_quota_stats(&bucket).await.expect("best-effort quota statistics");
+            let preview = checker
+                .check_quota_with_usage_reporting(&bucket, QuotaOperation::PutObject, 512, true)
+                .await
+                .expect("admin preview uses the same optional report");
+
+            // Exercise the real storage entry point before testing the new
+            // reporting semantics: the same ledger must admit and refuse
+            // these writes even when a scanner floor claims a million bytes.
+            let mut too_large = PutObjReader::from_vec(vec![0x5a; 8192]);
+            assert!(
+                matches!(
+                    store
+                        .put_object(&bucket, "too-large", &mut too_large, &ObjectOptions::default())
+                        .await,
+                    Err(StorageError::QuotaExceeded { .. })
+                ),
+                "protocol={protocol}, source={source}"
+            );
+            let mut fits = PutObjReader::from_vec(vec![0x5a; 512]);
+            store
+                .put_object(&bucket, "fits", &mut fits, &ObjectOptions::default())
+                .await
+                .expect("ledger admits 512 bytes");
+            let mut fills = PutObjReader::from_vec(vec![0x5a; 3584]);
+            store
+                .put_object(&bucket, "fills", &mut fills, &ObjectOptions::default())
+                .await
+                .expect("ledger admits exactly the remaining quota");
+            let mut exceeds = PutObjReader::from_vec(vec![0x5a; 1]);
+            assert!(
+                matches!(
+                    store
+                        .put_object(&bucket, "exceeds", &mut exceeds, &ObjectOptions::default())
+                        .await,
+                    Err(StorageError::QuotaExceeded { .. })
+                ),
+                "ledger cannot undercount protocol={protocol}, source={source}"
+            );
+
+            assert!(check.allowed && check.uses_durable_reservations);
+            let expected_usage = (source == "complete").then_some(1_000_000);
+            assert_eq!(
+                check.current_usage, expected_usage,
+                "protocol={protocol}, source={source}: a floor is not a current report"
+            );
+            assert_eq!(check.remaining, expected_usage.map(|_| 0));
+            assert_eq!(usage, expected_usage, "statistics use the same best-effort reporting contract");
+            assert_eq!(preview.current_usage, expected_usage);
+            assert_eq!(preview.remaining, expected_usage.map(|_| 0));
+            assert_eq!(preview.allowed, source != "complete", "unknown preview is advisory, not a reservation");
+            assert_eq!(
+                recorder.counter_value(METRIC_QUOTA_USAGE_REPORT_UNAVAILABLE_TOTAL, &[]) - unavailable_before,
+                if source == "complete" { 0 } else { 3 },
+                "each unknown check/statistics/preview report is counted"
+            );
+            assert_eq!(crate::data_usage::reload_unknown_bucket_usage_calls_for_test(&bucket), 0);
+            assert_eq!(persisted_quota(&store, &bucket).await.reservation_protocol, Some(protocol));
+            if let Some((path, original)) = snapshot {
+                assert_eq!(
+                    crate::config::com::read_config(store.clone(), &path)
+                        .await
+                        .expect("retained scanner evidence"),
+                    original
+                );
+            }
+            crate::data_usage::prepare_bucket_usage_for_namespace_change(&bucket, None)
+                .await
+                .expect("fixture cache cleanup");
+            crate::data_usage::invalidate_data_usage_snapshot_cache().await;
+            stop_reporting_fixture(&store).await;
+        }
+    }
+}
+
+#[tokio::test]
+#[serial]
+async fn snapshot_quota_admission_retains_degraded_floors_until_migration() {
+    for source in ["missing", "legacy", "incomplete", "observed"] {
+        let (_dirs, store, _) = isolated_durable_quota_store().await;
+        let bucket = format!("quota-compat-{}", Uuid::new_v4().simple());
+        create_bucket_with_quota_json(&store, &bucket, legacy_quota_json(4096)).await;
+        // An unregistered checker models a snapshot-protocol reader without
+        // starting the optional background migration during this assertion.
+        let checker = QuotaChecker::new(Arc::new(RwLock::new(BucketMetadataSys::new(store.clone()))));
+        install_reporting_snapshot(store.clone(), &bucket, source, 1000).await;
+        crate::data_usage::invalidate_data_usage_snapshot_cache().await;
+        let check = checker.check_quota(&bucket, QuotaOperation::PutObject, 512).await;
+        if source == "missing" {
+            assert!(matches!(check, Err(QuotaError::UsageUnavailable { .. })));
+        } else {
+            let check = check.expect("legacy admission retains its grounded compatibility fallback");
+            assert_eq!(check.current_usage, Some(1000));
+            assert!(check.allowed && !check.uses_durable_reservations);
+            assert!(
+                !checker
+                    .check_quota(&bucket, QuotaOperation::PutObject, 4096)
+                    .await
+                    .expect("legacy quota decision")
+                    .allowed
+            );
+        }
+        assert_eq!(persisted_quota(&store, &bucket).await.reservation_protocol, None);
+        crate::data_usage::prepare_bucket_usage_for_namespace_change(&bucket, None)
+            .await
+            .expect("fixture cache cleanup");
+        crate::data_usage::invalidate_data_usage_snapshot_cache().await;
+        stop_reporting_fixture(&store).await;
+    }
+}
+
+#[tokio::test(flavor = "current_thread")]
+#[serial]
+async fn quota_without_limit_keeps_the_zero_usage_io_fast_path() {
+    let (_dirs, store, sys) = isolated_durable_quota_store().await;
+    let bucket = format!("quota-unlimited-{}", Uuid::new_v4().simple());
+    create_bucket_with_quota_json(
+        &store,
+        &bucket,
+        serde_json::to_vec(&BucketQuota::new(None)).expect("unlimited quota encoding"),
+    )
+    .await;
+    let recorder = CapturingRecorder::default();
+    let _recorder = metrics::set_default_local_recorder(&recorder);
+    let check = QuotaChecker::new(sys)
+        .check_quota(&bucket, QuotaOperation::PutObject, u64::MAX)
+        .await
+        .expect("unlimited quota fast path");
+    assert!(check.allowed);
+    assert_eq!(check.current_usage, None);
+    assert_eq!(check.quota_limit, None);
+    assert_eq!(recorder.counter_value(METRIC_QUOTA_USAGE_REPORT_UNAVAILABLE_TOTAL, &[]), 0);
+    assert_eq!(crate::data_usage::reload_unknown_bucket_usage_calls_for_test(&bucket), 0);
+    stop_reporting_fixture(&store).await;
+}

crates/ecstore/src/bucket/quota/reservation.rs

@@ -595,7 +595,7 @@ async fn reserve_sharded(context: QuotaContext, old_size: u64, new_size: u64) ->
         let allow_create = shard_may_be_created(&allocator, data.shard_index, bootstrap);
         let shard_lock = store.new_ns_lock(RUSTFS_META_BUCKET, &data.shard_object).await?;
         let shard_guard = Arc::new(shard_lock.get_write_lock(get_lock_acquire_timeout()).await?);
-        let mut shard = load_current_shard_locked(
+        let (mut shard, shard_created) = load_current_shard_locked(
             Arc::clone(&store),
             &data.shard_object,
             bucket_incarnation,
@@ -640,7 +640,7 @@ async fn reserve_sharded(context: QuotaContext, old_size: u64, new_size: u64) ->
             });
         }
         let shard_was_empty = shard.grants.is_empty() && shard.reservations.is_empty() && shard.accounted_usage == 0;
-        if shard_was_empty {
+        if shard_created || shard_was_empty {
             fence_namespace_mutations(&store, RUSTFS_META_BUCKET, &data.shard_object, None).await?;
             save_shard_locked(Arc::clone(&store), &data.shard_object, &shard, &shard_guard).await?;
         }
@@ -1510,18 +1510,18 @@ async fn load_current_shard_locked(
     shard_index: u16,
     allow_create: bool,
     allocator: &QuotaAllocatorLedger,
-) -> Result<QuotaShardLedger> {
-    let mut shard = match load_shard_locked(Arc::clone(&store), object).await {
-        Ok(shard) if shard.matches(bucket_incarnation, quota_revision, shard_index) => shard,
+) -> Result<(QuotaShardLedger, bool)> {
+    let (mut shard, created) = match load_shard_locked(Arc::clone(&store), object).await {
+        Ok(shard) if shard.matches(bucket_incarnation, quota_revision, shard_index) => (shard, false),
         Ok(_) => return Err(StorageError::PartMissingOrCorrupt),
         Err(StorageError::ConfigNotFound) if allow_create => {
-            QuotaShardLedger::new(bucket_incarnation, quota_revision, shard_index)
+            (QuotaShardLedger::new(bucket_incarnation, quota_revision, shard_index), true)
         }
         Err(StorageError::ConfigNotFound) => return Err(StorageError::PartMissingOrCorrupt),
         Err(err) => return Err(err),
     };
     shard.adopt_grants(allocator)?;
-    Ok(shard)
+    Ok((shard, created))
 }
 
 async fn save_allocator_locked(
@@ -1646,7 +1646,7 @@ async fn reap_sharded_reservations(
     .await?;
     let shard_lock = store.new_ns_lock(RUSTFS_META_BUCKET, &data.shard_object).await?;
     let shard_guard = shard_lock.get_write_lock(get_lock_acquire_timeout()).await?;
-    let shard = load_current_shard_locked(
+    let (shard, _) = load_current_shard_locked(
         Arc::clone(&store),
         &data.shard_object,
         bucket_incarnation,
@@ -1709,7 +1709,7 @@ async fn reap_sharded_reservations(
     .await?;
     let shard_lock = store.new_ns_lock(RUSTFS_META_BUCKET, &data.shard_object).await?;
     let shard_guard = Arc::new(shard_lock.get_write_lock(get_lock_acquire_timeout()).await?);
-    let mut shard = load_current_shard_locked(
+    let (mut shard, _) = load_current_shard_locked(
         Arc::clone(&store),
         &data.shard_object,
         bucket_incarnation,
@@ -1774,7 +1774,7 @@ async fn mark_commit_started_sharded(data: &ShardedReservationData) -> Result<()
         let allocator = load_allocator_locked(Arc::clone(&store), &data.allocator_object).await?;
         let shard_lock = store.new_ns_lock(RUSTFS_META_BUCKET, &data.shard_object).await?;
         let shard_guard = Arc::new(shard_lock.get_write_lock(get_lock_acquire_timeout()).await?);
-        let mut shard = load_current_shard_locked(
+        let (mut shard, _) = load_current_shard_locked(
             Arc::clone(&store),
             &data.shard_object,
             data.bucket_incarnation,
@@ -1819,7 +1819,7 @@ async fn settle_sharded(data: &ShardedReservationData, committed: bool) -> Resul
         let allocator = load_allocator_locked(Arc::clone(&store), &data.allocator_object).await?;
         let shard_lock = store.new_ns_lock(RUSTFS_META_BUCKET, &data.shard_object).await?;
         let shard_guard = Arc::new(shard_lock.get_write_lock(get_lock_acquire_timeout()).await?);
-        let mut shard = load_current_shard_locked(
+        let (mut shard, _) = load_current_shard_locked(
             Arc::clone(&store),
             &data.shard_object,
             data.bucket_incarnation,
@@ -2535,4 +2535,70 @@ mod tests {
             1
         );
     }
+
+    #[tokio::test]
+    #[serial]
+    async fn sharded_reservation_persists_a_populated_lazy_shard_before_refill() {
+        use crate::object_api::PutObjReader;
+        use crate::storage_api_contracts::object::ObjectIO;
+
+        let (_directories, store) = metadata_sys::test_support::isolated_store_over_temp_disks().await;
+        metadata_sys::init_bucket_metadata_sys(Arc::clone(&store), Vec::new()).await;
+        crate::services::notification_sys::install_cross_pool_fence_fleet_proof_for_test();
+        let bucket = format!("quota-populated-bootstrap-{}", Uuid::new_v4().simple());
+        store
+            .make_bucket(&bucket, &MakeBucketOptions::default())
+            .await
+            .expect("create quota bucket");
+
+        let mut seed_shard = None;
+        let mut seed_name = None;
+        let mut candidate_name = None;
+        let mut bootstrap_name = None;
+        for index in 0..10_000 {
+            let object = format!("quota-populated-object-{index}");
+            let object_shard = shard_index(&object);
+            if seed_shard.is_none() {
+                seed_shard = Some(object_shard);
+                seed_name = Some(object);
+            } else if Some(object_shard) == seed_shard && candidate_name.is_none() {
+                candidate_name = Some(object);
+            } else if Some(object_shard) != seed_shard && bootstrap_name.is_none() {
+                bootstrap_name = Some(object);
+            }
+            if candidate_name.is_some() && bootstrap_name.is_some() {
+                break;
+            }
+        }
+        let seed_name = seed_name.expect("find a seeded shard");
+        let candidate_name = candidate_name.expect("find a second object in the seeded shard");
+        let bootstrap_name = bootstrap_name.expect("find an empty bootstrap shard");
+
+        let mut seed = PutObjReader::from_vec(vec![1]);
+        store
+            .put_object(&bucket, &seed_name, &mut seed, &ObjectOptions::default())
+            .await
+            .expect("seed existing usage before enabling v2");
+        store
+            .update_bucket_metadata_config(
+                &bucket,
+                "quota.json",
+                serde_json::to_vec(&super::super::BucketQuota::new_sharded(100_000)).expect("serialize v2 quota"),
+            )
+            .await
+            .expect("enable v2 quota");
+
+        let mut bootstrap = PutObjReader::from_vec(vec![2]);
+        store
+            .put_object(&bucket, &bootstrap_name, &mut bootstrap, &ObjectOptions::default())
+            .await
+            .expect("bootstrap an empty shard");
+
+        let mut candidate = PutObjReader::from_vec(vec![3]);
+        let result = store
+            .put_object(&bucket, &candidate_name, &mut candidate, &ObjectOptions::default())
+            .await
+            .expect("a populated shard must persist before refill and accept its first growth");
+        assert_eq!(result.size, 1);
+    }
 }

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

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+pub use rustfs_replication::config_cache_serde;
 pub use rustfs_replication::{
     ObjectOpts, OperatorRuleContract, REMOTE_TARGET_CAPABILITY_CONTRACT_VERSION, REMOTE_TARGET_READ_ONLY_HISTORICAL_FIELDS,
     REMOTE_TARGET_UNSUPPORTED_FIELDS, REMOTE_TARGET_WRITABLE_FIELDS, REPLICATION_CAPABILITY_CONTRACT_VERSION,

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

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use s3s::dto::ReplicationConfiguration;
+use rustfs_gateway_types::persistence::PersistedReplicationConfiguration;
 
 use super::replication_config_boundary::ReplicationConfigurationExt as _;
 use super::replication_filemeta_boundary::{
@@ -42,7 +42,7 @@ impl ReplicationLifecycleBridge {
         dead_code,
         reason = "declared boundary surface for the ECStore replication split plan; no caller in this port (backlog#1823)"
     )]
-    pub(crate) fn new_config(config: ReplicationConfiguration) -> ReplicationLifecycleConfig {
+    pub(crate) fn new_config(config: PersistedReplicationConfiguration) -> ReplicationLifecycleConfig {
         ReplicationConfig::new(Some(config), None)
     }
 
@@ -118,16 +118,17 @@ impl ReplicationLifecycleBridge {
 
 #[cfg(test)]
 mod tests {
-    use s3s::dto::{Destination, ReplicationRule, ReplicationRuleStatus};
+    use rustfs_gateway_types::dto::Status;
+    use rustfs_gateway_types::persistence::{PersistedReplicationDestination, PersistedReplicationRule};
 
     use super::super::replication_filemeta_boundary::{ReplicateTargetDecision, VersionPurgeStatusType};
     use super::*;
 
-    fn replication_rule() -> ReplicationRule {
-        ReplicationRule {
+    fn replication_rule() -> PersistedReplicationRule {
+        PersistedReplicationRule {
             delete_marker_replication: None,
             delete_replication: None,
-            destination: Destination {
+            destination: PersistedReplicationDestination {
                 bucket: "arn:aws:s3:::target-bucket".to_string(),
                 ..Default::default()
             },
@@ -137,13 +138,13 @@ mod tests {
             prefix: Some(String::new()),
             priority: Some(1),
             source_selection_criteria: None,
-            status: ReplicationRuleStatus::from_static(ReplicationRuleStatus::ENABLED),
+            status: Status::ENABLED.to_string(),
         }
     }
 
     #[test]
     fn has_pending_version_purge_preserves_replication_active_rule_behavior() {
-        let config = ReplicationLifecycleBridge::new_config(ReplicationConfiguration {
+        let config = ReplicationLifecycleBridge::new_config(PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![replication_rule()],
         });

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

@@ -17,8 +17,8 @@ use std::sync::Arc;
 use crate::bucket::{metadata::BucketMetadata, metadata_sys};
 use crate::disk::{BUCKET_META_PREFIX, RUSTFS_META_BUCKET};
 use crate::runtime::instance::InstanceContext;
+use rustfs_gateway_types::persistence::PersistedReplicationConfiguration;
 use rustfs_utils::path::path_join_buf;
-use s3s::dto::ReplicationConfiguration;
 use time::OffsetDateTime;
 
 use super::replication_error_boundary::{Error, Result};
@@ -36,11 +36,11 @@ impl ReplicationMetadataStore {
     pub(crate) const FORCE_DELETE_REPLICATION_FILE: &'static str = "config/replication/force-delete.bin";
     pub(crate) const FORCE_DELETE_REPLICATION_TRANSACTION_LOCK: &'static str = "config/replication/force-delete.bin.transaction";
 
-    pub(crate) async fn replication_config(bucket: &str) -> Result<(ReplicationConfiguration, OffsetDateTime)> {
+    pub(crate) async fn replication_config(bucket: &str) -> Result<(PersistedReplicationConfiguration, OffsetDateTime)> {
         metadata_sys::get_replication_config(bucket).await
     }
 
-    pub(crate) async fn optional_replication_config(bucket: &str) -> Result<Option<ReplicationConfiguration>> {
+    pub(crate) async fn optional_replication_config(bucket: &str) -> Result<Option<PersistedReplicationConfiguration>> {
         let config = match Self::replication_config(bucket).await {
             Ok((config, _)) => Some(config),
             Err(err) => {

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

@@ -16,7 +16,9 @@ use std::{collections::HashMap, fmt, sync::Arc};
 
 use super::replication_filemeta_boundary::metadata_keys;
 use crate::bucket::metadata::BucketMetadata;
-use s3s::dto::{BucketVersioningStatus, ReplicationConfiguration, ReplicationRuleStatus, VersioningConfiguration};
+use rustfs_gateway_types::dto::Status;
+use rustfs_gateway_types::persistence::PersistedReplicationConfiguration;
+use rustfs_gateway_types::persistence::PersistedVersioningConfiguration as VersioningConfiguration;
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
 use tracing::error;
@@ -39,7 +41,7 @@ use super::replication_target_boundary::{BucketTargets, ReplicationTargetStore};
 use super::replication_versioning_boundary::ReplicationVersioningStore;
 use super::runtime_boundary as runtime_sources;
 
-pub(crate) async fn get_replication_config(bucket: &str) -> Result<Option<ReplicationConfiguration>> {
+pub(crate) async fn get_replication_config(bucket: &str) -> Result<Option<PersistedReplicationConfiguration>> {
     let config = ReplicationMetadataStore::optional_replication_config(bucket).await?;
     validate_delete_replication_config(&VersioningConfiguration::default(), config.as_ref())?;
     Ok(config)
@@ -64,7 +66,7 @@ impl DeleteReplicationConfigSnapshot {
     #[cfg(test)]
     pub(crate) fn from_configs_for_test(
         versioning: VersioningConfiguration,
-        replication: Option<ReplicationConfiguration>,
+        replication: Option<PersistedReplicationConfiguration>,
     ) -> Self {
         let metadata = replication.map(|config| {
             let mut metadata = BucketMetadata::new("test-bucket");
@@ -78,7 +80,7 @@ impl DeleteReplicationConfigSnapshot {
         &self.versioning
     }
 
-    pub fn replication_config(&self) -> Option<&ReplicationConfiguration> {
+    pub fn replication_config(&self) -> Option<&PersistedReplicationConfiguration> {
         self.metadata
             .as_ref()
             .and_then(|metadata| metadata.replication_config.as_ref())
@@ -101,7 +103,7 @@ impl DeleteReplicationConfigSnapshot {
     pub(crate) fn active_delete_marker_rules_require_tags(&self, object: &str) -> bool {
         self.replication_config().is_some_and(|config| {
             config.rules.iter().any(|rule| {
-                if rule.status == ReplicationRuleStatus::from_static(ReplicationRuleStatus::DISABLED) {
+                if rule.status == Status::DISABLED.as_str() {
                     return false;
                 }
                 if !object.starts_with(rule.prefix()) {
@@ -122,12 +124,12 @@ impl DeleteReplicationConfigSnapshot {
 
 fn validate_delete_replication_config(
     versioning: &VersioningConfiguration,
-    config: Option<&ReplicationConfiguration>,
+    config: Option<&PersistedReplicationConfiguration>,
 ) -> Result<()> {
     if versioning
         .status
         .as_ref()
-        .is_some_and(|status| !matches!(status.as_str(), BucketVersioningStatus::ENABLED | BucketVersioningStatus::SUSPENDED))
+        .is_some_and(|status| !matches!(status.as_str(), "Enabled" | "Suspended"))
     {
         return Err(super::replication_error_boundary::Error::other(
             "bucket versioning configuration has an invalid status",
@@ -144,7 +146,7 @@ fn validate_delete_replication_config(
         let role = config.role.trim();
         let mut role_destination = None;
         for rule in &config.rules {
-            if rule.status.as_str() == ReplicationRuleStatus::ENABLED {
+            if rule.status.as_str() == Status::ENABLED.as_str() {
                 let destination = rule.destination.bucket.trim();
                 if role.is_empty() && destination.is_empty() {
                     return Err(super::replication_error_boundary::Error::other(
@@ -169,7 +171,7 @@ fn validate_delete_replication_config(
     Ok(())
 }
 
-fn replication_config_from_metadata(metadata: &BucketMetadata) -> Result<Option<&ReplicationConfiguration>> {
+fn replication_config_from_metadata(metadata: &BucketMetadata) -> Result<Option<&PersistedReplicationConfiguration>> {
     if !metadata.replication_config_xml.is_empty() && metadata.replication_config.is_none() {
         return Err(super::replication_error_boundary::Error::other(
             "persisted bucket replication configuration is invalid",
@@ -250,12 +252,15 @@ pub(crate) async fn load_delete_replication_config_in(
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct ReplicationConfig {
-    pub config: Option<ReplicationConfiguration>,
+    /// Carried in the scanner's persisted data usage cache, so its serde form
+    /// is the one the s3s DTO wrote there (see `config_cache_serde` in the replication crate).
+    #[serde(with = "super::replication_config_boundary::config_cache_serde")]
+    pub config: Option<PersistedReplicationConfiguration>,
     pub remotes: Option<BucketTargets>,
 }
 
 impl ReplicationConfig {
-    pub fn new(config: Option<ReplicationConfiguration>, remotes: Option<BucketTargets>) -> Self {
+    pub fn new(config: Option<PersistedReplicationConfiguration>, remotes: Option<BucketTargets>) -> Self {
         Self { config, remotes }
     }
 
@@ -468,7 +473,7 @@ fn check_replicate_delete_with_config(
     oi: &ObjectInfo,
     del_opts: &ObjectOptions,
     source_error: bool,
-    config: Option<&ReplicationConfiguration>,
+    config: Option<&PersistedReplicationConfiguration>,
     existing_delete_marker: bool,
     trust_persisted_replica_status: bool,
 ) -> ReplicateDecision {
@@ -587,7 +592,7 @@ pub(crate) async fn must_replicate(bucket: &str, object: &str, mopts: MustReplic
 }
 
 fn metadata_target_should_replicate(
-    cfg: &ReplicationConfiguration,
+    cfg: &PersistedReplicationConfiguration,
     opts: &ObjectOpts,
     mopts: &MustReplicateOptions,
     arn: &str,
@@ -597,20 +602,21 @@ fn metadata_target_should_replicate(
 
 #[cfg(test)]
 mod tests {
-    use s3s::dto::{
-        DeleteMarkerReplication, DeleteMarkerReplicationStatus, DeleteReplication, DeleteReplicationStatus, Destination,
-        ReplicaModifications, ReplicationRule, ReplicationRuleFilter, ReplicationRuleStatus, SourceSelectionCriteria, Tag,
+    use rustfs_gateway_types::dto::Status;
+    use rustfs_gateway_types::persistence::{
+        PersistedOptionalReplicationStatus, PersistedReplicationDestination, PersistedReplicationFilter,
+        PersistedReplicationRule, PersistedReplicationStatus, PersistedReplicationTag, PersistedSourceSelectionCriteria,
     };
 
     use super::super::replication_filemeta_boundary::VersionPurgeStatusType;
     use super::super::replication_target_boundary::BucketTarget;
     use super::*;
 
-    fn replication_rule() -> ReplicationRule {
-        ReplicationRule {
+    fn replication_rule() -> PersistedReplicationRule {
+        PersistedReplicationRule {
             delete_marker_replication: None,
             delete_replication: None,
-            destination: Destination {
+            destination: PersistedReplicationDestination {
                 bucket: "arn:aws:s3:::target-bucket".to_string(),
                 ..Default::default()
             },
@@ -620,7 +626,7 @@ mod tests {
             prefix: Some(String::new()),
             priority: Some(1),
             source_selection_criteria: None,
-            status: ReplicationRuleStatus::from_static(ReplicationRuleStatus::ENABLED),
+            status: Status::ENABLED.to_string(),
         }
     }
 
@@ -629,11 +635,11 @@ mod tests {
         let arn = "arn:rustfs:replication:us-east-1:target:bucket";
         let mut rule = replication_rule();
         rule.destination.bucket = arn.to_string();
-        rule.filter = Some(ReplicationRuleFilter {
+        rule.filter = Some(PersistedReplicationFilter {
             prefix: Some("admitted/".to_string()),
             ..Default::default()
         });
-        let cfg = ReplicationConfiguration {
+        let cfg = PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![rule],
         };
@@ -671,7 +677,7 @@ mod tests {
         assert!(!empty.replicate(&ObjectOpts::default()));
 
         let config = ReplicationConfig::new(
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: String::new(),
                 rules: vec![replication_rule()],
             }),
@@ -725,7 +731,7 @@ mod tests {
     fn delete_snapshot_rejects_enabled_rules_without_a_destination() {
         let mut rule = replication_rule();
         rule.destination.bucket.clear();
-        let config = ReplicationConfiguration {
+        let config = PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![rule],
         };
@@ -741,7 +747,7 @@ mod tests {
         let first = replication_rule();
         let mut second = replication_rule();
         second.destination.bucket = "arn:aws:s3:::other-target".to_string();
-        let config = ReplicationConfiguration {
+        let config = PersistedReplicationConfiguration {
             role: "arn:aws:s3:::role-target".to_string(),
             rules: vec![first, second],
         };
@@ -752,47 +758,47 @@ mod tests {
     #[test]
     fn delete_snapshot_rejects_unknown_status_values() {
         let invalid_versioning = VersioningConfiguration {
-            status: Some("Enabld".to_string().into()),
+            status: Some("Enabld".to_string()),
             ..Default::default()
         };
         assert!(validate_delete_replication_config(&invalid_versioning, None).is_err());
 
         let mut invalid_rule = replication_rule();
-        invalid_rule.status = "Enabld".to_string().into();
-        let config = ReplicationConfiguration {
+        invalid_rule.status = "Enabld".to_string();
+        let config = PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![invalid_rule],
         };
         assert!(validate_delete_replication_config(&VersioningConfiguration::default(), Some(&config)).is_err());
 
         let mut invalid_delete = replication_rule();
-        invalid_delete.delete_replication = Some(DeleteReplication {
-            status: "Enabld".to_string().into(),
+        invalid_delete.delete_replication = Some(PersistedReplicationStatus {
+            status: "Enabld".to_string(),
         });
-        let config = ReplicationConfiguration {
+        let config = PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![invalid_delete],
         };
         assert!(validate_delete_replication_config(&VersioningConfiguration::default(), Some(&config)).is_err());
 
         let mut invalid_delete_marker = replication_rule();
-        invalid_delete_marker.delete_marker_replication = Some(DeleteMarkerReplication {
-            status: Some("Enabld".to_string().into()),
+        invalid_delete_marker.delete_marker_replication = Some(PersistedOptionalReplicationStatus {
+            status: Some("Enabld".to_string()),
         });
-        let config = ReplicationConfiguration {
+        let config = PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![invalid_delete_marker],
         };
         assert!(validate_delete_replication_config(&VersioningConfiguration::default(), Some(&config)).is_err());
 
         let mut invalid_replica_modifications = replication_rule();
-        invalid_replica_modifications.source_selection_criteria = Some(SourceSelectionCriteria {
-            replica_modifications: Some(ReplicaModifications {
-                status: "Enabld".to_string().into(),
+        invalid_replica_modifications.source_selection_criteria = Some(PersistedSourceSelectionCriteria {
+            replica_modifications: Some(PersistedReplicationStatus {
+                status: "Enabld".to_string(),
             }),
             sse_kms_encrypted_objects: None,
         });
-        let config = ReplicationConfiguration {
+        let config = PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![invalid_replica_modifications],
         };
@@ -804,11 +810,11 @@ mod tests {
         let mut metadata = BucketMetadata::new("bucket");
         metadata.versioning_config_xml = b"configured".to_vec();
         metadata.versioning_config = Some(VersioningConfiguration {
-            status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
+            status: Some("Enabled".to_owned()),
             ..Default::default()
         });
         metadata.replication_config_xml = b"configured".to_vec();
-        metadata.replication_config = Some(ReplicationConfiguration {
+        metadata.replication_config = Some(PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![replication_rule()],
         });
@@ -848,7 +854,7 @@ mod tests {
         );
 
         let mut inconsistent = BucketMetadata::new("bucket");
-        inconsistent.replication_config = Some(ReplicationConfiguration {
+        inconsistent.replication_config = Some(PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![replication_rule()],
         });
@@ -863,11 +869,11 @@ mod tests {
         let arn = "arn:rustfs:replication:us-east-1:target:bucket";
         let mut rule = replication_rule();
         rule.destination.bucket = arn.to_string();
-        rule.delete_marker_replication = Some(DeleteMarkerReplication {
-            status: Some(DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::ENABLED)),
+        rule.delete_marker_replication = Some(PersistedOptionalReplicationStatus {
+            status: Some(Status::ENABLED.to_string()),
         });
         let mut metadata = BucketMetadata::new("bucket");
-        metadata.replication_config = Some(ReplicationConfiguration {
+        metadata.replication_config = Some(PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![rule],
         });
@@ -898,27 +904,27 @@ mod tests {
     fn delete_marker_source_read_is_required_only_for_tag_filtered_rules() {
         let mut prefix_rule = replication_rule();
         prefix_rule.prefix = Some("logs/".to_string());
-        prefix_rule.delete_marker_replication = Some(DeleteMarkerReplication {
-            status: Some(DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::ENABLED)),
+        prefix_rule.delete_marker_replication = Some(PersistedOptionalReplicationStatus {
+            status: Some(Status::ENABLED.to_string()),
         });
 
         let prefix_snapshot = DeleteReplicationConfigSnapshot::from_configs_for_test(
             VersioningConfiguration {
-                status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
+                status: Some("Enabled".to_owned()),
                 ..Default::default()
             },
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: String::new(),
                 rules: vec![prefix_rule],
             }),
         );
 
         let mut tag_rule = replication_rule();
-        tag_rule.delete_marker_replication = Some(DeleteMarkerReplication {
-            status: Some(DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::ENABLED)),
+        tag_rule.delete_marker_replication = Some(PersistedOptionalReplicationStatus {
+            status: Some(Status::ENABLED.to_string()),
         });
-        tag_rule.filter = Some(ReplicationRuleFilter {
-            tag: Some(Tag {
+        tag_rule.filter = Some(PersistedReplicationFilter {
+            tag: Some(PersistedReplicationTag {
                 key: Some("class".to_string()),
                 value: Some("audit".to_string()),
             }),
@@ -926,10 +932,10 @@ mod tests {
         });
         let tag_snapshot = DeleteReplicationConfigSnapshot::from_configs_for_test(
             VersioningConfiguration {
-                status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
+                status: Some("Enabled".to_owned()),
                 ..Default::default()
             },
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: String::new(),
                 rules: vec![tag_rule],
             }),
@@ -944,14 +950,14 @@ mod tests {
         let arn = "arn:rustfs:replication:us-east-1:target:bucket";
         let mut rule = replication_rule();
         rule.destination.bucket = arn.to_string();
-        rule.delete_replication = Some(DeleteReplication {
-            status: DeleteReplicationStatus::from_static(DeleteReplicationStatus::ENABLED),
+        rule.delete_replication = Some(PersistedReplicationStatus {
+            status: Status::ENABLED.to_string(),
         });
-        rule.delete_marker_replication = Some(DeleteMarkerReplication {
-            status: Some(DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::DISABLED)),
+        rule.delete_marker_replication = Some(PersistedOptionalReplicationStatus {
+            status: Some(Status::DISABLED.to_string()),
         });
         let config = ReplicationConfig::new(
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: String::new(),
                 rules: vec![rule],
             }),
@@ -985,22 +991,22 @@ mod tests {
     #[test]
     fn live_delete_does_not_trust_persisted_replica_status() {
         let mut rule = replication_rule();
-        rule.delete_replication = Some(DeleteReplication {
-            status: DeleteReplicationStatus::from_static(DeleteReplicationStatus::ENABLED),
+        rule.delete_replication = Some(PersistedReplicationStatus {
+            status: Status::ENABLED.to_string(),
         });
-        rule.source_selection_criteria = Some(SourceSelectionCriteria {
-            replica_modifications: Some(ReplicaModifications {
-                status: s3s::dto::ReplicaModificationsStatus::from_static(s3s::dto::ReplicaModificationsStatus::DISABLED),
+        rule.source_selection_criteria = Some(PersistedSourceSelectionCriteria {
+            replica_modifications: Some(PersistedReplicationStatus {
+                status: Status::DISABLED.to_string(),
             }),
             sse_kms_encrypted_objects: None,
         });
-        let replication = ReplicationConfiguration {
+        let replication = PersistedReplicationConfiguration {
             role: String::new(),
             rules: vec![rule],
         };
         let snapshot = DeleteReplicationConfigSnapshot::from_configs_for_test(
             VersioningConfiguration {
-                status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
+                status: Some("Enabled".to_owned()),
                 ..Default::default()
             },
             Some(replication.clone()),
@@ -1036,14 +1042,14 @@ mod tests {
         let arn = "arn:rustfs:replication:us-east-1:target:bucket";
         let mut rule = replication_rule();
         rule.destination.bucket = arn.to_string();
-        rule.delete_replication = Some(DeleteReplication {
-            status: DeleteReplicationStatus::from_static(DeleteReplicationStatus::ENABLED),
+        rule.delete_replication = Some(PersistedReplicationStatus {
+            status: Status::ENABLED.to_string(),
         });
-        rule.delete_marker_replication = Some(DeleteMarkerReplication {
-            status: Some(DeleteMarkerReplicationStatus::from_static(DeleteMarkerReplicationStatus::DISABLED)),
+        rule.delete_marker_replication = Some(PersistedOptionalReplicationStatus {
+            status: Some(Status::DISABLED.to_string()),
         });
         let config = ReplicationConfig::new(
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: String::new(),
                 rules: vec![rule],
             }),

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

@@ -4794,9 +4794,10 @@ mod tests {
     #[tokio::test]
     async fn heal_queue_marks_missing_versioning_state_as_missed() {
         use super::super::replication_target_boundary::BucketTargets;
-        use s3s::dto::{
-            DeleteReplication, DeleteReplicationStatus, Destination, ReplicationConfiguration, ReplicationRule,
-            ReplicationRuleStatus,
+        use rustfs_gateway_types::dto::Status;
+        use rustfs_gateway_types::persistence::{
+            PersistedReplicationConfiguration, PersistedReplicationDestination, PersistedReplicationRule,
+            PersistedReplicationStatus,
         };
 
         let arn = "arn:rustfs:replication:us-east-1:target:bucket";
@@ -4811,14 +4812,14 @@ mod tests {
                 ..Default::default()
             },
             ReplicationConfig::new(
-                Some(ReplicationConfiguration {
+                Some(PersistedReplicationConfiguration {
                     role: String::new(),
-                    rules: vec![ReplicationRule {
+                    rules: vec![PersistedReplicationRule {
                         delete_marker_replication: None,
-                        delete_replication: Some(DeleteReplication {
-                            status: DeleteReplicationStatus::from_static(DeleteReplicationStatus::ENABLED),
+                        delete_replication: Some(PersistedReplicationStatus {
+                            status: Status::ENABLED.to_string(),
                         }),
-                        destination: Destination {
+                        destination: PersistedReplicationDestination {
                             bucket: arn.to_string(),
                             ..Default::default()
                         },
@@ -4828,7 +4829,7 @@ mod tests {
                         prefix: Some(String::new()),
                         priority: Some(1),
                         source_selection_criteria: None,
-                        status: ReplicationRuleStatus::from_static(ReplicationRuleStatus::ENABLED),
+                        status: Status::ENABLED.to_string(),
                     }],
                 }),
                 Some(BucketTargets::default()),

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

@@ -85,6 +85,8 @@ use http_body_util::StreamBody;
 use metrics::counter;
 #[cfg(test)]
 use rmp_serde;
+#[cfg(test)]
+use rustfs_gateway_types::persistence::PersistedReplicationConfiguration;
 use rustfs_s3_types::EventName;
 use rustfs_utils::http::{
     AMZ_OBJECT_LOCK_LEGAL_HOLD, AMZ_OBJECT_LOCK_MODE, AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE, AMZ_TAGGING_DIRECTIVE,
@@ -92,8 +94,6 @@ use rustfs_utils::http::{
     insert_str, replication_target_versions,
 };
 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::fmt::Display;
 use std::pin::Pin;
@@ -6500,9 +6500,10 @@ mod tests {
 
     use super::super::replication_target_boundary::{BucketTarget, BucketTargets};
     use super::*;
-    use s3s::dto::{
-        BucketVersioningStatus, DeleteReplication, DeleteReplicationStatus, Destination, ExcludedPrefix, ReplicationRule,
-        ReplicationRuleStatus, VersioningConfiguration,
+    use rustfs_gateway_types::dto::Status;
+    use rustfs_gateway_types::persistence::PersistedVersioningConfiguration as VersioningConfiguration;
+    use rustfs_gateway_types::persistence::{
+        PersistedReplicationDestination, PersistedReplicationRule, PersistedReplicationStatus,
     };
     use std::collections::HashMap;
     use time::OffsetDateTime;
@@ -8568,7 +8569,7 @@ mod tests {
             ..Default::default()
         };
         let rcfg = ReplicationConfig::new(
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: role.to_string(),
                 rules: vec![],
             }),
@@ -8594,7 +8595,7 @@ mod tests {
         ReplicationVersioningStore::install_prefix_state_test_config(
             &bucket,
             VersioningConfiguration {
-                status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
+                status: Some("Enabled".to_owned()),
                 ..Default::default()
             },
         );
@@ -8627,22 +8628,20 @@ mod tests {
         ReplicationVersioningStore::install_prefix_state_test_config(
             &bucket,
             VersioningConfiguration {
-                status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
-                excluded_prefixes: Some(vec![ExcludedPrefix {
-                    prefix: Some("archive/".to_string()),
-                }]),
+                status: Some("Enabled".to_owned()),
+                excluded_prefixes: Some(vec![Some("archive/".to_string())]),
                 ..Default::default()
             },
         );
         let rcfg = ReplicationConfig::new(
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: String::new(),
-                rules: vec![ReplicationRule {
+                rules: vec![PersistedReplicationRule {
                     delete_marker_replication: None,
-                    delete_replication: Some(DeleteReplication {
-                        status: DeleteReplicationStatus::from_static(DeleteReplicationStatus::ENABLED),
+                    delete_replication: Some(PersistedReplicationStatus {
+                        status: Status::ENABLED.to_string(),
                     }),
-                    destination: Destination {
+                    destination: PersistedReplicationDestination {
                         bucket: arn.to_string(),
                         ..Default::default()
                     },
@@ -8652,7 +8651,7 @@ mod tests {
                     prefix: Some(String::new()),
                     priority: Some(1),
                     source_selection_criteria: None,
-                    status: ReplicationRuleStatus::from_static(ReplicationRuleStatus::ENABLED),
+                    status: Status::ENABLED.to_string(),
                 }],
             }),
             Some(BucketTargets {
@@ -8688,14 +8687,14 @@ mod tests {
         let admitted_arn = "arn:rustfs:replication:us-east-1:target:admitted";
         let current_role = "arn:rustfs:replication:us-east-1:target:current";
         let rcfg = ReplicationConfig::new(
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: current_role.to_string(),
-                rules: vec![ReplicationRule {
+                rules: vec![PersistedReplicationRule {
                     delete_marker_replication: None,
-                    delete_replication: Some(DeleteReplication {
-                        status: DeleteReplicationStatus::from_static(DeleteReplicationStatus::DISABLED),
+                    delete_replication: Some(PersistedReplicationStatus {
+                        status: Status::DISABLED.to_string(),
                     }),
-                    destination: Destination {
+                    destination: PersistedReplicationDestination {
                         bucket: current_role.to_string(),
                         ..Default::default()
                     },
@@ -8705,7 +8704,7 @@ mod tests {
                     prefix: Some(String::new()),
                     priority: Some(1),
                     source_selection_criteria: None,
-                    status: ReplicationRuleStatus::from_static(ReplicationRuleStatus::ENABLED),
+                    status: Status::ENABLED.to_string(),
                 }],
             }),
             Some(BucketTargets {
@@ -8753,12 +8752,12 @@ mod tests {
     #[tokio::test]
     async fn heal_rejects_semantically_invalid_replication_config() {
         let rcfg = ReplicationConfig::new(
-            Some(ReplicationConfiguration {
+            Some(PersistedReplicationConfiguration {
                 role: String::new(),
-                rules: vec![ReplicationRule {
+                rules: vec![PersistedReplicationRule {
                     delete_marker_replication: None,
                     delete_replication: None,
-                    destination: Destination {
+                    destination: PersistedReplicationDestination {
                         bucket: "arn:rustfs:replication:us-east-1:target:bucket".to_string(),
                         ..Default::default()
                     },
@@ -8768,7 +8767,7 @@ mod tests {
                     prefix: Some(String::new()),
                     priority: Some(1),
                     source_selection_criteria: None,
-                    status: ReplicationRuleStatus::from_static("Enabld"),
+                    status: "Enabld".to_owned(),
                 }],
             }),
             Some(BucketTargets::default()),

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

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use s3s::dto::ReplicationConfiguration;
+use rustfs_gateway_types::persistence::PersistedReplicationConfiguration;
 
 use super::replication_config_boundary::{ObjectOpts, ReplicationConfigurationExt};
 use super::replication_filemeta_boundary::ReplicationType;
@@ -20,7 +20,7 @@ use super::replication_filemeta_boundary::ReplicationType;
 pub(crate) struct ReplicationTargetConfigBridge;
 
 impl ReplicationTargetConfigBridge {
-    pub(crate) fn target_is_used_by_rules(config: &ReplicationConfiguration, arn: &str) -> bool {
+    pub(crate) fn target_is_used_by_rules(config: &PersistedReplicationConfiguration, arn: &str) -> bool {
         config
             .filter_target_arns(&ObjectOpts {
                 op_type: ReplicationType::All,
@@ -37,7 +37,7 @@ mod tests {
 
     #[test]
     fn target_config_bridge_matches_role_target() {
-        let config = ReplicationConfiguration {
+        let config = PersistedReplicationConfiguration {
             role: " arn:target ".to_string(),
             rules: Vec::new(),
         };

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

@@ -15,7 +15,7 @@
 use super::replication_error_boundary::Result;
 use crate::bucket::{versioning::VersioningApi as _, versioning_sys::BucketVersioningSys};
 #[cfg(test)]
-use s3s::dto::VersioningConfiguration;
+use rustfs_gateway_types::persistence::PersistedVersioningConfiguration as VersioningConfiguration;
 #[cfg(test)]
 use std::{collections::HashMap, sync::LazyLock, sync::Mutex};
 

crates/ecstore/src/bucket/tagging/mod.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use s3s::dto::Tag;
+use rustfs_gateway_types::cors_tagging::PersistedTag as Tag;
 use std::cmp::Ordering;
 use std::collections::HashMap;
 use url::form_urlencoded;

crates/ecstore/src/bucket/utils.rs

@@ -15,9 +15,23 @@
 use crate::disk::{MIGRATING_META_BUCKET, RUSTFS_META_BUCKET};
 use crate::error::{Error, Result, StorageError};
 use regex::Regex;
+use rustfs_gateway_types::cors_tagging::{
+    CorsTaggingCodecError, PersistedCorsConfiguration, PersistedTagging, parse_cors, parse_tagging, serialize_cors,
+    serialize_tagging,
+};
+use rustfs_gateway_types::persistence::{
+    PersistedAccelerateConfiguration, PersistedBucketEncryptionConfiguration, PersistedBucketLoggingStatus,
+    PersistedLifecycleConfiguration, PersistedNotificationConfiguration, PersistedObjectLockConfiguration,
+    PersistedPublicAccessBlockConfiguration, PersistedReplicationConfiguration, PersistedRequestPaymentConfiguration,
+    PersistedVersioningConfiguration, PersistedWebsiteConfiguration, PersistenceCodecError, parse_accelerate,
+    parse_bucket_encryption, parse_bucket_logging, parse_lifecycle_legacy_dates, parse_notification, parse_object_lock,
+    parse_public_access_block, parse_replication, parse_request_payment, parse_versioning, parse_website, serialize_accelerate,
+    serialize_bucket_encryption, serialize_bucket_logging, serialize_lifecycle_legacy_dates, serialize_notification,
+    serialize_object_lock, serialize_public_access_block, serialize_replication, serialize_request_payment, serialize_versioning,
+    serialize_website,
+};
 use rustfs_utils::WindowsFileNameError;
 use rustfs_utils::path::SLASH_SEPARATOR;
-use s3s::xml;
 use tracing::instrument;
 
 pub fn is_meta_bucketname(name: &str) -> bool {
@@ -74,37 +88,173 @@ pub fn check_valid_bucket_name_strict(bucket_name: &str) -> Result<()> {
     check_bucket_name_common(bucket_name, true)
 }
 
-// RUSTFS_COMPAT_TODO(s3gate-metadata-xml): the s3s codec reads persisted XML during migration. Remove after every supported writer uses the gateway codec and every retained metadata object and backup archive is verified or rewritten.
-pub fn deserialize<T>(input: &[u8]) -> xml::DeResult<T>
-where
-    T: for<'xml> xml::Deserialize<'xml>,
-{
-    let mut d = xml::Deserializer::new(input);
-    let ans = T::deserialize(&mut d)?;
-    d.expect_eof()?;
-    Ok(ans)
+/// A bucket configuration persisted as XML in the bucket metadata, together
+/// with the codec that reads and writes its stored bytes.
+///
+/// Every family reads and writes its stored bytes through the gateway
+/// persistence codecs (`rustfs_gateway_types::persistence` and
+/// `rustfs_gateway_types::cors_tagging`, rustfs/backlog#2745). The codecs keep
+/// the persisted bytes the `bucket_config_goldens` pin, so a document the old
+/// s3s codec wrote reads back and re-encodes unchanged.
+pub trait BucketConfigXml: Sized {
+    /// Decodes the stored bytes of one configuration document.
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError>;
+
+    /// Encodes the value as RustFS stores it.
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError>;
 }
 
-#[allow(
-    dead_code,
-    reason = "xml serialize helper with no caller in this port; the live sibling is deserialize (backlog#1823)"
-)]
-pub fn serialize_content<T: xml::SerializeContent>(val: &T) -> xml::SerResult<String> {
-    let mut buf = Vec::with_capacity(256);
-    {
-        let mut ser = xml::Serializer::new(&mut buf);
-        val.serialize_content(&mut ser)?;
-    }
-    Ok(String::from_utf8(buf).unwrap())
+/// Why a persisted bucket configuration could not be decoded or encoded.
+#[derive(Debug, thiserror::Error)]
+pub enum BucketConfigXmlError {
+    /// A gateway persistence codec refused the bytes or the value.
+    #[error(transparent)]
+    Persisted(#[from] PersistenceCodecError),
+    /// The gateway CORS or Tagging codec refused the bytes or the value.
+    #[error(transparent)]
+    CorsTagging(#[from] CorsTaggingCodecError),
 }
 
-pub fn serialize<T: xml::Serialize>(val: &T) -> xml::SerResult<Vec<u8>> {
-    let mut buf = Vec::with_capacity(256);
-    {
-        let mut ser = xml::Serializer::new(&mut buf);
-        val.serialize(&mut ser)?;
+/// Decodes one persisted bucket configuration document.
+pub fn deserialize<T: BucketConfigXml>(input: &[u8]) -> std::result::Result<T, BucketConfigXmlError> {
+    T::decode_config_xml(input)
+}
+
+/// Encodes one bucket configuration as RustFS persists it.
+pub fn serialize<T: BucketConfigXml>(val: &T) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+    val.encode_config_xml()
+}
+
+impl BucketConfigXml for PersistedReplicationConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_replication(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_replication(self)?)
+    }
+}
+
+impl BucketConfigXml for PersistedLifecycleConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_lifecycle_legacy_dates(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_lifecycle_legacy_dates(self)?)
+    }
+}
+
+// The gateway writers of these families are infallible: a value that exists is
+// always encodable, so only the readers can refuse bytes.
+impl BucketConfigXml for PersistedAccelerateConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_accelerate(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_accelerate(self))
+    }
+}
+
+impl BucketConfigXml for PersistedBucketLoggingStatus {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_bucket_logging(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_bucket_logging(self))
+    }
+}
+
+impl BucketConfigXml for PersistedCorsConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_cors(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_cors(self))
+    }
+}
+
+impl BucketConfigXml for PersistedNotificationConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_notification(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_notification(self))
+    }
+}
+
+impl BucketConfigXml for PersistedObjectLockConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_object_lock(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_object_lock(self))
+    }
+}
+
+impl BucketConfigXml for PersistedPublicAccessBlockConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_public_access_block(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_public_access_block(self))
+    }
+}
+
+impl BucketConfigXml for PersistedRequestPaymentConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_request_payment(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_request_payment(self))
+    }
+}
+
+impl BucketConfigXml for PersistedBucketEncryptionConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_bucket_encryption(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_bucket_encryption(self))
+    }
+}
+
+impl BucketConfigXml for PersistedTagging {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_tagging(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_tagging(self))
+    }
+}
+
+impl BucketConfigXml for PersistedVersioningConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_versioning(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_versioning(self))
+    }
+}
+
+impl BucketConfigXml for PersistedWebsiteConfiguration {
+    fn decode_config_xml(input: &[u8]) -> std::result::Result<Self, BucketConfigXmlError> {
+        Ok(parse_website(input)?)
+    }
+
+    fn encode_config_xml(&self) -> std::result::Result<Vec<u8>, BucketConfigXmlError> {
+        Ok(serialize_website(self))
     }
-    Ok(buf)
 }
 
 pub fn has_bad_path_component(path: &str) -> bool {
@@ -434,6 +584,40 @@ mod tests {
     use super::*;
     use proptest::prelude::*;
 
+    /// Every bucket-configuration family reads and writes through its own
+    /// gateway codec (rustfs/backlog#2745): the family's golden document
+    /// decodes and re-encodes to the same bytes, and a document of another
+    /// family is refused instead of decoding into an empty configuration.
+    #[test]
+    fn every_bucket_config_family_uses_its_own_gateway_codec() {
+        fn assert_family<T: BucketConfigXml>(family: &str, own: &[u8], foreign: &[u8]) {
+            let value = deserialize::<T>(own).unwrap_or_else(|err| panic!("{family}: own document must decode: {err}"));
+            let encoded = serialize(&value).unwrap_or_else(|err| panic!("{family}: value must encode: {err}"));
+            assert_eq!(encoded, own, "{family}: re-encoding must keep the persisted bytes");
+            assert!(deserialize::<T>(foreign).is_err(), "{family}: a foreign root element must be refused");
+        }
+
+        macro_rules! golden {
+            ($family:literal) => {
+                include_bytes!(concat!("../../tests/fixtures/bucket-config-goldens/", $family, "/minio.out.xml"))
+            };
+        }
+        let tagging = golden!("tagging");
+        let versioning = golden!("versioning");
+
+        assert_family::<PersistedAccelerateConfiguration>("accelerate", golden!("accelerate"), tagging);
+        assert_family::<PersistedBucketLoggingStatus>("logging", golden!("logging"), tagging);
+        assert_family::<PersistedCorsConfiguration>("cors", golden!("cors"), tagging);
+        assert_family::<PersistedNotificationConfiguration>("notification", golden!("notification"), tagging);
+        assert_family::<PersistedObjectLockConfiguration>("object_lock", golden!("object_lock"), tagging);
+        assert_family::<PersistedPublicAccessBlockConfiguration>("public_access_block", golden!("public_access_block"), tagging);
+        assert_family::<PersistedRequestPaymentConfiguration>("request_payment", golden!("request_payment"), tagging);
+        assert_family::<PersistedBucketEncryptionConfiguration>("encryption", golden!("encryption"), tagging);
+        assert_family::<PersistedTagging>("tagging", tagging, versioning);
+        assert_family::<PersistedVersioningConfiguration>("versioning", versioning, tagging);
+        assert_family::<PersistedWebsiteConfiguration>("website", golden!("website"), tagging);
+    }
+
     /// rustfs#5785: keys whose path segments exceed the on-disk NAME_MAX
     /// budget must be rejected up front as ObjectNameInvalid (4xx), not leak
     /// ENAMETOOLONG as InternalError 500 from the disk layer.

crates/ecstore/src/bucket/versioning/mod.rs

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use rustfs_gateway_types::persistence::PersistedVersioningConfiguration as VersioningConfiguration;
 use rustfs_utils::string::match_simple;
-use s3s::dto::{BucketVersioningStatus, VersioningConfiguration};
 
 pub trait VersioningApi {
     fn enabled(&self) -> bool;
@@ -28,10 +28,10 @@ pub trait VersioningApi {
 
 impl VersioningApi for VersioningConfiguration {
     fn enabled(&self) -> bool {
-        self.status == Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED))
+        self.status.as_deref() == Some("Enabled")
     }
     fn prefix_enabled(&self, prefix: &str) -> bool {
-        if self.status != Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)) {
+        if self.status.as_deref() != Some("Enabled") {
             return false;
         }
 
@@ -44,12 +44,10 @@ impl VersioningApi for VersioningConfiguration {
         }
 
         if let Some(ref excluded_prefixes) = self.excluded_prefixes {
-            for p in excluded_prefixes.iter() {
-                if let Some(ref sprefix) = p.prefix {
-                    let pattern = format!("{sprefix}*");
-                    if match_simple(&pattern, prefix) {
-                        return false;
-                    }
+            for sprefix in excluded_prefixes.iter().flatten() {
+                let pattern = format!("{sprefix}*");
+                if match_simple(&pattern, prefix) {
+                    return false;
                 }
             }
         }
@@ -58,11 +56,11 @@ impl VersioningApi for VersioningConfiguration {
     }
 
     fn prefix_suspended(&self, prefix: &str) -> bool {
-        if self.status == Some(BucketVersioningStatus::from_static(BucketVersioningStatus::SUSPENDED)) {
+        if self.status.as_deref() == Some("Suspended") {
             return true;
         }
 
-        if self.status == Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)) {
+        if self.status.as_deref() == Some("Enabled") {
             if prefix.is_empty() {
                 return false;
             }
@@ -75,12 +73,10 @@ impl VersioningApi for VersioningConfiguration {
             }
 
             if let Some(ref excluded_prefixes) = self.excluded_prefixes {
-                for p in excluded_prefixes.iter() {
-                    if let Some(ref sprefix) = p.prefix {
-                        let pattern = format!("{sprefix}*");
-                        if match_simple(&pattern, prefix) {
-                            return true;
-                        }
+                for sprefix in excluded_prefixes.iter().flatten() {
+                    let pattern = format!("{sprefix}*");
+                    if match_simple(&pattern, prefix) {
+                        return true;
                     }
                 }
             }
@@ -92,14 +88,12 @@ impl VersioningApi for VersioningConfiguration {
         self.prefix_enabled(prefix) || self.prefix_suspended(prefix)
     }
     fn suspended(&self) -> bool {
-        self.status == Some(BucketVersioningStatus::from_static(BucketVersioningStatus::SUSPENDED))
+        self.status.as_deref() == Some("Suspended")
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use s3s::dto::{BucketVersioningStatus, ExcludedPrefix};
-
     use super::*;
 
     struct LegacyVersioning;
@@ -134,10 +128,8 @@ mod tests {
     #[test]
     fn delete_state_treats_excluded_prefixes_as_unversioned() {
         let config = VersioningConfiguration {
-            status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::ENABLED)),
-            excluded_prefixes: Some(vec![ExcludedPrefix {
-                prefix: Some("archive/".to_string()),
-            }]),
+            status: Some("Enabled".to_owned()),
+            excluded_prefixes: Some(vec![Some("archive/".to_string())]),
             ..Default::default()
         };
 
@@ -146,7 +138,7 @@ mod tests {
         assert_eq!(config.delete_state("live/object"), (true, false));
 
         let suspended = VersioningConfiguration {
-            status: Some(BucketVersioningStatus::from_static(BucketVersioningStatus::SUSPENDED)),
+            status: Some("Suspended".to_owned()),
             ..Default::default()
         };
         assert_eq!(suspended.delete_state("archive/object"), (false, true));

crates/ecstore/src/bucket/versioning_sys.rs

@@ -17,7 +17,7 @@ use super::metadata::unreadable_config_refusal;
 use super::{metadata_sys::get_bucket_metadata_sys, versioning::VersioningApi};
 use crate::disk::RUSTFS_META_BUCKET;
 use crate::error::Result;
-use s3s::dto::VersioningConfiguration;
+use rustfs_gateway_types::persistence::PersistedVersioningConfiguration as VersioningConfiguration;
 use tracing::{error, warn};
 
 pub struct BucketVersioningSys {}
@@ -163,7 +163,7 @@ mod tests {
 
     fn enabled() -> VersioningConfiguration {
         VersioningConfiguration {
-            status: Some(s3s::dto::BucketVersioningStatus::from_static(s3s::dto::BucketVersioningStatus::ENABLED)),
+            status: Some("Enabled".to_owned()),
             ..Default::default()
         }
     }

crates/ecstore/src/cache_value/metacache_set.rs

@@ -40,7 +40,7 @@ const LOG_COMPONENT_ECSTORE: &str = "ecstore";
 const LOG_SUBSYSTEM_METACACHE: &str = "metacache";
 const EVENT_METACACHE_LISTING: &str = "metacache_listing";
 
-pub type AgreedFn = Box<dyn Fn(MetaCacheEntry) -> Pin<Box<dyn Future<Output = ()> + Send>> + Send + 'static>;
+pub type AgreedFn = Box<dyn Fn(MetaCacheEntry) -> Pin<Box<dyn Future<Output = Result<(), DiskError>> + Send>> + Send + 'static>;
 pub type PartialFn =
     Box<dyn Fn(MetaCacheEntries, &[Option<DiskError>]) -> Pin<Box<dyn Future<Output = ()> + Send>> + Send + 'static>;
 pub(crate) type PartialResultFn = Box<
@@ -970,7 +970,7 @@ async fn list_path_raw_inner(
                     tokio::select! {
                         biased;
                         _ = revjob_rx.cancelled() => return Ok(()),
-                        _ = agreed_fn(current) => {}
+                        result = agreed_fn(current) => result?
                     }
                     // warn!("list_path_raw: agreed_fn done");
                 }
@@ -1710,6 +1710,34 @@ mod tests {
             .expect("aborting the listing should drop the blocked producer");
     }
 
+    #[tokio::test]
+    async fn list_path_raw_propagates_agreed_callback_failure() {
+        let entry = MetaCacheEntry {
+            name: "bucket/object".to_owned(),
+            metadata: vec![1],
+            ..Default::default()
+        };
+        let result = timeout(
+            Duration::from_secs(1),
+            list_path_raw(
+                CancellationToken::new(),
+                ListPathRawOptions {
+                    disks: vec![None],
+                    min_disks: 1,
+                    test_reader_behaviors: vec![TestReaderBehavior::Entries(vec![entry])],
+                    agreed: Some(Box::new(|_| Box::pin(async { Err(DiskError::ErasureReadQuorum) }))),
+                    ..Default::default()
+                },
+            ),
+        )
+        .await
+        .expect("callback failure must terminate the walk");
+        assert_eq!(
+            result.expect_err("agreed resolution must not silently omit the key"),
+            DiskError::ErasureReadQuorum
+        );
+    }
+
     #[tokio::test]
     async fn list_path_raw_propagates_partial_callback_failure() {
         let first = MetaCacheEntry {
@@ -1811,6 +1839,7 @@ mod tests {
                     Box::pin(async move {
                         callback_started.notify_one();
                         std::future::pending::<()>().await;
+                        Ok(())
                     })
                 })),
                 ..Default::default()
@@ -1962,6 +1991,7 @@ mod tests {
                     let seen = seen_clone.clone();
                     Box::pin(async move {
                         seen.lock().expect("seen mutex poisoned").push(entry.name);
+                        Ok(())
                     })
                 })),
                 ..Default::default()
@@ -2004,6 +2034,7 @@ mod tests {
                     let seen = seen_clone.clone();
                     Box::pin(async move {
                         seen.lock().expect("seen mutex poisoned").push(entry.name);
+                        Ok(())
                     })
                 })),
                 ..Default::default()
@@ -2076,6 +2107,7 @@ mod tests {
                     let seen = agreed_seen.clone();
                     Box::pin(async move {
                         seen.lock().expect("seen mutex poisoned").push(entry.name);
+                        Ok(())
                     })
                 })),
                 partial: Some(Box::new(move |entries, _| {
@@ -2241,6 +2273,7 @@ mod tests {
                     let agreed_events = agreed_events.clone();
                     Box::pin(async move {
                         agreed_events.lock().expect("events lock").push((entry.name, 4usize, true));
+                        Ok(())
                     })
                 })),
                 partial: Some(Box::new(move |entries, _| {
@@ -2397,6 +2430,7 @@ mod tests {
                         let name = entry.name;
                         Box::pin(async move {
                             agreed_obs.lock().expect("obs lock").push((name, vec![Some(desc); 4], true));
+                            Ok(())
                         })
                     })),
                     partial: Some(Box::new(move |entries, _| {

crates/ecstore/src/cluster/rpc/http_auth.rs

@@ -94,6 +94,7 @@ const REPLAY_CACHE_AUTO_MEMORY_PERCENT: u64 = 13;
 const REPLAY_CACHE_AUTO_RPC_RPS_PER_CPU: usize = 4096;
 const REPLAY_CACHE_AUTO_MAX_CAPACITY: usize = 33_554_432;
 const NS_SCANNER_CAPABILITY_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-capability-v3";
+const NS_SCANNER_CHECKPOINT_COVERAGE_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-checkpoint-coverage-v1";
 const NS_SCANNER_TIER_REGISTRY_GENERATION_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-tier-registry-generation-v1";
 pub const TONIC_RPC_PREFIX: &str = "/node_service.NodeService";
 static INTERNODE_RPC_SIGNATURE_STRICT: LazyLock<bool> = LazyLock::new(|| {
@@ -642,6 +643,7 @@ fn update_ns_scanner_capability_mac(
     challenge: Uuid,
     server_epoch: Uuid,
     supports_tier_registry_generation: bool,
+    supports_checkpoint_coverage: bool,
 ) {
     mac.update(NS_SCANNER_CAPABILITY_AUTH_DOMAIN);
     mac.update(&NS_SCANNER_PROTOCOL_VERSION.to_be_bytes());
@@ -653,6 +655,9 @@ fn update_ns_scanner_capability_mac(
         // that receives generation-fenced scanner work.
         mac.update(NS_SCANNER_TIER_REGISTRY_GENERATION_AUTH_DOMAIN);
     }
+    if supports_checkpoint_coverage {
+        mac.update(NS_SCANNER_CHECKPOINT_COVERAGE_AUTH_DOMAIN);
+    }
 }
 
 fn generate_ns_scanner_capability_proof(
@@ -660,13 +665,20 @@ fn generate_ns_scanner_capability_proof(
     challenge: Uuid,
     server_epoch: Uuid,
     supports_tier_registry_generation: bool,
+    supports_checkpoint_coverage: bool,
 ) -> std::io::Result<Vec<u8>> {
     if challenge.is_nil() || server_epoch.is_nil() {
         return Err(std::io::Error::other("Invalid namespace scanner capability scope"));
     }
     let mut mac =
         <HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
-    update_ns_scanner_capability_mac(&mut mac, challenge, server_epoch, supports_tier_registry_generation);
+    update_ns_scanner_capability_mac(
+        &mut mac,
+        challenge,
+        server_epoch,
+        supports_tier_registry_generation,
+        supports_checkpoint_coverage,
+    );
     Ok(mac.finalize().into_bytes().to_vec())
 }
 
@@ -676,13 +688,20 @@ fn verify_ns_scanner_capability_proof(
     server_epoch: Uuid,
     proof: &[u8],
     supports_tier_registry_generation: bool,
+    supports_checkpoint_coverage: bool,
 ) -> std::io::Result<()> {
     if challenge.is_nil() || server_epoch.is_nil() {
         return Err(std::io::Error::other("Invalid namespace scanner capability scope"));
     }
     let mut mac =
         <HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
-    update_ns_scanner_capability_mac(&mut mac, challenge, server_epoch, supports_tier_registry_generation);
+    update_ns_scanner_capability_mac(
+        &mut mac,
+        challenge,
+        server_epoch,
+        supports_tier_registry_generation,
+        supports_checkpoint_coverage,
+    );
     mac.verify_slice(proof)
         .map_err(|_| std::io::Error::new(std::io::ErrorKind::PermissionDenied, "Invalid namespace scanner capability proof"))
 }
@@ -700,7 +719,22 @@ pub fn sign_ns_scanner_capability_with_tier_registry_generation(
     server_epoch: Uuid,
     supports_tier_registry_generation: bool,
 ) -> std::io::Result<Vec<u8>> {
-    generate_ns_scanner_capability_proof(&get_shared_secret()?, challenge, server_epoch, supports_tier_registry_generation)
+    sign_ns_scanner_capability_with_checkpoint_coverage(challenge, server_epoch, supports_tier_registry_generation, false)
+}
+
+pub fn sign_ns_scanner_capability_with_checkpoint_coverage(
+    challenge: Uuid,
+    server_epoch: Uuid,
+    supports_tier_registry_generation: bool,
+    supports_checkpoint_coverage: bool,
+) -> std::io::Result<Vec<u8>> {
+    generate_ns_scanner_capability_proof(
+        &get_shared_secret()?,
+        challenge,
+        server_epoch,
+        supports_tier_registry_generation,
+        supports_checkpoint_coverage,
+    )
 }
 
 pub fn verify_ns_scanner_capability_with_tier_registry_generation(
@@ -709,7 +743,30 @@ pub fn verify_ns_scanner_capability_with_tier_registry_generation(
     proof: &[u8],
     supports_tier_registry_generation: bool,
 ) -> std::io::Result<()> {
-    verify_ns_scanner_capability_proof(&get_shared_secret()?, challenge, server_epoch, proof, supports_tier_registry_generation)
+    verify_ns_scanner_capability_with_checkpoint_coverage(
+        challenge,
+        server_epoch,
+        proof,
+        supports_tier_registry_generation,
+        false,
+    )
+}
+
+pub fn verify_ns_scanner_capability_with_checkpoint_coverage(
+    challenge: Uuid,
+    server_epoch: Uuid,
+    proof: &[u8],
+    supports_tier_registry_generation: bool,
+    supports_checkpoint_coverage: bool,
+) -> std::io::Result<()> {
+    verify_ns_scanner_capability_proof(
+        &get_shared_secret()?,
+        challenge,
+        server_epoch,
+        proof,
+        supports_tier_registry_generation,
+        supports_checkpoint_coverage,
+    )
 }
 
 #[derive(Clone, Copy)]
@@ -1776,13 +1833,30 @@ mod tests {
         let secret = "test-scanner-capability-secret";
         let challenge = Uuid::new_v4();
         let server_epoch = Uuid::new_v4();
-        let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, false)
+        let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, false, false)
             .expect("capability proof should be generated");
 
-        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false).is_ok());
-        assert!(verify_ns_scanner_capability_proof(secret, Uuid::new_v4(), server_epoch, &proof, false).is_err());
-        assert!(verify_ns_scanner_capability_proof(secret, challenge, Uuid::new_v4(), &proof, false).is_err());
-        assert!(verify_ns_scanner_capability_proof("different-secret", challenge, server_epoch, &proof, false).is_err());
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, false).is_ok());
+        assert!(verify_ns_scanner_capability_proof(secret, Uuid::new_v4(), server_epoch, &proof, false, false).is_err());
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, Uuid::new_v4(), &proof, false, false).is_err());
+        assert!(verify_ns_scanner_capability_proof("different-secret", challenge, server_epoch, &proof, false, false).is_err());
+    }
+
+    #[test]
+    fn namespace_scanner_capability_proof_binds_checkpoint_coverage_support() {
+        let secret = "checkpoint-capability-test-secret";
+        let challenge = Uuid::new_v4();
+        let server_epoch = Uuid::new_v4();
+        let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, true)
+            .expect("checkpoint capability proof");
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, true).is_ok());
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, false).is_err());
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, true).is_err());
+        let legacy = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, false)
+            .expect("legacy generation capability proof");
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &legacy, true, true).is_err());
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &[], true, true).is_err());
+        assert!(verify_ns_scanner_capability_proof(secret, Uuid::new_v4(), server_epoch, &proof, true, true).is_err());
     }
 
     #[test]
@@ -1790,14 +1864,14 @@ mod tests {
         let secret = "test-scanner-capability-secret";
         let challenge = Uuid::new_v4();
         let server_epoch = Uuid::new_v4();
-        let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true)
+        let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, false)
             .expect("generation capability proof should be generated");
 
-        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true).is_ok());
-        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false).is_err());
-        let legacy = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, false)
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, false).is_ok());
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, false).is_err());
+        let legacy = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, false, false)
             .expect("legacy capability proof should be generated");
-        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &legacy, true).is_err());
+        assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &legacy, true, false).is_err());
     }
 
     /// Security regression for GHSA-r5qv-rc46-hv8q (internode RPC fail-closed,

crates/ecstore/src/cluster/rpc/internode_data_transport.rs

@@ -13,18 +13,19 @@
 // limitations under the License.
 
 use crate::cluster::rpc::{
-    build_auth_headers, build_put_file_auth_trailer, verify_ns_scanner_capability_with_tier_registry_generation,
-    verify_put_file_capability,
+    build_auth_headers, build_put_file_auth_trailer, verify_ns_scanner_capability_with_checkpoint_coverage,
+    verify_ns_scanner_capability_with_tier_registry_generation, verify_put_file_capability,
 };
 use crate::disk::error::{Error, Result};
 use crate::disk::{FileReader, FileWriter};
 use crate::storage_api_contracts::internode::{
-    NS_SCANNER_BODY_SHA256_QUERY, NS_SCANNER_CAPABILITY_CHALLENGE_QUERY, NS_SCANNER_CYCLE_QUERY, NS_SCANNER_LEADER_EPOCH_QUERY,
-    NS_SCANNER_PROTOCOL_VERSION, NS_SCANNER_PROTOCOL_VERSION_QUERY, NS_SCANNER_REQUEST_ID_QUERY, NS_SCANNER_SERVER_EPOCH_QUERY,
-    NS_SCANNER_SESSION_ID_QUERY, NS_SCANNER_SESSION_SEQUENCE_QUERY, NS_SCANNER_TIER_REGISTRY_GENERATION_QUERY,
-    NsScannerCapabilityResponse, PUT_FILE_AUTH_QUERY, PUT_FILE_AUTH_V1, PUT_FILE_CAPABILITY_CHALLENGE_QUERY,
-    PUT_FILE_CAPABILITY_QUERY, PUT_FILE_CAPABILITY_VERSION, PUT_FILE_NONCE_QUERY, PUT_FILE_SERVER_EPOCH_QUERY,
-    PutFileCapabilityResponse, WALK_DIR_BODY_SHA256_QUERY, WALK_DIR_STREAM_COMPLETION_QUERY, WALK_DIR_STREAM_COMPLETION_V1,
+    NS_SCANNER_BODY_SHA256_QUERY, NS_SCANNER_CAPABILITY_CHALLENGE_QUERY, NS_SCANNER_CHECKPOINT_COVERAGE_QUERY,
+    NS_SCANNER_CYCLE_QUERY, NS_SCANNER_LEADER_EPOCH_QUERY, NS_SCANNER_PROTOCOL_VERSION, NS_SCANNER_PROTOCOL_VERSION_QUERY,
+    NS_SCANNER_REQUEST_ID_QUERY, NS_SCANNER_SERVER_EPOCH_QUERY, NS_SCANNER_SESSION_ID_QUERY, NS_SCANNER_SESSION_SEQUENCE_QUERY,
+    NS_SCANNER_TIER_REGISTRY_GENERATION_QUERY, NsScannerCapabilityResponse, PUT_FILE_AUTH_QUERY, PUT_FILE_AUTH_V1,
+    PUT_FILE_CAPABILITY_CHALLENGE_QUERY, PUT_FILE_CAPABILITY_QUERY, PUT_FILE_CAPABILITY_VERSION, PUT_FILE_NONCE_QUERY,
+    PUT_FILE_SERVER_EPOCH_QUERY, PutFileCapabilityResponse, WALK_DIR_BODY_SHA256_QUERY, WALK_DIR_STREAM_COMPLETION_QUERY,
+    WALK_DIR_STREAM_COMPLETION_V1,
 };
 use async_trait::async_trait;
 use http::{HeaderMap, HeaderValue, Method, header::CONTENT_TYPE};
@@ -250,6 +251,7 @@ pub struct NsScannerStreamRequest {
 pub struct NsScannerCapabilityRequest {
     pub endpoint: String,
     pub supports_tier_registry_generation: bool,
+    pub supports_checkpoint_coverage: bool,
 }
 
 /// Data-plane stream opener used by `RemoteDisk`.
@@ -289,6 +291,7 @@ pub trait InternodeDataTransport: Send + Sync + std::fmt::Debug {
             server_epoch,
             proof: Vec::new(),
             supports_tier_registry_generation: None,
+            supports_checkpoint_coverage: None,
         })
     }
     // Interface facet nobody calls yet: every transport implements both, but no
@@ -379,6 +382,18 @@ impl InternodeDataTransport for TcpHttpInternodeDataTransport {
     }
 
     async fn probe_ns_scanner_capability(&self, request: NsScannerCapabilityRequest) -> Result<NsScannerCapabilityResponse> {
+        let request = if request.supports_checkpoint_coverage {
+            match self.probe_ns_scanner_capability_once(&request).await {
+                Ok(response) => return Ok(response),
+                Err(error) if ns_scanner_capability_error_allows_legacy(&error) => NsScannerCapabilityRequest {
+                    supports_checkpoint_coverage: false,
+                    ..request
+                },
+                Err(error) => return Err(error),
+            }
+        } else {
+            request
+        };
         if request.supports_tier_registry_generation {
             return match self.probe_ns_scanner_capability_once(&request).await {
                 Ok(response) => Ok(response),
@@ -390,6 +405,7 @@ impl InternodeDataTransport for TcpHttpInternodeDataTransport {
                     let legacy_request = NsScannerCapabilityRequest {
                         endpoint: request.endpoint.clone(),
                         supports_tier_registry_generation: false,
+                        supports_checkpoint_coverage: false,
                     };
                     match self.probe_ns_scanner_capability_once(&legacy_request).await {
                         Ok(mut response) => {
@@ -447,18 +463,32 @@ impl TcpHttpInternodeDataTransport {
         if response.version != NS_SCANNER_PROTOCOL_VERSION || response.server_epoch.is_nil() {
             return Err(Error::other("incompatible remote namespace scanner capability response"));
         }
-        if let Err(err) = verify_ns_scanner_capability_with_tier_registry_generation(
+        if let Err(err) = verify_ns_scanner_capability_with_checkpoint_coverage(
             challenge,
             response.server_epoch,
             &response.proof,
             request.supports_tier_registry_generation,
+            request.supports_checkpoint_coverage,
         ) {
+            if request.supports_checkpoint_coverage
+                && verify_ns_scanner_capability_with_tier_registry_generation(
+                    challenge,
+                    response.server_epoch,
+                    &response.proof,
+                    request.supports_tier_registry_generation,
+                )
+                .is_ok()
+            {
+                normalize_ns_scanner_capability_response(&mut response, request.supports_tier_registry_generation, false);
+                return Ok(response);
+            }
             // A permissive older peer can ignore the additive marker and
             // return a valid legacy-scope proof with HTTP 200. Accept that
             // response only after independently authenticating the legacy
             // scope; all other verification failures remain fail-closed.
             if request.supports_tier_registry_generation && ns_scanner_capability_legacy_proof_is_valid(challenge, &response) {
                 response.supports_tier_registry_generation = None;
+                response.supports_checkpoint_coverage = None;
                 return Ok(response);
             }
             return Err(Error::other(format!("remote namespace scanner capability authentication failed: {err}")));
@@ -468,7 +498,11 @@ impl TcpHttpInternodeDataTransport {
         // verified scope so an intermediary cannot strip or rewrite the field
         // and force a silent downgrade after a successful generation-bound
         // handshake.
-        normalize_ns_scanner_capability_response(&mut response, request.supports_tier_registry_generation);
+        normalize_ns_scanner_capability_response(
+            &mut response,
+            request.supports_tier_registry_generation,
+            request.supports_checkpoint_coverage,
+        );
         Ok(response)
     }
 
@@ -798,8 +832,13 @@ fn build_walk_dir_url(request: &WalkDirStreamRequest) -> String {
     )
 }
 
-fn normalize_ns_scanner_capability_response(response: &mut NsScannerCapabilityResponse, requested_generation_support: bool) {
+fn normalize_ns_scanner_capability_response(
+    response: &mut NsScannerCapabilityResponse,
+    requested_generation_support: bool,
+    requested_checkpoint_coverage: bool,
+) {
     response.supports_tier_registry_generation = requested_generation_support.then_some(true);
+    response.supports_checkpoint_coverage = requested_checkpoint_coverage.then_some(true);
 }
 
 fn ns_scanner_capability_legacy_proof_is_valid(challenge: Uuid, response: &NsScannerCapabilityResponse) -> bool {
@@ -832,7 +871,7 @@ fn build_ns_scanner_url(request: &NsScannerStreamRequest) -> String {
 
 fn build_ns_scanner_capability_url(request: &NsScannerCapabilityRequest, challenge: Uuid) -> String {
     format!(
-        "{}{}?{}={}&{}={}{}",
+        "{}{}?{}={}&{}={}{}{}",
         request.endpoint,
         NS_SCANNER_PATH,
         NS_SCANNER_PROTOCOL_VERSION_QUERY,
@@ -843,6 +882,11 @@ fn build_ns_scanner_capability_url(request: &NsScannerCapabilityRequest, challen
             format!("&{}=true", NS_SCANNER_TIER_REGISTRY_GENERATION_QUERY)
         } else {
             String::new()
+        },
+        if request.supports_checkpoint_coverage {
+            format!("&{}=true", NS_SCANNER_CHECKPOINT_COVERAGE_QUERY)
+        } else {
+            String::new()
         }
     )
 }
@@ -1001,6 +1045,7 @@ mod tests {
             .probe_ns_scanner(NsScannerCapabilityRequest {
                 endpoint: "http://node1:9000".to_string(),
                 supports_tier_registry_generation: false,
+                supports_checkpoint_coverage: false,
             })
             .await
             .expect_err("legacy transport should report namespace scanner as unsupported");
@@ -1027,6 +1072,97 @@ mod tests {
         assert!(matches!(open_err, Error::MethodNotAllowed));
     }
 
+    #[tokio::test]
+    async fn namespace_scanner_checkpoint_capability_authenticates_new_and_legacy_peers() {
+        crate::runtime::sources::ensure_test_rpc_secret();
+        for peer in ["current", "strict-old", "permissive-old", "invalid-proof", "missing-proof"] {
+            let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+                .await
+                .expect("capability listener");
+            let address = listener.local_addr().expect("capability listener address");
+            let server_epoch = Uuid::new_v4();
+            let server = tokio::spawn(async move {
+                let requests = if peer == "strict-old" { 2 } else { 1 };
+                for index in 0..requests {
+                    let (mut socket, _) = listener.accept().await.expect("capability request");
+                    let mut bytes = Vec::new();
+                    while !bytes.windows(4).any(|window| window == b"\r\n\r\n") {
+                        let mut chunk = [0; 1024];
+                        let read = socket.read(&mut chunk).await.expect("capability headers");
+                        assert!(read > 0 && bytes.len() < 16 * 1024, "bounded complete capability headers");
+                        bytes.extend_from_slice(&chunk[..read]);
+                    }
+                    let request = std::str::from_utf8(&bytes).expect("HTTP headers");
+                    let target = request.split_whitespace().nth(1).expect("HTTP request target");
+                    let url = reqwest::Url::parse(&format!("http://{address}{target}")).expect("capability URL");
+                    let query: HashMap<_, _> = url.query_pairs().into_owned().collect();
+                    assert_eq!(query.get(NS_SCANNER_TIER_REGISTRY_GENERATION_QUERY).map(String::as_str), Some("true"));
+                    assert_eq!(query.contains_key(NS_SCANNER_CHECKPOINT_COVERAGE_QUERY), index == 0);
+                    if peer == "strict-old" && index == 0 {
+                        socket
+                            .write_all(b"HTTP/1.1 400 Bad Request\r\ncontent-length: 0\r\nconnection: close\r\n\r\n")
+                            .await
+                            .expect("legacy parser rejection");
+                        continue;
+                    }
+                    let challenge = query[NS_SCANNER_CAPABILITY_CHALLENGE_QUERY].parse().expect("challenge UUID");
+                    let proof = match peer {
+                        "invalid-proof" => vec![0; 32],
+                        "missing-proof" => Vec::new(),
+                        _ => crate::cluster::rpc::sign_ns_scanner_capability_with_checkpoint_coverage(
+                            challenge,
+                            server_epoch,
+                            true,
+                            peer == "current",
+                        )
+                        .expect("server capability proof"),
+                    };
+                    let body = rmp_serde::to_vec_named(&NsScannerCapabilityResponse {
+                        version: NS_SCANNER_PROTOCOL_VERSION,
+                        server_epoch,
+                        proof,
+                        supports_tier_registry_generation: Some(true),
+                        // Strip a supported bit, or forge it for an older peer.
+                        supports_checkpoint_coverage: (peer != "current").then_some(true),
+                    })
+                    .expect("capability response");
+                    socket
+                        .write_all(
+                            format!("HTTP/1.1 200 OK\r\ncontent-length: {}\r\nconnection: close\r\n\r\n", body.len()).as_bytes(),
+                        )
+                        .await
+                        .expect("capability response headers");
+                    socket.write_all(&body).await.expect("capability response body");
+                }
+                requests
+            });
+            let response = tokio::time::timeout(
+                Duration::from_secs(10),
+                TcpHttpInternodeDataTransport.probe_ns_scanner_capability(NsScannerCapabilityRequest {
+                    endpoint: format!("http://{address}"),
+                    supports_tier_registry_generation: true,
+                    supports_checkpoint_coverage: true,
+                }),
+            )
+            .await
+            .expect("bounded capability probe");
+            if peer.ends_with("proof") {
+                assert!(
+                    response
+                        .expect_err("unverified capability must fail closed")
+                        .to_string()
+                        .contains("authentication failed")
+                );
+            } else {
+                let response = response.expect("authenticated capability");
+                assert_eq!(response.server_epoch, server_epoch);
+                assert_eq!(response.supports_tier_registry_generation, Some(true));
+                assert_eq!(response.supports_checkpoint_coverage, (peer == "current").then_some(true));
+            }
+            assert_eq!(server.await.expect("capability server"), if peer == "strict-old" { 2 } else { 1 });
+        }
+    }
+
     #[tokio::test]
     async fn walk_dir_restores_explicit_remote_missing_error() {
         let _ = rustfs_credentials::set_global_rpc_secret("walk-dir-error-test-secret".to_string());
@@ -1769,6 +1905,7 @@ mod tests {
             &NsScannerCapabilityRequest {
                 endpoint: "http://node1:9000".to_string(),
                 supports_tier_registry_generation: false,
+                supports_checkpoint_coverage: false,
             },
             challenge,
         );
@@ -1788,6 +1925,7 @@ mod tests {
             &NsScannerCapabilityRequest {
                 endpoint: "http://node1:9000".to_string(),
                 supports_tier_registry_generation: true,
+                supports_checkpoint_coverage: false,
             },
             challenge,
         );
@@ -1826,13 +1964,14 @@ mod tests {
             server_epoch: Uuid::new_v4(),
             proof: Vec::new(),
             supports_tier_registry_generation: None,
+            supports_checkpoint_coverage: None,
         };
 
-        normalize_ns_scanner_capability_response(&mut response, true);
+        normalize_ns_scanner_capability_response(&mut response, true, true);
         assert_eq!(response.supports_tier_registry_generation, Some(true));
 
         response.supports_tier_registry_generation = Some(false);
-        normalize_ns_scanner_capability_response(&mut response, false);
+        normalize_ns_scanner_capability_response(&mut response, false, false);
         assert_eq!(response.supports_tier_registry_generation, None);
     }
 
@@ -1846,6 +1985,7 @@ mod tests {
             proof: crate::cluster::rpc::sign_ns_scanner_capability(challenge, Uuid::new_v4())
                 .expect("placeholder proof should be generated"),
             supports_tier_registry_generation: None,
+            supports_checkpoint_coverage: None,
         };
         // A proof bound to a different challenge cannot authorize the legacy
         // fallback, even though the response has the expected shape.

crates/ecstore/src/cluster/rpc/mod.rs

@@ -36,12 +36,13 @@ 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_ns_scanner_capability_with_tier_registry_generation, 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_ns_scanner_capability_with_tier_registry_generation, 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_mutation_body_digest_reject_unsigned, verify_tonic_rpc_response_proof,
-    verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
+    sign_ns_scanner_capability, sign_ns_scanner_capability_with_checkpoint_coverage,
+    sign_ns_scanner_capability_with_tier_registry_generation, 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_ns_scanner_capability_with_checkpoint_coverage, verify_ns_scanner_capability_with_tier_registry_generation,
+    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_mutation_body_digest_reject_unsigned,
+    verify_tonic_rpc_response_proof, verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
 };
 #[cfg(test)]
 pub(crate) use internode_data_transport::TcpHttpInternodeDataTransport;

crates/ecstore/src/cluster/rpc/peer_rest_client.rs

@@ -1954,6 +1954,15 @@ impl PeerRestClient {
         Ok((self.topology_member.clone(), epoch))
     }
 
+    pub async fn probe_restore_copyback_capability(&self, topology_fingerprint: String) -> Result<(String, Uuid)> {
+        let probe = rustfs_protos::restore_copyback_capability_probe(Uuid::new_v4().as_bytes());
+        let result = self
+            .heal_control(rustfs_protos::HEAL_CONTROL_PROTOCOL_VERSION, topology_fingerprint, probe)
+            .await?;
+        let epoch = decode_remote_version_state_capability(&self.topology_member, &result)?;
+        Ok((self.topology_member.clone(), epoch))
+    }
+
     pub async fn probe_cross_pool_fence(&self, topology_fingerprint: String) -> Result<(String, u32, Uuid)> {
         let mut probe = rustfs_protos::CROSS_POOL_FENCE_CAPABILITY_PROBE_PREFIX.to_vec();
         probe.extend_from_slice(Uuid::new_v4().as_bytes());

crates/ecstore/src/cluster/rpc/peer_s3_client.rs

@@ -417,8 +417,10 @@ impl S3PeerSys {
         let errs = join_all(futures).await;
 
         let mut pool_errs = Vec::new();
+        let mut all_pools_have_participants = true;
         for pool_idx in 0..self.pools_count {
             let per_pool_errs = pool_participant_errors(&self.clients, &errs, pool_idx);
+            all_pools_have_participants &= !per_pool_errs.is_empty();
             pool_errs.push(reduce_pool_write_quorum_errs(&per_pool_errs));
         }
 
@@ -451,6 +453,17 @@ impl S3PeerSys {
         for pool_idx in 0..self.pools_count {
             let per_pool_errs = pool_participant_errors(&self.clients, &errs, pool_idx);
             if let Some(pool_err) = reduce_pool_write_quorum_errs(&per_pool_errs) {
+                // A success/busy split can miss quorum without a majority error.
+                // Keep that refusal retryable without masking other peer failures.
+                let pool_err = if pool_err == Error::ErasureWriteQuorum
+                    && all_pools_have_participants
+                    && per_pool_errs.iter().any(|err| err.as_ref() == Some(&Error::TooManyOpenFiles))
+                    && errs.iter().flatten().all(|err| *err == Error::TooManyOpenFiles)
+                {
+                    Error::TooManyOpenFiles
+                } else {
+                    pool_err
+                };
                 tracing::error!("heal_bucket per_pool_errs: {per_pool_errs:?}");
                 tracing::error!("heal_bucket reduce_write_quorum_errs: {pool_err}");
                 return Err(pool_err);
@@ -1810,6 +1823,7 @@ mod tests {
     #[derive(Debug)]
     struct TestPeerS3Client {
         pools: Option<Vec<usize>>,
+        heal_bucket_result: Result<HealResultItem>,
         make_bucket_result: Result<()>,
         list_bucket_result: Result<Vec<BucketInfo>>,
         delete_bucket_result: Result<()>,
@@ -1819,7 +1833,7 @@ mod tests {
     #[async_trait]
     impl PeerS3Client for TestPeerS3Client {
         async fn heal_bucket(&self, _bucket: &str, _opts: &HealOpts) -> Result<HealResultItem> {
-            unreachable!("not used by quorum tests")
+            self.heal_bucket_result.clone()
         }
 
         async fn make_bucket(&self, _bucket: &str, _opts: &MakeBucketOptions) -> Result<()> {
@@ -1835,8 +1849,11 @@ mod tests {
             self.delete_bucket_result.clone()
         }
 
-        async fn get_bucket_info(&self, _bucket: &str, _opts: &BucketOptions) -> Result<BucketInfo> {
-            unreachable!("not used by quorum tests")
+        async fn get_bucket_info(&self, bucket: &str, _opts: &BucketOptions) -> Result<BucketInfo> {
+            Ok(BucketInfo {
+                name: bucket.to_string(),
+                ..Default::default()
+            })
         }
 
         fn get_pools(&self) -> Option<Vec<usize>> {
@@ -1848,6 +1865,17 @@ mod tests {
         test_peer_with_make_bucket(pools, Ok(()))
     }
 
+    fn test_peer_with_heal_bucket(pools: &[usize], heal_bucket_result: Result<HealResultItem>) -> Client {
+        Arc::new(Box::new(TestPeerS3Client {
+            pools: Some(pools.to_vec()),
+            heal_bucket_result,
+            make_bucket_result: Ok(()),
+            list_bucket_result: Ok(Vec::new()),
+            delete_bucket_result: Ok(()),
+            make_bucket_calls: Arc::new(AtomicUsize::new(0)),
+        }))
+    }
+
     fn test_peer_with_make_bucket(pools: &[usize], make_bucket_result: Result<()>) -> Client {
         test_peer_with_results(pools, make_bucket_result, Ok(Vec::new()))
     }
@@ -1885,6 +1913,7 @@ mod tests {
     ) -> Client {
         Arc::new(Box::new(TestPeerS3Client {
             pools: Some(pools.to_vec()),
+            heal_bucket_result: Ok(HealResultItem::default()),
             make_bucket_result,
             list_bucket_result,
             delete_bucket_result,
@@ -2634,6 +2663,119 @@ mod tests {
         assert_eq!(err, Error::VolumeExists);
     }
 
+    #[tokio::test]
+    async fn test_heal_bucket_preserves_busy_refusal_below_error_quorum() {
+        for busy_count in 2..=4 {
+            let peer_sys = S3PeerSys {
+                clients: (0..4)
+                    .map(|peer| {
+                        test_peer_with_heal_bucket(
+                            &[0],
+                            if peer < busy_count {
+                                Err(Error::TooManyOpenFiles)
+                            } else {
+                                Ok(HealResultItem::default())
+                            },
+                        )
+                    })
+                    .collect(),
+                pools_count: 1,
+            };
+
+            let error = peer_sys
+                .heal_bucket("bucket", &HealOpts::default())
+                .await
+                .expect_err("busy peers must not turn a failed heal into success");
+            assert_eq!(error, Error::TooManyOpenFiles, "busy peers: {busy_count}");
+        }
+    }
+
+    #[tokio::test]
+    async fn test_heal_bucket_busy_peer_preserves_success_quorum() {
+        let peer_sys = S3PeerSys {
+            clients: vec![
+                test_peer_with_heal_bucket(&[0], Err(Error::TooManyOpenFiles)),
+                test_peer(&[0]),
+                test_peer(&[0]),
+                test_peer(&[0]),
+            ],
+            pools_count: 1,
+        };
+
+        peer_sys
+            .heal_bucket("bucket", &HealOpts::default())
+            .await
+            .expect("three successful peers still satisfy the four-peer write quorum");
+    }
+
+    #[tokio::test]
+    async fn test_heal_bucket_busy_peers_do_not_hide_other_failures() {
+        for failure in [Error::FaultyDisk, Error::VolumeNotFound, Error::ErasureWriteQuorum] {
+            let peer_sys = S3PeerSys {
+                clients: vec![
+                    test_peer_with_heal_bucket(&[0], Err(Error::TooManyOpenFiles)),
+                    test_peer_with_heal_bucket(&[0], Err(Error::TooManyOpenFiles)),
+                    test_peer_with_heal_bucket(&[0], Err(failure.clone())),
+                    test_peer(&[0]),
+                ],
+                pools_count: 1,
+            };
+
+            let error = peer_sys
+                .heal_bucket("bucket", &HealOpts::default())
+                .await
+                .expect_err("a mixed failure must still fail write quorum");
+            assert_eq!(error, Error::ErasureWriteQuorum, "non-busy failure: {failure}");
+        }
+    }
+
+    #[tokio::test]
+    async fn test_heal_bucket_busy_pool_does_not_hide_another_pool_failure() {
+        let peer_sys = S3PeerSys {
+            clients: vec![
+                test_peer_with_heal_bucket(&[0], Err(Error::TooManyOpenFiles)),
+                test_peer_with_heal_bucket(&[0], Err(Error::TooManyOpenFiles)),
+                test_peer(&[0]),
+                test_peer(&[0]),
+                test_peer_with_heal_bucket(&[1], Err(Error::FaultyDisk)),
+            ],
+            pools_count: 2,
+        };
+
+        let error = peer_sys
+            .heal_bucket("bucket", &HealOpts::default())
+            .await
+            .expect_err("the busy split must not hide a non-busy failure from another pool");
+        assert_eq!(error, Error::ErasureWriteQuorum);
+    }
+
+    #[tokio::test]
+    async fn test_heal_bucket_missing_pool_participants_remains_quorum_failure() {
+        for occupied_pool in 0..2 {
+            let peer_sys = S3PeerSys {
+                clients: vec![
+                    test_peer_with_heal_bucket(&[occupied_pool], Err(Error::TooManyOpenFiles)),
+                    test_peer_with_heal_bucket(&[occupied_pool], Err(Error::TooManyOpenFiles)),
+                    test_peer(&[occupied_pool]),
+                    test_peer(&[occupied_pool]),
+                ],
+                pools_count: 2,
+            };
+
+            let error = peer_sys
+                .heal_bucket(
+                    "bucket",
+                    &HealOpts {
+                        recreate: true,
+                        ..Default::default()
+                    },
+                )
+                .await
+                .expect_err("a pool without participants cannot be treated as a busy gate");
+            assert_eq!(error, Error::ErasureWriteQuorum, "pool with participants: {occupied_pool}");
+        }
+    }
+
     #[test]
     fn heal_bucket_mode_fails_closed_on_incomplete_topology() {
         let mut opts = HealOpts::default();

crates/ecstore/src/cluster/rpc/remote_disk.rs

@@ -54,6 +54,7 @@ use rustfs_io_metrics::internode_metrics::{
     INTERNODE_STAGE_BATCH_READ_VERSION_RPC_ROUNDTRIP, INTERNODE_STAGE_READ_VERSION_REQUEST_ENCODE,
     INTERNODE_STAGE_READ_VERSION_RESPONSE_DECODE, INTERNODE_STAGE_READ_VERSION_RPC_ROUNDTRIP,
 };
+use rustfs_io_metrics::walk_metrics::{RemoteWalkFailureReason, RemoteWalkGuard};
 use rustfs_protos::ChannelClass;
 use rustfs_protos::evict_failed_connection;
 use rustfs_protos::proto_gen::node_service::RenamePartRequest;
@@ -306,23 +307,76 @@ fn record_batch_read_version_gate_decision(mode: BatchMetadataRpcMode, decision:
     .increment(1);
 }
 
-async fn copy_stream_with_buffer<R, W>(reader: &mut R, writer: &mut W, buffer_size: usize) -> io::Result<u64>
+struct ObservedWalkWriter<'a, W> {
+    inner: &'a mut W,
+    observation: &'a mut RemoteWalkGuard,
+}
+
+impl<W: AsyncWrite + Unpin> AsyncWrite for ObservedWalkWriter<'_, W> {
+    fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
+        match Pin::new(&mut *self.inner).poll_write(cx, buf) {
+            Poll::Ready(Ok(written)) => {
+                self.observation.written(written);
+                Poll::Ready(Ok(written))
+            }
+            result => result,
+        }
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut *self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut *self.inner).poll_shutdown(cx)
+    }
+}
+
+#[derive(Debug)]
+struct WalkCopyError {
+    reason: RemoteWalkFailureReason,
+    source: io::Error,
+}
+
+async fn copy_stream_with_buffer<R, W>(
+    reader: &mut R,
+    writer: &mut W,
+    buffer_size: usize,
+    observation: &mut RemoteWalkGuard,
+) -> std::result::Result<u64, WalkCopyError>
 where
     R: AsyncRead + Unpin,
     W: AsyncWrite + Unpin,
 {
     let mut copied = 0_u64;
     let mut buffer = vec![0_u8; buffer_size];
+    let _scratch = observation.scratch_allocated(buffer.capacity());
 
     loop {
-        let bytes_read = reader.read(&mut buffer).await?;
+        let bytes_read = reader.read(&mut buffer).await.map_err(|source| WalkCopyError {
+            reason: RemoteWalkFailureReason::Read,
+            source,
+        })?;
+        observation.read(bytes_read);
         if bytes_read == 0 {
-            writer.flush().await?;
+            writer.flush().await.map_err(|source| WalkCopyError {
+                reason: RemoteWalkFailureReason::Flush,
+                source,
+            })?;
             return Ok(copied);
         }
 
-        writer.write_all(&buffer[..bytes_read]).await?;
-        copied += bytes_read as u64;
+        ObservedWalkWriter {
+            inner: writer,
+            observation,
+        }
+        .write_all(&buffer[..bytes_read])
+        .await
+        .map_err(|source| WalkCopyError {
+            reason: RemoteWalkFailureReason::Write,
+            source,
+        })?;
+        copied += u64::try_from(bytes_read).unwrap_or(u64::MAX);
     }
 }
 
@@ -1089,12 +1143,19 @@ impl RemoteDisk {
         let probe = self.data_transport.probe_ns_scanner_capability(NsScannerCapabilityRequest {
             endpoint: self.endpoint.grid_host(),
             supports_tier_registry_generation: true,
+            supports_checkpoint_coverage: true,
         });
         let result = timeout(NS_SCANNER_CAPABILITY_PROBE_TIMEOUT, probe)
             .await
             .map_err(|_| DiskError::other("remote namespace scanner capability probe timed out"))?;
         match result {
-            Ok(response) if response.supports_tier_registry_generation == Some(true) => Ok(Some(response.server_epoch)),
+            // RUSTFS_COMPAT_TODO(ns-scanner-checkpoint-coverage): old strict readers cannot accept the coverage field. Remove after every supported peer authenticates both scanner capabilities.
+            Ok(response)
+                if response.supports_tier_registry_generation == Some(true)
+                    && response.supports_checkpoint_coverage == Some(true) =>
+            {
+                Ok(Some(response.server_epoch))
+            }
             Ok(_) => Ok(None),
             // RUSTFS_COMPAT_TODO(ns-scanner-rpc-v3): old peers and legacy transports lack the authenticated startup-epoch handshake. Remove after every supported peer implements namespace scanner protocol v3.
             Err(DiskError::MethodNotAllowed) => Ok(None),
@@ -3599,8 +3660,15 @@ impl DiskAPI for RemoteDisk {
             "Remote disk RPC started"
         );
 
+        let mut observation = RemoteWalkGuard::start();
         let disk = self.disk_ref().await;
-        let body = serde_json::to_vec(&opts)?;
+        let body = match serde_json::to_vec(&opts) {
+            Ok(body) => body,
+            Err(err) => {
+                observation.finish_error(RemoteWalkFailureReason::Encoding);
+                return Err(err.into());
+            }
+        };
         let stall_timeout = opts.stall_timeout_duration().unwrap_or_else(get_drive_walkdir_stall_timeout);
         let bucket = opts.bucket.clone();
         let base_dir = opts.base_dir.clone();
@@ -3611,56 +3679,71 @@ impl DiskAPI for RemoteDisk {
             opts.timeout_duration().unwrap_or_else(get_drive_walkdir_timeout)
         };
 
-        self.execute_with_timeout_for_op_and_health_action(
-            "walk_dir",
-            || async {
-                let mut last_err = None;
+        let mut failure_reason = None;
+        let result = self
+            .execute_with_timeout_for_op_and_health_action(
+                "walk_dir",
+                || async {
+                    let mut last_err = None;
 
-                for attempt in 1..=2 {
-                    let mut reader = match self
-                        .data_transport
-                        .open_walk_dir(WalkDirStreamRequest {
-                            endpoint: self.endpoint.grid_host(),
-                            disk: disk.clone(),
-                            body: body.clone(),
-                            stall_timeout: Some(stall_timeout),
-                        })
-                        .await
-                    {
-                        Ok(reader) => reader,
-                        Err(err) => {
-                            if attempt == 1 && Self::is_retryable_walk_dir_error(&err) {
-                                warn!(
-                                    endpoint = %self.endpoint,
-                                    addr = %self.addr,
-                                    disk = %disk_for_log,
-                                    bucket = %bucket,
-                                    base_dir = %base_dir,
-                                    attempt,
-                                    stall_timeout_ms = stall_timeout.as_millis(),
-                                    error = %err,
-                                    "remote walk_dir returned retryable transport error; retrying"
-                                );
-                                last_err = Some(err);
-                                continue;
+                    for attempt in 1..=2 {
+                        let mut reader = match self
+                            .data_transport
+                            .open_walk_dir(WalkDirStreamRequest {
+                                endpoint: self.endpoint.grid_host(),
+                                disk: disk.clone(),
+                                body: body.clone(),
+                                stall_timeout: Some(stall_timeout),
+                            })
+                            .await
+                        {
+                            Ok(reader) => reader,
+                            Err(err) => {
+                                if attempt == 1 && Self::is_retryable_walk_dir_error(&err) {
+                                    warn!(
+                                        endpoint = %self.endpoint,
+                                        addr = %self.addr,
+                                        disk = %disk_for_log,
+                                        bucket = %bucket,
+                                        base_dir = %base_dir,
+                                        attempt,
+                                        stall_timeout_ms = stall_timeout.as_millis(),
+                                        error = %err,
+                                        "remote walk_dir returned retryable transport error; retrying"
+                                    );
+                                    last_err = Some(err);
+                                    continue;
+                                }
+
+                                failure_reason = Some(RemoteWalkFailureReason::Open);
+                                return Err(err);
                             }
+                        };
 
-                            return Err(err);
+                        match copy_stream_with_buffer(&mut reader, wr, DEFAULT_READ_BUFFER_SIZE, &mut observation).await {
+                            Ok(_) => return Ok(()),
+                            Err(error) => {
+                                failure_reason = Some(error.reason);
+                                return Err(DiskError::Io(error.source));
+                            }
                         }
-                    };
-
-                    match copy_stream_with_buffer(&mut reader, wr, DEFAULT_READ_BUFFER_SIZE).await {
-                        Ok(_) => return Ok(()),
-                        Err(io_err) => return Err(DiskError::Io(io_err)),
                     }
-                }
 
-                Err(last_err.unwrap_or_else(|| DiskError::other("walk_dir retry exhausted without captured error")))
-            },
-            timeout_duration,
-            FailureHealthAction::IgnoreFailure,
-        )
-        .await
+                    Err(last_err.unwrap_or_else(|| DiskError::other("walk_dir retry exhausted without captured error")))
+                },
+                timeout_duration,
+                FailureHealthAction::IgnoreFailure,
+            )
+            .await;
+        match &result {
+            Ok(()) => observation.finish(true),
+            Err(error) => observation.finish_error(failure_reason.unwrap_or(match error {
+                DiskError::Timeout => RemoteWalkFailureReason::OperationTimeout,
+                DiskError::FaultyDisk => RemoteWalkFailureReason::FaultyAdmission,
+                _ => RemoteWalkFailureReason::Other,
+            })),
+        }
+        result
     }
 
     #[tracing::instrument(level = "trace", skip_all)]
@@ -4932,6 +5015,7 @@ mod tests {
         calls: Arc<StdMutex<Vec<RecordedTransportCall>>>,
         ns_scanner_probe_status: Arc<StdMutex<Option<u16>>>,
         ns_scanner_generation_support: Arc<StdMutex<Option<bool>>>,
+        ns_scanner_checkpoint_support: Arc<StdMutex<Option<bool>>>,
     }
 
     impl Default for RecordingInternodeDataTransport {
@@ -4940,6 +5024,7 @@ mod tests {
                 calls: Arc::default(),
                 ns_scanner_probe_status: Arc::default(),
                 ns_scanner_generation_support: Arc::new(StdMutex::new(Some(true))),
+                ns_scanner_checkpoint_support: Arc::new(StdMutex::new(Some(true))),
             }
         }
     }
@@ -5190,6 +5275,7 @@ mod tests {
                 calls: Arc::default(),
                 ns_scanner_probe_status: Arc::new(StdMutex::new(Some(status))),
                 ns_scanner_generation_support: Arc::new(StdMutex::new(Some(true))),
+                ns_scanner_checkpoint_support: Arc::new(StdMutex::new(Some(true))),
             }
         }
 
@@ -5198,6 +5284,7 @@ mod tests {
                 calls: Arc::default(),
                 ns_scanner_probe_status: Arc::default(),
                 ns_scanner_generation_support: Arc::new(StdMutex::new(support)),
+                ns_scanner_checkpoint_support: Arc::new(StdMutex::new(Some(true))),
             }
         }
 
@@ -5898,6 +5985,7 @@ mod tests {
                 server_epoch,
                 proof: Vec::new(),
                 supports_tier_registry_generation,
+                supports_checkpoint_coverage: *self.ns_scanner_checkpoint_support.lock().expect("checkpoint capability lock"),
             })
         }
 
@@ -8128,7 +8216,7 @@ mod tests {
 
         let copy_task = tokio::spawn(async move {
             let mut cursor = Cursor::new(payload);
-            copy_stream_with_buffer(&mut cursor, &mut write_half, 4 * 1024)
+            copy_stream_with_buffer(&mut cursor, &mut write_half, 4 * 1024, &mut RemoteWalkGuard::default())
                 .await
                 .expect("operation should succeed");
         });
@@ -8140,6 +8228,459 @@ mod tests {
         assert_eq!(copied, expected);
     }
 
+    struct WalkTestWriter {
+        bytes: Vec<u8>,
+        accept_limit: usize,
+        zero_write: bool,
+        fail_flush: bool,
+        flushed: bool,
+        write_error: Option<io::Error>,
+        flush_error: Option<io::Error>,
+    }
+
+    impl WalkTestWriter {
+        fn new(accept_limit: usize) -> Self {
+            Self {
+                bytes: Vec::new(),
+                accept_limit,
+                zero_write: false,
+                fail_flush: false,
+                flushed: false,
+                write_error: None,
+                flush_error: None,
+            }
+        }
+    }
+
+    impl AsyncWrite for WalkTestWriter {
+        fn poll_write(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
+            if self.zero_write {
+                return Poll::Ready(Ok(0));
+            }
+            let remaining = self.accept_limit.saturating_sub(self.bytes.len());
+            if remaining == 0 {
+                return Poll::Ready(Err(self
+                    .write_error
+                    .take()
+                    .unwrap_or_else(|| io::Error::new(io::ErrorKind::BrokenPipe, "injected downstream failure"))));
+            }
+            let written = remaining.min(buf.len()).min(7);
+            self.bytes.extend_from_slice(&buf[..written]);
+            Poll::Ready(Ok(written))
+        }
+
+        fn poll_flush(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            self.flushed = true;
+            if let Some(error) = self.flush_error.take() {
+                return Poll::Ready(Err(error));
+            }
+            Poll::Ready(if self.fail_flush {
+                Err(io::Error::other("injected flush failure"))
+            } else {
+                Ok(())
+            })
+        }
+
+        fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            self.poll_flush(cx)
+        }
+    }
+
+    #[tokio::test]
+    async fn walk_stream_preserves_boundaries_and_short_writes() {
+        for size in [
+            0,
+            1,
+            DEFAULT_READ_BUFFER_SIZE - 1,
+            DEFAULT_READ_BUFFER_SIZE,
+            DEFAULT_READ_BUFFER_SIZE + 1,
+            4 * 1024 * 1024,
+        ] {
+            let payload: Vec<u8> = (0..=250).cycle().take(size).collect();
+            let mut reader = Cursor::new(&payload);
+            let mut writer = WalkTestWriter::new(usize::MAX);
+            let copied =
+                copy_stream_with_buffer(&mut reader, &mut writer, DEFAULT_READ_BUFFER_SIZE, &mut RemoteWalkGuard::default())
+                    .await
+                    .expect("walk boundary copy");
+            assert_eq!(copied, u64::try_from(size).expect("test size fits"));
+            assert_eq!(writer.bytes, payload);
+            assert!(writer.flushed, "EOF must flush even an empty walk");
+        }
+    }
+
+    #[tokio::test]
+    async fn walk_stream_propagates_write_zero_and_flush_failures() {
+        for (zero_write, fail_flush, expected) in [(true, false, io::ErrorKind::WriteZero), (false, true, io::ErrorKind::Other)] {
+            let mut reader = Cursor::new(b"walk payload");
+            let mut writer = WalkTestWriter::new(usize::MAX);
+            writer.zero_write = zero_write;
+            writer.fail_flush = fail_flush;
+            let error =
+                copy_stream_with_buffer(&mut reader, &mut writer, DEFAULT_READ_BUFFER_SIZE, &mut RemoteWalkGuard::default())
+                    .await
+                    .expect_err("injected write/flush failure must propagate");
+            assert_eq!(error.source.kind(), expected);
+            assert!(matches!(
+                (error.reason, fail_flush),
+                (RemoteWalkFailureReason::Flush, true) | (RemoteWalkFailureReason::Write, false)
+            ));
+            if fail_flush {
+                assert_eq!(writer.bytes, b"walk payload");
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn walk_stream_backpressure_limits_read_ahead_and_is_cancellable() {
+        let mut reader = Cursor::new(vec![5; 4 * DEFAULT_READ_BUFFER_SIZE]);
+        let (mut writer, mut consumer) = duplex(64);
+        {
+            let mut observation = RemoteWalkGuard::default();
+            let copy = copy_stream_with_buffer(&mut reader, &mut writer, DEFAULT_READ_BUFFER_SIZE, &mut observation);
+            tokio::pin!(copy);
+            assert!(futures::poll!(&mut copy).is_pending(), "a stalled consumer must backpressure the walk");
+        }
+        assert_eq!(reader.position(), u64::try_from(DEFAULT_READ_BUFFER_SIZE).expect("buffer fits"));
+        drop(writer);
+        let mut published = Vec::new();
+        consumer
+            .read_to_end(&mut published)
+            .await
+            .expect("read published prefix after cancellation");
+        assert_eq!(published, vec![5; 64], "cancellation must not publish additional buffered bytes");
+    }
+
+    struct WalkMetricsTestGate(bool);
+
+    impl WalkMetricsTestGate {
+        fn enable() -> Self {
+            let previous = rustfs_io_metrics::metrics_enabled();
+            rustfs_io_metrics::set_metrics_enabled(true);
+            Self(previous)
+        }
+    }
+
+    impl Drop for WalkMetricsTestGate {
+        fn drop(&mut self) {
+            rustfs_io_metrics::set_metrics_enabled(self.0);
+        }
+    }
+
+    fn assert_walk_failure_reason(recorder: &crate::test_metrics::CapturingRecorder, expected: Option<&str>) {
+        for reason in [
+            "encoding",
+            "open",
+            "read",
+            "write",
+            "flush",
+            "operation_timeout",
+            "faulty_admission",
+            "other",
+            "abandoned",
+        ] {
+            assert_eq!(
+                recorder.counter_value("rustfs_remote_walk_failures_total", &[("reason", reason)]),
+                u64::from(expected == Some(reason)),
+                "one logical terminal reason: {reason}",
+            );
+        }
+    }
+
+    #[derive(Debug)]
+    struct WalkFailureSource(u8);
+
+    impl std::fmt::Display for WalkFailureSource {
+        fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(formatter, "original walk source {}", self.0)
+        }
+    }
+
+    impl std::error::Error for WalkFailureSource {}
+
+    #[test]
+    #[serial_test::serial]
+    fn walk_terminal_reasons_distinguish_identical_io_kinds_and_retain_error_sources() {
+        let _gate = WalkMetricsTestGate::enable();
+        for reason in ["read", "write", "flush"] {
+            let recorder = crate::test_metrics::CapturingRecorder::default();
+            metrics::with_local_recorder(&recorder, || {
+                let runtime = tokio::runtime::Builder::new_current_thread()
+                    .enable_time()
+                    .build()
+                    .expect("walk failure runtime");
+                runtime.block_on(async {
+                    let source: Box<dyn std::error::Error + Send + Sync> = Box::new(WalkFailureSource(7));
+                    let original_source = std::ptr::from_ref(source.as_ref());
+                    let error = io::Error::new(io::ErrorKind::BrokenPipe, source);
+                    let payload = b"walk payload".to_vec();
+                    let mut writer = WalkTestWriter::new(usize::MAX);
+                    let step = match reason {
+                        "read" => WalkDirTestStep::PartialDataThenError { data: payload, error },
+                        "write" => {
+                            writer.accept_limit = 9;
+                            writer.write_error = Some(error);
+                            WalkDirTestStep::Data(payload)
+                        }
+                        "flush" => {
+                            writer.flush_error = Some(error);
+                            WalkDirTestStep::Data(payload)
+                        }
+                        _ => unreachable!("the fixture only covers three copy boundaries"),
+                    };
+                    let transport = RetryingWalkDirInternodeDataTransport::with_steps(vec![step]);
+                    let disk = new_remote_disk_with_transport(Arc::new(transport.clone())).await;
+                    let error = disk
+                        .walk_dir(WalkDirOptions::default(), &mut writer)
+                        .await
+                        .expect_err("the actual walk must retain the injected failure");
+                    let DiskError::Io(error) = error else {
+                        panic!("copy failures must keep their existing DiskError::Io shape");
+                    };
+                    assert_eq!(error.kind(), io::ErrorKind::BrokenPipe);
+                    assert_eq!(error.to_string(), "original walk source 7");
+                    let returned_source = error.get_ref().expect("original typed failure source");
+                    assert!(returned_source.downcast_ref::<WalkFailureSource>().is_some());
+                    assert!(
+                        std::ptr::addr_eq(std::ptr::from_ref(returned_source), original_source),
+                        "observation must move the original boxed source rather than wrap or clone it",
+                    );
+                    let expected = if reason == "write" {
+                        &b"walk payl"[..]
+                    } else {
+                        &b"walk payload"[..]
+                    };
+                    assert_eq!(writer.bytes, expected);
+                    assert_eq!(writer.flushed, reason == "flush");
+                    assert_eq!(transport.calls().len(), 1, "a copy failure must never retry an already-used writer");
+                    assert_eq!(disk.health.waiting_count(), 0);
+                    assert!(!disk.health.is_faulty(), "walk output errors retain IgnoreFailure health policy");
+                });
+            });
+            assert_walk_failure_reason(&recorder, Some(reason));
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_completed_total", &[("outcome", "error")]), 1);
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_read_bytes_total", &[]), 12);
+            assert_eq!(
+                recorder.counter_value("rustfs_remote_walk_written_bytes_total", &[]),
+                if reason == "write" { 9 } else { 12 },
+            );
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_scratch_allocated_bytes_total", &[]), 1_048_576);
+        }
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn walk_terminal_reasons_keep_final_open_errors_separate_from_wrapper_admission_and_deadline() {
+        let _gate = WalkMetricsTestGate::enable();
+        for (steps, expected, calls) in [
+            (vec![WalkDirTestStep::Error(DiskError::FileNotFound)], DiskError::FileNotFound, 1),
+            (
+                vec![
+                    WalkDirTestStep::Error(DiskError::Timeout),
+                    WalkDirTestStep::Error(DiskError::Timeout),
+                ],
+                DiskError::Timeout,
+                2,
+            ),
+            (vec![WalkDirTestStep::Error(DiskError::FaultyDisk)], DiskError::FaultyDisk, 1),
+        ] {
+            let recorder = crate::test_metrics::CapturingRecorder::default();
+            metrics::with_local_recorder(&recorder, || {
+                let runtime = tokio::runtime::Builder::new_current_thread()
+                    .enable_time()
+                    .build()
+                    .expect("open failure runtime");
+                runtime.block_on(async {
+                    let transport = RetryingWalkDirInternodeDataTransport::with_steps(steps);
+                    let disk = new_remote_disk_with_transport(Arc::new(transport.clone())).await;
+                    let mut writer = Vec::new();
+                    let actual = disk
+                        .walk_dir(WalkDirOptions::default(), &mut writer)
+                        .await
+                        .expect_err("the final open failure must propagate");
+                    assert_eq!(actual, expected);
+                    assert_eq!(transport.calls().len(), calls);
+                    assert!(writer.is_empty());
+                    assert_eq!(disk.health.waiting_count(), 0);
+                });
+            });
+            assert_walk_failure_reason(&recorder, Some("open"));
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_completed_total", &[("outcome", "error")]), 1);
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_scratch_allocations_total", &[]), 0);
+        }
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn walk_terminal_reasons_record_faulty_admission_without_opening_a_stream() {
+        let _gate = WalkMetricsTestGate::enable();
+        let recorder = crate::test_metrics::CapturingRecorder::default();
+        metrics::with_local_recorder(&recorder, || {
+            let runtime = tokio::runtime::Builder::new_current_thread()
+                .enable_time()
+                .build()
+                .expect("faulty admission runtime");
+            runtime.block_on(async {
+                let transport = RetryingWalkDirInternodeDataTransport::with_steps(Vec::new());
+                let disk = new_remote_disk_with_transport(Arc::new(transport.clone())).await;
+                disk.health.mark_offline(&disk.endpoint, "walk-admission-fixture");
+                let mut writer = Vec::new();
+                assert!(matches!(
+                    disk.walk_dir(WalkDirOptions::default(), &mut writer).await,
+                    Err(DiskError::FaultyDisk)
+                ));
+                assert!(transport.calls().is_empty());
+                assert!(writer.is_empty());
+                assert_eq!(disk.health.waiting_count(), 0);
+            });
+        });
+        assert_walk_failure_reason(&recorder, Some("faulty_admission"));
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_completed_total", &[("outcome", "error")]), 1);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_scratch_allocations_total", &[]), 0);
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn walk_stream_counts_partial_output_before_failure() {
+        let recorder = crate::test_metrics::CapturingRecorder::default();
+        let _gate = WalkMetricsTestGate::enable();
+        metrics::with_local_recorder(&recorder, || {
+            let runtime = tokio::runtime::Builder::new_current_thread().build().expect("test runtime");
+            runtime.block_on(async {
+                let mut observation = RemoteWalkGuard::start();
+                let mut reader = Cursor::new(b"walk payload");
+                let mut writer = WalkTestWriter::new(9);
+                let result = copy_stream_with_buffer(&mut reader, &mut writer, DEFAULT_READ_BUFFER_SIZE, &mut observation).await;
+                observation.finish(result.is_ok());
+                assert_eq!(result.expect_err("partial downstream failure").source.kind(), io::ErrorKind::BrokenPipe);
+                assert_eq!(writer.bytes, b"walk payl");
+            });
+        });
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_read_bytes_total", &[]), 12);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_written_bytes_total", &[]), 9);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_completed_total", &[("outcome", "error")]), 1);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_scratch_allocated_bytes_total", &[]), 1_048_576);
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn walk_stream_open_retry_is_one_logical_observation() {
+        let _gate = WalkMetricsTestGate::enable();
+        let recorder = crate::test_metrics::CapturingRecorder::default();
+        metrics::with_local_recorder(&recorder, || {
+            let runtime = tokio::runtime::Builder::new_current_thread()
+                .enable_time()
+                .build()
+                .expect("test runtime");
+            runtime.block_on(async {
+                let transport = RetryingWalkDirInternodeDataTransport::with_steps(vec![
+                    WalkDirTestStep::Error(DiskError::Io(io::Error::new(io::ErrorKind::ConnectionReset, "retryable open"))),
+                    WalkDirTestStep::Data(b"walk payload".to_vec()),
+                ]);
+                let disk = new_remote_disk_with_transport(Arc::new(transport.clone())).await;
+                let mut output = Vec::new();
+                disk.walk_dir(WalkDirOptions::default(), &mut output)
+                    .await
+                    .expect("retried walk must complete");
+                assert_eq!(output, b"walk payload");
+                assert_eq!(transport.calls().len(), 2);
+            });
+        });
+        assert_walk_failure_reason(&recorder, None);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_started_total", &[]), 1);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_completed_total", &[("outcome", "ok")]), 1);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_read_bytes_total", &[]), 12);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_written_bytes_total", &[]), 12);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_scratch_allocations_total", &[]), 1);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_scratch_allocated_bytes_total", &[]), 1_048_576);
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn walk_stream_counts_partial_input_before_reader_failure() {
+        let _gate = WalkMetricsTestGate::enable();
+        let recorder = crate::test_metrics::CapturingRecorder::default();
+        metrics::with_local_recorder(&recorder, || {
+            let runtime = tokio::runtime::Builder::new_current_thread()
+                .enable_time()
+                .build()
+                .expect("test runtime");
+            runtime.block_on(async {
+                let transport = RetryingWalkDirInternodeDataTransport::with_steps(vec![WalkDirTestStep::PartialDataThenError {
+                    data: b"walk payload".to_vec(),
+                    error: io::Error::new(io::ErrorKind::ConnectionReset, "partial input failure"),
+                }]);
+                let disk = new_remote_disk_with_transport(Arc::new(transport.clone())).await;
+                let mut output = Vec::new();
+                let error = disk
+                    .walk_dir(WalkDirOptions::default(), &mut output)
+                    .await
+                    .expect_err("partial input must fail");
+                assert!(matches!(error, DiskError::Io(error) if error.kind() == io::ErrorKind::ConnectionReset));
+                assert_eq!(output, b"walk payload");
+                assert_eq!(transport.calls().len(), 1);
+            });
+        });
+        assert_walk_failure_reason(&recorder, Some("read"));
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_read_bytes_total", &[]), 12);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_written_bytes_total", &[]), 12);
+        assert_eq!(recorder.counter_value("rustfs_remote_walk_completed_total", &[("outcome", "error")]), 1);
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn walk_stream_remote_cancellation_and_timeout_release_tracking() {
+        let _gate = WalkMetricsTestGate::enable();
+        for (cancelled, retried_open) in [(true, false), (false, false), (true, true), (false, true)] {
+            let recorder = crate::test_metrics::CapturingRecorder::default();
+            metrics::with_local_recorder(&recorder, || {
+                let runtime = tokio::runtime::Builder::new_current_thread()
+                    .enable_time()
+                    .start_paused(true)
+                    .build()
+                    .expect("paused runtime");
+                runtime.block_on(async {
+                    let mut steps = Vec::new();
+                    if retried_open {
+                        steps.push(WalkDirTestStep::Error(DiskError::Io(io::Error::new(
+                            io::ErrorKind::ConnectionReset,
+                            "transient open before an unfinished copy",
+                        ))));
+                    }
+                    steps.push(WalkDirTestStep::Data(vec![6; DEFAULT_READ_BUFFER_SIZE * 4]));
+                    let transport = RetryingWalkDirInternodeDataTransport::with_steps(steps);
+                    let disk = new_remote_disk_with_transport(Arc::new(transport.clone())).await;
+                    let opts = WalkDirOptions {
+                        timeout_ms: Some(1000),
+                        ..Default::default()
+                    };
+                    let (mut writer, mut consumer) = duplex(64);
+                    let mut walk = Box::pin(disk.walk_dir(opts, &mut writer));
+                    assert!(futures::poll!(&mut walk).is_pending(), "walk must reach a backpressured await");
+                    assert_eq!(transport.calls().len(), if retried_open { 2 } else { 1 });
+                    if cancelled {
+                        drop(walk);
+                    } else {
+                        tokio::time::advance(Duration::from_secs(1)).await;
+                        assert!(matches!(walk.await, Err(DiskError::Timeout)));
+                    }
+                    assert_eq!(disk.health.waiting_count(), 0, "health tracking must be released");
+                    drop(writer);
+                    let mut published = Vec::new();
+                    consumer.read_to_end(&mut published).await.expect("published prefix");
+                    assert_eq!(published, vec![6; 64]);
+                });
+            });
+            assert_walk_failure_reason(&recorder, Some(if cancelled { "abandoned" } else { "operation_timeout" }));
+            let outcome = if cancelled { "cancelled" } else { "error" };
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_started_total", &[]), 1);
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_completed_total", &[("outcome", outcome)]), 1);
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_read_bytes_total", &[]), 1_048_576);
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_written_bytes_total", &[]), 64);
+            assert_eq!(recorder.counter_value("rustfs_remote_walk_scratch_allocations_total", &[]), 1);
+        }
+    }
+
     #[tokio::test]
     async fn test_remote_disk_disk_id() {
         let url = url::Url::parse("http://remote-server:9000").expect("operation should succeed");
@@ -8540,6 +9081,28 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn test_remote_disk_namespace_scanner_falls_back_until_checkpoint_support_is_authenticated() {
+        for support in [None, Some(false)] {
+            let transport = RecordingInternodeDataTransport::default();
+            *transport
+                .ns_scanner_checkpoint_support
+                .lock()
+                .expect("checkpoint capability lock") = support;
+            let remote_disk = new_remote_disk_with_transport(Arc::new(transport.clone())).await;
+            assert_eq!(remote_disk.ns_scanner_server_epoch().await.expect("old peer fallback"), None);
+            assert!(matches!(transport.calls().as_slice(), [RecordedTransportCall::NsScannerProbe(_)]));
+            *transport
+                .ns_scanner_checkpoint_support
+                .lock()
+                .expect("checkpoint capability lock") = Some(true);
+            assert_eq!(
+                remote_disk.ns_scanner_server_epoch().await.expect("upgraded peer"),
+                Some(Uuid::from_u128(1))
+            );
+        }
+    }
+
     #[tokio::test]
     async fn test_remote_disk_namespace_scanner_capability_falls_back_without_generation_support() {
         for support in [None, Some(false)] {

crates/ecstore/src/cluster/rpc/runtime_sources.rs

@@ -322,6 +322,19 @@ where
     with_read_version_diagnostic_context(context, boundary, future)
 }
 
+/// Capture before spawning without inventing an entry for a generic task.
+#[cfg(feature = "diagnostic-read-version-caller")]
+pub fn with_captured_read_version_context<F>(
+    boundary: ReadVersionContextBoundary,
+    future: F,
+) -> impl std::future::Future<Output = F::Output>
+where
+    F: std::future::Future,
+{
+    let context = ReadVersionDiagnosticContext::capture();
+    with_read_version_diagnostic_context(context, boundary, Box::pin(future))
+}
+
 /// Observe a named entry even when its scope retains an earlier source.
 #[cfg(feature = "diagnostic-read-version-caller")]
 pub fn observe_read_version_context_boundary(boundary: ReadVersionContextBoundary) {
@@ -1337,4 +1350,65 @@ mod tests {
         assert_eq!(caller, Some(ReadVersionRequestCaller::Peer));
         assert_eq!(current_read_version_request_caller(), None);
     }
+    #[cfg(feature = "diagnostic-read-version-caller")]
+    #[tokio::test]
+    async fn captured_context_keeps_existing_values_without_creating_an_entry() {
+        use rustfs_io_metrics::s3_http_metrics::{
+            S3HttpRequestGuard, current_s3_http_operation_name, observe_s3_http_operation, with_s3_http_operation_context,
+        };
+
+        let mut request = S3HttpRequestGuard::new("PUT");
+        let operation = request.in_scope(|| {
+            observe_s3_http_operation(rustfs_s3_ops::S3Operation::PutObject);
+            current_s3_http_operation_context().expect("captured PUT operation")
+        });
+        for inherited in [false, true] {
+            let make_future = || {
+                with_captured_read_version_context(ReadVersionContextBoundary::BackgroundTask, async {
+                    tokio::task::yield_now().await;
+                    (
+                        current_read_version_request_caller(),
+                        current_read_version_entry_source(),
+                        current_s3_http_operation_name(),
+                    )
+                })
+            };
+            let captured = if inherited {
+                with_s3_http_operation_context(Some(operation), async {
+                    with_read_version_request_caller(ReadVersionRequestCaller::Object, async {
+                        with_read_version_entry(ReadVersionEntrySource::TierConfigReload, async { make_future() }).await
+                    })
+                    .await
+                })
+                .await
+            } else {
+                make_future()
+            };
+            assert_eq!(current_read_version_request_caller(), None);
+            assert_eq!(current_read_version_entry_source(), None);
+            let observed = tokio::spawn(captured).await.expect("captured child joins");
+            let expected = if inherited {
+                (
+                    Some(ReadVersionRequestCaller::Object),
+                    Some(ReadVersionEntrySource::TierConfigReload),
+                    Some("s3:PutObject"),
+                )
+            } else {
+                (None, None, None)
+            };
+            assert_eq!(observed, expected);
+            assert_eq!(current_s3_http_operation_name(), None);
+        }
+
+        let polled = std::sync::atomic::AtomicBool::new(false);
+        with_read_version_entry(ReadVersionEntrySource::TierConfigReload, async {
+            let unpolled = with_captured_read_version_context(ReadVersionContextBoundary::BackgroundTask, async {
+                polled.store(true, std::sync::atomic::Ordering::Relaxed);
+            });
+            drop(unpolled);
+        })
+        .await;
+        assert!(!polled.load(std::sync::atomic::Ordering::Relaxed));
+        assert_eq!(current_read_version_entry_source(), None);
+    }
 }

crates/ecstore/src/config/com.rs

@@ -48,7 +48,6 @@ use rustfs_filemeta::FileInfo;
 use rustfs_heal_contracts::heal_channel::{HealOpts, HealScanMode};
 use serde_json::{Map, Value};
 use std::collections::{HashMap, HashSet};
-use std::hash::{DefaultHasher, Hash, Hasher};
 use std::sync::LazyLock;
 use std::sync::{Arc, RwLock};
 use tokio::io::AsyncReadExt;
@@ -56,6 +55,12 @@ use tokio::sync::{OwnedRwLockWriteGuard, RwLock as AsyncRwLock};
 use tracing::{debug, error, info, instrument, warn};
 use uuid::Uuid;
 
+#[cfg(test)]
+mod compatibility_tests;
+mod diagnostics;
+
+use diagnostics::{CompatibilityDiagnostics, DecodeFailure, report_decode_failure};
+
 pub const CONFIG_PREFIX: &str = "config";
 const SERVER_CONFIG_OBJECT: &str = "config/config.json";
 const CONFIG_TRANSACTION_LOCK_SUFFIX: &str = ".transaction.lock";
@@ -75,8 +80,18 @@ where
     F::Output: Send + 'static,
 {
     // Capture before spawning; detached transactions outlive their request waiter.
-    let context = rustfs_io_metrics::s3_http_metrics::current_s3_http_operation_context();
-    tokio::spawn(rustfs_io_metrics::s3_http_metrics::with_s3_http_operation_context(context, future))
+    #[cfg(feature = "diagnostic-read-version-caller")]
+    let future = crate::cluster::rpc::runtime_sources::with_read_version_diagnostic_context(
+        crate::cluster::rpc::runtime_sources::ReadVersionDiagnosticContext::capture(),
+        rustfs_io_metrics::internode_metrics::ReadVersionContextBoundary::ConfigTask,
+        future,
+    );
+    #[cfg(not(feature = "diagnostic-read-version-caller"))]
+    let future = rustfs_io_metrics::s3_http_metrics::with_s3_http_operation_context(
+        rustfs_io_metrics::s3_http_metrics::current_s3_http_operation_context(),
+        future,
+    );
+    tokio::spawn(future)
 }
 
 /// Runs one complete server-config transaction while holding both the local
@@ -179,7 +194,7 @@ const EVENT_SERVER_CONFIG_READ_FAILED: &str = "server_config_read_failed";
 const EVENT_SERVER_CONFIG_HEAL_RESULT: &str = "server_config_heal_result";
 const EVENT_SERVER_CONFIG_RECOVERED: &str = "server_config_recovered_after_heal";
 const EVENT_SERVER_CONFIG_FALLBACK: &str = "server_config_corruption_fallback";
-const EVENT_SERVER_CONFIG_SCALAR_SECTION_IGNORED: &str = "server_config_scalar_section_ignored";
+const EVENT_SERVER_CONFIG_COMPATIBILITY_IGNORED: &str = "server_config_compatibility_ignored";
 
 fn config_corruption_recovery_enabled() -> bool {
     rustfs_utils::get_env_bool(ENV_CONFIG_RECOVER_ON_CORRUPTION, DEFAULT_CONFIG_RECOVER_ON_CORRUPTION)
@@ -230,55 +245,6 @@ fn server_config_decrypt_fn() -> Option<ServerConfigDecryptFn> {
     SERVER_CONFIG_DECRYPT_FN.read().ok().and_then(|guard| guard.clone())
 }
 
-/// Dedup set for [`warn_ignored_scalar_section`], keyed by (subsystem, value)
-/// hash. The persisted config is re-read on a short interval (event-notifier
-/// reconcile runs every 5s), so an undeduplicated warn would flood the log with
-/// one line per cycle for the same unchanged remnant.
-static IGNORED_SCALAR_SECTION_WARNED: LazyLock<RwLock<HashSet<u64>>> = LazyLock::new(|| RwLock::new(HashSet::new()));
-const IGNORED_SCALAR_SECTION_WARNED_CAP: usize = 64;
-
-fn should_warn_ignored_scalar_section(subsystem_key: &str, config_value: &Value) -> bool {
-    let mut hasher = DefaultHasher::new();
-    subsystem_key.hash(&mut hasher);
-    config_value.to_string().hash(&mut hasher);
-    let digest = hasher.finish();
-
-    let Ok(mut seen) = IGNORED_SCALAR_SECTION_WARNED.write() else {
-        return true;
-    };
-    if seen.contains(&digest) {
-        return false;
-    }
-    if seen.len() >= IGNORED_SCALAR_SECTION_WARNED_CAP {
-        seen.clear();
-    }
-    seen.insert(digest);
-    true
-}
-
-fn warn_ignored_scalar_section(subsystem_key: &str, config_value: &Value) {
-    if !should_warn_ignored_scalar_section(subsystem_key, config_value) {
-        return;
-    }
-    let mut rendered = config_value.to_string();
-    if rendered.len() > 128 {
-        let mut cut = 128;
-        while !rendered.is_char_boundary(cut) {
-            cut -= 1;
-        }
-        rendered.truncate(cut);
-        rendered.push('…');
-    }
-    warn!(
-        event = EVENT_SERVER_CONFIG_SCALAR_SECTION_IGNORED,
-        component = LOG_COMPONENT_CONFIG,
-        subsystem = LOG_SUBSYSTEM_CONFIG,
-        config_subsystem = subsystem_key,
-        ignored_value = %rendered,
-        "Ignoring persisted {subsystem_key} config with a legacy scalar shape; it carries no decodable settings and is dropped on the next config save"
-    );
-}
-
 #[cfg(test)]
 fn replace_server_config_decrypt_fn_for_test(decrypt_fn: Option<ServerConfigDecryptFn>) -> Option<ServerConfigDecryptFn> {
     SERVER_CONFIG_DECRYPT_FN
@@ -316,6 +282,19 @@ fn scanner_config_descriptor() -> ScalarConfigDescriptor {
     }
 }
 
+fn storage_class_config_descriptor() -> ScalarConfigDescriptor {
+    ScalarConfigDescriptor {
+        subsystem_key: STORAGE_CLASS_SUB_SYS,
+        default_kvs: &storageclass::DEFAULT_KVS,
+        valid_keys: &[
+            storageclass::CLASS_STANDARD,
+            storageclass::CLASS_RRS,
+            storageclass::OPTIMIZE,
+            storageclass::INLINE_BLOCK,
+        ],
+    }
+}
+
 fn heal_config_descriptor() -> ScalarConfigDescriptor {
     ScalarConfigDescriptor {
         subsystem_key: HEAL_SUB_SYS,
@@ -1016,12 +995,16 @@ fn parse_target_scalar_value(key: &str, value: &Value) -> Option<String> {
     }
 }
 
-fn decode_scalar_config_object(config_obj: &Map<String, Value>, descriptor: ScalarConfigDescriptor) -> Result<KVS> {
+fn decode_scalar_config_object(
+    config_obj: &Map<String, Value>,
+    descriptor: ScalarConfigDescriptor,
+    diagnostics: &mut CompatibilityDiagnostics,
+) -> Result<KVS> {
     let mut overrides = KVS::new();
     for (key, value) in config_obj {
         if !descriptor.valid_keys.contains(&key.as_str()) || key == COMMENT_KEY {
             if key != "default" && key != DEFAULT_DELIMITER && key != COMMENT_KEY {
-                warn!(config_key = %format!("{}.{key}", descriptor.subsystem_key), "Ignoring unknown persisted scalar config key");
+                diagnostics.unknown_key(descriptor.subsystem_key, key);
             }
             continue;
         }
@@ -1038,14 +1021,18 @@ fn decode_scalar_config_object(config_obj: &Map<String, Value>, descriptor: Scal
     Ok(overrides)
 }
 
-fn decode_scalar_config_value(config_value: &Value, descriptor: ScalarConfigDescriptor) -> Result<KVS> {
+fn decode_scalar_config_value(
+    config_value: &Value,
+    descriptor: ScalarConfigDescriptor,
+    diagnostics: &mut CompatibilityDiagnostics,
+) -> Result<KVS> {
     match config_value {
         Value::Object(config_obj) => {
             let mut overrides = match config_obj.get("default").or_else(|| config_obj.get(DEFAULT_DELIMITER)) {
-                Some(value) => decode_scalar_config_value(value, descriptor)?,
+                Some(value) => decode_scalar_config_value(value, descriptor, diagnostics)?,
                 None => KVS::new(),
             };
-            let direct = decode_scalar_config_object(config_obj, descriptor)?;
+            let direct = decode_scalar_config_object(config_obj, descriptor, diagnostics)?;
             if !direct.is_empty() {
                 overrides.extend(direct);
             }
@@ -1062,7 +1049,7 @@ fn decode_scalar_config_value(config_value: &Value, descriptor: ScalarConfigDesc
                 })?;
                 if !descriptor.valid_keys.contains(&key) || key == COMMENT_KEY {
                     if key != COMMENT_KEY {
-                        warn!(config_key = %format!("{}.{key}", descriptor.subsystem_key), "Ignoring unknown persisted scalar config key");
+                        diagnostics.unknown_key(descriptor.subsystem_key, key);
                     }
                     continue;
                 }
@@ -1085,12 +1072,12 @@ fn decode_scalar_config_value(config_value: &Value, descriptor: ScalarConfigDesc
         // every consumer of the persisted config (startup falls back to the
         // default config, the admin config API cannot read-modify-write, and
         // the notify reconciler retries forever). Ignore them with a deduped
-        // warning instead; the next config save scrubs them (see
+        // compatibility diagnostic instead; the next config save scrubs them (see
         // `normalize_scalar_section_seed`). Malformed values inside object or
         // KVS-array shapes stay hard errors above — those shapes are where
         // data (including fields from newer versions) can live.
         _ => {
-            warn_ignored_scalar_section(descriptor.subsystem_key, config_value);
+            diagnostics.legacy_shape(descriptor.subsystem_key, config_value);
             Ok(KVS::new())
         }
     }
@@ -1100,6 +1087,7 @@ fn apply_external_scalar_config_map(
     cfg: &mut Config,
     root: &Map<String, Value>,
     descriptor: ScalarConfigDescriptor,
+    diagnostics: &mut CompatibilityDiagnostics,
 ) -> Result<bool> {
     let Some(config_value) = root.get(descriptor.subsystem_key) else {
         return Ok(false);
@@ -1107,7 +1095,7 @@ fn apply_external_scalar_config_map(
     if descriptor.subsystem_key == HEAL_SUB_SYS && config_value.is_null() {
         return Ok(false);
     }
-    let overrides = decode_scalar_config_value(config_value, descriptor)?;
+    let overrides = decode_scalar_config_value(config_value, descriptor, diagnostics)?;
 
     if overrides.is_empty() {
         return Ok(false);
@@ -1246,14 +1234,20 @@ fn apply_external_audit_map(cfg: &mut Config, root: &Map<String, Value>) -> bool
     apply_external_target_descriptors(cfg, audit_obj, &audit_target_descriptors())
 }
 
-fn apply_external_storage_class_map(cfg: &mut Config, root: &Map<String, Value>) -> bool {
+fn apply_external_storage_class_map(cfg: &mut Config, root: &Map<String, Value>) -> Result<bool> {
     let sc = root.get("storageclass").or_else(|| root.get("storage_class"));
     let Some(Value::Object(sc_obj)) = sc else {
-        return false;
+        return Ok(false);
     };
 
     let mut applied = false;
     let kvs = storage_class_kvs_mut(cfg);
+    if let Some(nested) = sc_obj.get("default").or_else(|| sc_obj.get(DEFAULT_DELIMITER)) {
+        let values =
+            decode_scalar_config_value(nested, storage_class_config_descriptor(), &mut CompatibilityDiagnostics::default())?;
+        applied = !values.is_empty();
+        kvs.extend(values);
+    }
 
     if let Some(v) = sc_obj.get("standard").and_then(parse_storage_class_value) {
         kvs.insert(storageclass::CLASS_STANDARD.to_string(), v);
@@ -1274,7 +1268,7 @@ fn apply_external_storage_class_map(cfg: &mut Config, root: &Map<String, Value>)
         applied = true;
     }
 
-    applied
+    Ok(applied)
 }
 
 fn decode_server_config_blob(data: &[u8]) -> Result<Config> {
@@ -1288,9 +1282,10 @@ fn decode_server_config_blob(data: &[u8]) -> Result<Config> {
     };
 
     let mut cfg = Config::new();
-    let has_storage = apply_external_storage_class_map(&mut cfg, &root);
-    let has_scanner = apply_external_scalar_config_map(&mut cfg, &root, scanner_config_descriptor())?;
-    let has_heal = apply_external_scalar_config_map(&mut cfg, &root, heal_config_descriptor())?;
+    let mut diagnostics = CompatibilityDiagnostics::default();
+    let has_storage = apply_external_storage_class_map(&mut cfg, &root)?;
+    let has_scanner = apply_external_scalar_config_map(&mut cfg, &root, scanner_config_descriptor(), &mut diagnostics)?;
+    let has_heal = apply_external_scalar_config_map(&mut cfg, &root, heal_config_descriptor(), &mut diagnostics)?;
     let has_oidc = apply_external_oidc_map(&mut cfg, &root);
     let has_notify = apply_external_notify_map(&mut cfg, &root);
     let has_audit = apply_external_audit_map(&mut cfg, &root);
@@ -1298,6 +1293,7 @@ fn decode_server_config_blob(data: &[u8]) -> Result<Config> {
     if !has_storage && !has_scanner && !has_heal && !has_oidc && !has_notify && !has_audit && !has_header {
         return Err(Error::other("unrecognized external server config shape"));
     }
+    diagnostics.report();
     Ok(cfg)
 }
 
@@ -1370,6 +1366,8 @@ fn build_scalar_config_object(cfg: &Config, descriptor: ScalarConfigDescriptor)
 
 fn rendered_scalar_config_kvs_entries(rendered: &HashMap<String, String>) -> Vec<Value> {
     let mut entries = Vec::with_capacity(rendered.len());
+    let mut rendered = rendered.iter().collect::<Vec<_>>();
+    rendered.sort_by_key(|(key, _)| *key);
     for (key, value) in rendered {
         let mut entry = Map::new();
         entry.insert("key".to_string(), Value::String(key.clone()));
@@ -1380,6 +1378,12 @@ fn rendered_scalar_config_kvs_entries(rendered: &HashMap<String, String>) -> Vec
     entries
 }
 
+fn has_extra_kvs_attributes(entry: &Map<String, Value>) -> bool {
+    entry
+        .keys()
+        .any(|key| !matches!(key.as_str(), "key" | "value" | "hidden_if_empty" | "hiddenIfEmpty"))
+}
+
 fn sync_rendered_scalar_config_value(
     existing: Option<Value>,
     rendered: &Map<String, Value>,
@@ -1400,15 +1404,20 @@ fn sync_rendered_scalar_config_value(
                 config_obj.remove(*key);
             }
 
-            if let Some(nested_key) = nested_key {
-                let nested = config_obj.remove(nested_key);
-                let synced = if direct_had_known {
-                    sync_rendered_scalar_config_value(nested, &Map::new(), descriptor)?
-                } else {
-                    sync_rendered_scalar_config_value(nested, rendered, descriptor)?
+            // Clear shadow overrides too: removing the preferred branch must
+            // never expose a stale value from the other default alias.
+            for alias in ["default", DEFAULT_DELIMITER] {
+                let Some(nested) = config_obj.remove(alias) else {
+                    continue;
                 };
-                if let Some(value) = synced {
-                    config_obj.insert(nested_key.to_string(), value);
+                let empty = Map::new();
+                let desired = if !direct_had_known && Some(alias) == nested_key {
+                    rendered
+                } else {
+                    &empty
+                };
+                if let Some(value) = sync_rendered_scalar_config_value(Some(nested), desired, descriptor)? {
+                    config_obj.insert(alias.to_string(), value);
                 }
             }
 
@@ -1432,6 +1441,7 @@ fn sync_rendered_scalar_config_value(
                         })
                 })
                 .collect::<Result<HashMap<_, _>>>()?;
+            let desired = pending.clone();
             let mut updated = Vec::with_capacity(entries.len().saturating_add(pending.len()));
             for entry in entries {
                 let Some(entry_obj) = entry.as_object() else {
@@ -1446,7 +1456,12 @@ fn sync_rendered_scalar_config_value(
                     updated.push(entry);
                     continue;
                 }
-                let Some(value) = pending.remove(key) else {
+                pending.remove(key);
+                let value = desired
+                    .get(key)
+                    .cloned()
+                    .or_else(|| has_extra_kvs_attributes(entry_obj).then(|| descriptor.default_kvs.get(key)));
+                let Some(value) = value else {
                     continue;
                 };
                 let mut entry_obj = entry_obj.clone();
@@ -1558,6 +1573,7 @@ fn sync_rendered_oidc_provider(existing: Value, rendered: Option<&Value>) -> Opt
                         .collect::<HashMap<_, _>>()
                 })
                 .unwrap_or_default();
+            let desired = pending.clone();
             let mut updated = Vec::with_capacity(entries.len().saturating_add(pending.len()));
             for entry in entries {
                 let Some(entry_obj) = entry.as_object() else {
@@ -1572,7 +1588,12 @@ fn sync_rendered_oidc_provider(existing: Value, rendered: Option<&Value>) -> Opt
                     updated.push(entry);
                     continue;
                 }
-                let Some(value) = pending.remove(key) else {
+                pending.remove(key);
+                let value = desired
+                    .get(key)
+                    .cloned()
+                    .or_else(|| has_extra_kvs_attributes(entry_obj).then(|| oidc::DEFAULT_IDENTITY_OPENID_KVS.get(key)));
+                let Some(value) = value else {
                     continue;
                 };
                 let mut entry_obj = entry_obj.clone();
@@ -1594,7 +1615,14 @@ fn sync_rendered_oidc_object(existing: Option<Value>, rendered: &Map<String, Val
     };
     let mut merged = Map::new();
     for (provider_key, provider) in existing {
-        if let Some(provider) = sync_rendered_oidc_provider(provider, rendered.get(&provider_key)) {
+        if let Some(provider) = sync_rendered_oidc_provider(
+            provider,
+            rendered.get(if provider_key == DEFAULT_DELIMITER {
+                "default"
+            } else {
+                &provider_key
+            }),
+        ) {
             merged.insert(provider_key, provider);
         }
     }
@@ -1789,7 +1817,12 @@ fn build_audit_object(cfg: &Config) -> Map<String, Value> {
     build_target_object(cfg, &audit_target_descriptors())
 }
 
-fn sync_rendered_target_instance(existing: Value, rendered: Option<&Value>, valid_keys: &[&str]) -> Option<Value> {
+fn sync_rendered_target_instance(
+    existing: Value,
+    rendered: Option<&Value>,
+    valid_keys: &[&str],
+    baseline: &KVS,
+) -> Option<Value> {
     match existing {
         Value::Object(mut instance) => {
             for key in valid_keys {
@@ -1810,6 +1843,7 @@ fn sync_rendered_target_instance(existing: Value, rendered: Option<&Value>, vali
                         .collect::<HashMap<_, _>>()
                 })
                 .unwrap_or_default();
+            let desired = pending.clone();
             let mut updated = Vec::with_capacity(entries.len().saturating_add(pending.len()));
             for entry in entries {
                 let Some(entry_obj) = entry.as_object() else {
@@ -1824,7 +1858,12 @@ fn sync_rendered_target_instance(existing: Value, rendered: Option<&Value>, vali
                     updated.push(entry);
                     continue;
                 }
-                let Some(value) = pending.remove(key) else {
+                pending.remove(key);
+                let value = desired
+                    .get(key)
+                    .cloned()
+                    .or_else(|| has_extra_kvs_attributes(entry_obj).then(|| baseline.get(key)));
+                let Some(value) = value else {
                     continue;
                 };
                 let mut entry_obj = entry_obj.clone();
@@ -1843,92 +1882,110 @@ fn sync_rendered_target_object(
     target_obj: &mut Map<String, Value>,
     rendered_target: &Map<String, Value>,
     descriptors: &[TargetConfigDescriptor],
+    cfg: &Config,
 ) {
     for descriptor in descriptors {
-        let existing = target_obj.remove(descriptor.external_key);
-        let alias = target_obj.remove(descriptor.subsystem_key);
-        let mut section = existing
-            .or(alias)
-            .and_then(|value| value.as_object().cloned())
-            .unwrap_or_default();
-        let rendered = rendered_target.get(descriptor.external_key).and_then(Value::as_object);
-
-        if is_target_instance_shorthand(&section, descriptor.valid_keys) {
-            let has_named_instances = rendered.is_some_and(|instances| instances.keys().any(|name| name != "default"));
-            if !has_named_instances {
-                if let Some(section) = sync_rendered_target_instance(
-                    Value::Object(section),
-                    rendered.and_then(|instances| instances.get("default")),
-                    descriptor.valid_keys,
-                ) {
-                    target_obj.insert(descriptor.external_key.to_string(), section);
-                }
+        let effective_default = cfg
+            .0
+            .get(descriptor.subsystem_key)
+            .map(|subsystem| merged_target_default_kvs(subsystem, descriptor.default_kvs))
+            .unwrap_or_else(|| (**descriptor.default_kvs).clone());
+        for key in [descriptor.external_key, descriptor.subsystem_key] {
+            let existing = target_obj.remove(key);
+            if existing.is_none() && key != descriptor.external_key {
                 continue;
             }
-
-            let mut nested = Map::new();
-            if let Some(default) = sync_rendered_target_instance(
-                Value::Object(section),
-                rendered.and_then(|instances| instances.get("default")),
-                descriptor.valid_keys,
+            let rendered = rendered_target.get(descriptor.external_key).and_then(Value::as_object);
+            if let Some(section) = sync_rendered_target_section(
+                existing,
+                rendered,
+                *descriptor,
+                &effective_default,
+                cfg.0.get(descriptor.subsystem_key),
             ) {
-                nested.insert("default".to_string(), default);
+                target_obj.insert(key.to_string(), section);
             }
-            if let Some(rendered) = rendered {
-                for (instance_name, instance) in rendered {
-                    if instance_name != "default" {
-                        nested.insert(instance_name.clone(), instance.clone());
-                    }
-                }
-            }
-            if !nested.is_empty() {
-                target_obj.insert(descriptor.external_key.to_string(), Value::Object(nested));
-            }
-            continue;
-        }
-
-        if let Some(default_alias) = section.remove(DEFAULT_DELIMITER) {
-            if let Some(default) = section.get_mut("default") {
-                if let Some(alias) = sync_rendered_target_instance(default_alias, None, descriptor.valid_keys) {
-                    match (default, alias) {
-                        (Value::Object(default), Value::Object(alias)) => {
-                            for (key, value) in alias {
-                                default.entry(key).or_insert(value);
-                            }
-                        }
-                        (Value::Array(default), Value::Array(alias)) => default.extend(alias),
-                        _ => {}
-                    }
-                }
-            } else {
-                section.insert("default".to_string(), default_alias);
-            }
-        }
-
-        let mut merged = Map::new();
-        for (instance_name, instance) in section {
-            if let Some(instance) = sync_rendered_target_instance(
-                instance,
-                rendered.and_then(|instances| instances.get(&instance_name)),
-                descriptor.valid_keys,
-            ) {
-                merged.insert(instance_name, instance);
-            }
-        }
-        if let Some(rendered) = rendered {
-            for (instance_name, instance) in rendered {
-                if !merged.contains_key(instance_name) {
-                    merged.insert(instance_name.clone(), instance.clone());
-                }
-            }
-        }
-
-        if !merged.is_empty() {
-            target_obj.insert(descriptor.external_key.to_string(), Value::Object(merged));
         }
     }
 }
 
+fn sync_rendered_target_section(
+    existing: Option<Value>,
+    rendered: Option<&Map<String, Value>>,
+    descriptor: TargetConfigDescriptor,
+    effective_default: &KVS,
+    configured: Option<&HashMap<String, KVS>>,
+) -> Option<Value> {
+    let section = match existing {
+        Some(Value::Object(section)) => section,
+        Some(value) if rendered.is_none_or(Map::is_empty) => return Some(value),
+        _ => Map::new(),
+    };
+    if is_target_instance_shorthand(&section, descriptor.valid_keys) {
+        let has_named = rendered.is_some_and(|instances| instances.keys().any(|name| name != "default"));
+        let default = sync_rendered_target_instance(
+            Value::Object(section),
+            rendered.and_then(|instances| instances.get("default")),
+            descriptor.valid_keys,
+            descriptor.default_kvs,
+        );
+        if !has_named {
+            return default;
+        }
+        let mut nested = rendered.cloned().unwrap_or_default();
+        if let Some(default) = default {
+            nested.insert("default".to_string(), default);
+        }
+        return Some(Value::Object(nested));
+    }
+    let mut merged = Map::new();
+    for (instance_name, instance) in section {
+        let rendered_name = if instance_name == DEFAULT_DELIMITER {
+            "default"
+        } else {
+            &instance_name
+        };
+        let removed = rendered_name != "default" && configured.is_none_or(|instances| !instances.contains_key(&instance_name));
+        if let Some(mut instance) = sync_rendered_target_instance(
+            instance,
+            rendered.and_then(|instances| instances.get(rendered_name)),
+            descriptor.valid_keys,
+            if rendered_name == "default" || removed {
+                descriptor.default_kvs
+            } else {
+                effective_default
+            },
+        ) {
+            // A retained KVS attribute must not turn a deleted target into an
+            // active instance through inheritance from an enabled default.
+            if removed
+                && let Value::Array(entries) = &mut instance
+                && entries.iter().any(|entry| {
+                    entry
+                        .get("key")
+                        .and_then(Value::as_str)
+                        .is_some_and(|key| descriptor.valid_keys.contains(&key))
+                })
+                && !entries
+                    .iter()
+                    .any(|entry| entry.get("key").and_then(Value::as_str) == Some(ENABLE_KEY))
+            {
+                entries.extend(rendered_scalar_config_kvs_entries(&HashMap::from([(
+                    ENABLE_KEY.to_string(),
+                    "off".to_string(),
+                )])));
+            }
+            merged.insert(instance_name, instance);
+        }
+    }
+    if let Some(rendered) = rendered {
+        for (instance_name, instance) in rendered {
+            merged.entry(instance_name.clone()).or_insert_with(|| instance.clone());
+        }
+    }
+    (!merged.is_empty()).then_some(Value::Object(merged))
+}
+
 fn encode_server_config_blob(cfg: &Config, seed: Option<&[u8]>) -> Result<Vec<u8>> {
     let mut root = seed.and_then(parse_object_seed).unwrap_or_default();
 
@@ -1939,23 +1996,21 @@ fn encode_server_config_blob(cfg: &Config, seed: Option<&[u8]>) -> Result<Vec<u8
         root.insert("region".to_string(), Value::String(RUSTFS_REGION.to_string()));
     }
 
-    let mut sc_obj = match root.remove("storageclass") {
-        Some(Value::Object(v)) => v,
-        _ => Map::new(),
-    };
-    for key in [
-        storageclass::CLASS_STANDARD,
-        storageclass::CLASS_RRS,
-        storageclass::OPTIMIZE,
-        storageclass::INLINE_BLOCK,
-    ] {
-        sc_obj.remove(key);
+    let sc_seed = root.remove("storageclass").filter(Value::is_object);
+    let sc_rendered = build_storageclass_object(cfg);
+    if let Some(value) = sync_rendered_scalar_config_value(sc_seed, &sc_rendered, storage_class_config_descriptor())? {
+        root.insert("storageclass".to_string(), value);
     }
-    for (k, v) in build_storageclass_object(cfg) {
-        sc_obj.insert(k, v);
+    if let Some(existing) = root.remove("storage_class") {
+        let descriptor = storage_class_config_descriptor();
+        let mut rendered = build_storageclass_object(cfg);
+        rendered
+            .entry(storageclass::INLINE_BLOCK)
+            .or_insert_with(|| Value::String(storageclass::DEFAULT_KVS.get(storageclass::INLINE_BLOCK)));
+        if let Some(value) = sync_rendered_scalar_config_value(Some(existing), &rendered, descriptor)? {
+            root.insert("storage_class".to_string(), value);
+        }
     }
-    root.insert("storageclass".to_string(), Value::Object(sc_obj));
-    root.remove("storage_class");
 
     for descriptor in [scanner_config_descriptor(), heal_config_descriptor()] {
         let existing = normalize_scalar_section_seed(root.remove(descriptor.subsystem_key));
@@ -1965,41 +2020,55 @@ fn encode_server_config_blob(cfg: &Config, seed: Option<&[u8]>) -> Result<Vec<u8
         }
     }
 
-    let existing_oidc = root.remove("openid").or_else(|| root.remove(IDENTITY_OPENID_SUB_SYS));
-    if let Some(oidc_value) = sync_rendered_oidc_object(existing_oidc, &build_oidc_object(cfg)) {
-        root.insert("openid".to_string(), oidc_value);
+    let rendered_oidc = build_oidc_object(cfg);
+    for key in ["openid", IDENTITY_OPENID_SUB_SYS] {
+        let existing = root.remove(key);
+        if existing.is_none() && key != "openid" {
+            continue;
+        }
+        if key == "openid"
+            && rendered_oidc.is_empty()
+            && let Some(value @ (Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_) | Value::Array(_))) =
+                existing.as_ref()
+        {
+            root.insert(key.to_string(), value.clone());
+            continue;
+        }
+        if let Some(oidc_value) = sync_rendered_oidc_object(existing, &rendered_oidc) {
+            root.insert(key.to_string(), oidc_value);
+        }
     }
-    root.remove(IDENTITY_OPENID_SUB_SYS);
 
     let mut notify_obj = match root.remove("notify") {
         Some(Value::Object(v)) => v,
         _ => Map::new(),
     };
     let rendered_notify = build_notify_object(cfg);
-    sync_rendered_target_object(&mut notify_obj, &rendered_notify, &notify_target_descriptors());
+    sync_rendered_target_object(&mut notify_obj, &rendered_notify, &notify_target_descriptors(), cfg);
     if notify_obj.is_empty() {
         root.remove("notify");
     } else {
         root.insert("notify".to_string(), Value::Object(notify_obj));
     }
-    for descriptor in notify_target_descriptors() {
-        root.remove(descriptor.subsystem_key);
-    }
 
-    let mut logger_obj = match root.remove("logger") {
-        Some(Value::Object(v)) => v,
-        _ => Map::new(),
-    };
     let rendered_audit = build_audit_object(cfg);
-    sync_rendered_target_object(&mut logger_obj, &rendered_audit, &audit_target_descriptors());
-    if logger_obj.is_empty() {
-        root.remove("logger");
-    } else {
-        root.insert("logger".to_string(), Value::Object(logger_obj));
-    }
-    root.remove("audit");
-    for descriptor in audit_target_descriptors() {
-        root.remove(descriptor.subsystem_key);
+    for key in ["logger", "audit"] {
+        let existing = root.remove(key);
+        if existing.is_none() && key != "logger" {
+            continue;
+        }
+        let mut logger_obj = match existing {
+            Some(Value::Object(value)) => value,
+            Some(value) if rendered_audit.is_empty() => {
+                root.insert(key.to_string(), value);
+                continue;
+            }
+            _ => Map::new(),
+        };
+        sync_rendered_target_object(&mut logger_obj, &rendered_audit, &audit_target_descriptors(), cfg);
+        if !logger_obj.is_empty() {
+            root.insert(key.to_string(), Value::Object(logger_obj));
+        }
     }
 
     Ok(serde_json::to_vec(&Value::Object(root))?)
@@ -2015,10 +2084,43 @@ fn is_standard_object_server_config(data: &[u8]) -> bool {
     matches!(root.get("version"), Some(Value::String(v)) if !v.trim().is_empty())
         && matches!(root.get("storageclass"), Some(Value::Object(_)))
         && !root.contains_key("storage_class")
+        && !root.contains_key("audit")
+        && !root.contains_key(IDENTITY_OPENID_SUB_SYS)
+        && !has_nested_config_aliases(&root)
         && !matches!(root.get(HEAL_SUB_SYS), Some(value) if scalar_section_shape_is_ignorable(value))
         && !matches!(root.get(SCANNER_SUB_SYS), Some(value) if scalar_section_shape_is_ignorable(value))
 }
 
+fn has_nested_config_aliases(root: &Map<String, Value>) -> bool {
+    let dual_default = |value: &Value| {
+        value
+            .as_object()
+            .is_some_and(|value| value.contains_key("default") && value.contains_key(DEFAULT_DELIMITER))
+    };
+    if [SCANNER_SUB_SYS, HEAL_SUB_SYS, "openid"]
+        .iter()
+        .filter_map(|key| root.get(*key))
+        .any(dual_default)
+    {
+        return true;
+    }
+    for (name, descriptors) in [
+        ("notify", notify_target_descriptors()),
+        ("logger", audit_target_descriptors()),
+    ] {
+        if let Some(section) = root.get(name).and_then(Value::as_object) {
+            for descriptor in descriptors {
+                if section.contains_key(descriptor.subsystem_key)
+                    || section.get(descriptor.external_key).is_some_and(dual_default)
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+
 fn configs_semantically_equal(lhs: &Config, rhs: &Config) -> bool {
     build_storageclass_object(lhs) == build_storageclass_object(rhs)
         && build_scalar_config_object(lhs, scanner_config_descriptor())
@@ -2311,41 +2413,19 @@ fn decode_persisted_server_config_with_seed(data: &[u8]) -> Result<(Config, Vec<
         Ok(cfg) => Ok((cfg, data.to_vec())),
         Err(raw_decode_err) => {
             let Some(decrypt) = server_config_decrypt_fn() else {
-                error!(
-                    event = EVENT_SERVER_CONFIG_DECODE_FAILED,
-                    component = LOG_COMPONENT_CONFIG,
-                    subsystem = LOG_SUBSYSTEM_CONFIG,
-                    size = data.len(),
-                    error = %raw_decode_err,
-                    "persisted server config cannot be decoded, object is corrupt"
-                );
+                report_decode_failure(data, DecodeFailure::Corrupt, None);
                 return Err(Error::other(ServerConfigCorruptError(raw_decode_err.to_string())));
             };
 
             let Some(decrypted) = decrypt(data) else {
-                error!(
-                    event = EVENT_SERVER_CONFIG_DECRYPT_FAILED,
-                    component = LOG_COMPONENT_CONFIG,
-                    subsystem = LOG_SUBSYSTEM_CONFIG,
-                    size = data.len(),
-                    error = %raw_decode_err,
-                    "persisted server config cannot be decoded or decrypted"
-                );
+                report_decode_failure(data, DecodeFailure::Decrypt, None);
                 return Err(Error::other(ServerConfigDecryptError(raw_decode_err.to_string())));
             };
 
             decode_server_config_blob(&decrypted)
                 .map(|config| (config, decrypted.clone()))
                 .map_err(|err| {
-                    error!(
-                        event = EVENT_SERVER_CONFIG_DECODE_FAILED,
-                        component = LOG_COMPONENT_CONFIG,
-                        subsystem = LOG_SUBSYSTEM_CONFIG,
-                        size = decrypted.len(),
-                        encrypted_size = data.len(),
-                        error = %err,
-                        "decrypted persisted server config cannot be decoded, object is corrupt"
-                    );
+                    report_decode_failure(&decrypted, DecodeFailure::Corrupt, Some(data.len()));
                     Error::other(ServerConfigCorruptError(err.to_string()))
                 })
         }
@@ -2841,7 +2921,7 @@ mod tests {
         new_and_save_server_config, read_config, read_config_no_lock_preserve_empty_with_metadata, read_config_preserve_empty,
         read_config_with_metadata, read_config_without_migrate, read_server_config_snapshot, save_config_with_opts_inner,
         save_server_config, save_server_config_snapshot, save_server_config_snapshot_with_generation,
-        server_config_transaction_lock_path, should_warn_ignored_scalar_section, storage_class_kvs_mut,
+        server_config_transaction_lock_path, storage_class_kvs_mut,
     };
     use crate::config::{audit, heal, notify, oidc, scanner};
     use crate::disk::{RUSTFS_META_BUCKET, endpoint::Endpoint};
@@ -2930,6 +3010,110 @@ mod tests {
         assert_eq!(current_s3_http_operation_name(), None);
     }
 
+    #[cfg(feature = "diagnostic-read-version-caller")]
+    #[tokio::test]
+    async fn diagnostic_config_tasks_preserve_first_owner_across_nested_spawns() {
+        use crate::cluster::rpc::runtime_sources::{
+            current_read_version_entry_source, current_read_version_request_caller, with_read_version_entry,
+            with_read_version_request_caller,
+        };
+        use rustfs_io_metrics::internode_metrics::{ReadVersionEntrySource, ReadVersionRequestCaller};
+        use rustfs_io_metrics::s3_http_metrics::{
+            S3HttpRequestGuard, current_s3_http_operation_context, current_s3_http_operation_name, observe_s3_http_operation,
+            with_s3_http_operation_context,
+        };
+
+        let mut request = S3HttpRequestGuard::new("PUT");
+        let operation = request.in_scope(|| {
+            observe_s3_http_operation(rustfs_s3_ops::S3Operation::CreateBucket);
+            current_s3_http_operation_context().expect("captured bucket operation")
+        });
+        let task = with_s3_http_operation_context(Some(operation), async {
+            with_read_version_request_caller(ReadVersionRequestCaller::Object, async {
+                with_read_version_entry(ReadVersionEntrySource::TierConfigReload, async {
+                    super::spawn_config_task(async {
+                        assert_eq!(current_s3_http_operation_name(), Some("s3:CreateBucket"));
+                        assert_eq!(current_read_version_request_caller(), Some(ReadVersionRequestCaller::Object));
+                        assert_eq!(current_read_version_entry_source(), Some(ReadVersionEntrySource::TierConfigReload));
+                        with_read_version_entry(ReadVersionEntrySource::ConfigRead, async {
+                            super::spawn_config_task(async {
+                                assert_eq!(current_s3_http_operation_name(), Some("s3:CreateBucket"));
+                                assert_eq!(current_read_version_request_caller(), Some(ReadVersionRequestCaller::Object));
+                                assert_eq!(current_read_version_entry_source(), Some(ReadVersionEntrySource::TierConfigReload));
+                                Err::<(), _>("config failure")
+                            })
+                            .await
+                            .expect("nested config task joins")
+                        })
+                        .await
+                    })
+                })
+                .await
+            })
+            .await
+        })
+        .await;
+        drop(request);
+        assert_eq!(task.await.expect("config task joins"), Err("config failure"));
+        assert_eq!(current_s3_http_operation_name(), None);
+        assert_eq!(current_read_version_request_caller(), None);
+        assert_eq!(current_read_version_entry_source(), None);
+        super::spawn_config_task(async {
+            assert_eq!(current_s3_http_operation_name(), None);
+            assert_eq!(current_read_version_request_caller(), None);
+            assert_eq!(current_read_version_entry_source(), None, "internal work invents no entry owner");
+            with_read_version_entry(ReadVersionEntrySource::ConfigRead, async {
+                assert_eq!(current_read_version_entry_source(), Some(ReadVersionEntrySource::ConfigRead));
+            })
+            .await;
+        })
+        .await
+        .expect("unscoped config task joins");
+    }
+
+    #[cfg(feature = "diagnostic-read-version-caller")]
+    #[tokio::test]
+    async fn diagnostic_config_tasks_keep_context_and_permit_after_waiter_drop() {
+        use crate::cluster::rpc::runtime_sources::{
+            current_read_version_entry_source, current_read_version_request_caller, with_read_version_entry,
+            with_read_version_request_caller,
+        };
+        use rustfs_io_metrics::internode_metrics::{ReadVersionEntrySource, ReadVersionRequestCaller};
+
+        let admission = Arc::new(tokio::sync::Semaphore::new(1));
+        let permit = admission.clone().acquire_owned().await.expect("config task permit");
+        let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();
+        let (release_tx, release_rx) = tokio::sync::oneshot::channel();
+        let (finished_tx, finished_rx) = tokio::sync::oneshot::channel();
+        let task = with_read_version_request_caller(ReadVersionRequestCaller::MetadataRead, async {
+            with_read_version_entry(ReadVersionEntrySource::ServerInfoPools, async {
+                super::spawn_config_task(async move {
+                    entered_tx.send(()).expect("waiter is present");
+                    release_rx.await.expect("config task may finish");
+                    let observed = (current_read_version_request_caller(), current_read_version_entry_source());
+                    drop(permit);
+                    finished_tx.send(observed).expect("completion observer is present");
+                })
+            })
+            .await
+        })
+        .await;
+        entered_rx.await.expect("config task started");
+        drop(task);
+        assert_eq!(admission.available_permits(), 0, "dropping the waiter keeps admission owned");
+        release_tx.send(()).expect("detached config task remains alive");
+        assert_eq!(
+            finished_rx.await.expect("detached config task completes"),
+            (
+                Some(ReadVersionRequestCaller::MetadataRead),
+                Some(ReadVersionEntrySource::ServerInfoPools)
+            )
+        );
+        assert_eq!(admission.available_permits(), 1);
+        assert_eq!(current_read_version_request_caller(), None);
+        assert_eq!(current_read_version_entry_source(), None);
+    }
+
     #[test]
     fn system_metadata_volume_failures_map_to_retryable_write_errors() {
         for error in [Error::VolumeNotFound, Error::BucketNotFound(RUSTFS_META_BUCKET.to_string())] {
@@ -4000,15 +4184,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn ignored_scalar_section_warning_dedups_by_content() {
-        let value = Value::String("dedup-probe".to_string());
-        assert!(should_warn_ignored_scalar_section("dedup-test-subsystem", &value));
-        assert!(!should_warn_ignored_scalar_section("dedup-test-subsystem", &value));
-        let changed = Value::String("dedup-probe-changed".to_string());
-        assert!(should_warn_ignored_scalar_section("dedup-test-subsystem", &changed));
-    }
-
     #[test]
     fn valid_heal_object_and_kvs_array_shapes_remain_accepted() {
         let empty_object = br#"{"version":"33","storageclass":{"standard":"","rrs":""},"heal":{}}"#;
@@ -4195,7 +4370,7 @@ mod tests {
     }
 
     #[test]
-    fn target_default_alias_is_canonicalized_without_losing_unknown_fields() {
+    fn target_default_aliases_keep_unknown_fields_at_their_original_paths() {
         let seed = br#"{
           "version":"33",
           "storageclass":{"standard":"","rrs":""},
@@ -4214,9 +4389,9 @@ mod tests {
         let value: Value = serde_json::from_slice(&encoded).expect("encoded config should be valid json");
         let webhook = value["notify"]["webhook"].as_object().expect("webhook section");
 
-        assert!(webhook.get(DEFAULT_DELIMITER).is_none());
+        assert_eq!(webhook[DEFAULT_DELIMITER]["endpoint"].as_str(), Some(expected_endpoint.as_str()));
         assert_eq!(webhook["default"]["endpoint"].as_str(), Some(expected_endpoint.as_str()));
-        assert_eq!(webhook["default"]["future_alias"].as_str(), Some("keep"));
+        assert_eq!(webhook[DEFAULT_DELIMITER]["future_alias"].as_str(), Some("keep"));
         assert_eq!(webhook["default"]["future_default"].as_str(), Some("keep"));
     }
 
@@ -5406,6 +5581,43 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn alias_snapshot_reset_is_conditional_and_second_save_does_not_write() {
+        let seed =
+            br#"{"version":"33","scanner":{"default":{"cycle":"61","future":"preferred"},"_":{"cycle":"59","future":"shadow"}}}"#
+                .to_vec();
+        let store = Arc::new(RecoveryMockStore::new(RecoveryReadState::Blob(seed), None));
+        let snapshot = read_server_config_snapshot(store.clone()).await.expect("read alias snapshot");
+        let mut reset = snapshot.config.clone();
+        reset.0.remove(SCANNER_SUB_SYS);
+        assert!(
+            save_server_config_snapshot(store.clone(), &reset, &snapshot)
+                .await
+                .expect("save reset")
+        );
+        assert_eq!(
+            store
+                .last_put_preconditions
+                .lock()
+                .unwrap()
+                .as_ref()
+                .unwrap()
+                .if_match_value(),
+            Some("config-1")
+        );
+        drop(snapshot);
+        let snapshot = read_server_config_snapshot(store.clone())
+            .await
+            .expect("reload reset snapshot");
+        assert!(build_scalar_config_object(&snapshot.config, super::scanner_config_descriptor()).is_empty());
+        assert!(
+            !save_server_config_snapshot(store.clone(), &snapshot.config, &snapshot)
+                .await
+                .expect("save unchanged aliases")
+        );
+        assert_eq!(store.write_calls.load(Ordering::SeqCst), 1);
+    }
+
     #[tokio::test]
     async fn server_config_snapshot_save_returns_committed_generation() {
         let baseline = encode_server_config_blob(&Config::new(), None).expect("baseline config should encode");

crates/ecstore/src/config/com/compatibility_tests.rs

@@ -0,0 +1,327 @@
+// Copyright 2026 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 super::*;
+
+const MINIO_CONFIG: &[u8] = include_bytes!("../../../tests/fixtures/server-config/minio-2025-09-07.json");
+
+fn roundtrip(cfg: &Config, seed: &[u8]) -> (Config, Value) {
+    let encoded = encode_server_config_blob(cfg, Some(seed)).expect("encode config with seed");
+    let decoded = decode_server_config_blob(&encoded).expect("reload saved config");
+    let repeated = encode_server_config_blob(&decoded, Some(&encoded)).expect("encode reloaded config");
+    let encoded_value: Value = serde_json::from_slice(&encoded).unwrap();
+    let repeated_value: Value = serde_json::from_slice(&repeated).unwrap();
+    assert_eq!(encoded_value, repeated_value, "a second save must preserve JSON values");
+    (decoded, encoded_value)
+}
+
+#[test]
+fn pinned_minio_config_preserves_unsupported_heal_settings_without_applying_them() {
+    assert!(
+        Config::unmarshal(MINIO_CONFIG).is_err(),
+        "the complete fixture exercises the external fallback"
+    );
+    let cfg = decode_server_config_blob(MINIO_CONFIG).expect("decode real MinIO config");
+    let heal = cfg.get_value(HEAL_SUB_SYS, DEFAULT_DELIMITER).unwrap_or_default();
+    for key in ["bitrotscan", "drive_workers", "max_io", "max_sleep"] {
+        assert!(heal.lookup(key).is_none(), "MinIO heal controls must not be mapped by name");
+    }
+    assert_eq!(
+        cfg.get_value(STORAGE_CLASS_SUB_SYS, DEFAULT_DELIMITER)
+            .unwrap()
+            .get("optimize"),
+        "availability"
+    );
+    let (_, saved) = roundtrip(&cfg, MINIO_CONFIG);
+    let original: Value = serde_json::from_slice(MINIO_CONFIG).unwrap();
+    assert_eq!(saved["heal"], original["heal"], "unsupported KVS entries survive unchanged");
+    assert_eq!(saved["cache"], original["cache"]);
+}
+
+#[test]
+fn scalar_default_alias_reset_cannot_expose_shadow_overrides() {
+    for (subsystem, key, old, shadow, defaults) in [
+        (SCANNER_SUB_SYS, rustfs_config::SCANNER_CYCLE, "61", "59", &*scanner::DEFAULT_KVS),
+        (HEAL_SUB_SYS, rustfs_config::HEAL_BITROT_CYCLE, "off", "48h", &*heal::DEFAULT_KVS),
+    ] {
+        let seed = serde_json::to_vec(&serde_json::json!({"version":"33", subsystem: {
+            "default": {key: old, "future":"preferred"},
+            "_": [{"key":key,"value":shadow,"future_attribute":"keep"}, {"key":"future","value":"shadow"}]
+        }}))
+        .unwrap();
+        let mut cfg = decode_server_config_blob(&seed).unwrap();
+        cfg.0.remove(subsystem);
+        let (decoded, saved) = roundtrip(&cfg, &seed);
+        assert_eq!(
+            decoded
+                .get_value(subsystem, DEFAULT_DELIMITER)
+                .unwrap_or_default()
+                .lookup(key)
+                .unwrap_or_else(|| defaults.get(key)),
+            defaults.get(key)
+        );
+        assert_eq!(saved[subsystem]["default"]["future"], "preferred");
+        assert_eq!(saved[subsystem]["_"][0]["value"], defaults.get(key));
+        assert_eq!(saved[subsystem]["_"][0]["future_attribute"], "keep");
+        assert_eq!(saved[subsystem]["_"][1]["value"], "shadow");
+    }
+}
+
+#[test]
+fn root_aliases_keep_unknown_data_and_sync_known_values() {
+    let seed = br#"{"version":"33",
+      "storageclass":{"standard":"EC:2","future":"canonical"},
+      "storage_class":{"_":[{"key":"standard","value":"EC:4","extra":"keep"},{"key":"future","value":"native"}]},
+      "openid":{"default":{"config_url":"https://id.example/new","client_id":"new","future":"canonical"}},
+      "identity_openid":{"_":{"config_url":"https://id.example/old","client_id":"old","future":"alias"}},
+      "audit":{"webhook":{"default":{"enable":true,"endpoint":"https://audit.example/new","future":"audit"}}},
+      "logger":{"audit_webhook":{"_":{"enable":true,"endpoint":"https://audit.example/old","future":"logger"}}}
+    }"#;
+    let cfg = decode_server_config_blob(seed).unwrap();
+    let (decoded, saved) = roundtrip(&cfg, seed);
+    assert!(configs_semantically_equal(&cfg, &decoded));
+    assert_eq!(saved["storageclass"]["future"], "canonical");
+    assert_eq!(saved["storage_class"]["_"][0]["value"], "EC:2");
+    assert_eq!(saved["storage_class"]["_"][0]["extra"], "keep");
+    assert_eq!(saved["storage_class"]["_"][1]["value"], "native");
+    assert_eq!(saved["openid"]["default"]["future"], "canonical");
+    assert_eq!(saved["identity_openid"]["_"]["future"], "alias");
+    assert_eq!(saved["identity_openid"]["_"]["client_id"], "new");
+    assert_eq!(saved["audit"]["webhook"]["default"]["future"], "audit");
+    assert_eq!(saved["logger"]["audit_webhook"]["_"]["future"], "logger");
+    assert_eq!(saved["logger"]["audit_webhook"]["_"]["endpoint"], "https://audit.example/new");
+}
+
+#[test]
+fn storageclass_nested_alias_reset_clears_inline_override_and_retains_attributes() {
+    let seed = br#"{"version":"33","storageclass":{"standard":"EC:2","_": [
+      {"key":"inline_block","value":"64KiB","extra":{"owner":"future"}},
+      {"key":"future","value":"keep"}]},
+      "storage_class":{"default":{"standard":"EC:4","future":"alias"}}}"#;
+    let (decoded, saved) = roundtrip(&Config::new(), seed);
+    assert_eq!(
+        decoded
+            .get_value(STORAGE_CLASS_SUB_SYS, DEFAULT_DELIMITER)
+            .unwrap()
+            .get("inline_block"),
+        storageclass::DEFAULT_KVS.get("inline_block")
+    );
+    assert_eq!(saved["storageclass"]["_"][0]["extra"]["owner"], "future");
+    assert_eq!(saved["storageclass"]["_"][1]["value"], "keep");
+    assert_eq!(saved["storage_class"]["default"]["future"], "alias");
+}
+
+#[test]
+fn duplicate_known_kvs_entries_are_updated_consistently() {
+    let seed = br#"{"version":"33","scanner":[
+      {"key":"cycle","value":"61","extra":"first"},
+      {"key":"cycle","value":"62","extra":"last"}]}"#;
+    let mut cfg = decode_server_config_blob(seed).unwrap();
+    cfg.0
+        .get_mut(SCANNER_SUB_SYS)
+        .unwrap()
+        .get_mut(DEFAULT_DELIMITER)
+        .unwrap()
+        .insert("cycle".to_string(), "73".to_string());
+    let (decoded, saved) = roundtrip(&cfg, seed);
+    assert_eq!(decoded.get_value(SCANNER_SUB_SYS, DEFAULT_DELIMITER).unwrap().get("cycle"), "73");
+    for entry in saved["scanner"].as_array().unwrap() {
+        assert_eq!(entry["value"], "73");
+    }
+}
+
+#[test]
+fn removed_target_with_kvs_attributes_stays_disabled_under_enabled_default() {
+    let seed = br#"{"version":"33","notify":{"webhook":{
+      "default":{"enable":true,"endpoint":"https://notify.example/default"},
+      "removed":[{"key":"endpoint","value":"https://notify.example/old","extra":"keep"}]
+    }}}"#;
+    let mut cfg = decode_server_config_blob(seed).unwrap();
+    cfg.0
+        .get_mut(rustfs_config::notify::NOTIFY_WEBHOOK_SUB_SYS)
+        .unwrap()
+        .remove("removed");
+    let (decoded, saved) = roundtrip(&cfg, seed);
+    let removed = decoded
+        .get_value(rustfs_config::notify::NOTIFY_WEBHOOK_SUB_SYS, "removed")
+        .unwrap();
+    assert_eq!(removed.get(ENABLE_KEY), "off");
+    assert_eq!(saved["notify"]["webhook"]["removed"][0]["extra"], "keep");
+    assert_eq!(saved["notify"]["webhook"]["removed"][0]["value"], "");
+}
+
+#[test]
+fn empty_preferred_aliases_keep_presence_precedence_but_accept_new_settings() {
+    let seed = br#"{"version":"33","openid":null,"identity_openid":{"default":{"config_url":"https://old.example"}},
+      "audit":null,"logger":{"webhook":{"default":{"enable":true,"endpoint":"https://old.example"}}},
+      "scanner":{"default":null,"_":{"cycle":"59","future":"keep"}}}"#;
+    let cfg = decode_server_config_blob(seed).unwrap();
+    assert!(build_oidc_object(&cfg).is_empty());
+    assert!(build_audit_object(&cfg).is_empty());
+    assert!(build_scalar_config_object(&cfg, scanner_config_descriptor()).is_empty());
+    let (_, reset) = roundtrip(&cfg, seed);
+    assert!(reset["openid"].is_null(), "the preferred null alias must keep shadow config masked");
+    assert!(reset["identity_openid"]["default"].get("config_url").is_none());
+    let reset_cfg = decode_server_config_blob(&serde_json::to_vec(&reset).unwrap()).unwrap();
+    assert!(
+        build_oidc_object(&reset_cfg).is_empty(),
+        "the old shadow provider must stay unapplied after save"
+    );
+    let updated = decode_server_config_blob(br#"{"version":"33","openid":{"default":{"config_url":"https://new.example"}},"audit":{"webhook":{"default":{"enable":true,"endpoint":"https://new.example"}}},"scanner":{"cycle":"73"}}"#).unwrap();
+    let (decoded, _) = roundtrip(&updated, seed);
+    assert!(configs_semantically_equal(&updated, &decoded));
+}
+
+#[test]
+fn storageclass_null_precedence_is_materialized_before_alias_resave() {
+    let seed = br#"{"version":"33","storageclass":null,"storage_class":{"standard":"EC:4","rrs":"EC:2","optimize":"capacity"}}"#;
+    let cfg = decode_server_config_blob(seed).unwrap();
+    let (_, saved) = roundtrip(&cfg, seed);
+    assert_eq!(saved["storageclass"]["standard"], "");
+    assert_eq!(saved["storageclass"]["rrs"], "");
+    assert_eq!(saved["storage_class"]["standard"], "");
+    assert_eq!(saved["storage_class"]["rrs"], "");
+    assert_eq!(saved["storage_class"]["optimize"], "availability");
+}
+
+#[derive(Clone, Default)]
+struct LogCapture(std::sync::Arc<std::sync::Mutex<Vec<u8>>>);
+
+impl std::io::Write for LogCapture {
+    fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+        self.0.lock().unwrap().extend_from_slice(bytes);
+        Ok(bytes.len())
+    }
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for LogCapture {
+    type Writer = Self;
+    fn make_writer(&'a self) -> Self {
+        self.clone()
+    }
+}
+
+fn captured_logs(run: impl FnOnce(&tracing::Dispatch)) -> String {
+    let capture = LogCapture::default();
+    let dispatch = tracing::Dispatch::new(
+        tracing_subscriber::fmt()
+            .without_time()
+            .with_ansi(false)
+            .with_writer(capture.clone())
+            .finish(),
+    );
+    tracing::dispatcher::with_default(&dispatch, || run(&dispatch));
+    String::from_utf8(capture.0.lock().unwrap().clone()).unwrap()
+}
+
+#[test]
+fn compatibility_reports_are_bounded_summaries_and_never_log_untrusted_payloads() {
+    let make_blob = |prefix: &str, keys: usize| {
+        let mut settings = Map::new();
+        for i in 0..keys {
+            settings.insert(format!("SECRET_KEY_{prefix}_{i}"), Value::String("SECRET_VALUE".to_string()));
+        }
+        serde_json::to_vec(&serde_json::json!({"version":"33", "heal":settings, "scanner":"SECRET_LEGACY_PAYLOAD"})).unwrap()
+    };
+    let a = make_blob("a", 1000);
+    let b = make_blob("b", 65);
+    let logs = captured_logs(|dispatch| {
+        for _ in 0..100 {
+            decode_server_config_blob(&a).unwrap();
+        }
+        decode_server_config_blob(&b).unwrap();
+        decode_server_config_blob(&a).unwrap();
+        let barrier = std::sync::Barrier::new(12);
+        let concurrent = make_blob("concurrent", 80);
+        std::thread::scope(|scope| {
+            for _ in 0..12 {
+                let (barrier, concurrent) = (&barrier, &concurrent);
+                scope.spawn(move || {
+                    tracing::dispatcher::with_default(dispatch, || {
+                        barrier.wait();
+                        decode_server_config_blob(concurrent).unwrap();
+                    })
+                });
+            }
+        });
+    });
+    assert_eq!(
+        logs.matches(EVENT_SERVER_CONFIG_COMPATIBILITY_IGNORED).count(),
+        3,
+        "one summary per diagnostic set, including concurrent readers: {logs}"
+    );
+    assert!(logs.contains("unknown_key_count=1000"));
+    assert!(!logs.contains("SECRET"));
+    assert!(logs.len() < 2000, "log volume must not grow with unknown-key count");
+}
+
+#[test]
+fn malformed_known_values_still_fail_without_a_successful_compatibility_warning() {
+    let logs = captured_logs(|_| {
+        for seed in [
+            br#"{"version":"33","heal":{"future":"secret","bitrot_cycle":null}}"#.as_slice(),
+            br#"{"version":"33","scanner":[{"key":"cycle","value":[]}]}"#.as_slice(),
+            br#"{"version":"33","scanner":[false]}"#.as_slice(),
+            br#"{"scanner":null,"heal":"SECRET"}"#.as_slice(),
+        ] {
+            assert!(decode_server_config_blob(seed).is_err());
+        }
+    });
+    assert!(!logs.contains(EVENT_SERVER_CONFIG_COMPATIBILITY_IGNORED));
+    assert!(!logs.contains("secret"));
+}
+
+#[test]
+#[serial_test::serial]
+fn final_decode_failures_are_deduplicated_without_changing_error_classification() {
+    let previous = replace_server_config_decrypt_fn_for_test(None);
+    let logs = captured_logs(|_| {
+        for _ in 0..100 {
+            let err = decode_persisted_server_config(br#"{SECRET_CORRUPT_A"#).unwrap_err();
+            assert!(is_server_config_corrupt_error(&err));
+        }
+        assert!(decode_persisted_server_config(br#"{SECRET_CORRUPT_B"#).is_err());
+        assert!(decode_persisted_server_config(br#"{SECRET_CORRUPT_A"#).is_err());
+        replace_server_config_decrypt_fn_for_test(Some(std::sync::Arc::new(|_| None)));
+        for _ in 0..100 {
+            let err = decode_persisted_server_config(b"SECRET_CIPHERTEXT").unwrap_err();
+            assert!(is_server_config_decrypt_error(&err));
+        }
+    });
+    replace_server_config_decrypt_fn_for_test(previous);
+    assert_eq!(logs.matches(EVENT_SERVER_CONFIG_DECODE_FAILED).count(), 2);
+    assert_eq!(logs.matches(EVENT_SERVER_CONFIG_DECRYPT_FAILED).count(), 1);
+    assert!(!logs.contains("SECRET"));
+}
+
+#[test]
+#[serial_test::serial]
+fn pinned_minio_plaintext_exercises_the_legacy_decrypt_entry_without_false_errors() {
+    // The fixture is plaintext from MinIO; this envelope is produced by RustFS.
+    let encrypted = rustfs_crypto::encrypt_data(b"fixture-test-key", MINIO_CONFIG).unwrap();
+    let previous = replace_server_config_decrypt_fn_for_test(Some(std::sync::Arc::new(|data| {
+        rustfs_crypto::decrypt_data(b"fixture-test-key", data).ok()
+    })));
+    let logs = captured_logs(|_| {
+        let (cfg, seed) = decode_persisted_server_config_with_seed(&encrypted).unwrap();
+        assert_eq!(seed, MINIO_CONFIG);
+        roundtrip(&cfg, &seed);
+    });
+    replace_server_config_decrypt_fn_for_test(previous);
+    assert!(!logs.contains(EVENT_SERVER_CONFIG_DECODE_FAILED));
+    assert!(!logs.contains(EVENT_SERVER_CONFIG_DECRYPT_FAILED));
+}

crates/ecstore/src/config/com/diagnostics.rs

@@ -0,0 +1,206 @@
+// Copyright 2026 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::collections::VecDeque;
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::sync::{LazyLock, Mutex};
+use std::time::{Duration, Instant};
+
+use serde_json::Value;
+use tracing::{error, warn};
+
+use super::{
+    EVENT_SERVER_CONFIG_COMPATIBILITY_IGNORED, EVENT_SERVER_CONFIG_DECODE_FAILED, EVENT_SERVER_CONFIG_DECRYPT_FAILED,
+    HEAL_SUB_SYS, LOG_COMPONENT_CONFIG, LOG_SUBSYSTEM_CONFIG,
+};
+
+const RECENT_REPORTS: usize = 64;
+const FAILURE_REPORT_INTERVAL: Duration = Duration::from_secs(300);
+
+#[derive(Default)]
+struct Reports(VecDeque<Report>);
+
+struct Report {
+    key: u64,
+    reported: Instant,
+    suppressed: u64,
+}
+
+impl Reports {
+    fn observe(&mut self, key: u64, now: Instant, repeat: Option<Duration>) -> Option<u64> {
+        if let Some(index) = self.0.iter().position(|report| report.key == key) {
+            let mut report = self.0.remove(index)?;
+            let emit = repeat.is_some_and(|interval| now.saturating_duration_since(report.reported) >= interval);
+            let suppressed = report.suppressed;
+            if emit {
+                report.reported = now;
+                report.suppressed = 0;
+            } else {
+                report.suppressed = report.suppressed.saturating_add(1);
+            }
+            self.0.push_back(report);
+            return emit.then_some(suppressed);
+        }
+        if self.0.len() == RECENT_REPORTS {
+            self.0.pop_front();
+        }
+        self.0.push_back(Report {
+            key,
+            reported: now,
+            suppressed: 0,
+        });
+        Some(0)
+    }
+}
+
+static COMPATIBILITY_REPORTS: LazyLock<Mutex<Reports>> = LazyLock::new(Mutex::default);
+static FAILURE_REPORTS: LazyLock<Mutex<Reports>> = LazyLock::new(Mutex::default);
+
+fn observe(reports: &Mutex<Reports>, key: u64, repeat: Option<Duration>) -> Option<u64> {
+    // Never hold this process-local diagnostics lock across tracing or I/O.
+    reports
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+        .observe(key, Instant::now(), repeat)
+}
+
+#[derive(Default)]
+pub(super) struct CompatibilityDiagnostics {
+    digest: DefaultHasher,
+    unknown_keys: usize,
+    legacy_shapes: usize,
+    legacy_heal_keys: u8,
+    shape_kinds: u8,
+}
+
+const LEGACY_HEAL_KEYS: [&str; 4] = ["bitrotscan", "drive_workers", "max_io", "max_sleep"];
+const SHAPE_KINDS: [&str; 6] = ["null", "boolean", "number", "string", "array", "object"];
+
+fn shape(value: &Value) -> usize {
+    match value {
+        Value::Null => 0,
+        Value::Bool(_) => 1,
+        Value::Number(_) => 2,
+        Value::String(_) => 3,
+        Value::Array(_) => 4,
+        Value::Object(_) => 5,
+    }
+}
+
+impl CompatibilityDiagnostics {
+    pub(super) fn unknown_key(&mut self, subsystem: &str, key: &str) {
+        ("unknown_key", subsystem, key).hash(&mut self.digest);
+        self.unknown_keys += 1;
+        if subsystem == HEAL_SUB_SYS
+            && let Some(index) = LEGACY_HEAL_KEYS.iter().position(|known| *known == key)
+        {
+            self.legacy_heal_keys |= 1 << index;
+        }
+    }
+
+    pub(super) fn legacy_shape(&mut self, subsystem: &str, value: &Value) {
+        let kind = shape(value);
+        ("legacy_shape", subsystem, kind).hash(&mut self.digest);
+        self.legacy_shapes += 1;
+        self.shape_kinds |= 1 << kind;
+    }
+
+    pub(super) fn report(&self) {
+        if self.unknown_keys == 0 && self.legacy_shapes == 0 {
+            return;
+        }
+        if observe(&COMPATIBILITY_REPORTS, self.digest.finish(), None).is_none() {
+            return;
+        }
+        let legacy_heal_keys = LEGACY_HEAL_KEYS
+            .iter()
+            .enumerate()
+            .filter_map(|(index, key)| (self.legacy_heal_keys & (1 << index) != 0).then_some(*key))
+            .collect::<Vec<_>>();
+        let legacy_shape_kinds = SHAPE_KINDS
+            .iter()
+            .enumerate()
+            .filter_map(|(index, kind)| (self.shape_kinds & (1 << index) != 0).then_some(*kind))
+            .collect::<Vec<_>>();
+        warn!(
+            event = EVENT_SERVER_CONFIG_COMPATIBILITY_IGNORED,
+            component = LOG_COMPONENT_CONFIG,
+            subsystem = LOG_SUBSYSTEM_CONFIG,
+            state = "ignored",
+            unknown_key_count = self.unknown_keys,
+            legacy_shape_count = self.legacy_shapes,
+            ?legacy_heal_keys,
+            ?legacy_shape_kinds,
+            "Persisted server config contains unsupported settings; unknown fields are retained but not applied"
+        );
+    }
+}
+
+#[derive(Hash)]
+pub(super) enum DecodeFailure {
+    Corrupt,
+    Decrypt,
+}
+
+pub(super) fn report_decode_failure(data: &[u8], failure: DecodeFailure, encrypted_size: Option<usize>) {
+    let mut digest = DefaultHasher::new();
+    failure.hash(&mut digest);
+    data.hash(&mut digest);
+    let Some(suppressed_attempts) = observe(&FAILURE_REPORTS, digest.finish(), Some(FAILURE_REPORT_INTERVAL)) else {
+        return;
+    };
+    let event = match failure {
+        DecodeFailure::Corrupt => EVENT_SERVER_CONFIG_DECODE_FAILED,
+        DecodeFailure::Decrypt => EVENT_SERVER_CONFIG_DECRYPT_FAILED,
+    };
+    error!(
+        event,
+        component = LOG_COMPONENT_CONFIG,
+        subsystem = LOG_SUBSYSTEM_CONFIG,
+        state = "failed",
+        size = data.len(),
+        encrypted_size,
+        suppressed_attempts,
+        "Persisted server config could not be decoded; the read remains failed"
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reports_keep_history_without_confusing_keys_with_versions() {
+        let mut reports = Reports::default();
+        let now = Instant::now();
+        assert_eq!(reports.observe(1, now, None), Some(0));
+        assert_eq!(reports.observe(2, now, None), Some(0));
+        assert_eq!(reports.observe(1, now, None), None);
+        for key in 3..=65 {
+            assert_eq!(reports.observe(key, now, None), Some(0));
+        }
+        assert_eq!(reports.0.len(), RECENT_REPORTS);
+        assert_eq!(reports.observe(2, now, None), Some(0), "only the least recently used entry is evicted");
+    }
+
+    #[test]
+    fn failures_report_at_the_interval_boundary_and_count_suppressed_reads() {
+        let mut reports = Reports::default();
+        let now = Instant::now();
+        assert_eq!(reports.observe(1, now, Some(FAILURE_REPORT_INTERVAL)), Some(0));
+        assert_eq!(reports.observe(1, now + Duration::from_secs(299), Some(FAILURE_REPORT_INTERVAL)), None);
+        assert_eq!(reports.observe(1, now + FAILURE_REPORT_INTERVAL, Some(FAILURE_REPORT_INTERVAL)), Some(1));
+        assert_eq!(reports.observe(2, now + FAILURE_REPORT_INTERVAL, Some(FAILURE_REPORT_INTERVAL)), Some(0));
+    }
+}

crates/ecstore/src/config/scanner.rs

@@ -17,12 +17,13 @@ use rustfs_config::{
     DEFAULT_SCANNER_BITROT_CYCLE_SECS, DEFAULT_SCANNER_CACHE_SAVE_TIMEOUT_SECS, DEFAULT_SCANNER_CYCLE_MAX_DIRECTORIES,
     DEFAULT_SCANNER_CYCLE_MAX_DURATION_SECS, DEFAULT_SCANNER_CYCLE_MAX_OBJECTS, DEFAULT_SCANNER_DISK_IO_BUDGET,
     DEFAULT_SCANNER_IDLE_MODE, DEFAULT_SCANNER_MAX_CONCURRENT_DISK_SCANS, DEFAULT_SCANNER_MAX_CONCURRENT_SET_SCANS,
-    DEFAULT_SCANNER_SPEED, DEFAULT_SCANNER_WALKERS_PER_DISK, DEFAULT_SCANNER_YIELD_EVERY_N_OBJECTS, SCANNER_ALERT_EXCESS_FOLDERS,
-    SCANNER_ALERT_EXCESS_VERSION_SIZE, SCANNER_ALERT_EXCESS_VERSIONS, SCANNER_BITROT_CYCLE, SCANNER_CACHE_SAVE_TIMEOUT,
-    SCANNER_CYCLE, SCANNER_CYCLE_MAX_DIRECTORIES, SCANNER_CYCLE_MAX_DURATION, SCANNER_CYCLE_MAX_OBJECTS, SCANNER_DELAY,
+    DEFAULT_SCANNER_RECOVERY_BACKOFF_CAP_SECS, DEFAULT_SCANNER_SPEED, DEFAULT_SCANNER_WALKERS_PER_DISK,
+    DEFAULT_SCANNER_YIELD_EVERY_N_OBJECTS, SCANNER_ALERT_EXCESS_FOLDERS, SCANNER_ALERT_EXCESS_VERSION_SIZE,
+    SCANNER_ALERT_EXCESS_VERSIONS, SCANNER_BITROT_CYCLE, SCANNER_CACHE_SAVE_TIMEOUT, SCANNER_CYCLE,
+    SCANNER_CYCLE_MAX_DIRECTORIES, SCANNER_CYCLE_MAX_DURATION, SCANNER_CYCLE_MAX_OBJECTS, SCANNER_DELAY,
     SCANNER_DISK_IO_BUDGET_BYTES_PER_SEC, SCANNER_DISK_IO_BUDGET_IOPS, SCANNER_IDLE_MODE, SCANNER_MAX_CONCURRENT_DISK_SCANS,
-    SCANNER_MAX_CONCURRENT_SET_SCANS, SCANNER_MAX_WAIT, SCANNER_SPEED, SCANNER_START_DELAY, SCANNER_WALKERS_PER_DISK,
-    SCANNER_YIELD_EVERY_N_OBJECTS,
+    SCANNER_MAX_CONCURRENT_SET_SCANS, SCANNER_MAX_WAIT, SCANNER_RECOVERY_BACKOFF_CAP, SCANNER_SPEED, SCANNER_START_DELAY,
+    SCANNER_WALKERS_PER_DISK, SCANNER_YIELD_EVERY_N_OBJECTS,
 };
 use std::sync::LazyLock;
 
@@ -83,6 +84,11 @@ pub static DEFAULT_KVS: LazyLock<KVS> = LazyLock::new(|| {
             value: DEFAULT_SCANNER_CACHE_SAVE_TIMEOUT_SECS.to_string(),
             hidden_if_empty: false,
         },
+        KV {
+            key: SCANNER_RECOVERY_BACKOFF_CAP.to_owned(),
+            value: DEFAULT_SCANNER_RECOVERY_BACKOFF_CAP_SECS.to_string(),
+            hidden_if_empty: false,
+        },
         KV {
             key: SCANNER_MAX_CONCURRENT_SET_SCANS.to_owned(),
             value: DEFAULT_SCANNER_MAX_CONCURRENT_SET_SCANS.to_string(),