chore(gateway): merge main into integration

2026-11-11 04:39:00 +00:00 · 2026-11-11 06:51:41 +08:00
47 changed files with 273 additions and 3249 deletions
@@ -71,7 +71,7 @@ s3s-footprint-check: ## Check the s3s dependency footprint ratchet stays frozen
 	./scripts/check_s3s_footprint.sh

 .PHONY: test-count-ratchet-check
-test-count-ratchet-check: ## Check no workspace crate fell below its test floor or rose above its #[ignore] ceiling in the committed baseline
+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

@@ -61,12 +61,10 @@ script-tests: ## Run shell script tests
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_check_doc_paths.py
 	./scripts/check_embedded_secrets.sh --self-test
 	./scripts/check_s3s_footprint.sh --self-test
-	./scripts/test_check_test_count_ratchet.sh
 	$(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_download_release_asset.py
-	$(RUSTFS_PYTHON_BIN) ./scripts/test_reference_binary.py
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_inspect_btf_prototypes.py
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_release_build_workflow.py
 	$(RUSTFS_PYTHON_BIN) -m unittest discover -s scripts/release -p "test_*.py"
@@ -90,10 +88,8 @@ script-tests: ## Run shell script tests
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_inspect_validation_runner.py
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_retain_validation_evidence.py
 	$(RUSTFS_PYTHON_BIN) ./scripts/test_ci_timing_report.py
-	$(RUSTFS_PYTHON_BIN) ./scripts/test_junit_diff.py
 	$(RUSTFS_PYTHON_BIN) ./scripts/s3-tests/test_report_compat.py
 	$(RUSTFS_PYTHON_BIN) ./scripts/s3-tests/test_runner_tools.py
-	$(RUSTFS_PYTHON_BIN) ./scripts/s3-tests/test_reference_parity.py
 	bash -n ./scripts/validate_object_data_cache_cold_stampede.sh
 	$(RUSTFS_PYTHON_BIN) ./scripts/check_object_data_cache_follower_samples.py --self-test
 	./scripts/validate_object_data_cache_cold_stampede.sh --self-test
@@ -1,20 +0,0 @@
-# Pinned RustFS release used as the "reference" target of parity lanes
-# (.github/workflows/reference-parity.yml). This is the single place that names
-# the reference release; .github/actions/reference-binary resolves, downloads and
-# verifies it, and fails on a missing pin, a missing asset or a digest mismatch.
-#
-# Bumping the reference is a reviewed event: every per-test difference between
-# the candidate and the reference is measured against this exact build.
-#
-# Each sha256 is the value published in the release's SHA256SUMS asset, which
-# matches the digest GitHub reports for the same asset. The action checks both.
-
-schema = 1
-repository = "rustfs/rustfs"
-version = "1.0.5"
-tag = "1.0.5"
-
-[platforms.linux-x86_64-gnu]
-asset = "rustfs-linux-x86_64-gnu-v1.0.5.zip"
-sha256 = "5addae2f74756bf80104d0975e6347cda843bc2daffdfcd1f0cb80118b95cbd0"
-executable = "rustfs"
@@ -1,24 +0,0 @@
-# Targets of the s3-tests reference parity lane (.github/workflows/reference-parity.yml).
-#
-# Exactly one target uses `binary = "reference"` (the release pinned in
-# .config/reference-binary.toml). Every other target uses `binary = "candidate"`
-# (the binary built from the branch under test) and is compared per node id
-# against the reference. All targets run the same harness, test list and server
-# configuration; `env` adds only the target's own RUSTFS_* settings.
-#
-# Adding a target is one more [[targets]] table, for example:
-#
-#   [[targets]]
-#   name = "candidate-gateway"
-#   binary = "candidate"
-#   env = { RUSTFS_S3_STACK = "gateway" }
-
-schema = 1
-
-[[targets]]
-name = "reference"
-binary = "reference"
-
-[[targets]]
-name = "candidate-legacy"
-binary = "candidate"
@@ -1,12 +0,0 @@
-# Tolerated per-test differences of the s3-tests reference parity lane.
-#
-# One entry per line, four fields separated by " | ":
-#
-#   <target> | <pytest node id> | <tracking issue URL> | <reason>
-#
-# <target> is a candidate name from .config/reference-parity-targets.toml, the
-# node id is exactly as the lane prints it (s3tests/functional/test_s3.py::...),
-# and the issue URL is https://github.com/rustfs/<repo>/issues/<number>.
-#
-# Same semantics as scripts/junit_diff.py --allow: an entry whose difference no
-# longer occurs is stale and fails the lane, so remove it when it is fixed.
@@ -4,17 +4,15 @@
 # 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 = "..."]. The tests column is a floor and the ignored column is a
-# ceiling: CI fails when a crate's tests fall below its row or its ignored count
-# rises above it. Extra tests and fewer ignores pass; --update tightens the rows.
-# Lowering a tests row or raising an ignored row is a reviewed statement that
-# tests were intentionally removed or ignored; justify it in the PR description.
-# Regenerate with:
+# #[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	1026	20
-rustfs	6440	64
+rustfs	6438	64
 rustfs-audit	70	0
-rustfs-checksums	28	1
+rustfs-checksums	26	0
 rustfs-common	36	0
 rustfs-concurrency	87	0
 rustfs-config	43	0
@@ -45,7 +43,7 @@ rustfs-policy	758	0
 rustfs-protocols	770	1
 rustfs-protos	75	0
 rustfs-replication	209	0
-rustfs-rio	225	1
+rustfs-rio	223	0
 rustfs-rio-v2	34	6
 rustfs-s3-client	71	0
 rustfs-s3-ops	8	0
@@ -61,6 +59,6 @@ rustfs-targets	612	26
 rustfs-test-utils	1	0
 rustfs-tls-runtime	44	0
 rustfs-trusted-proxies	72	0
-rustfs-utils	253	1
+rustfs-utils	251	0
 rustfs-zip	30	0
 zstd	11	0
@@ -1,96 +0,0 @@
-# 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.
-
-name: "Reference RustFS binary"
-description: "Download the pinned reference RustFS release, verify its sha256 and expose the executable path. A missing pin, missing asset or digest mismatch fails the step."
-
-inputs:
-  pin-file:
-    description: "Pin file naming the reference release (repository-relative)"
-    required: false
-    default: ".config/reference-binary.toml"
-  platform:
-    description: "Platform table in the pin file"
-    required: false
-    default: "linux-x86_64-gnu"
-  destination:
-    description: "Directory that receives the executable; defaults to $RUNNER_TEMP/reference-binary"
-    required: false
-    default: ""
-
-outputs:
-  path:
-    description: "Absolute path of the verified executable"
-    value: ${{ steps.unpack.outputs.path }}
-  version:
-    description: "Pinned reference version"
-    value: ${{ steps.pin.outputs.version }}
-  sha256:
-    description: "Pinned and verified archive sha256"
-    value: ${{ steps.pin.outputs.sha256 }}
-
-runs:
-  using: "composite"
-  steps:
-    - name: Resolve reference pin
-      id: pin
-      shell: bash
-      env:
-        PIN_TOOL: ${{ github.action_path }}/reference_binary.py
-        PIN_FILE: ${{ inputs.pin-file }}
-        PIN_PLATFORM: ${{ inputs.platform }}
-      run: |
-        set -euo pipefail
-        resolved="$(python3 "$PIN_TOOL" resolve --pin "$PIN_FILE" --platform "$PIN_PLATFORM")"
-        printf '%s\n' "$resolved"
-        printf '%s\n' "$resolved" >> "$GITHUB_OUTPUT"
-
-    - name: Download and verify reference archive
-      id: download
-      shell: bash
-      env:
-        GH_TOKEN: ${{ github.token }}
-        ASSET_DOWNLOADER: ${{ github.action_path }}/../setup/download_release_asset.py
-        REF_REPOSITORY: ${{ steps.pin.outputs.repository }}
-        REF_TAG: ${{ steps.pin.outputs.tag }}
-        REF_ASSET: ${{ steps.pin.outputs.asset }}
-        REF_SHA256: ${{ steps.pin.outputs.sha256 }}
-      run: |
-        set -euo pipefail
-        archive="$RUNNER_TEMP/reference-archive/$REF_ASSET"
-        # Fails unless the release lists exactly one asset of this name whose
-        # published digest equals the pin and whose downloaded bytes match it.
-        python3 "$ASSET_DOWNLOADER" --repository "$REF_REPOSITORY" --tag "$REF_TAG" \
-          --asset "$REF_ASSET" --output "$archive" --sha256 "$REF_SHA256"
-        echo "archive=$archive" >> "$GITHUB_OUTPUT"
-
-    - name: Unpack reference executable
-      id: unpack
-      shell: bash
-      env:
-        PIN_TOOL: ${{ github.action_path }}/reference_binary.py
-        REF_ARCHIVE: ${{ steps.download.outputs.archive }}
-        REF_SHA256: ${{ steps.pin.outputs.sha256 }}
-        REF_EXECUTABLE: ${{ steps.pin.outputs.executable }}
-        REF_DESTINATION: ${{ inputs.destination }}
-      run: |
-        set -euo pipefail
-        destination="${REF_DESTINATION:-$RUNNER_TEMP/reference-binary}"
-        unpacked="$(python3 "$PIN_TOOL" unpack --archive "$REF_ARCHIVE" --sha256 "$REF_SHA256" \
-          --executable "$REF_EXECUTABLE" --destination "$destination")"
-        path="${unpacked#path=}"
-        test -x "$path"
-        echo "Reference executable: $path"
-        "$path" --version
-        echo "path=$path" >> "$GITHUB_OUTPUT"
@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-# 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.
-"""Resolve and unpack the pinned reference RustFS release binary.
-
-`resolve` reads the pin file and prints the selected platform's identity as
-`key=value` lines (GitHub step-output format). `unpack` re-verifies the
-downloaded archive digest against the pin and extracts exactly one executable.
-Every missing or malformed input is a failure; nothing is skipped.
-"""
-
-import argparse
-import hashlib
-from pathlib import Path
-import re
-import sys
-import tomllib
-import zipfile
-
-REPOSITORY = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]*/[A-Za-z0-9][A-Za-z0-9_.-]*")
-TAG = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.+-]*")
-PLATFORM = re.compile(r"[a-z0-9][a-z0-9_-]*")
-ASSET = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.+-]*\.zip")
-SHA256 = re.compile(r"[0-9a-f]{64}")
-EXECUTABLE = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]*")
-MAX_EXECUTABLE_BYTES = 1024 * 1024 * 1024
-
-
-class PinError(Exception):
-    """A pin, archive or argument that cannot be trusted."""
-
-
-def field(table, key, pattern, where):
-    value = table.get(key)
-    if not isinstance(value, str) or not pattern.fullmatch(value):
-        raise PinError(f"{where}: missing or invalid '{key}'")
-    return value
-
-
-def resolve(pin_path, platform):
-    if not PLATFORM.fullmatch(platform or ""):
-        raise PinError("invalid platform name")
-    try:
-        data = tomllib.loads(Path(pin_path).read_text(encoding="utf-8"))
-    except FileNotFoundError as exc:
-        raise PinError(f"{pin_path}: reference pin file is missing") from exc
-    except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError) as exc:
-        raise PinError(f"{pin_path}: cannot read reference pin: {exc}") from exc
-    if data.get("schema") != 1 or type(data.get("schema")) is not int:
-        raise PinError(f"{pin_path}: unsupported pin schema")
-    identity = {
-        "repository": field(data, "repository", REPOSITORY, pin_path),
-        "version": field(data, "version", TAG, pin_path),
-        "tag": field(data, "tag", TAG, pin_path),
-    }
-    platforms = data.get("platforms")
-    if not isinstance(platforms, dict) or not platforms:
-        raise PinError(f"{pin_path}: no pinned platforms")
-    entry = platforms.get(platform)
-    if not isinstance(entry, dict):
-        raise PinError(f"{pin_path}: no pin for platform '{platform}'")
-    where = f"{pin_path} [platforms.{platform}]"
-    identity["asset"] = field(entry, "asset", ASSET, where)
-    identity["sha256"] = field(entry, "sha256", SHA256, where)
-    identity["executable"] = field(entry, "executable", EXECUTABLE, where)
-    if identity["version"] not in identity["asset"]:
-        raise PinError(f"{where}: asset name does not carry version {identity['version']}")
-    unknown = set(entry) - {"asset", "sha256", "executable"}
-    if unknown:
-        raise PinError(f"{where}: unknown keys {sorted(unknown)}")
-    return identity
-
-
-def file_sha256(path):
-    with open(path, "rb") as stream:
-        return hashlib.file_digest(stream, "sha256").hexdigest()
-
-
-def unpack(archive, sha256, executable, destination):
-    if not SHA256.fullmatch(sha256 or "") or not EXECUTABLE.fullmatch(executable or ""):
-        raise PinError("invalid expected digest or executable name")
-    try:
-        actual = file_sha256(archive)
-    except OSError as exc:
-        raise PinError(f"{archive}: reference archive is missing or unreadable") from exc
-    if actual != sha256:
-        raise PinError(f"{archive}: sha256 {actual} does not match the pinned digest")
-    try:
-        with zipfile.ZipFile(archive) as bundle:
-            matches = [info for info in bundle.infolist() if info.filename == executable]
-            if len(matches) != 1:
-                raise PinError(f"{archive}: must contain exactly one top-level '{executable}'")
-            info = matches[0]
-            if info.is_dir() or not 0 < info.file_size <= MAX_EXECUTABLE_BYTES:
-                raise PinError(f"{archive}: '{executable}' is not a plausible executable")
-            destination = Path(destination)
-            destination.mkdir(parents=True, exist_ok=True)
-            target = destination / executable
-            with bundle.open(info) as source, open(target, "wb") as sink:
-                while chunk := source.read(1024 * 1024):
-                    sink.write(chunk)
-    except zipfile.BadZipFile as exc:
-        raise PinError(f"{archive}: not a valid zip archive") from exc
-    target.chmod(0o755)
-    return target
-
-
-def main(argv=None):
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    sub = parser.add_subparsers(dest="mode", required=True)
-    res = sub.add_parser("resolve")
-    res.add_argument("--pin", required=True)
-    res.add_argument("--platform", required=True)
-    unp = sub.add_parser("unpack")
-    unp.add_argument("--archive", required=True)
-    unp.add_argument("--sha256", required=True)
-    unp.add_argument("--executable", required=True)
-    unp.add_argument("--destination", required=True)
-    args = parser.parse_args(argv)
-    try:
-        if args.mode == "resolve":
-            for key, value in resolve(args.pin, args.platform).items():
-                print(f"{key}={value}")
-        else:
-            print(f"path={unpack(args.archive, args.sha256, args.executable, args.destination)}")
-    except PinError as exc:
-        print(f"reference binary: {exc}", file=sys.stderr)
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
@@ -869,33 +869,6 @@
      "failure_owner": "watchdog",
      "origin": "baseline"
    },
-    {
-      "workflow": ".github/workflows/reference-parity.yml",
-      "name": "Reference Parity",
-      "roles": [
-        "pr",
-        "periodic",
-        "manual"
-      ],
-      "events": [
-        "pull_request",
-        "schedule",
-        "workflow_dispatch"
-      ],
-      "cadence": "nightly",
-      "timezone": "UTC",
-      "schedule": [
-        "37 1 * * *"
-      ],
-      "owner": "@overtrue",
-      "policy": "active",
-      "monitor": "workflow",
-      "max_age_hours": 36,
-      "result_owner": "reference-parity.yml",
-      "disposition": "s3-tests per-node-id parity of branch candidates against the pinned reference release",
-      "failure_owner": "watchdog",
-      "origin": "added"
-    },
    {
      "workflow": ".github/workflows/functional-chain-health.yml",
      "name": "Functional chain health",
@@ -1,308 +0,0 @@
-# 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.
-
-# s3-tests reference parity lane (rustfs/backlog#2773).
-#
-# Runs the ceph/s3-tests implemented list (scripts/s3-tests/implemented_tests.txt)
-# against every target in .config/reference-parity-targets.toml and fails on
-# any per-node-id difference between a candidate and the reference:
-#
-#   - reference: the release pinned in .config/reference-binary.toml, downloaded
-#     and sha256-verified by .github/actions/reference-binary;
-#   - candidate targets: the debug binary built from this checkout exactly as
-#     ci.yml's build-rustfs-debug-binary job builds it for S3 Implemented Tests.
-#
-# Every target runs the same harness (scripts/s3-tests/run.sh from this
-# checkout), test list and server configuration on its own hosted runner. A
-# target's failures get one rerun against a fresh server; a case that passes it
-# is flaky, not a difference. scripts/s3-tests/reference_parity.py judges the
-# result and honours .config/reference-parity-tolerated.txt, whose entries must
-# each match a real difference.
-#
-# Report-only: not part of the Test and Lint aggregate. Scheduled failures are
-# owned by the scheduled-validation watchdog (.github/scheduled-validations.json).
-
-name: Reference Parity
-
-on:
-  pull_request:
-    paths:
-      - ".github/workflows/reference-parity.yml"
-      - ".github/actions/reference-binary/**"
-      - ".config/reference-binary.toml"
-      - ".config/reference-parity-targets.toml"
-      - ".config/reference-parity-tolerated.txt"
-      - "scripts/s3-tests/reference_parity.py"
-      - "scripts/junit_diff.py"
-  schedule:
-    - cron: "37 1 * * *"
-  workflow_dispatch:
-
-# Matches ci.yml: these variables are hashed into the rust-cache key, so the
-# candidate build reads the same ci-dev cache as build-rustfs-debug-binary.
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: 1
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  plan:
-    name: Plan parity targets
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    outputs:
-      targets: ${{ steps.targets.outputs.targets }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
-        with:
-          persist-credentials: false
-
-      - name: Validate target list
-        id: targets
-        run: |
-          set -euo pipefail
-          targets="$(python3 scripts/s3-tests/reference_parity.py targets --config .config/reference-parity-targets.toml)"
-          echo "targets=${targets}" >> "$GITHUB_OUTPUT"
-          echo "Parity targets: ${targets}"
-
-  build-candidate:
-    name: Build candidate binary
-    # Critical-path CPU and cache ownership: the same debug build as ci.yml's
-    # build-rustfs-debug-binary, reading the ci-dev cache written on sm-standard-4.
-    runs-on: sm-standard-4
-    timeout-minutes: 60
-    env:
-      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
-    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: Build debug binary
-        run: python3 scripts/e2e_binary.py build --bins --features e2e-test-hooks
-
-      - name: Upload candidate binary
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: reference-parity-candidate-binary
-          overwrite: true
-          path: |
-            target/debug/rustfs
-            target/debug/rustfs.e2e.json
-          if-no-files-found: error
-          retention-days: 1
-
-  s3tests:
-    name: s3-tests (${{ matrix.target.name }})
-    needs: [ plan, build-candidate ]
-    runs-on: ubuntu-latest
-    timeout-minutes: 75
-    strategy:
-      fail-fast: false
-      matrix:
-        target: ${{ fromJSON(needs.plan.outputs.targets) }}
-    env:
-      TARGET_NAME: ${{ matrix.target.name }}
-      TARGET_KIND: ${{ matrix.target.binary }}
-      # Above this many first-run failures the target is systemically broken;
-      # a rerun would only repeat it, so the first run is judged as is.
-      RERUN_CAP: "50"
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
-        with:
-          persist-credentials: false
-
-      - name: Fetch pinned reference binary
-        id: reference
-        if: matrix.target.binary == 'reference'
-        uses: ./.github/actions/reference-binary
-
-      - name: Download candidate binary
-        if: matrix.target.binary == 'candidate'
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          name: reference-parity-candidate-binary
-          path: target/debug
-
-      - name: Select target binary
-        env:
-          REFERENCE_PATH: ${{ steps.reference.outputs.path }}
-        run: |
-          set -euo pipefail
-          case "$TARGET_KIND" in
-            reference) binary="$REFERENCE_PATH" ;;
-            candidate) chmod +x target/debug/rustfs; binary="$PWD/target/debug/rustfs" ;;
-            *) echo "unknown target binary kind: $TARGET_KIND" >&2; exit 1 ;;
-          esac
-          test -x "$binary"
-          echo "TARGET_BINARY=$binary" >> "$GITHUB_ENV"
-          mkdir -p "parity/$TARGET_NAME"
-          {
-            echo "target=$TARGET_NAME"
-            echo "binary=$TARGET_KIND"
-            echo "sha256=$(sha256sum "$binary" | cut -d' ' -f1)"
-            echo "version=$("$binary" --version | tr '\n' ' ')"
-          } | tee "parity/$TARGET_NAME/target.txt"
-
-      - name: Apply target environment
-        env:
-          TARGET_JSON: ${{ toJSON(matrix.target) }}
-        run: |
-          set -euo pipefail
-          python3 scripts/s3-tests/reference_parity.py export-env --target-json "$TARGET_JSON" \
-            | tee -a "$GITHUB_ENV" "parity/$TARGET_NAME/target-env.txt"
-
-      - name: Run implemented s3-tests
-        run: |
-          set -uo pipefail
-          report="parity/$TARGET_NAME"
-          harness="artifacts/s3tests-single"
-
-          # Same invocation as ci.yml's S3 Implemented Tests, with a fresh data
-          # root and port per run. $1 optionally replaces the test list.
-          run_suite() {
-            local list="$1" label="$2" root port
-            root="${RUNNER_TEMP}/rustfs-s3tests-${label}"
-            rm -rf "$harness" "$root"
-            mkdir -p "$root"
-            port="$(python3 -c 'import socket; s=socket.socket(); s.bind(("127.0.0.1", 0)); print(s.getsockname()[1]); s.close()')"
-            env DEPLOY_MODE=binary \
-              RUSTFS_BINARY="$TARGET_BINARY" \
-              TEST_MODE=single \
-              MAXFAIL=0 \
-              XDIST=4 \
-              S3_PORT="$port" \
-              DATA_ROOT="$root" \
-              S3TESTS_CONF="$harness/s3tests.conf" \
-              ${list:+IMPLEMENTED_TESTS_FILE="$list"} \
-              ./scripts/s3-tests/run.sh
-          }
-
-          # A run is usable only if it produced a JUnit report; test failures
-          # are data for the comparison, a missing report is a lane failure.
-          keep() {
-            local prefix="$1"
-            for file in pytest.log compat-report.md; do
-              if [[ -f "$harness/$file" ]]; then cp "$harness/$file" "$report/${prefix}${file}"; fi
-            done
-            if [[ -f "$harness/rustfs-single/rustfs.log" ]]; then cp "$harness/rustfs-single/rustfs.log" "$report/${prefix}rustfs.log"; fi
-            test -s "$harness/junit.xml" || { echo "::error::$TARGET_NAME produced no JUnit report (${prefix:-first} run)"; return 1; }
-            cp "$harness/junit.xml" "$report/${prefix}junit.xml"
-          }
-
-          run_suite "" first
-          echo "first_run_exit=$?" >> "$report/target.txt"
-          keep "" || exit 1
-          cp "$harness/selected-nodeids.txt" "$report/selected-nodeids.txt" || exit 1
-
-          failures="$(python3 scripts/s3-tests/reference_parity.py failed --report "$report")" || exit 1
-          count="$(printf '%s' "$failures" | grep -c . || true)"
-          echo "first_run_failures=$count" >> "$report/target.txt"
-          if (( count == 0 )); then
-            exit 0
-          fi
-          if (( count > RERUN_CAP )); then
-            echo "::warning::$TARGET_NAME has $count failures (cap $RERUN_CAP); judging the first run without a rerun"
-            echo "rerun=skipped-over-cap" >> "$report/target.txt"
-            exit 0
-          fi
-          printf '%s\n' "$failures" > "$RUNNER_TEMP/rerun-tests.txt"
-          run_suite "$RUNNER_TEMP/rerun-tests.txt" rerun
-          echo "rerun_exit=$?" >> "$report/target.txt"
-          keep rerun- || exit 1
-
-      - name: Upload target report
-        if: always()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: reference-parity-report-${{ matrix.target.name }}
-          overwrite: true
-          path: parity/${{ matrix.target.name }}/
-          if-no-files-found: error
-          retention-days: 14
-
-  compare:
-    name: Compare targets
-    needs: [ plan, s3tests ]
-    if: always() && needs.plan.result == 'success'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
-        with:
-          persist-credentials: false
-
-      - name: Download target reports
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          pattern: reference-parity-report-*
-          path: parity-download
-
-      - name: Compare per node id
-        env:
-          TARGETS: ${{ needs.plan.outputs.targets }}
-          S3TESTS_RESULT: ${{ needs.s3tests.result }}
-        run: |
-          set -uo pipefail
-          mkdir -p parity
-          for dir in parity-download/reference-parity-report-*; do
-            if [[ -d "$dir" ]]; then mv "$dir" "parity/${dir#parity-download/reference-parity-report-}"; fi
-          done
-          python3 scripts/s3-tests/reference_parity.py compare \
-            --targets-json "$TARGETS" \
-            --reports parity \
-            --tolerated .config/reference-parity-tolerated.txt \
-            --markdown "$GITHUB_STEP_SUMMARY" \
-            --json parity/diff.json > parity/diff.md
-          status=$?
-          cat parity/diff.md
-          if [[ "$S3TESTS_RESULT" != "success" ]]; then
-            echo "::error::s3-tests target jobs finished with '$S3TESTS_RESULT'"
-            status=1
-          fi
-          exit "$status"
-
-      - name: Upload parity diff
-        if: always()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: reference-parity-diff
-          overwrite: true
-          path: |
-            parity/diff.md
-            parity/diff.json
-          if-no-files-found: warn
-          retention-days: 14
@@ -322,9 +322,9 @@ dependencies = [

 [[package]]
 name = "archive-trait"
-version = "0.0.16"
+version = "0.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b5040ca935c09888e7dfb04383b4d62fa3571e25bc66b6f345b591e97958524"
+checksum = "999bf88cc483664cab77700ca2fdfb0415a73412abe284ef5bc2319d00938e00"
 dependencies = [
 "cap-std",
 "thiserror 2.0.21",
@@ -811,9 +811,9 @@ dependencies = [

 [[package]]
 name = "async-nats"
-version = "0.52.0"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "015f0a7a3b0b29701b78c76a4d4a122624c97c71fa30363381664eb729d619c7"
+checksum = "a4f92759f418774b78c36ef07885849150ce950c67d9bcdeff8a9c253f57d9a1"
 dependencies = [
 "aws-lc-rs",
 "base64 0.22.1",
@@ -3906,9 +3906,9 @@ dependencies = [

 [[package]]
 name = "dial9"
-version = "0.5.8"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c83757d61dc75b3e9d3579a3004c7fe0c42aff2f779ca9eeec7f0c8e1ae3fc10"
+checksum = "2f3298a54fd82af243c9f122595762f5b0e48bd3d1ea8fe3f3eb5e95c130e881"
 dependencies = [
 "bon",
 "dial9-core",
@@ -3990,9 +3990,9 @@ dependencies = [

 [[package]]
 name = "dial9-tokio-telemetry"
-version = "0.5.8"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0eb05627c12c57e40510e63f9a3d5f628ab4b32fec9ccdb0ae98544c13f15e"
+checksum = "0428cba60fbcf37ab82666f3a7ef3b6d0671e90dfb6a352376813b471319f061"
 dependencies = [
 "bon",
 "bytes",
@@ -4525,9 +4525,9 @@ dependencies = [

 [[package]]
 name = "flate2"
-version = "1.1.11"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "626d4928326b646e70f65ed36fc7cf9f206bdb68a0019ee7c6b4709da4e084c4"
+checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
 dependencies = [
 "crc32fast",
 "miniz_oxide",
@@ -4594,7 +4594,7 @@ checksum = "94e7099f6313ecacbe1256e8ff9d617b75d1bcb16a6fddef94866d225a01a14a"
 dependencies = [
 "io-lifetimes 2.0.4",
 "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -5385,9 +5385,9 @@ dependencies = [

 [[package]]
 name = "hotpath"
-version = "0.31.1"
+version = "0.30.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4039758c8bca06a34c475d17aaafc17ac1073ce2cecd8dba8c82e69edb300bbe"
+checksum = "d9632c1fd213e63c1b88d8f3e59543da4999b17f859cc1e1d67cf8f2207e8935"
 dependencies = [
 "arc-swap",
 "async-channel",
@@ -5420,15 +5420,15 @@ dependencies = [

 [[package]]
 name = "hotpath-drain"
-version = "0.31.1"
+version = "0.30.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbba0a3badfb9ebf95f22dc6cdb4afcd0ff07b91a85fa3196fd1060576ea3065"
+checksum = "738324f75aec847dea984f6806402f4f1bdfab437b4700fc8c3ebcad2dff6424"

 [[package]]
 name = "hotpath-macros"
-version = "0.31.1"
+version = "0.30.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d980014875338771b00ac44f1c9e2ea1a10650aa68ce54226233bc767714361"
+checksum = "5d92fdfec803932e5764ea93c201cf7c6c2d8cff1871da44f64f5094c9c3ef8a"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -6412,9 +6412,9 @@ dependencies = [

 [[package]]
 name = "lzma-rust2"
-version = "0.25.0"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1d73c59a56771343712b22ea5615092c612c16ba291c0979e3105dfeec4890"
+checksum = "490750560fa7851fbbf5d3ab1a8750f09350ed361ed8aed85b1e1e40587812ee"
 dependencies = [
 "sha2 0.11.1",
 ]
@@ -10388,18 +10388,18 @@ dependencies = [

 [[package]]
 name = "rustfs-mimalloc"
-version = "0.7.4"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7914232a854336c62058c24a8362c553ac8e7adba2e2395ce9097db24d1510"
+checksum = "216ecfc9341b5d6e2506d47ce57c9232ae1b8020bb10264ea05286fb234286e7"
 dependencies = [
 "rustfs-mimalloc-sys",
 ]

 [[package]]
 name = "rustfs-mimalloc-sys"
-version = "0.7.4"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8073624242781448512682f1931624ee67108b6b7873b22fb29c1a1df689ac0c"
+checksum = "fb16ad68f96883407a75cdb88252b43dc2ea592428f0fc54ff7885756de4b814"
 dependencies = [
 "cc",
 ]
@@ -11773,9 +11773,9 @@ dependencies = [

 [[package]]
 name = "serde_spanned"
-version = "1.1.3"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c187e0a369471c550af028cba56d4f4fa2a489ad28151ae95a4d340a2a8b782"
+checksum = "4e7523beb55eece201a2356bee0bbca0d1ab466c14c07703b2e0ee6d42cb0c2c"
 dependencies = [
 "serde_core",
 ]
@@ -12105,9 +12105,9 @@ dependencies = [

 [[package]]
 name = "smallvec"
-version = "1.16.5"
+version = "1.16.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "149309498a5f7334b12ddae0cad8aba81ce785fe91755068867e017cf98fee46"
+checksum = "d0d5d4b1981b8bbbb7aed204cae5726d683d5d6ac7e74ec54122ea28f315e7c8"
 dependencies = [
 "serde",
 ]
@@ -12302,9 +12302,9 @@ dependencies = [

 [[package]]
 name = "starshard"
-version = "2.4.1"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0883700b50fd0b62120ebc4c07230e02f0cf1ead474c3b3b44eaa13e0a999ea"
+checksum = "fc45de5060fab0de00d7a42230877543ae00c37caf6f49975e69851089b023ac"
 dependencies = [
 "async-trait",
 "hashbrown 0.17.1",
@@ -12553,9 +12553,9 @@ dependencies = [

 [[package]]
 name = "tar-codec"
-version = "0.0.16"
+version = "0.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6875ba507bbec6022500f46477159a03f07ebdffdb4ea043254974531df1dac2"
+checksum = "b9dad615e50d181afea4bafea23dacb8e33ed52dde06503813570634b932d467"
 dependencies = [
 "archive-trait",
 "tar-framing",
@@ -12565,9 +12565,9 @@ dependencies = [

 [[package]]
 name = "tar-framing"
-version = "0.0.16"
+version = "0.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49727b1a300514960d425d0e741a7da3e693170f3db39de3180fdbbc07e542c5"
+checksum = "563e8181b47c9cdcce569eae3ad431eec71543d6269dd60c7bd2350f70bcd233"
 dependencies = [
 "thiserror 2.0.21",
 "tokio",
@@ -12941,9 +12941,9 @@ dependencies = [

 [[package]]
 name = "toml"
-version = "1.2.1+spec-1.1.0"
+version = "1.2.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5755c51863cdac711f1956baf8eb9588e060755f7d3c4c979e70ea1e1f32cd7"
+checksum = "c5ffcdf8f50436dbbfd675c1fe1b8e0854f42b7defea8584bdebe1aee900e561"
 dependencies = [
 "indexmap 2.14.2",
 "serde_core",
@@ -12956,9 +12956,9 @@ dependencies = [

 [[package]]
 name = "toml_datetime"
-version = "1.1.3+spec-1.1.0"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "173f25c883cd2176a2d8212155638c0a60d484a9d84546d270866f40f56b6e49"
+checksum = "2b86d767906c6c42421dcba507eb9d203e779497710a47782a224bb871653053"
 dependencies = [
 "serde_core",
 ]
@@ -13851,6 +13851,15 @@ dependencies = [
 "windows-targets 0.52.6",
 ]

+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.60.2"
@@ -14023,7 +14032,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f3fd376f71958b862e7afb20cfe5a22830e1963462f3a17f49d82a6c1d1f42d"
 dependencies = [
 "bitflags 2.13.2",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -14273,9 +14282,9 @@ dependencies = [

 [[package]]
 name = "zip"
-version = "9.5.0"
+version = "9.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700e6c427aff64acdbf02e85fbfd946c2ee12319d1af013092f3a2178914ff8"
+checksum = "eaeb7f16d2605b49aef586996ded29e65642fab7259a3077e537351df6d80426"
 dependencies = [
 "aes 0.9.4",
 "bzip2",
@@ -156,7 +156,7 @@ async_zip = { default-features = false, version = "0.0.19" }
 mysql_async = { default-features = false, version = "0.37.1" }
 async-compression = { version = "0.4.52" }
 async-trait = "0.1.92"
-async-nats = { version = "0.52.0", default-features = false }
+async-nats = { version = "0.51.0", default-features = false }
 axum = "0.8.9"
 futures = "0.3.34"
 futures-core = "0.3.34"
@@ -256,8 +256,8 @@ anyhow = "1.0.104"
 arc-swap = "1.9.3"
 rustfs-tokio-tar = { version = "0.7.1" }
 # Candidate Snowball parser versions exercised by rustfs-zip compatibility fixtures.
-tar-codec = "0.0.16"
-tar-framing = "0.0.16"
+tar-codec = "0.0.15"
+tar-framing = "0.0.15"
 atoi = "3.1.1"
 atomic_enum = "0.3.0"
 aws-config = { version = "1.13.0" }
@@ -401,7 +401,7 @@ dav-server = "0.11.0"
 # Performance Analysis and Memory Profiling
 rustfs-mimalloc = { version = "0.7.3" }
 # Preserve Unicode focus filters until rustfs/backlog#2302 is resolved.
-hotpath = { version = "0.31.1", default-features = false }
+hotpath = { version = "0.30.3", default-features = false }
 # Snapshot testing for output format regression detection
 insta = { version = "1.49" }

@@ -902,104 +902,4 @@ mod tests {
        assert_eq!(raw.len(), 8);
        assert_eq!(&raw[..], reference.digest().to_be_bytes().as_slice());
    }
-
-    #[test]
-    fn checksums_streaming_chunks_and_header_encoding_match_oneshot_across_unaligned_boundaries() {
-        use crate::http::HttpChecksum;
-
-        let all = [
-            ChecksumAlgorithm::Crc32,
-            ChecksumAlgorithm::Crc32c,
-            ChecksumAlgorithm::Crc64Nvme,
-            ChecksumAlgorithm::Sha1,
-            ChecksumAlgorithm::Sha256,
-            ChecksumAlgorithm::Sha512,
-            ChecksumAlgorithm::Xxhash3,
-            ChecksumAlgorithm::Xxhash64,
-            ChecksumAlgorithm::Xxhash128,
-        ];
-
-        for &payload_len in &[0usize, 1, 31, 33, 1024, 4096 + 37, 64 * 1024 + 19] {
-            let payload: Vec<u8> = (0..payload_len).map(|i| ((i * 19 + 5) % 253) as u8).collect();
-            for algorithm in all {
-                let mut one_shot = algorithm.into_impl();
-                one_shot.update(&payload);
-                let expected_raw = one_shot.finalize();
-                assert_eq!(expected_raw.len(), algorithm.raw_len());
-
-                let mut one_shot_hdr = algorithm.into_impl();
-                one_shot_hdr.update(&payload);
-                let expected_headers = one_shot_hdr.headers();
-
-                for &chunk_size in &[1usize, 31, 1021, 4096] {
-                    if payload_len > 4096 && chunk_size == 1 {
-                        continue;
-                    }
-                    let mut streaming: Box<dyn HttpChecksum> = algorithm.into_impl();
-                    for chunk in payload.chunks(chunk_size) {
-                        streaming.update(chunk);
-                    }
-                    let actual_headers = streaming.headers();
-                    assert_eq!(
-                        actual_headers.get(algorithm.http_header_name()),
-                        expected_headers.get(algorithm.http_header_name()),
-                        "{algorithm:?} streaming mismatch at payload_len={payload_len}, chunk_size={chunk_size}"
-                    );
-                }
-            }
-        }
-    }
-
-    #[test]
-    #[ignore = "utility throughput microbenchmark; run via cargo test -p rustfs-checksums --lib --release -- --ignored --nocapture"]
-    fn microbench_checksums_streaming_chunks_and_header_encoding() {
-        use crate::http::HttpChecksum;
-        use std::hint::black_box;
-        use std::time::Instant;
-
-        let all = [
-            ChecksumAlgorithm::Crc32,
-            ChecksumAlgorithm::Crc32c,
-            ChecksumAlgorithm::Crc64Nvme,
-            ChecksumAlgorithm::Sha1,
-            ChecksumAlgorithm::Sha256,
-            ChecksumAlgorithm::Sha512,
-            ChecksumAlgorithm::Xxhash3,
-            ChecksumAlgorithm::Xxhash64,
-            ChecksumAlgorithm::Xxhash128,
-        ];
-
-        let payload: Vec<u8> = (0..(256 * 1024)).map(|i| ((i * 19 + 5) % 253) as u8).collect();
-        for &chunk_size in &[4 * 1024usize, 64 * 1024, 256 * 1024] {
-            for algorithm in all {
-                let mut one_shot = algorithm.into_impl();
-                one_shot.update(&payload);
-                let expected_headers = one_shot.headers();
-
-                let iters = 8usize;
-                let t0 = Instant::now();
-                let mut last_headers = http::HeaderMap::new();
-                for _ in 0..iters {
-                    let mut streaming: Box<dyn HttpChecksum> = algorithm.into_impl();
-                    for chunk in payload.chunks(chunk_size) {
-                        streaming.update(black_box(chunk));
-                    }
-                    last_headers = streaming.headers();
-                    black_box(&last_headers);
-                }
-                let elapsed = t0.elapsed();
-                assert_eq!(
-                    last_headers.get(algorithm.http_header_name()),
-                    expected_headers.get(algorithm.http_header_name()),
-                    "{algorithm:?} streaming chunk_size={chunk_size} header mismatch"
-                );
-                let total_mib = (payload.len() * iters) as f64 / (1024.0 * 1024.0);
-                let mibs = total_mib / elapsed.as_secs_f64().max(1e-9);
-                println!(
-                    "[microbench][checksums] algo={algorithm:?} chunk_size={chunk_size}B throughput={mibs:.1} MiB/s (size={}B)",
-                    algorithm.raw_len()
-                );
-            }
-        }
-    }
 }
@@ -21,15 +21,12 @@

 #[cfg(test)]
 mod tests {
-    use crate::common::{RustFSTestEnvironment, admin_create_user, init_logging};
+    use crate::common::{RustFSTestEnvironment, init_logging};
    use aws_sdk_s3::Client;
    use aws_sdk_s3::primitives::ByteStream;
-    use aws_sdk_s3::types::{BucketVersioningStatus, Delete, ObjectIdentifier, VersioningConfiguration};
    use std::error::Error;
    use tracing::info;

-    type TestResult = Result<(), Box<dyn Error + Send + Sync>>;
-
    async fn create_bucket(client: &Client, bucket: &str) -> Result<(), Box<dyn Error + Send + Sync>> {
        client.create_bucket().bucket(bucket).send().await?;
        Ok(())
@@ -93,7 +90,7 @@ mod tests {
        Ok(())
    }

-    /// Duplicate and repeated slashes after a leading slash collapse MinIO-style across single and bulk operations.
+    /// Duplicate and repeated slashes after a leading slash collapse MinIO-style.
    #[tokio::test]
    async fn test_put_object_with_duplicate_slashes_normalized() -> Result<(), Box<dyn Error + Send + Sync>> {
        init_logging();
@@ -147,258 +144,8 @@ mod tests {
            "GET after DELETE with raw key must return HTTP 404, got {error:?}"
        );

-        assert_bulk_delete_normalizes_keys(&client).await?;
-        assert_bulk_delete_authorizes_normalized_keys(&env, &client).await?;
-        assert_bulk_delete_preserves_version_identity(&client).await?;
-
        env.stop_server();
        info!("Test completed successfully");
        Ok(())
    }
-
-    async fn assert_bulk_delete_normalizes_keys(client: &Client) -> TestResult {
-        let bucket = "test-bulk-leading-slash";
-        create_bucket(client, bucket).await?;
-        let cases = [
-            ("/foo/bar", "foo/bar"),
-            ("//keyname", "keyname"),
-            ("/dir///sub//file", "dir/sub/file"),
-            ("/folder///", "folder/"),
-            ("/literal%2F+名", "literal%2F+名"),
-            ("plain", "plain"),
-        ];
-        let invalid = ["///", "/dir/../keep", "dir//keep"];
-        client
-            .put_object()
-            .bucket(bucket)
-            .key("keep")
-            .body(ByteStream::from_static(b"keep"))
-            .send()
-            .await?;
-        client
-            .put_object()
-            .bucket(bucket)
-            .key("dir/keep")
-            .body(ByteStream::from_static(b"keep"))
-            .send()
-            .await?;
-
-        for quiet in [false, true] {
-            for (raw, _) in cases {
-                client
-                    .put_object()
-                    .bucket(bucket)
-                    .key(raw)
-                    .body(ByteStream::from_static(b""))
-                    .send()
-                    .await?;
-            }
-            let listing = client.list_objects_v2().bucket(bucket).send().await?;
-            let stored: Vec<_> = listing.contents().iter().filter_map(|object| object.key()).collect();
-            let mut expected: Vec<_> = cases
-                .iter()
-                .map(|(_, normalized)| *normalized)
-                .chain(["dir/keep", "keep"])
-                .collect();
-            expected.sort_unstable();
-            assert_eq!(stored, expected, "PUT must store the exact normalized targets before bulk deletion");
-            let objects = cases
-                .iter()
-                .map(|(raw, _)| *raw)
-                .chain(invalid)
-                .map(|key| ObjectIdentifier::builder().key(key).build())
-                .collect::<Result<Vec<_>, _>>()?;
-            let delete = Delete::builder().set_objects(Some(objects)).quiet(quiet).build()?;
-            // A second identical batch also pins idempotent deletion of absent normalized keys.
-            for _ in 0..2 {
-                let output = client.delete_objects().bucket(bucket).delete(delete.clone()).send().await?;
-                let errors: Vec<_> = output.errors().iter().map(|error| (error.key(), error.code())).collect();
-                assert_eq!(
-                    errors,
-                    invalid.map(|key| (Some(key), Some("InvalidArgument"))),
-                    "unexpected per-key errors: {output:?}"
-                );
-                let deleted: Vec<_> = output.deleted().iter().filter_map(|object| object.key()).collect();
-                let expected = if quiet {
-                    vec![]
-                } else {
-                    cases.iter().map(|(raw, _)| *raw).collect()
-                };
-                assert_eq!(deleted, expected, "responses must retain request keys, including directory slashes");
-            }
-            let listing = client.list_objects_v2().bucket(bucket).send().await?;
-            let remaining: Vec<_> = listing.contents().iter().filter_map(|object| object.key()).collect();
-            assert_eq!(
-                remaining,
-                ["dir/keep", "keep"],
-                "bulk delete must remove normalized objects without resolving dot segments"
-            );
-        }
-        Ok(())
-    }
-
-    async fn assert_bulk_delete_authorizes_normalized_keys(env: &RustFSTestEnvironment, admin: &Client) -> TestResult {
-        let bucket = "test-bulk-slash-policy";
-        let user = "bulk-slash-user";
-        admin_create_user(env, user, "bulkSlashTestSecret123!").await?;
-        create_bucket(admin, bucket).await?;
-        for key in ["allowed/item", "protected/item"] {
-            admin
-                .put_object()
-                .bucket(bucket)
-                .key(key)
-                .body(ByteStream::from_static(b"keep"))
-                .send()
-                .await?;
-        }
-        let policy = serde_json::json!({
-            "Version": "2012-10-17",
-            "Statement": [
-                {"Effect": "Allow", "Principal": {"AWS": [user]}, "Action": ["s3:DeleteObject"],
-                 "Resource": [format!("arn:aws:s3:::{bucket}/*")]},
-                {"Effect": "Deny", "Principal": {"AWS": [user]}, "Action": ["s3:DeleteObject"],
-                 "Resource": [format!("arn:aws:s3:::{bucket}/protected/*")]}
-            ]
-        });
-        admin
-            .put_bucket_policy()
-            .bucket(bucket)
-            .policy(policy.to_string())
-            .send()
-            .await?;
-        let client = env.create_s3_client_with_credentials(user, "bulkSlashTestSecret123!");
-        let output = client
-            .delete_objects()
-            .bucket(bucket)
-            .delete(
-                Delete::builder()
-                    .objects(ObjectIdentifier::builder().key("/allowed///item").build()?)
-                    .objects(ObjectIdentifier::builder().key("/protected///item").build()?)
-                    .build()?,
-            )
-            .send()
-            .await?;
-        assert_eq!(output.deleted().len(), 1, "allowed normalized key must be deleted: {output:?}");
-        assert_eq!(output.deleted()[0].key(), Some("/allowed///item"));
-        assert_eq!(output.errors().len(), 1, "normalized resource denial must apply: {output:?}");
-        assert_eq!(output.errors()[0].key(), Some("/protected///item"));
-        assert_eq!(output.errors()[0].code(), Some("AccessDenied"));
-        let listing = admin.list_objects_v2().bucket(bucket).send().await?;
-        let remaining: Vec<_> = listing.contents().iter().filter_map(|object| object.key()).collect();
-        assert_eq!(remaining, ["protected/item"], "only the authorized object may be removed");
-        let protected = admin.get_object().bucket(bucket).key("protected/item").send().await?;
-        assert_eq!(protected.body.collect().await?.into_bytes().as_ref(), b"keep");
-        Ok(())
-    }
-
-    async fn assert_bulk_delete_preserves_version_identity(client: &Client) -> TestResult {
-        let bucket = "test-bulk-slash-versions";
-        let raw = "/history///file";
-        let normalized = "history/file";
-        create_bucket(client, bucket).await?;
-        client
-            .put_bucket_versioning()
-            .bucket(bucket)
-            .versioning_configuration(
-                VersioningConfiguration::builder()
-                    .status(BucketVersioningStatus::Enabled)
-                    .build(),
-            )
-            .send()
-            .await?;
-        let first = client
-            .put_object()
-            .bucket(bucket)
-            .key(raw)
-            .body(ByteStream::from_static(b"old"))
-            .send()
-            .await?;
-        let first_id = first.version_id().ok_or("first PUT omitted version ID")?;
-        let latest = client
-            .put_object()
-            .bucket(bucket)
-            .key(raw)
-            .body(ByteStream::from_static(b"latest"))
-            .send()
-            .await?;
-        let latest_id = latest.version_id().ok_or("latest PUT omitted version ID")?;
-        let invalid = client
-            .delete_objects()
-            .bucket(bucket)
-            .delete(
-                Delete::builder()
-                    .objects(ObjectIdentifier::builder().key("///").build()?)
-                    .build()?,
-            )
-            .send()
-            .await?;
-        assert!(invalid.deleted().is_empty(), "slash-only keys must not delete a versioned object");
-        assert_eq!(
-            invalid.errors().len(),
-            1,
-            "slash-only keys must remain invalid in versioned buckets: {invalid:?}"
-        );
-        assert_eq!(invalid.errors()[0].key(), Some("///"));
-        assert_eq!(invalid.errors()[0].code(), Some("InvalidArgument"));
-        let deleted = client
-            .delete_objects()
-            .bucket(bucket)
-            .delete(
-                Delete::builder()
-                    .objects(ObjectIdentifier::builder().key(raw).version_id(first_id).build()?)
-                    .build()?,
-            )
-            .send()
-            .await?;
-        assert!(deleted.errors().is_empty(), "historical delete failed: {deleted:?}");
-        assert_eq!(deleted.deleted().len(), 1);
-        assert_eq!(deleted.deleted()[0].key(), Some(raw));
-        assert_eq!(deleted.deleted()[0].version_id(), Some(first_id));
-        let listing = client.list_object_versions().bucket(bucket).send().await?;
-        assert_eq!(listing.versions().len(), 1, "only the latest data version should remain: {listing:?}");
-        assert_eq!(listing.versions()[0].version_id(), Some(latest_id));
-
-        let deleted = client
-            .delete_objects()
-            .bucket(bucket)
-            .delete(
-                Delete::builder()
-                    .objects(ObjectIdentifier::builder().key(raw).build()?)
-                    .build()?,
-            )
-            .send()
-            .await?;
-        assert!(deleted.errors().is_empty(), "delete marker creation failed: {deleted:?}");
-        assert_eq!(deleted.deleted().len(), 1);
-        assert_eq!(deleted.deleted()[0].key(), Some(raw));
-        assert_eq!(deleted.deleted()[0].delete_marker(), Some(true));
-        let marker = deleted.deleted()[0]
-            .delete_marker_version_id()
-            .ok_or("missing delete marker ID")?;
-        let listing = client.list_object_versions().bucket(bucket).send().await?;
-        assert_eq!(listing.delete_markers().len(), 1);
-        assert_eq!(listing.delete_markers()[0].key(), Some(normalized));
-        assert_eq!(listing.delete_markers()[0].version_id(), Some(marker));
-
-        let deleted = client
-            .delete_objects()
-            .bucket(bucket)
-            .delete(
-                Delete::builder()
-                    .objects(ObjectIdentifier::builder().key(raw).version_id(marker).build()?)
-                    .build()?,
-            )
-            .send()
-            .await?;
-        assert!(deleted.errors().is_empty(), "explicit marker removal failed: {deleted:?}");
-        assert_eq!(deleted.deleted().len(), 1);
-        assert_eq!(deleted.deleted()[0].key(), Some(raw));
-        assert_eq!(deleted.deleted()[0].version_id(), Some(marker));
-        let listing = client.list_object_versions().bucket(bucket).send().await?;
-        assert!(listing.delete_markers().is_empty());
-        let restored = client.get_object().bucket(bucket).key(normalized).send().await?;
-        assert_eq!(restored.version_id(), Some(latest_id));
-        assert_eq!(restored.body.collect().await?.into_bytes().as_ref(), b"latest");
-        Ok(())
-    }
 }
@@ -4325,28 +4325,20 @@ fn take_presynced_tmp_file(file: &Path) -> bool {
    PRESYNCED_TMP_FILES.remove(file).is_some()
 }

-fn open_lazy_local_file_std(
-    file_path: &Path,
-    volume_dir: &Path,
-    _reclaim_on_shutdown: bool,
-    parent_exists: bool,
-) -> std::io::Result<std::fs::File> {
-    let mut open_opts = std::fs::OpenOptions::new();
-    open_opts.write(true).create(true).truncate(true);
-    let file = match parent_exists.then(|| open_opts.open(file_path)) {
-        Some(Ok(file)) => file,
-        Some(Err(err)) if err.kind() != std::io::ErrorKind::NotFound => return Err(to_file_error(err)),
-        _ => {
-            if let Some(parent) = file_path.parent()
-                && (volume_dir.as_os_str().is_empty() || !volume_dir.starts_with(parent))
-                && let Err(err) = super::fs::create_dir_all_std(parent)
-                && err.kind() != std::io::ErrorKind::AlreadyExists
-            {
-                return Err(to_file_error(err));
-            }
-            open_opts.open(file_path).map_err(to_file_error)?
-        }
-    };
+fn open_lazy_local_file_std(file_path: &Path, volume_dir: &Path, _reclaim_on_shutdown: bool) -> std::io::Result<std::fs::File> {
+    if let Some(parent) = file_path.parent()
+        && (volume_dir.as_os_str().is_empty() || !volume_dir.starts_with(parent))
+        && let Err(err) = super::fs::create_dir_all_std(parent)
+        && err.kind() != std::io::ErrorKind::AlreadyExists
+    {
+        return Err(to_file_error(err));
+    }
+    let file = std::fs::OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(file_path)
+        .map_err(to_file_error)?;
    #[cfg(target_os = "macos")]
    if _reclaim_on_shutdown {
        let _ = set_std_fd_nocache(&file);
@@ -4361,7 +4353,6 @@ struct LazyLocalFileWriter {
    reclaim_on_shutdown: bool,
    sync_on_close: bool,
    mark_dir_presynced: bool,
-    parent_exists: bool,
    bytes_written: usize,
    state: LazyLocalFileWriterState,
 }
@@ -4382,7 +4373,6 @@ impl LazyLocalFileWriter {
        reclaim_on_shutdown: bool,
        sync_on_close: bool,
        mark_dir_presynced: bool,
-        parent_exists: bool,
    ) -> Self {
        Self {
            file_path,
@@ -4391,7 +4381,6 @@ impl LazyLocalFileWriter {
            reclaim_on_shutdown,
            sync_on_close,
            mark_dir_presynced,
-            parent_exists,
            bytes_written: 0,
            state: LazyLocalFileWriterState::Unopened,
        }
@@ -4404,13 +4393,12 @@ impl LazyLocalFileWriter {
        let reclaim_on_shutdown = self.reclaim_on_shutdown;
        let sync_on_close = self.sync_on_close;
        let mark_dir_presynced = self.mark_dir_presynced;
-        let parent_exists = self.parent_exists;
        match std::mem::replace(&mut self.state, LazyLocalFileWriterState::Closed) {
            LazyLocalFileWriterState::Unopened => {
                let file_path = self.file_path.clone();
                let volume_dir = self.volume_dir.clone();
                self.state = LazyLocalFileWriterState::Writing(tokio::task::spawn_blocking(move || {
-                    let mut file = open_lazy_local_file_std(&file_path, &volume_dir, reclaim_on_shutdown, parent_exists)?;
+                    let mut file = open_lazy_local_file_std(&file_path, &volume_dir, reclaim_on_shutdown)?;
                    std::io::Write::write_all(&mut file, &payload).map_err(to_file_error)?;
                    if close_after {
                        if sync_on_close {
@@ -4552,9 +4540,8 @@ impl AsyncWrite for LazyLocalFileWriter {
                    let file_path = self.file_path.clone();
                    let volume_dir = self.volume_dir.clone();
                    let reclaim_on_shutdown = self.reclaim_on_shutdown;
-                    let parent_exists = self.parent_exists;
                    self.state = LazyLocalFileWriterState::Closing(tokio::task::spawn_blocking(move || {
-                        open_lazy_local_file_std(&file_path, &volume_dir, reclaim_on_shutdown, parent_exists).map(drop)
+                        open_lazy_local_file_std(&file_path, &volume_dir, reclaim_on_shutdown).map(drop)
                    }));
                }
                LazyLocalFileWriterState::Open(file) => {
@@ -5606,14 +5593,11 @@ impl LocalIoBackend for StdBackend {
                let file_path = local_disk_object_path(self.io_root(), volume, path)?;
                check_path_length(file_path.to_string_lossy().as_ref())?;
                let mut mark_dir_presynced = false;
-                let mut parent_exists = false;
                if let Some(parent) = file_path.parent() {
                    check_path_length(parent.to_string_lossy().as_ref())?;
-                    parent_exists = parent == volume_dir;
                    if volume == RUSTFS_META_TMP_BUCKET {
                        unmark_presynced_tmp_file(&file_path);
                        let parent_was_presynced = unmark_presynced_tmp_data_dir(parent);
-                        parent_exists |= parent_was_presynced;
                        let file_name = file_path.file_name().and_then(|n| n.to_str()).unwrap_or_default();
                        mark_dir_presynced = sync_on_close
                            && (file_name == "part.1"
@@ -5667,7 +5651,6 @@ impl LocalIoBackend for StdBackend {
                    reclaim_on_shutdown,
                    sync_on_close,
                    mark_dir_presynced,
-                    parent_exists,
                )))
            }
            WriteMode::Append => {
@@ -286,15 +286,12 @@ pub(super) fn fsync_inline_commit_std(

    if destination_was_absent {
        let mut ancestor = dst.parent().and_then(Path::parent);
-        let mut ancestor_step = 0usize;
        while let Some(ancestor_dir) = ancestor {
            if !ancestor_dir.starts_with(dst_volume_dir) {
                break;
            }
            let fsync_started = rustfs_io_metrics::put_stage_timer();
-            if let Err(err) =
-                os::fsync_commit_ancestor_directory_limited_std(ancestor_dir, dst_volume_dir, ancestor_step, commit_guard)
-            {
+            if let Err(err) = os::fsync_dir_limited_std(ancestor_dir) {
                rustfs_io_metrics::record_put_object_stage_duration_from(
                    rustfs_io_metrics::PUT_STAGE_SET_DISK_RENAME_ANCESTOR_DIR_FSYNC,
                    fsync_started,
@@ -313,7 +310,6 @@ pub(super) fn fsync_inline_commit_std(
                break;
            }
            ancestor = ancestor_dir.parent();
-            ancestor_step += 1;
        }
    }
    Ok(())
@@ -1128,8 +1128,6 @@ struct PreparedDeleteReceiptEntry {
    journal_raw: Vec<u8>,
    journal: DeleteRecoveryJournal,
    sole_transaction: bool,
-    had_old_data_dir: bool,
-    rollback_dir_fd: Option<Arc<std::fs::File>>,
 }

 #[derive(Clone)]
@@ -1139,8 +1137,6 @@ struct PublishedDeleteReceiptEntry {
    file_path: PathBuf,
    staging_root: PathBuf,
    journal_raw: Vec<u8>,
-    had_old_data_dir: bool,
-    rollback_dir_fd: Option<Arc<std::fs::File>>,
 }

 const PREPARED_DELETE_RECEIPTS_PER_SHARD: usize = 64;
@@ -2499,9 +2495,8 @@ impl LocalDisk {
                    Err(err) if err.kind() == ErrorKind::NotFound => return Ok(Ok(None)),
                    Err(err) => return Err(err),
                };
-                type PreparedDeleteTuple =
-                    (Option<Uuid>, Option<Vec<u8>>, Vec<u8>, DeleteRecoveryJournal, bool, bool, Option<bool>);
-                let (old_dir, target, journal_raw, journal, sole_transaction, destination_missing, old_data_dir_state) =
+                type PreparedDeleteTuple = (Option<Uuid>, Option<Vec<u8>>, Vec<u8>, DeleteRecoveryJournal, bool, bool, bool);
+                let (old_dir, target, journal_raw, journal, sole_transaction, destination_missing, old_data_dir_present) =
                    match (|| -> Result<Option<PreparedDeleteTuple>> {
                        let mut meta = FileMeta::load(&buf)?;
                        let mut deleted_headers: Vec<_> = meta
@@ -2518,12 +2513,13 @@ impl LocalDisk {
                        if old_dir.is_some_and(|dir| dir == transaction || dir.is_nil()) {
                            return Err(DiskError::FileCorrupt);
                        }
-                        let mut old_path_to_verify = None;
                        if let Some(uuid) = old_dir {
                            meta.data.remove(vec![fi_clone.version_id.unwrap_or_default(), uuid])?;
                            let old_path = path_join(&[file_path.as_path(), Path::new(uuid.to_string().as_str())]);
                            check_path_length(old_path.to_string_lossy().as_ref())?;
-                            old_path_to_verify = Some(old_path);
+                            if old_path.join(STORAGE_FORMAT_FILE).exists() {
+                                return Ok(None);
+                            }
                        }
                        let surviving: HashSet<_> = meta
                            .versions
@@ -2605,12 +2601,6 @@ impl LocalDisk {
                                }
                            }
                        }
-                        if let Some(old_path) = old_path_to_verify
-                            && (!scanned_file_path || old_data_dir_exists)
-                            && old_path.join(STORAGE_FORMAT_FILE).exists()
-                        {
-                            return Ok(None);
-                        }
                        sole_transaction &= predecessors.is_empty();
                        let mut sparse = fi_clone;
                        sparse.data = None;
@@ -2636,21 +2626,15 @@ impl LocalDisk {
                            journal,
                            sole_transaction,
                            scanned_file_path && !destination_exists,
-                            scanned_file_path.then_some(old_data_dir_exists),
+                            scanned_file_path && old_data_dir_exists,
                        )))
                    })() {
                        Ok(Some(tuple)) => tuple,
                        Ok(None) => return Ok(Ok(None)),
                        Err(err) => return Ok(Err(err)),
                    };
-                let staged = match tempfile::Builder::new().prefix("delete-prep-").tempdir_in(&staging_root) {
-                    Ok(dir) => dir,
-                    Err(err) if err.kind() == ErrorKind::NotFound => {
-                        std::fs::create_dir_all(&staging_root)?;
-                        tempfile::Builder::new().prefix("delete-prep-").tempdir_in(&staging_root)?
-                    }
-                    Err(err) => return Err(err),
-                };
+                std::fs::create_dir_all(&staging_root)?;
+                let staged = tempfile::Builder::new().prefix("delete-prep-").tempdir_in(&staging_root)?;
                let staged_dir = staged.path().to_path_buf();
                let backup_path = staged_dir.join(STORAGE_FORMAT_FILE_BACKUP);
                if std::fs::hard_link(&xl_path, &backup_path).is_err() {
@@ -2674,12 +2658,8 @@ impl LocalDisk {
                for file in written_files {
                    file.sync_data()?;
                }
-                #[cfg(unix)]
-                let rollback_dir_fd = sync.then(|| std::fs::File::open(&staged_dir).ok().map(Arc::new)).flatten();
-                #[cfg(not(unix))]
-                let rollback_dir_fd: Option<Arc<std::fs::File>> = None;
                if sync {
-                    os::fsync_directory_handle_std(&staged_dir, rollback_dir_fd.as_deref())?;
+                    os::fsync_dir_std(&staged_dir)?;
                }
                if !destination_missing {
                    match std::fs::symlink_metadata(&destination) {
@@ -2702,12 +2682,8 @@ impl LocalDisk {
                }
                let old_data_path = old_dir
                    .map(|uuid| file_path.join(uuid.to_string()))
-                    .filter(|p| old_data_dir_state.unwrap_or_else(|| p.is_dir()));
-                #[cfg(unix)]
-                let file_path_dir = sync.then(|| std::fs::File::open(&file_path).ok()).flatten();
-                #[cfg(not(unix))]
-                let file_path_dir: Option<std::fs::File> = None;
-                if sync && let Err(err) = os::fsync_directory_handle_std(&file_path, file_path_dir.as_ref()) {
+                    .filter(|p| old_data_dir_present || p.is_dir());
+                if sync && let Err(err) = os::fsync_dir_std(&file_path) {
                    let _ = std::fs::remove_dir_all(&destination);
                    return Err(err);
                }
@@ -2716,15 +2692,11 @@ impl LocalDisk {
                let mut reserved_data_path = None;
                if let Some(old_path) = old_data_path {
                    let reserved_marker = old_path.join(format!("{RESERVED_DELETE_DATA_DIR_MARKER_PREFIX}{transaction}"));
-                    #[cfg(unix)]
-                    let old_dir_file = sync.then(|| std::fs::File::open(&old_path).ok()).flatten();
-                    #[cfg(not(unix))]
-                    let old_dir_file: Option<std::fs::File> = None;
                    let reserve_res = (|| -> std::io::Result<()> {
                        let marker = std::fs::File::create(&reserved_marker)?;
                        if sync {
                            marker.sync_all()?;
-                            os::fsync_directory_handle_std(&old_path, old_dir_file.as_ref())?;
+                            os::fsync_dir_std(&old_path)?;
                        }
                        Ok(())
                    })();
@@ -2733,7 +2705,7 @@ impl LocalDisk {
                        let _ = std::fs::remove_dir_all(&destination);
                        return Err(err);
                    }
-                    reserved_data_path = Some((old_path, reserved_marker, old_dir_file));
+                    reserved_data_path = Some((old_path, reserved_marker));
                }
                if let Some(ref target_bytes) = target {
                    // A provisional head must stay outside the published recovery transaction.
@@ -2765,7 +2737,7 @@ impl LocalDisk {
                        })()
                    };
                    if let Err(err) = write_res {
-                        if let Some((_, reserved_marker, _)) = &reserved_data_path {
+                        if let Some((_, reserved_marker)) = &reserved_data_path {
                            let _ = std::fs::remove_file(reserved_marker);
                        }
                        let _ = std::fs::remove_dir_all(&destination);
@@ -2774,20 +2746,19 @@ impl LocalDisk {
                } else if let Err(err) = std::fs::remove_file(&xl_path)
                    && err.kind() != ErrorKind::NotFound
                {
-                    if let Some((_, reserved_marker, _)) = &reserved_data_path {
+                    if let Some((_, reserved_marker)) = &reserved_data_path {
                        let _ = std::fs::remove_file(reserved_marker);
                    }
                    let _ = std::fs::remove_dir_all(&destination);
                    return Err(err);
                }
                if sync {
-                    os::fsync_directory_handle_std(&file_path, file_path_dir.as_ref())?;
+                    os::fsync_dir_std(&file_path)?;
                }
-                let had_old_data_dir = reserved_data_path.is_some();
-                if let Some((old_path, reserved_marker, old_dir_file)) = reserved_data_path {
+                if let Some((old_path, reserved_marker)) = reserved_data_path {
                    let recovery_marker = old_path.join(format!("{RECOVERY_DELETE_DATA_DIR_MARKER_PREFIX}{transaction}"));
                    match std::fs::rename(&reserved_marker, &recovery_marker) {
-                        Ok(()) if sync => os::fsync_directory_handle_std(&old_path, old_dir_file.as_ref())?,
+                        Ok(()) if sync => os::fsync_dir_std(&old_path)?,
                        Ok(()) => {}
                        Err(err) if err.kind() == ErrorKind::NotFound => {}
                        Err(err) => return Err(err),
@@ -2803,11 +2774,9 @@ impl LocalDisk {
                        journal_raw,
                        journal,
                        sole_transaction,
-                        had_old_data_dir,
-                        rollback_dir_fd,
                    },
                );
-                Ok(Ok(Some(old_dir.filter(|_| had_old_data_dir))))
+                Ok(Ok(Some(old_dir)))
            },
        )
        .await
@@ -2860,13 +2829,7 @@ impl LocalDisk {
                Some(entry.bucket_path),
                entry.file_path,
                entry.staging_root,
-                Some((
-                    entry.journal_raw,
-                    entry.journal,
-                    entry.sole_transaction,
-                    entry.had_old_data_dir,
-                    entry.rollback_dir_fd,
-                )),
+                Some((entry.journal_raw, entry.journal, entry.sole_transaction)),
            ),
            None => {
                self.reject_multipart_delete_recovery_mutation(volume, object)?;
@@ -2897,7 +2860,7 @@ impl LocalDisk {
            lease,
            sync,
            move || -> std::io::Result<Result<Option<(DeleteRecoveryJournal, bool, bool)>>> {
-                if let Some((journal_raw, journal, sole_transaction, had_old_data_dir, rollback_dir_fd)) = cached_receipt
+                if let Some((journal_raw, journal, sole_transaction)) = cached_receipt
                    && rollback.join(PREPARED).is_file()
                {
                    let tmp_receipt = staging_root.join(format!("receipt-{transaction}.tmp"));
@@ -2911,7 +2874,7 @@ impl LocalDisk {
                        os::record_native_publication(&receipt_path);
                        std::fs::rename(&tmp_receipt, &receipt_path)?;
                        if sync {
-                            os::fsync_directory_handle_std(&rollback, rollback_dir_fd.as_deref())?;
+                            os::fsync_dir_std(&rollback)?;
                        }
                        Ok(())
                    })();
@@ -2928,8 +2891,6 @@ impl LocalDisk {
                                file_path: root,
                                staging_root,
                                journal_raw,
-                                had_old_data_dir,
-                                rollback_dir_fd,
                            },
                        );
                    }
@@ -3066,34 +3027,29 @@ impl LocalDisk {
            None
        };
        let cached_published = rollback_open_path.as_deref().and_then(take_published_delete_receipt);
-        let (object_path, bucket_path, staging_root, root, cached_journal_raw, cached_had_old_data_dir, mut rollback_dir_fd) =
-            match cached_published {
-                Some(entry) => (
-                    entry.object_path,
-                    entry.bucket_path,
-                    entry.staging_root,
-                    entry.file_path,
-                    Some(entry.journal_raw),
-                    Some(entry.had_old_data_dir),
-                    entry.rollback_dir_fd,
-                ),
-                None => {
-                    self.reject_multipart_delete_recovery_mutation(volume, object)?;
-                    if !safe_path(object, false) {
-                        return Err(DiskError::InvalidPath);
-                    }
-                    let obj_path = self.get_object_path(volume, object)?;
-                    (
-                        obj_path,
-                        self.io_get_bucket_path(volume)?,
-                        self.io_get_bucket_path(RUSTFS_META_TMP_BUCKET)?,
-                        self.io_get_object_path(volume, object)?,
-                        None,
-                        None,
-                        None,
-                    )
+        let (object_path, bucket_path, staging_root, root, cached_journal_raw) = match cached_published {
+            Some(entry) => (
+                entry.object_path,
+                entry.bucket_path,
+                entry.staging_root,
+                entry.file_path,
+                Some(entry.journal_raw),
+            ),
+            None => {
+                self.reject_multipart_delete_recovery_mutation(volume, object)?;
+                if !safe_path(object, false) {
+                    return Err(DiskError::InvalidPath);
                }
-            };
+                let obj_path = self.get_object_path(volume, object)?;
+                (
+                    obj_path,
+                    self.io_get_bucket_path(volume)?,
+                    self.io_get_bucket_path(RUSTFS_META_TMP_BUCKET)?,
+                    self.io_get_object_path(volume, object)?,
+                    None,
+                )
+            }
+        };
        let metadata_owner = os::acquire_metadata_mutation_lease(&object_path, namespace_owner).await;
        let volume_guard = os::disk_volume_mutation_lock(&self.root, volume).read_owned().await;
        let owner: Option<Arc<dyn Send + Sync>> = Some(Arc::new((metadata_owner, volume_guard)));
@@ -3167,61 +3123,56 @@ impl LocalDisk {
            let recovery_committed = format!("{RECOVERY_DELETE_DATA_DIR_MARKER_PREFIX}{transaction}");
            let reserved = format!("{RESERVED_DELETE_DATA_DIR_MARKER_PREFIX}{transaction}");
            let mut had_physical_data_dirs = false;
-            let fast_cleanup = cached_journal_raw.is_some();
-            if cached_had_old_data_dir != Some(false) {
-                let bases: &[&Path] = if fast_cleanup { &[&root] } else { &[&root, &rollback] };
-                for data_dir in &data_dirs {
-                    for base in bases {
-                        let dir_path = base.join(data_dir.to_string());
-                        match std::fs::read_dir(&dir_path) {
-                            Ok(entries) => {
-                                had_physical_data_dirs = true;
-                                let mut removable = Vec::new();
-                                let mut preserve_dir = false;
-                                for entry in recovery_entries(entries, work_budget.as_deref()) {
-                                    let entry = entry?;
-                                    let name = entry.file_name();
-                                    let Some(name) = name.to_str() else {
-                                        preserve_dir = true;
-                                        continue;
-                                    };
-                                    if entry.file_type()?.is_file()
-                                        && (delete_recovery_part_file(name)
-                                            || name == committed
-                                            || name == recovery_committed
-                                            || name == reserved
-                                            || is_delete_transaction_marker(name, RESERVED_DELETE_DATA_DIR_MARKER_PREFIX))
-                                    {
-                                        removable.push(entry.path());
-                                    } else {
-                                        preserve_dir = true;
-                                    }
-                                }
-                                for path in removable {
-                                    ignore_not_found(std::fs::remove_file(path))?;
-                                }
-                                let mut dir_removed = false;
-                                if !preserve_dir {
-                                    match std::fs::remove_dir(&dir_path) {
-                                        Ok(()) => dir_removed = true,
-                                        Err(err) if err.kind() == ErrorKind::NotFound => dir_removed = true,
-                                        Err(err) if is_dir_not_empty_error(&err) => {}
-                                        Err(err) => return Err(err),
-                                    }
-                                }
-                                if !dir_removed && sync {
-                                    os::fsync_dir_std(&dir_path)?;
+            for data_dir in &data_dirs {
+                for base in [&root, &rollback] {
+                    let dir_path = base.join(data_dir.to_string());
+                    match std::fs::read_dir(&dir_path) {
+                        Ok(entries) => {
+                            had_physical_data_dirs = true;
+                            let mut removable = Vec::new();
+                            let mut preserve_dir = false;
+                            for entry in recovery_entries(entries, work_budget.as_deref()) {
+                                let entry = entry?;
+                                let name = entry.file_name();
+                                let Some(name) = name.to_str() else {
+                                    preserve_dir = true;
+                                    continue;
+                                };
+                                if entry.file_type()?.is_file()
+                                    && (delete_recovery_part_file(name)
+                                        || name == committed
+                                        || name == recovery_committed
+                                        || name == reserved
+                                        || is_delete_transaction_marker(name, RESERVED_DELETE_DATA_DIR_MARKER_PREFIX))
+                                {
+                                    removable.push(entry.path());
+                                } else {
+                                    preserve_dir = true;
+                                }
+                            }
+                            for path in removable {
+                                ignore_not_found(std::fs::remove_file(path))?;
+                            }
+                            if sync {
+                                os::fsync_dir_std(&dir_path)?;
+                            }
+                            if !preserve_dir {
+                                match std::fs::remove_dir(&dir_path) {
+                                    Ok(()) => {}
+                                    Err(err) if err.kind() == ErrorKind::NotFound || is_dir_not_empty_error(&err) => {}
+                                    Err(err) => return Err(err),
                                }
                            }
-                            Err(err) if err.kind() == ErrorKind::NotFound => {}
-                            Err(err) => return Err(err),
                        }
+                        Err(err) if err.kind() == ErrorKind::NotFound => {}
+                        Err(err) => return Err(err),
                    }
                }
            }
            if had_physical_data_dirs && sync && root.is_dir() {
                os::fsync_dir_std(&root)?;
            }
+            let fast_cleanup = cached_journal_raw.is_some();
            if fast_cleanup {
                let backup_or_marker = if has_original {
                    Some(STORAGE_FORMAT_FILE_BACKUP)
@@ -3270,15 +3221,12 @@ impl LocalDisk {
                    }
                }
            }
-            let rollback_sync = rollback_dir_fd.take();
-            if sync && let Err(err) = os::fsync_directory_handle_std(&rollback, rollback_sync.as_deref()) {
-                drop(rollback_sync);
+            if sync && let Err(err) = os::fsync_dir_std(&rollback) {
                if has_target || had_physical_data_dirs {
                    let _ = persist_receipt(true);
                }
                return Err(err);
            }
-            drop(rollback_sync);
            #[cfg(all(any(test, feature = "test-util"), not(windows)))]
            os::prepared_publication_test_hooks::run(os::prepared_publication_test_hooks::Stage::Remove, &receipt_path);
            if let Err(err) = ignore_not_found(std::fs::remove_file(&receipt_path)) {
@@ -619,6 +619,10 @@ pub(crate) mod prepare_rename_test_hooks {
        }
    }

+    pub(crate) fn has_after_component_opened() -> bool {
+        !AFTER_COMPONENT_OPENED.lock().is_empty()
+    }
+
    /// Hooks keyed by a directory component name, run before a Windows
    /// directory pin retries a transient sharing conflict on it.
    #[cfg(windows)]
@@ -1288,28 +1292,6 @@ pub(crate) fn fsync_dir_limited_std(dir: &Path) -> io::Result<()> {
    fsync_dir_std(dir)
 }

-pub(crate) fn fsync_commit_ancestor_directory_limited_std(
-    dir: &Path,
-    base_dir: &Path,
-    step_from_destination: usize,
-    guard: &RenameCommitGuard,
-) -> io::Result<()> {
-    #[cfg(target_os = "linux")]
-    if base_dir == guard.directories.destination_base
-        && guard.directories.destination_path.ancestors().nth(1 + step_from_destination) == Some(dir)
-        && let Some(ancestors) = guard.directories.destination_ancestors.get()
-        && let Some(idx) = ancestors.len().checked_sub(1 + step_from_destination)
-        && let Some(file) = ancestors.get(idx)
-    {
-        #[cfg(test)]
-        fsync_dir_recorder::record_limited(dir);
-        return fsync_directory_handle_std(dir, Some(file));
-    }
-    #[cfg(not(target_os = "linux"))]
-    let _ = (base_dir, step_from_destination, guard);
-    fsync_dir_limited_std(dir)
-}
-
 /// Reuse the published directory without bypassing group commit or sync admission.
 pub(crate) async fn fsync_commit_directory(
    dir: &Path,
@@ -6014,7 +5996,6 @@ struct LinuxCommitDirectories {
    destination_path: PathBuf,
    source: LinuxCommitDirectory,
    destination: std::sync::OnceLock<LinuxCommitDirectory>,
-    destination_ancestors: std::sync::OnceLock<Vec<std::fs::File>>,
    destination_base: PathBuf,
 }

@@ -6031,8 +6012,6 @@ impl LinuxCommitDirectories {
                .ok_or_else(|| io::Error::other("missing destination directory guard"))?,
        );
        let directory = LinuxCommitDirectory::new(directory)?;
-        let ancestors = parents.into_iter().map(std::fs::File::from).collect();
-        let _ = self.destination_ancestors.set(ancestors);
        Ok(self.destination.get_or_init(|| directory))
    }

@@ -6042,7 +6021,7 @@ impl LinuxCommitDirectories {
            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "file parent does not match its commit guard"))
    }

-    fn validate(&self, check_destination: bool) -> io::Result<()> {
+    fn validate(&self) -> io::Result<()> {
        use std::os::unix::fs::MetadataExt;
        // A pinned directory may have been unlinked or replaced. Do not report a
        // successful publication into a detached object tree.
@@ -6051,9 +6030,8 @@ impl LinuxCommitDirectories {
            return Err(io::Error::new(io::ErrorKind::InvalidData, "commit directory identity changed"));
        }
        let destination = self.prepare_destination()?;
-        if check_destination
-            && ((self.source.device, self.source.inode) != (destination.device, destination.inode)
-                || self.source_path.as_os_str() != self.destination_path.as_os_str())
+        if (self.source.device, self.source.inode) != (destination.device, destination.inode)
+            || self.source_path.as_os_str() != self.destination_path.as_os_str()
        {
            let current = self.root.open_directory(&self.destination_path)?.metadata()?;
            if (current.dev(), current.ino()) != (destination.device, destination.inode) {
@@ -6067,9 +6045,8 @@ impl LinuxCommitDirectories {
        record_native_publication(destination);
        let source_name = self.file_name(source, true)?;
        let destination_name = self.file_name(destination, false)?;
-        let destination_was_prepared = self.destination.get().is_some();
        let destination_parent = self.prepare_destination()?;
-        self.validate(destination_was_prepared)?;
+        self.validate()?;
        let mut attempt = 0;
        loop {
            if let Some(prepared) = prepared {
@@ -6291,7 +6268,7 @@ pub(crate) fn multipart_payload_commit_guard_std(
    source_parent: &Path,
 ) -> io::Result<RenameCommitGuard> {
    let original = &metadata_guard.directories;
-    original.validate(true)?;
+    original.validate()?;
    let source = LinuxCommitDirectory::new(original.root.open_directory(source_parent)?)?;
    let destination = original.prepare_destination()?;
    // Clone the pinned file identity, never recapture the target pathname
@@ -6308,7 +6285,6 @@ pub(crate) fn multipart_payload_commit_guard_std(
            destination_path: original.destination_path.clone(),
            source,
            destination: std::sync::OnceLock::from(destination),
-            destination_ancestors: std::sync::OnceLock::new(),
            destination_base: original.destination_base.clone(),
        }),
    })
@@ -6390,7 +6366,6 @@ pub(crate) fn prepare_rename_commit_guard(
                destination_path: destination_parent.to_path_buf(),
                source,
                destination,
-                destination_ancestors: std::sync::OnceLock::new(),
                destination_base: destination_base.to_path_buf(),
            }),
        })
@@ -7500,7 +7475,6 @@ fn same_parent_commit_guard(
                    device: dir.device,
                    inode: dir.inode,
                }),
-                destination_ancestors: std::sync::OnceLock::new(),
                destination_base: base.to_path_buf(),
            }),
        });
@@ -8540,7 +8514,37 @@ pub(crate) fn mkdir_all_below_existing_base_std(
        let flags = OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC;
        let mode = Mode::RWXU | Mode::RWXG | Mode::RWXO;
        #[cfg(target_os = "linux")]
-        let base = publication_root.open_directory(base_dir)?.into();
+        let base = {
+            use rustix::fs::{ResolveFlags, openat2};
+            use std::os::fd::AsFd;
+
+            let owned_base = (base_dir != publication_root.io_path.as_path() && base_dir != publication_root.path.as_path())
+                .then(|| publication_root.open_directory(base_dir).map(std::os::fd::OwnedFd::from))
+                .transpose()?;
+            #[cfg(test)]
+            let has_hook = prepare_rename_test_hooks::has_after_component_opened();
+            #[cfg(not(test))]
+            let has_hook = false;
+            if !has_hook {
+                let base_fd = owned_base
+                    .as_ref()
+                    .map_or_else(|| publication_root.directory.as_fd(), AsFd::as_fd);
+                let target = if relative.as_os_str().is_empty() {
+                    Path::new(".")
+                } else {
+                    relative
+                };
+                match openat2(base_fd, target, flags, Mode::empty(), ResolveFlags::BENEATH | ResolveFlags::NO_SYMLINKS) {
+                    Ok(leaf) => return Ok(vec![leaf]),
+                    Err(Errno::NOENT | Errno::NOSYS) => {}
+                    Err(err) => return Err(err.into()),
+                }
+            }
+            match owned_base {
+                Some(base) => base,
+                None => publication_root.open_directory(base_dir)?.into(),
+            }
+        };
        #[cfg(not(target_os = "linux"))]
        let base = {
            // The configured endpoint is trusted; every component beneath it
@@ -1873,123 +1873,4 @@ mod tests {
        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
        assert!(err.to_string().contains("invalid checksum value"), "unexpected error: {err}");
    }
-
-    fn software_crc32_bitwise(reflected_poly: u32, data: &[u8]) -> [u8; 4] {
-        let mut crc = !0u32;
-        for &b in data {
-            crc ^= u32::from(b);
-            for _ in 0..8 {
-                let mask = (crc & 1).wrapping_neg();
-                crc = (crc >> 1) ^ (reflected_poly & mask);
-            }
-        }
-        (!crc).to_be_bytes()
-    }
-
-    fn software_crc64_nvme_bitwise(data: &[u8]) -> [u8; 8] {
-        let reflected_poly = super::CRC64_NVME_POLYNOMIAL.reverse_bits();
-        let mut crc = !0u64;
-        for &b in data {
-            crc ^= u64::from(b);
-            for _ in 0..8 {
-                let mask = (crc & 1).wrapping_neg();
-                crc = (crc >> 1) ^ (reflected_poly & mask);
-            }
-        }
-        (!crc).to_be_bytes()
-    }
-
-    #[test]
-    fn rio_crc_simd_matches_bitwise_scalar_across_tail_and_vector_boundaries() {
-        for &size in &[
-            0usize,
-            1,
-            7,
-            8,
-            15,
-            16,
-            17,
-            31,
-            32,
-            33,
-            63,
-            64,
-            65,
-            127,
-            128,
-            129,
-            255,
-            256,
-            257,
-            1024,
-            4096 + 17,
-            64 * 1024,
-        ] {
-            let payload: Vec<u8> = (0..size).map(|i| ((i * 31 + 17) % 251) as u8).collect();
-            let crc32_simd = Checksum::new_from_data(ChecksumType::CRC32, &payload).expect("crc32");
-            let crc32c_simd = Checksum::new_from_data(ChecksumType::CRC32C, &payload).expect("crc32c");
-            let crc64_simd = Checksum::new_from_data(ChecksumType::CRC64_NVME, &payload).expect("crc64nvme");
-
-            let crc32_sw = software_crc32_bitwise(0xEDB88320, &payload);
-            let crc32c_sw = software_crc32_bitwise(0x82F63B78, &payload);
-            let crc64_sw = software_crc64_nvme_bitwise(&payload);
-
-            assert_eq!(crc32_simd.raw.as_slice(), &crc32_sw, "CRC32 SIMD vs scalar mismatch at {size}B");
-            assert_eq!(crc32c_simd.raw.as_slice(), &crc32c_sw, "CRC32C SIMD vs scalar mismatch at {size}B");
-            assert_eq!(crc64_simd.raw.as_slice(), &crc64_sw, "CRC64_NVME SIMD vs scalar mismatch at {size}B");
-        }
-    }
-
-    #[test]
-    #[ignore = "utility throughput microbenchmark; run via cargo test -p rustfs-rio --lib --release -- --ignored --nocapture"]
-    fn microbench_rio_checksum_simd_vs_scalar_and_all_base_algorithms() {
-        use std::hint::black_box;
-        use std::io::Write as _;
-        use std::time::Instant;
-
-        for &(size, iters) in &[(1024usize, 100usize), (64 * 1024, 20), (1024 * 1024, 4)] {
-            let payload: Vec<u8> = (0..size).map(|i| ((i * 31 + 17) % 251) as u8).collect();
-            let total_mib = (size * iters) as f64 / (1024.0 * 1024.0);
-
-            // Verify SIMD-accelerated CRC32 / CRC32C / CRC64_NVME against bitwise scalar reference at 1 KiB & 64 KiB.
-            if size <= 64 * 1024 {
-                let crc32_simd = Checksum::new_from_data(ChecksumType::CRC32, &payload).expect("crc32");
-                let crc32c_simd = Checksum::new_from_data(ChecksumType::CRC32C, &payload).expect("crc32c");
-                let crc64_simd = Checksum::new_from_data(ChecksumType::CRC64_NVME, &payload).expect("crc64nvme");
-
-                let t_sw = Instant::now();
-                let crc32_sw = software_crc32_bitwise(0xEDB88320, black_box(&payload));
-                let crc32c_sw = software_crc32_bitwise(0x82F63B78, black_box(&payload));
-                let crc64_sw = software_crc64_nvme_bitwise(black_box(&payload));
-                let sw_elapsed = t_sw.elapsed();
-
-                assert_eq!(crc32_simd.raw.as_slice(), &crc32_sw, "CRC32 SIMD vs scalar mismatch at {size}B");
-                assert_eq!(crc32c_simd.raw.as_slice(), &crc32c_sw, "CRC32C SIMD vs scalar mismatch at {size}B");
-                assert_eq!(crc64_simd.raw.as_slice(), &crc64_sw, "CRC64_NVME SIMD vs scalar mismatch at {size}B");
-                println!(
-                    "[microbench][rio::checksum] size={size}B bitwise scalar reference check passed in {:?}",
-                    sw_elapsed
-                );
-            }
-
-            for &checksum_type in super::BASE_CHECKSUM_TYPES {
-                let mut hasher = checksum_type.hasher().expect("base checksum type must have hasher");
-                let t0 = Instant::now();
-                let mut digest = Vec::new();
-                for _ in 0..iters {
-                    hasher.reset();
-                    hasher.write_all(black_box(&payload)).expect("hasher write_all");
-                    digest = hasher.finalize();
-                    black_box(&digest);
-                }
-                let elapsed = t0.elapsed();
-                assert_eq!(digest.len(), checksum_type.raw_byte_len());
-                let mibs = total_mib / elapsed.as_secs_f64().max(1e-9);
-                println!(
-                    "[microbench][rio::checksum] size={size}B algo={} throughput={mibs:.1} MiB/s",
-                    checksum_type
-                );
-            }
-        }
-    }
 }
@@ -735,166 +735,4 @@ mod tests {
            }
        }
    }
-
-    #[test]
-    fn highwayhash_simd_matches_portable_scalar_and_chunked_slices_across_unaligned_boundaries() {
-        use highway::PortableHash;
-
-        for &size in &[
-            0usize,
-            1,
-            7,
-            15,
-            31,
-            32,
-            33,
-            63,
-            64,
-            65,
-            127,
-            128,
-            129,
-            255,
-            257,
-            1024,
-            4096 + 17,
-            64 * 1024,
-        ] {
-            let payload = generate_compat_test_data(size);
-
-            let mut h_simd = HighwayHasher::new(MAGIC_HIGHWAY_HASH256_PARSED_KEY);
-            h_simd.append(&payload);
-            let simd_digest = u8x32_from_u64x4(h_simd.finalize256());
-
-            let mut h_scalar = PortableHash::new(MAGIC_HIGHWAY_HASH256_PARSED_KEY);
-            h_scalar.append(&payload);
-            let scalar_digest = u8x32_from_u64x4(h_scalar.finalize256());
-
-            assert_eq!(
-                simd_digest, scalar_digest,
-                "HighwayHasher SIMD must match PortableHash scalar byte-for-byte at {size}B"
-            );
-
-            for &chunk_size in &[17usize, 61, 4096] {
-                if size > 4096 && chunk_size < 61 {
-                    continue;
-                }
-                let slices: Vec<&[u8]> = payload.chunks(chunk_size).collect();
-                for algo in [
-                    HashAlgorithm::HighwayHash256S,
-                    HashAlgorithm::HighwayHash256SLegacy,
-                    HashAlgorithm::SHA256,
-                    HashAlgorithm::BLAKE2b512,
-                    HashAlgorithm::Md5,
-                ] {
-                    let contig_out = algo.hash_encode(&payload);
-                    let sliced_out = algo.hash_encode_slices(slices.iter().copied());
-                    assert_eq!(
-                        contig_out.as_ref(),
-                        sliced_out.as_ref(),
-                        "{algo:?} contiguous vs {chunk_size}B sliced digest mismatch at {size}B"
-                    );
-                }
-            }
-        }
-    }
-
-    #[test]
-    #[ignore = "utility throughput microbenchmark; run via cargo test -p rustfs-utils --lib --features hash --release -- --ignored --nocapture"]
-    fn microbench_highwayhash_simd_vs_portable_scalar_and_hash_algorithms() {
-        use highway::PortableHash;
-        use std::hint::black_box;
-        use std::time::Instant;
-
-        for &(size, iters) in &[(1024usize, 200usize), (64 * 1024, 40), (1024 * 1024, 8)] {
-            let payload = generate_compat_test_data(size);
-
-            // 1. Compare HighwayHasher (runtime SIMD: AVX2/SSE4.1/NEON) against PortableHash scalar reference.
-            let t_simd = Instant::now();
-            let mut simd_digest = [0u8; 32];
-            for _ in 0..iters {
-                let mut h = HighwayHasher::new(MAGIC_HIGHWAY_HASH256_PARSED_KEY);
-                h.append(black_box(&payload));
-                simd_digest = u8x32_from_u64x4(h.finalize256());
-                black_box(&simd_digest);
-            }
-            let simd_elapsed = t_simd.elapsed();
-
-            let t_scalar = Instant::now();
-            let mut scalar_digest = [0u8; 32];
-            for _ in 0..iters {
-                let mut h = PortableHash::new(MAGIC_HIGHWAY_HASH256_PARSED_KEY);
-                h.append(black_box(&payload));
-                scalar_digest = u8x32_from_u64x4(h.finalize256());
-                black_box(&scalar_digest);
-            }
-            let scalar_elapsed = t_scalar.elapsed();
-
-            assert_eq!(
-                simd_digest, scalar_digest,
-                "HighwayHasher SIMD must match PortableHash scalar byte-for-byte at {size}B"
-            );
-            let total_mib = (size * iters) as f64 / (1024.0 * 1024.0);
-            let simd_mibs = total_mib / simd_elapsed.as_secs_f64().max(1e-9);
-            let scalar_mibs = total_mib / scalar_elapsed.as_secs_f64().max(1e-9);
-            println!(
-                "[microbench][utils::hash] size={size}B HighwayHash256S SIMD={simd_mibs:.1} MiB/s vs PortableScalar={scalar_mibs:.1} MiB/s (speedup={:.2}x)",
-                simd_mibs / scalar_mibs.max(1e-9)
-            );
-
-            // 2. Compare contiguous hash_encode vs 4 KiB chunked hash_encode_slices across all bitrot algorithms.
-            let slices: Vec<&[u8]> = payload.chunks(4096).collect();
-            for algo in [
-                HashAlgorithm::HighwayHash256S,
-                HashAlgorithm::HighwayHash256SLegacy,
-                HashAlgorithm::SHA256,
-                HashAlgorithm::BLAKE2b512,
-                HashAlgorithm::Md5,
-            ] {
-                let t_contig = Instant::now();
-                let mut contig_out = Vec::new();
-                for _ in 0..iters {
-                    contig_out = algo.hash_encode(black_box(&payload)).as_ref().to_vec();
-                    black_box(&contig_out);
-                }
-                let contig_elapsed = t_contig.elapsed();
-
-                let t_sliced = Instant::now();
-                let mut sliced_out = Vec::new();
-                for _ in 0..iters {
-                    sliced_out = algo.hash_encode_slices(black_box(slices.iter().copied())).as_ref().to_vec();
-                    black_box(&sliced_out);
-                }
-                let sliced_elapsed = t_sliced.elapsed();
-
-                assert_eq!(contig_out, sliced_out, "{algo:?} contiguous vs 4KiB sliced digest mismatch at {size}B");
-                let contig_mibs = total_mib / contig_elapsed.as_secs_f64().max(1e-9);
-                let sliced_mibs = total_mib / sliced_elapsed.as_secs_f64().max(1e-9);
-                println!(
-                    "[microbench][utils::hash] size={size}B algo={algo:?} contiguous={contig_mibs:.1} MiB/s vs sliced(4KiB)={sliced_mibs:.1} MiB/s"
-                );
-            }
-        }
-
-        // 3. Key-routing microbenchmark: crc_hash (CRC32) vs sip_hash (SipHash-1-3).
-        let keys: Vec<String> = (0..1024)
-            .map(|i| format!("bucket/prefix-{i}/object-key-{i}.parquet"))
-            .collect();
-        let t_crc = Instant::now();
-        let mut crc_acc = 0usize;
-        for key in &keys {
-            crc_acc ^= crc_hash(black_box(key), 16);
-        }
-        let crc_ns = t_crc.elapsed().as_nanos();
-
-        let t_sip = Instant::now();
-        let mut sip_acc = 0usize;
-        for key in &keys {
-            sip_acc ^= sip_hash(black_box(key), 16, &[0u8; 16]);
-        }
-        black_box(sip_acc);
-        let sip_ns = t_sip.elapsed().as_nanos();
-        assert!(black_box(crc_acc) < 16 && black_box(sip_acc) < 16);
-        println!("[microbench][utils::hash] 1024 object keys: crc_hash={crc_ns}ns total, sip_hash={sip_ns}ns total");
-    }
 }
@@ -101,7 +101,6 @@ Scheduled lanes never block a PR. Their workflow-local gate fails the run. The v
 | `coverage.yml` (weekly) | `coverage` | report-only trend; lcov and JSON artifact | yes (disabled) | `make coverage` |
 | `runner-hygiene.yml` (monthly) | `check-ephemerality` | runner ephemerality | yes | dispatch |
 | `e2e-upgrade.yml` (weekly, and on version tags) | `upgrade` (serial cases sharing one harness build) | upgrade and rollback gate; server logs | yes | `python3 scripts/e2e_binary.py build`, then the job's `python3 scripts/e2e_binary.py run -- cargo test --locked -p e2e_test` commands with `RUSTFS_UPGRADE_SOURCE_BINARY` pointing at the pinned previous release (`UPGRADE_SOURCE_VERSION`) |
-| `reference-parity.yml` (nightly, and on PRs that change the lane's own files) | `plan`, `build-candidate`, `s3tests` (one job per target in `.config/reference-parity-targets.toml`), `compare` | report-only parity gate: fails on any per-node-id s3-tests difference between a branch candidate and the release pinned in `.config/reference-binary.toml` that `.config/reference-parity-tolerated.txt` does not list, and on a stale tolerated entry; per-target JUnit, logs and `diff.md`/`diff.json` | yes | `DEPLOY_MODE=binary RUSTFS_BINARY=<binary> MAXFAIL=0 XDIST=4 ./scripts/s3-tests/run.sh` once per target, then `python3 scripts/s3-tests/reference_parity.py compare` as in the `compare` job |
 | `oidc-keycloak.yml` (weekly) | `oidc-keycloak-live` | live OIDC gate | yes | see the PR row |
 | `targets-integration.yml` (nightly) | `targets-live` | live target gate; container logs | yes (disabled) | see the PR row |
 | `gateway-integration-sync.yml` (weekdays) | `sync` | merges `main` into `gateway/integration` as a `--no-ff` merge commit; a conflicting merge is aborted and opens a `sync/<source>-<date>` pull request listing the conflicting files, which keeps the run green; a rejected push or missing pull request fails it | yes | dispatch, optionally with `source_ref` |
@@ -254,15 +254,11 @@ impl DefaultAdminUsecase {
    /// absent from `buckets_usage` — absent already means "unknown" on the
    /// wire, distinct from a present zero — and the snapshot is marked
    /// non-converged so clients can tell it is not the whole namespace. A
-    /// snapshot that is structurally incomplete (`snapshot_measured` is false),
-    /// or that measured nothing the namespace still contains, carries no usable
-    /// information and is dropped exactly as before.
-    fn narrow_data_usage_snapshot_to_measured_buckets(
-        info: &mut DataUsageInfo,
-        snapshot_measured: bool,
-        buckets: impl IntoIterator<Item = String>,
-    ) {
-        if !snapshot_measured {
+    /// snapshot that is structurally incomplete, or that measured nothing the
+    /// namespace still contains, carries no usable information and is dropped
+    /// exactly as before.
+    fn narrow_data_usage_snapshot_to_measured_buckets(info: &mut DataUsageInfo, buckets: impl IntoIterator<Item = String>) {
+        if !info.is_complete_bucket_usage_snapshot() && !info.is_valid_partial_snapshot() {
            *info = DataUsageInfo::default();
            return;
        }
@@ -279,31 +275,13 @@ impl DefaultAdminUsecase {

        let covers_namespace = current_buckets.len() == info.buckets_usage.len();
        info.buckets_count = info.buckets_usage.len() as u64;
-        if !covers_namespace || !info.is_complete_bucket_usage_snapshot() {
-            // Some bucket in the namespace was never measured, or holds
-            // mutations no scan has reconciled yet, so the totals below are
-            // not the converged truth.
+        if !covers_namespace {
+            // Some bucket in the namespace was never measured, so the totals
+            // below are a floor rather than the converged truth.
            info.usage_snapshot_converged = Some(false);
        }
    }

-    /// Overlay single-process counts on a persisted snapshot and narrow it
-    /// for display.
-    ///
-    /// Whether the snapshot measured anything is decided before the overlay.
-    /// The overlay clears `usage_snapshot_complete` when it holds counts it
-    /// cannot reconcile with the snapshot, such as writes into a bucket that
-    /// has no verified baseline. That makes the totals unconverged, not the
-    /// scanned buckets unusable; treating it as structural incompleteness
-    /// blanked usage for every bucket for as long as one such bucket kept
-    /// receiving writes, because each write restarts its scanner fence.
-    async fn present_data_usage_snapshot(mut info: DataUsageInfo, buckets: impl IntoIterator<Item = String>) -> DataUsageInfo {
-        let snapshot_measured = info.is_complete_bucket_usage_snapshot() || info.is_valid_partial_snapshot();
-        apply_bucket_usage_memory_overlay(&mut info).await;
-        Self::narrow_data_usage_snapshot_to_measured_buckets(&mut info, snapshot_measured, buckets);
-        info
-    }
-
    async fn rebalance_status_snapshot(store: &ECStore) -> AdminUsecaseResult<Option<RebalanceMeta>> {
        store.rebalance_status_meta_snapshot().await.map_err(|err| {
            error!("refresh rebalance metadata for pool status failed: {:?}", err);
@@ -345,7 +323,8 @@ impl DefaultAdminUsecase {
    /// This path never triggers a live full-version listing
    /// (rustfs/backlog#1306); freshness is owned by the scanner.
    pub(crate) async fn query_data_usage_info_with_store(store: Arc<ECStore>) -> AdminUsecaseResult<DataUsageInfo> {
-        let info = Self::map_data_usage_load_result(load_admin_data_usage_from_backend_cached(store.clone()).await)?;
+        let mut info = Self::map_data_usage_load_result(load_admin_data_usage_from_backend_cached(store.clone()).await)?;
+        apply_bucket_usage_memory_overlay(&mut info).await;
        let buckets = store
            .list_bucket(&BucketOptions {
                cached: true,
@@ -354,7 +333,11 @@ impl DefaultAdminUsecase {
            })
            .await
            .map_err(|_| Self::app_error(S3ErrorCode::InternalError, "list_bucket failed"))?;
-        let mut info = Self::present_data_usage_snapshot(info, buckets.into_iter().map(|bucket| bucket.name)).await;
+        // Serve what the scan measured; buckets it never reached stay absent
+        // (absent means unknown on the wire, unlike a present zero) and the
+        // snapshot is flagged non-converged. See rustfs#5806 for why blanking
+        // the whole document instead was worse than the rule it enforced.
+        Self::narrow_data_usage_snapshot_to_measured_buckets(&mut info, buckets.into_iter().map(|bucket| bucket.name));

        let storage_info = StorageAdminApi::storage_info(store.as_ref()).await;

@@ -893,12 +876,6 @@ mod tests {
        });
    }

-    /// Narrow a snapshot no overlay has touched, judging it as persisted.
-    fn narrow_persisted_snapshot(info: &mut DataUsageInfo, buckets: impl IntoIterator<Item = String>) {
-        let snapshot_measured = info.is_complete_bucket_usage_snapshot() || info.is_valid_partial_snapshot();
-        DefaultAdminUsecase::narrow_data_usage_snapshot_to_measured_buckets(info, snapshot_measured, buckets);
-    }
-
    /// rustfs#5806: a bucket the last scan never reached must not blank the
    /// usage the scan *did* measure — that turned every bucket creation into a
    /// deployment-wide usage blackout until the next cycle.
@@ -920,7 +897,10 @@ mod tests {
        // A brand-new bucket the scan never saw: keep bucket-a, omit bucket-new,
        // and say so via the convergence flag.
        let mut info = measured("bucket-a");
-        narrow_persisted_snapshot(&mut info, ["bucket-a".to_string(), "bucket-new".to_string(), ".rustfs.sys".to_string()]);
+        DefaultAdminUsecase::narrow_data_usage_snapshot_to_measured_buckets(
+            &mut info,
+            ["bucket-a".to_string(), "bucket-new".to_string(), ".rustfs.sys".to_string()],
+        );
        assert!(info.buckets_usage.contains_key("bucket-a"), "measured usage must survive");
        assert!(!info.buckets_usage.contains_key("bucket-new"), "unmeasured bucket stays absent");
        assert_eq!(info.usage_snapshot_converged, Some(false));
@@ -929,19 +909,22 @@ mod tests {

        // Full coverage leaves the snapshot untouched.
        let mut info = measured("bucket-a");
-        narrow_persisted_snapshot(&mut info, ["bucket-a".to_string(), ".rustfs.sys".to_string()]);
+        DefaultAdminUsecase::narrow_data_usage_snapshot_to_measured_buckets(
+            &mut info,
+            ["bucket-a".to_string(), ".rustfs.sys".to_string()],
+        );
        assert_eq!(info.usage_snapshot_converged, None, "a covering snapshot is not downgraded");
        assert_eq!(info.buckets_count, 1);

        // A bucket deleted since the scan must not linger in the response.
        let mut info = measured("bucket-gone");
-        narrow_persisted_snapshot(&mut info, ["bucket-live".to_string()]);
+        DefaultAdminUsecase::narrow_data_usage_snapshot_to_measured_buckets(&mut info, ["bucket-live".to_string()]);
        assert_eq!(info, DataUsageInfo::default(), "nothing measured is still in the namespace");

        // Structurally incomplete snapshots carry no usable information.
        let mut info = measured("bucket-a");
        info.usage_snapshot_complete = false;
-        narrow_persisted_snapshot(&mut info, ["bucket-a".to_string()]);
+        DefaultAdminUsecase::narrow_data_usage_snapshot_to_measured_buckets(&mut info, ["bucket-a".to_string()]);
        assert_eq!(info, DataUsageInfo::default());

        // A structurally valid partial admin view can still carry useful
@@ -962,7 +945,7 @@ mod tests {
            tombstone: false,
            segment_invalidation_proof: None,
        }];
-        narrow_persisted_snapshot(&mut info, ["bucket-a".to_string()]);
+        DefaultAdminUsecase::narrow_data_usage_snapshot_to_measured_buckets(&mut info, ["bucket-a".to_string()]);
        assert_eq!(info.usage_snapshot_converged, Some(false));
        assert_eq!(info.buckets_count, 1);
        assert_eq!(info.objects_total_count, 7);
@@ -974,63 +957,11 @@ mod tests {
            buckets_count: 0,
            ..Default::default()
        };
-        narrow_persisted_snapshot(&mut info, [".rustfs.sys".to_string()]);
+        DefaultAdminUsecase::narrow_data_usage_snapshot_to_measured_buckets(&mut info, [".rustfs.sys".to_string()]);
        assert_eq!(info.usage_snapshot_converged, None);
        assert_eq!(info.buckets_count, 0);
    }

-    /// A write into a bucket without a verified baseline leaves process-local
-    /// counts the overlay cannot reconcile, so it clears
-    /// `usage_snapshot_complete`. That must flag the response non-converged,
-    /// not erase every bucket the persisted scan measured: under continuous
-    /// writes the scanner fence never clears and the blackout never ends.
-    #[tokio::test]
-    async fn unverified_bucket_writes_do_not_blank_measured_usage() {
-        let measured_bucket = "admin-usage-measured";
-        let unverified_bucket = "admin-usage-unverified";
-        let mut persisted = DataUsageInfo {
-            last_update: Some(std::time::SystemTime::now() - std::time::Duration::from_secs(60)),
-            usage_snapshot_complete: true,
-            buckets_count: 1,
-            ..Default::default()
-        };
-        persisted.buckets_usage.insert(
-            measured_bucket.to_string(),
-            rustfs_data_usage::BucketUsageInfo {
-                objects_count: 4_000,
-                versions_count: 4_000,
-                size: 8_192_000,
-                ..Default::default()
-            },
-        );
-        persisted.bucket_sizes.insert(measured_bucket.to_string(), 8_192_000);
-        persisted.calculate_totals();
-        assert!(persisted.is_complete_bucket_usage_snapshot());
-
-        crate::app::storage_api::test::data_usage::record_bucket_object_write_memory(unverified_bucket, None, 1_024).await;
-
-        let info = DefaultAdminUsecase::present_data_usage_snapshot(
-            persisted,
-            [measured_bucket.to_string(), unverified_bucket.to_string()],
-        )
-        .await;
-
-        assert_eq!(
-            info.buckets_usage
-                .get(measured_bucket)
-                .map(|usage| (usage.objects_count, usage.size)),
-            Some((4_000, 8_192_000)),
-            "usage the scanner measured must survive an unrelated unverified bucket"
-        );
-        assert!(
-            !info.buckets_usage.contains_key(unverified_bucket),
-            "a bucket without a verified baseline stays absent (unknown)"
-        );
-        assert_eq!(info.usage_snapshot_converged, Some(false));
-        assert!(!info.is_complete_bucket_usage_snapshot());
-        assert_eq!(info.objects_total_count, 4_000);
-    }
-
    #[tokio::test]
    async fn execute_query_storage_info_returns_internal_error_when_store_uninitialized() {
        let usecase = DefaultAdminUsecase::without_context();
@@ -17,7 +17,6 @@
 use super::*;
 use crate::app::storage_api::object_usecase::DeleteObjectCondition;
 use s3s::dto::ObjectIdentifier;
-use std::borrow::Cow;
 use std::collections::HashSet;

 async fn authorize_recursive_delete<T>(
@@ -82,19 +81,6 @@ async fn authorize_recursive_delete<T>(
    result
 }

-// XML body keys bypass s3s's URL-path normalization. Match its private slash
-// normalizer without URL-decoding or resolving dot segments in client keys.
-fn normalize_delete_object_key(key: &str) -> Cow<'_, str> {
-    if !key.starts_with('/') {
-        return Cow::Borrowed(key);
-    }
-    let mut normalized = key.split('/').filter(|part| !part.is_empty()).collect::<Vec<_>>().join("/");
-    if key.ends_with('/') {
-        normalized.push('/');
-    }
-    Cow::Owned(normalized)
-}
-
 fn successful_delete_audit_objects(
    delete: &s3s::dto::Delete,
    successful_results: impl IntoIterator<Item = bool>,
@@ -104,9 +90,7 @@ fn successful_delete_audit_objects(
        .iter()
        .zip(successful_results)
        .filter(|(_, successful)| *successful)
-        .map(|(requested, _)| {
-            AuditObjectVersion::new(normalize_delete_object_key(&requested.key).into_owned(), requested.version_id.clone())
-        })
+        .map(|(requested, _)| AuditObjectVersion::new(requested.key.clone(), requested.version_id.clone()))
        .collect()
 }

@@ -606,10 +590,7 @@ impl DefaultObjectUsecase {
        // Per-key denials are audited once per denied action, in aggregate, after the loop.
        let mut bulk_denials = crate::storage::access::BulkDenialAudit::start(&mut req)?;
        for (idx, obj_id) in delete.objects.iter().enumerate() {
-            // Authorization and every storage side effect must address the same
-            // normalized object; retain the request key only for response entries.
-            let key = normalize_delete_object_key(&obj_id.key);
-            if let Err(err) = validate_object_key(&key, "DeleteObjects") {
+            if let Err(err) = validate_object_key(&obj_id.key, "DeleteObjects") {
                delete_results[idx].error = Some(s3s::dto::Error {
                    code: Some(err.code().as_str().to_string()),
                    key: Some(obj_id.key.clone()),
@@ -642,7 +623,7 @@ impl DefaultObjectUsecase {
            {
                let req_info = req_info_mut(&mut req)?;
                req_info.bucket = Some(bucket.clone());
-                req_info.object = Some(key.to_string());
+                req_info.object = Some(obj_id.key.clone());
                req_info.version_id = version_id.clone();
            }

@@ -689,7 +670,7 @@ impl DefaultObjectUsecase {
                }
            }

-            if let Err(err) = validate_table_catalog_object_mutation(&bucket, &key).await {
+            if let Err(err) = validate_table_catalog_object_mutation(&bucket, &obj_id.key).await {
                delete_results[idx].error = Some(s3s::dto::Error {
                    code: Some("InvalidRequest".to_string()),
                    key: Some(obj_id.key.clone()),
@@ -699,9 +680,9 @@ impl DefaultObjectUsecase {
                continue;
            }

-            let synthetic_version_id = delete_condition.is_none() && version_id.is_none() && is_dir_object(&key);
+            let synthetic_version_id = delete_condition.is_none() && version_id.is_none() && is_dir_object(&obj_id.key);
            let object = ObjectToDelete {
-                object_name: key.into_owned(),
+                object_name: obj_id.key.clone(),
                version_id: version_uuid,
                delete_condition,
                synthetic_version_id,
@@ -929,16 +910,15 @@ impl DefaultObjectUsecase {
        let deleted = (!delete.quiet.unwrap_or_default()).then(|| {
            delete_results
                .iter()
-                .enumerate()
-                .filter_map(|(idx, result)| result.delete_object.as_ref().map(|object| (idx, result, object)))
-                .map(|(idx, result, object)| DeletedObject {
+                .filter_map(|result| result.delete_object.as_ref().map(|object| (result, object)))
+                .map(|(result, object)| DeletedObject {
                    delete_marker: { if object.delete_marker { Some(true) } else { None } },
                    delete_marker_version_id: delete_marker_response_version_id(
                        object.delete_marker_version_id,
                        object.delete_marker && result.version_suspended && result.requested_version_id.is_none(),
                        result.synthetic_version_id,
                    ),
-                    key: Some(delete.objects[idx].key.clone()),
+                    key: Some(object.object_name.clone()),
                    version_id: delete_entry_response_version_id(
                        object.version_id,
                        object.delete_marker,
@@ -956,12 +936,7 @@ impl DefaultObjectUsecase {

        let errors = delete_results
            .iter()
-            .enumerate()
-            .filter_map(|(idx, result)| {
-                let mut error = result.error.clone()?;
-                error.key = Some(delete.objects[idx].key.clone());
-                Some(error)
-            })
+            .filter_map(|v| v.error.clone())
            .collect::<Vec<s3s::dto::Error>>();
        let output = DeleteObjectsOutput {
            deleted,
@@ -2844,57 +2819,11 @@ mod tests {
        assert_eq!(err.message(), Some("Not init"));
    }

-    #[test]
-    fn delete_objects_key_normalization_matches_s3s_path_keys() {
-        use s3s::path::{
-            parse_path_style_with_validation_and_normalization, parse_virtual_hosted_style_with_validation_and_normalization,
-        };
-        use s3s::validation::AwsNameValidation;
-
-        for key in [
-            "plain",
-            "/a/b",
-            "//a/b",
-            "/dir///sub//file",
-            "/dir///",
-            "/",
-            "///",
-            "dir//file",
-            "/literal%2F+名",
-            "/dir/../file",
-            "/dir/./file",
-            "/dir\\file",
-            "/a\0b",
-        ] {
-            let normalized = normalize_delete_object_key(key);
-            let path = parse_path_style_with_validation_and_normalization(
-                &format!("/test-bucket/{key}"),
-                &AwsNameValidation::new(),
-                true,
-            )
-            .expect("path-style key should parse before storage validation");
-            let virtual_host = parse_virtual_hosted_style_with_validation_and_normalization(
-                Some("test-bucket"),
-                &format!("/{key}"),
-                &AwsNameValidation::new(),
-                true,
-            )
-            .expect("virtual-hosted key should parse before storage validation");
-            assert_eq!(Some(normalized.as_ref()), path.get_object_key(), "path-style mismatch for {key:?}");
-            assert_eq!(
-                Some(normalized.as_ref()),
-                virtual_host.get_object_key(),
-                "virtual-hosted mismatch for {key:?}"
-            );
-        }
-        assert_eq!(normalize_delete_object_key(""), "");
-    }
-
    #[test]
    fn delete_objects_audit_details_include_only_successful_request_entries() {
        let requested = vec![
            ObjectIdentifier {
-                key: "/first-key".to_string(),
+                key: "first-key".to_string(),
                version_id: None,
                ..Default::default()
            },
@@ -2904,7 +2833,7 @@ mod tests {
                ..Default::default()
            },
            ObjectIdentifier {
-                key: "//versioned-key".to_string(),
+                key: "versioned-key".to_string(),
                version_id: Some("requested-version".to_string()),
                ..Default::default()
            },
@@ -14460,8 +14460,8 @@ fn object_mutation_entrypoints_call_reserved_prefix_guard() {
    assert_ordered(
        method(delete, "fn execute_delete_objects_owned("),
        &[
-            "validate_object_key(&key, \"DeleteObjects\")",
-            "if let Err(err) = validate_table_catalog_object_mutation(&bucket, &key).await {",
+            "validate_object_key(&obj_id.key, \"DeleteObjects\")",
+            "if let Err(err) = validate_table_catalog_object_mutation(&bucket, &obj_id.key).await {",
            "continue;\n            }",
            "authorized_deletes.push(AuthorizedDelete { idx, object });",
        ],
@@ -37,7 +37,7 @@ their issue closes.
 | `check_no_planning_docs.sh` | ci-gate | Blocks committed planning-type documents | ci.yml Quick Checks; `make pre-commit` |
 | `check_no_tokio_io_uring.sh` | ci-gate | Keeps tokio's io-uring backend disabled | ci.yml Quick Checks |
 | `check_s3s_footprint.sh` | ci-gate | Exact, lower-only baseline on the direct s3s surface ahead of the gateway migration (reads `.config/s3s-footprint-baseline.txt`; `s3_error_lines` leaves out lines whose file imports the macro from `rustfs-s3-types`, rule in the script header); `--mode allowlist` fails on any Rust file referencing s3s outside `.config/s3s-edge-allowlist.txt`, `--dry-run` lists them | ci.yml Quick Checks; `make pre-commit`; `make script-tests` (`--self-test`) |
-| `check_test_count_ratchet.sh` | ci-gate | Per-crate test-count floor and `#[ignore]` ceiling against `.config/test-count-baseline.txt`; no crate may fall below its tests row or rise above its ignored row (extra tests and new crates pass with a note) | ci.yml Quick Checks; `make pre-commit` |
+| `check_test_count_ratchet.sh` | ci-gate | Exact per-crate test-count and `#[ignore]` ratchet against `.config/test-count-baseline.txt`; no crate may lose tests or gain ignores | ci.yml Quick Checks; `make pre-commit` |
 | `check_unsafe_code_allowances.sh` | ci-gate | Unsafe-code allowance ledger guard | ci.yml Quick Checks |
 | `layer-dependency-baseline.txt` | ci-gate (data) | Committed baseline consumed by `check_layer_dependencies.sh` | [Architecture guard troubleshooting](../docs/operations/architecture-guard-troubleshooting.md) |
 | `static.sh` | ci-gate | Static-build helper executed inside image builds | `Dockerfile.source`, `Dockerfile.decommission-local` |
@@ -55,11 +55,6 @@ their issue closes.
 | `test_prepare_replacement_migration.py` | dev-tool | Verifies maintenance approval scope, publication, and stopped-writer assertion | Python unittest; same runbook |
 | `test_diagnose_scanner_enumeration_restart.py` | dev-tool | Driver report validation and positive convergence oracle tests | Python unittest; same guide |
 | `test_object_generation_protocol_model.py` | dev-tool | Bounded single-slot, four-voter promise/accept design model and recovery/retirement examples; no production runtime evidence | `python3 scripts/test_object_generation_protocol_model.py`; [Generation contract](../docs/architecture/unified-object-generation.md#executable-design-model-and-acceptance-mapping) |
-| `junit_diff.py` | dev-tool | Case-by-case pass/fail/skip diff of two JUnit XML reports (reference vs candidate stack); exit 1 on any difference or stale `--allow` entry, 2 on unreadable input | `python3 scripts/junit_diff.py a.xml b.xml`; backlog T3.1 |
-| `test_junit_diff.py` | ci-gate | Contract tests and fixtures (`scripts/tests/junit_diff/`) for `junit_diff.py` | `make script-tests` |
-| `s3-tests/reference_parity.py` | ci-gate | Plans the reference parity targets, lists a run's failures for the single rerun, and compares every candidate's s3-tests JUnit against the pinned reference per node id with a tolerated-difference file | `.github/workflows/reference-parity.yml`; backlog T3.2 |
-| `s3-tests/test_reference_parity.py` | ci-gate | Contract tests for `reference_parity.py` | `make script-tests` |
-| `test_reference_binary.py` | ci-gate | Contract tests for `.github/actions/reference-binary/reference_binary.py` (pin resolution and verified unpacking) | `make script-tests` |
 | `e2e-run.sh` | ci-gate | Boots a rustfs server and runs the `s3s-e2e` black-box conformance tool against it | ci.yml `e2e-tests` jobs; `docs/testing/README.md` |
 | `run_ecstore_validation_suite.sh` | dev-tool | ecstore black-box validation suite (`quick`/`full`/`destructive`/`fuzz` profiles) | `docs/testing/README.md`, `docs/testing/ecstore-validation-suite-design.md` |
 | `run_e2e_tests.sh` | dev-tool | Local `e2e_test` crate runner (starts a server, applies filters, cleans up) | `crates/e2e_test/README.md` |
@@ -3,8 +3,7 @@
 # section 1 rule 3; task T0.3 in rustfs/backlog#2738).
 #
 # No PR may lower the number of tests in any workspace crate, and no PR may
-# add #[ignore] without a reviewed baseline change: "delete the test to get
-# green" is rejected in CI. The counter
+# add #[ignore]: "delete the test to get green" is rejected in CI. The counter
 # is deliberately per crate, never a workspace total — a drop in one crate
 # must not hide behind an addition in another.
 #
@@ -26,37 +25,26 @@
 # doc comments that mention `#[test]` out of the count.
 #
 # The counts are compared row by row with .config/test-count-baseline.txt
-# (`<package>\t<tests>\t<ignored>`, one row per member). The baseline is a
-# FLOOR on tests and a CEILING on ignored. It used to be an exact value in both
-# columns, which made every PR that adds a test edit the same file; on a branch
-# that takes many commits a week those PRs conflict with one another. What the
-# ratchet protects is that nobody deletes or ignores tests to get green without
-# it showing in the diff, and that only needs a one-sided bound:
+# (`<package>\t<tests>\t<ignored>`, one row per member). The baseline is an
+# EXACT value, not a floor, in both columns:
 #
 #   - tests below the row fails: `crate <name>: <actual> < baseline <n>`.
 #     Restore the tests. If the removal is intentional, lower the row in the
 #     same PR and justify it in the PR description, so the reduction is visible
 #     in the diff instead of disappearing into a green check.
-#   - tests above the row passes and prints a note on stdout. Rows are raised
-#     only by `--update`, in whichever PR chooses to tighten them.
-#   - ignored above the row fails (the line contains `ignored >`): raise the
-#     row in the same PR and justify the new #[ignore] in the PR description.
-#     Ignored below the row passes with a note.
+#   - tests above the row fails as well, telling the author to raise the row in
+#     the same PR. An exact baseline cannot drift upward silently, so the next
+#     deletion is always measured against the true count.
+#   - ignored above the row fails (the line contains `ignored`); adding
+#     #[ignore] is not accepted on gateway/integration. Ignored below the row
+#     fails too, asking for the row to be lowered so that ratchet stays tight.
 #   - a row whose crate is no longer a member fails (deleting a crate deletes
-#     its tests; remove the row in the same PR).
-#   - a member without a row passes with a note, so adding a crate does not
-#     block on this file; the next `--update` picks it up. Until then the new
-#     crate has no floor.
-#
-# Failures go to stderr and exit 1. Notes go to stdout and never use the
-# failure shapes above (` < baseline`, `ignored >`, `not a workspace member`).
+#     its tests), and a member without a row fails.
 #
 # `--update` rewrites the baseline from the current tree. Review the diff it
 # produces before committing it; it is the only sanctioned way to change the
 # file other than editing the single row a PR touched.
 #
-# Contract tests: scripts/test_check_test_count_ratchet.sh (make script-tests).
-#
 # Usage:
 #   scripts/check_test_count_ratchet.sh            # compare against the baseline
 #   scripts/check_test_count_ratchet.sh --update   # regenerate the baseline
@@ -144,12 +132,10 @@ if [[ "$mode" == "update" ]]; then
        echo "# One row per workspace member: <package>, tests, ignored, tab-separated."
        echo "# tests counts #[test], #[tokio::test], #[tokio::test(...)] and #[test_case(...)]"
        echo "# attribute lines under the package directory; ignored counts #[ignore] and"
-        echo "# #[ignore = \"...\"]. The tests column is a floor and the ignored column is a"
-        echo "# ceiling: CI fails when a crate's tests fall below its row or its ignored count"
-        echo "# rises above it. Extra tests and fewer ignores pass; --update tightens the rows."
-        echo "# Lowering a tests row or raising an ignored row is a reviewed statement that"
-        echo "# tests were intentionally removed or ignored; justify it in the PR description."
-        echo "# Regenerate with:"
+        echo "# #[ignore = \"...\"]. Both columns are exact: CI fails when a crate's tests fall"
+        echo "# below or rise above its row, or when its ignored count changes. Raise a row in"
+        echo "# the PR that adds tests; lowering one is a reviewed statement that tests were"
+        echo "# intentionally removed. Regenerate with:"
        echo "#   scripts/check_test_count_ratchet.sh --update"
        cat "$TMP_DIR/actual"
    } >"$BASELINE_FILE"
@@ -179,10 +165,9 @@ if cut -f1 "$TMP_DIR/baseline" | LC_ALL=C sort | uniq -d | grep . >"$TMP_DIR/dup
    exit 1
 fi

-# Every violation is one line on stderr; every note is one line on stdout. The
-# `<actual> < baseline <n>` and `ignored >` shapes are the acceptance contract
-# of rustfs/backlog#2738 and the contract tests; notes must never reuse them.
-awk -F'\t' -v notes="$TMP_DIR/notes" '
+# Every violation is one line. The `<actual> < baseline <n>` and `ignored`
+# shapes are the acceptance contract of rustfs/backlog#2738; keep them.
+awk -F'\t' '
 NR == FNR {
    baseline_tests[$1] = $2
    baseline_ignored[$1] = $3
@@ -191,18 +176,18 @@ NR == FNR {
 {
    seen[$1] = 1
    if (!($1 in baseline_tests)) {
-        printf "crate %s: no baseline row (%d tests, %d ignore attributes); run --update to add it\n", $1, $2, $3 >notes
+        printf "crate %s: no baseline row (%d tests, %d ignored); add it in this PR\n", $1, $2, $3
        next
    }
    if ($2 + 0 < baseline_tests[$1] + 0) {
        printf "crate %s: %d < baseline %d\n", $1, $2, baseline_tests[$1]
    } else if ($2 + 0 > baseline_tests[$1] + 0) {
-        printf "crate %s: %d above baseline %d; run --update to tighten\n", $1, $2, baseline_tests[$1] >notes
+        printf "crate %s: %d > baseline %d; raise the baseline row to %d in this PR\n", $1, $2, baseline_tests[$1], $2
    }
    if ($3 + 0 > baseline_ignored[$1] + 0) {
-        printf "crate %s: %d ignored > baseline %d; raise the baseline row to %d in this PR and justify the new #[ignore] in the PR description\n", $1, $3, baseline_ignored[$1], $3
+        printf "crate %s: %d ignored > baseline %d; adding #[ignore] is not accepted\n", $1, $3, baseline_ignored[$1]
    } else if ($3 + 0 < baseline_ignored[$1] + 0) {
-        printf "crate %s: %d ignore attributes below baseline %d; run --update to tighten\n", $1, $3, baseline_ignored[$1] >notes
+        printf "crate %s: %d ignored < baseline %d; lower the baseline row to %d in this PR\n", $1, $3, baseline_ignored[$1], $3
    }
 }
 END {
@@ -214,19 +199,14 @@ END {
 }
 ' "$TMP_DIR/baseline" "$TMP_DIR/actual" | LC_ALL=C sort >"$TMP_DIR/violations"

-if [[ -f "$TMP_DIR/notes" ]]; then
-    LC_ALL=C sort "$TMP_DIR/notes" | sed 's/^/note: /'
-fi
-
 if grep -q . "$TMP_DIR/violations"; then
    cat "$TMP_DIR/violations" >&2
    echo "error: test-count ratchet violated (rustfs/backlog#2734 section 1 rule 3)." >&2
    echo "  A crate below its baseline lost tests: restore them. If the removal is" >&2
    echo "  intentional, lower that row in $BASELINE_FILE in the same PR and" >&2
-    echo "  justify it in the PR description. A crate above its ignored baseline" >&2
-    echo "  raises that row in the same PR with a justification in the PR description" >&2
-    echo "  ('$0 --update' rewrites the file; review the diff)." >&2
+    echo "  justify it in the PR description. A crate above its baseline raises its" >&2
+    echo "  row in the same PR ('$0 --update' rewrites the file; review the diff)." >&2
    exit 1
 fi

-echo "test-count ratchet OK: $crate_count crates, $total_tests tests, $total_ignored ignored; every crate at or above its tests floor and at or below its ignored ceiling in $BASELINE_FILE"
+echo "test-count ratchet OK: $crate_count crates, $total_tests tests, $total_ignored ignored match $BASELINE_FILE"
@@ -1,167 +0,0 @@
-#!/usr/bin/env python3
-# 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.
-"""Compare two JUnit XML reports case by case.
-
-Cases are aligned on classname + name and reduced to pass / fail / skip. A case
-present in only one report is reported as `missing` on the other side. A
-`<flakyFailure>` case that finally passed is a pass and is listed separately.
-
-Exit codes: 0 no unallowed differences and no stale allow-list entry; 1 at least
-one difference or stale allow-list entry; 2 unreadable or malformed input.
-"""
-
-import argparse
-import json
-import sys
-import xml.etree.ElementTree as ET
-
-PASS, FAIL, SKIP, MISSING = "pass", "fail", "skip", "missing"
-_RETRY_TAGS = {"flakyFailure", "flakyError", "rerunFailure", "rerunError"}
-
-
-class InputError(Exception):
-    """Input that cannot be trusted as a report; maps to exit code 2."""
-
-
-def case_id(classname, name):
-    return f"{classname}::{name}" if classname else name
-
-
-def parse_report(path):
-    """Return ({case_id: state}, [flaky case ids]) for one JUnit file."""
-    try:
-        with open(path, "rb") as handle:
-            data = handle.read()
-    except OSError as exc:
-        raise InputError(f"{path}: cannot read: {exc.strerror or exc}") from exc
-    if not data.strip():
-        raise InputError(f"{path}: file is empty")
-    try:
-        root = ET.fromstring(data)
-    except ET.ParseError as exc:
-        raise InputError(f"{path}: malformed XML: {exc}") from exc
-    if root.tag not in ("testsuites", "testsuite"):
-        raise InputError(f"{path}: unexpected root element <{root.tag}>")
-    states, flaky = {}, []
-    for case in root.iter("testcase"):
-        name = case.get("name")
-        if not name:
-            raise InputError(f"{path}: <testcase> without a name")
-        cid = case_id(case.get("classname", ""), name)
-        if cid in states:
-            raise InputError(f"{path}: duplicate case {cid}")
-        tags = {child.tag for child in case}
-        if tags & {"failure", "error"}:
-            state = FAIL
-        elif "skipped" in tags:
-            state = SKIP
-        else:
-            state = PASS
-        states[cid] = state
-        if state == PASS and tags & _RETRY_TAGS:
-            flaky.append(cid)
-    if not states:
-        raise InputError(f"{path}: report contains no test cases")
-    return states, sorted(flaky)
-
-
-def read_allow(path):
-    try:
-        with open(path, encoding="utf-8") as handle:
-            lines = handle.read().splitlines()
-    except (OSError, UnicodeDecodeError) as exc:
-        raise InputError(f"{path}: cannot read allow-list: {exc}") from exc
-    return {line.strip() for line in lines if line.strip() and not line.lstrip().startswith("#")}
-
-
-def counts(states):
-    result = {PASS: 0, FAIL: 0, SKIP: 0}
-    for state in states.values():
-        result[state] += 1
-    return result
-
-
-def compare(a, b, allow):
-    diffs = []
-    for cid in sorted(set(a) | set(b)):
-        sa, sb = a.get(cid, MISSING), b.get(cid, MISSING)
-        if sa != sb:
-            diffs.append({"case": cid, "a": sa, "b": sb, "allowed": cid in allow})
-    stale = sorted(allow - {d["case"] for d in diffs})
-    return diffs, stale
-
-
-def render(args, diffs, stale, flaky_a, flaky_b, counts_a, counts_b):
-    out = []
-    for label, c in ((args.label_a, counts_a), (args.label_b, counts_b)):
-        out.append(f"{label}: pass={c[PASS]} fail={c[FAIL]} skip={c[SKIP]}")
-    for label, flaky in ((args.label_a, flaky_a), (args.label_b, flaky_b)):
-        if flaky:
-            out.append(f"\nFlaky in {label} (passed after retry, not a difference):")
-            out.extend(f"  {cid}" for cid in flaky)
-    if diffs:
-        width = max(len("case"), *(len(d["case"]) for d in diffs))
-        wa = max(len(args.label_a), 7)
-        out.append("")
-        out.append(f"{'case':<{width}}  {args.label_a:<{wa}}  {args.label_b}")
-        for d in diffs:
-            note = "  (allowed)" if d["allowed"] else ""
-            out.append(f"{d['case']:<{width}}  {d['a']:<{wa}}  {d['b']}{note}")
-    if stale:
-        out.append("\nStale allow-list entries (no matching difference; remove them):")
-        out.extend(f"  {cid}" for cid in stale)
-    if not diffs and not stale:
-        out.append("\nNo differences.")
-    return "\n".join(out)
-
-
-def main(argv=None):
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("a", help="first JUnit XML report")
-    parser.add_argument("b", help="second JUnit XML report")
-    parser.add_argument("--label-a", default="a")
-    parser.add_argument("--label-b", default="b")
-    parser.add_argument("--json", metavar="PATH", help="write a machine-readable summary")
-    parser.add_argument("--allow", metavar="FILE", help="case ids (one per line) whose difference is tolerated")
-    args = parser.parse_args(argv)
-    if args.label_a == args.label_b:
-        print("error: --label-a and --label-b must differ", file=sys.stderr)
-        return 2
-    try:
-        states_a, flaky_a = parse_report(args.a)
-        states_b, flaky_b = parse_report(args.b)
-        allow = read_allow(args.allow) if args.allow else set()
-        diffs, stale = compare(states_a, states_b, allow)
-        counts_a, counts_b = counts(states_a), counts(states_b)
-        if args.json:
-            summary = {
-                "labels": {"a": args.label_a, "b": args.label_b},
-                "counts": {args.label_a: counts_a, args.label_b: counts_b},
-                "differences": diffs,
-                "flaky": {args.label_a: flaky_a, args.label_b: flaky_b},
-                "stale_allow": stale,
-            }
-            with open(args.json, "w", encoding="utf-8") as handle:
-                json.dump(summary, handle, indent=2, sort_keys=True)
-                handle.write("\n")
-    except (InputError, OSError) as exc:
-        print(f"error: {exc}", file=sys.stderr)
-        return 2
-    print(render(args, diffs, stale, flaky_a, flaky_b, counts_a, counts_b))
-    return 1 if stale or any(not d["allowed"] for d in diffs) else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
@@ -1,329 +0,0 @@
-#!/usr/bin/env python3
-# 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.
-"""Plan and judge the s3-tests reference parity lane.
-
-Subcommands:
-  targets    validate the target list and print it as a JSON matrix
-  export-env validate one target's extra environment and print KEY=VALUE lines
-  failed     print the failed test names of one run, in implemented_tests.txt form
-  compare    compare every candidate against the reference, per pytest node id
-
-`compare` reads <reports>/<target>/selected-nodeids.txt, junit.xml and the
-optional rerun-junit.xml of every target. Each node id is reduced to pass /
-fail / skip / missing; a case that failed and then passed its single rerun is a
-pass and is listed as flaky. A tolerated entry must match a real difference.
-
-Exit codes: 0 no untolerated difference and no stale entry; 1 a difference, a
-stale tolerated entry or an incomplete run; 2 missing or malformed input.
-"""
-
-import argparse
-import json
-from pathlib import Path
-import re
-import sys
-import tomllib
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-import junit_diff  # noqa: E402  (sibling script, not a package)
-
-PASS, FAIL, SKIP, MISSING = junit_diff.PASS, junit_diff.FAIL, junit_diff.SKIP, junit_diff.MISSING
-NAME = re.compile(r"[a-z][a-z0-9-]{0,39}")
-ENV_KEY = re.compile(r"RUSTFS_[A-Z0-9_]+")
-ENV_VALUE = re.compile(r"[A-Za-z0-9._,:/=+-]*")
-ISSUE = re.compile(r"https://github\.com/rustfs/[A-Za-z0-9_.-]+/issues/[1-9][0-9]*")
-NODEID = re.compile(r"[A-Za-z0-9_/]+\.py(::[A-Za-z0-9_]+)+(\[[^\]\s]*\])?")
-TEST_FILE_PREFIX = "s3tests/functional/test_s3.py::"
-BINARIES = ("reference", "candidate")
-
-
-class InputError(Exception):
-    """Input that cannot be trusted; maps to exit code 2."""
-
-
-# --- target list -----------------------------------------------------------
-
-def load_targets(path):
-    try:
-        data = tomllib.loads(Path(path).read_text(encoding="utf-8"))
-    except FileNotFoundError as exc:
-        raise InputError(f"{path}: target list is missing") from exc
-    except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError) as exc:
-        raise InputError(f"{path}: cannot read target list: {exc}") from exc
-    if data.get("schema") != 1 or type(data.get("schema")) is not int or set(data) != {"schema", "targets"}:
-        raise InputError(f"{path}: unsupported target list schema")
-    return validate_targets(data["targets"], str(path))
-
-
-def validate_targets(targets, where="targets"):
-    if not isinstance(targets, list) or len(targets) < 2:
-        raise InputError(f"{where}: need one reference and at least one candidate")
-    result, names = [], set()
-    for item in targets:
-        if not isinstance(item, dict) or not set(item) <= {"name", "binary", "env"}:
-            raise InputError(f"{where}: invalid target entry {item!r}")
-        name, binary, env = item.get("name"), item.get("binary"), item.get("env", {})
-        if not isinstance(name, str) or not NAME.fullmatch(name) or name in names:
-            raise InputError(f"{where}: invalid or duplicate target name {name!r}")
-        if binary not in BINARIES:
-            raise InputError(f"{where}: target {name} has unknown binary {binary!r}")
-        validate_env(env, f"{where}: target {name}")
-        names.add(name)
-        result.append({"name": name, "binary": binary, "env": dict(env)})
-    if [t["binary"] for t in result].count("reference") != 1:
-        raise InputError(f"{where}: exactly one target must use the reference binary")
-    return result
-
-
-def validate_env(env, where):
-    if not isinstance(env, dict):
-        raise InputError(f"{where}: env must be a table")
-    for key, value in env.items():
-        if not isinstance(key, str) or not ENV_KEY.fullmatch(key):
-            raise InputError(f"{where}: env key {key!r} must match RUSTFS_[A-Z0-9_]+")
-        if not isinstance(value, str) or not ENV_VALUE.fullmatch(value):
-            raise InputError(f"{where}: env value for {key} has unsupported characters")
-    return env
-
-
-# --- node ids and reports --------------------------------------------------
-
-def nodeid_to_case(nodeid):
-    """Map a pytest node id to the classname::name id that junit_diff uses."""
-    if not NODEID.fullmatch(nodeid):
-        raise InputError(f"invalid pytest node id {nodeid!r}")
-    path, *parts = nodeid.split("::")
-    module = path[: -len(".py")].replace("/", ".")
-    classname = ".".join([module, *parts[:-1]])
-    return junit_diff.case_id(classname, parts[-1])
-
-
-def read_selected(path):
-    try:
-        lines = Path(path).read_text(encoding="utf-8").splitlines()
-    except FileNotFoundError as exc:
-        raise InputError(f"{path}: selected node id list is missing") from exc
-    except (OSError, UnicodeDecodeError) as exc:
-        raise InputError(f"{path}: cannot read selected node ids: {exc}") from exc
-    nodeids = [line.strip() for line in lines if line.strip()]
-    if not nodeids:
-        raise InputError(f"{path}: selected node id list is empty")
-    if len(set(nodeids)) != len(nodeids):
-        raise InputError(f"{path}: duplicate selected node id")
-    by_case = {}
-    for nodeid in nodeids:
-        case = nodeid_to_case(nodeid)
-        if case in by_case:
-            raise InputError(f"{path}: node ids {by_case[case]} and {nodeid} collide")
-        by_case[case] = nodeid
-    return nodeids, by_case
-
-
-def target_states(directory):
-    """Return (nodeids, {nodeid: state}, [flaky nodeids]) for one target run."""
-    directory = Path(directory)
-    if not directory.is_dir():
-        raise InputError(f"{directory}: report directory is missing")
-    nodeids, by_case = read_selected(directory / "selected-nodeids.txt")
-    try:
-        first, _ = junit_diff.parse_report(str(directory / "junit.xml"))
-    except junit_diff.InputError as exc:
-        raise InputError(str(exc)) from exc
-    unexpected = sorted(set(first) - set(by_case))
-    if unexpected:
-        raise InputError(f"{directory}: junit.xml has unselected cases: {', '.join(unexpected[:5])}")
-    states = {by_case[case]: state for case, state in first.items()}
-    flaky = []
-    rerun_path = directory / "rerun-junit.xml"
-    if rerun_path.exists():
-        try:
-            rerun, _ = junit_diff.parse_report(str(rerun_path))
-        except junit_diff.InputError as exc:
-            raise InputError(str(exc)) from exc
-        for case, state in sorted(rerun.items()):
-            nodeid = by_case.get(case)
-            if nodeid is None or states.get(nodeid) != FAIL:
-                raise InputError(f"{rerun_path}: {case} was rerun without failing first")
-            if state == PASS:
-                flaky.append(nodeid)
-            states[nodeid] = PASS if state == PASS else FAIL
-    for nodeid in nodeids:
-        states.setdefault(nodeid, MISSING)
-    return nodeids, states, flaky
-
-
-def failed_names(directory):
-    _, states, _ = target_states(directory)
-    names = []
-    for nodeid, state in states.items():
-        if state == FAIL:
-            if not nodeid.startswith(TEST_FILE_PREFIX):
-                raise InputError(f"cannot express {nodeid} as an implemented_tests.txt entry")
-            names.append(nodeid[len(TEST_FILE_PREFIX):])
-    return sorted(names)
-
-
-# --- tolerated differences ---------------------------------------------------
-
-def read_tolerated(path, candidates):
-    try:
-        lines = Path(path).read_text(encoding="utf-8").splitlines()
-    except FileNotFoundError as exc:
-        raise InputError(f"{path}: tolerated-difference file is missing") from exc
-    except (OSError, UnicodeDecodeError) as exc:
-        raise InputError(f"{path}: cannot read tolerated differences: {exc}") from exc
-    entries = {}
-    for number, line in enumerate(lines, 1):
-        if not line.strip() or line.lstrip().startswith("#"):
-            continue
-        fields = [part.strip() for part in line.split(" | ")]
-        if len(fields) != 4 or not all(fields):
-            raise InputError(f"{path}:{number}: expected '<target> | <node id> | <issue URL> | <reason>'")
-        target, nodeid, issue, _reason = fields
-        if target not in candidates:
-            raise InputError(f"{path}:{number}: {target!r} is not a candidate target")
-        nodeid_to_case(nodeid)
-        if not ISSUE.fullmatch(issue):
-            raise InputError(f"{path}:{number}: tracking issue must be a https://github.com/rustfs/<repo>/issues/<n> URL")
-        if (target, nodeid) in entries:
-            raise InputError(f"{path}:{number}: duplicate entry for {target} {nodeid}")
-        entries[(target, nodeid)] = issue
-    return entries
-
-
-# --- comparison ----------------------------------------------------------------
-
-def count(states):
-    result = {PASS: 0, FAIL: 0, SKIP: 0, MISSING: 0}
-    for state in states.values():
-        result[state] += 1
-    return result
-
-
-def compare(targets, reports, tolerated_path):
-    reference = next(t["name"] for t in targets if t["binary"] == "reference")
-    candidates = [t["name"] for t in targets if t["binary"] == "candidate"]
-    tolerated = read_tolerated(tolerated_path, set(candidates))
-    runs = {t["name"]: target_states(Path(reports) / t["name"]) for t in targets}
-    selected = runs[reference][0]
-    for name, (nodeids, _, _) in runs.items():
-        if nodeids != selected:
-            raise InputError(f"{name}: selected node ids differ from the {reference} run")
-    ref_states = runs[reference][1]
-    differences = []
-    for name in candidates:
-        states = runs[name][1]
-        for nodeid in selected:
-            if ref_states[nodeid] != states[nodeid]:
-                issue = tolerated.get((name, nodeid))
-                differences.append({"target": name, "nodeid": nodeid, "reference": ref_states[nodeid],
-                                    "candidate": states[nodeid], "tolerated": issue})
-    seen = {(d["target"], d["nodeid"]) for d in differences}
-    stale = [{"target": t, "nodeid": n, "issue": i} for (t, n), i in sorted(tolerated.items()) if (t, n) not in seen]
-    incomplete = {name: [n for n in selected if run[1][n] == MISSING] for name, run in runs.items()}
-    return {
-        "reference": reference,
-        "candidates": candidates,
-        "selected": len(selected),
-        "counts": {name: count(run[1]) for name, run in runs.items()},
-        "flaky": {name: run[2] for name, run in runs.items()},
-        "differences": differences,
-        "stale_tolerated": stale,
-        "incomplete": {name: ids for name, ids in incomplete.items() if ids},
-    }
-
-
-def failed(summary):
-    return bool(summary["stale_tolerated"] or summary["incomplete"]
-                or any(not d["tolerated"] for d in summary["differences"]))
-
-
-def render(summary):
-    out = ["## s3-tests reference parity", ""]
-    out.append(f"Reference target `{summary['reference']}`; {summary['selected']} selected node ids per target.")
-    out += ["", "| Target | pass | fail | skip | missing | flaky (passed on rerun) |", "|---|---:|---:|---:|---:|---:|"]
-    for name, c in summary["counts"].items():
-        out.append(f"| `{name}` | {c[PASS]} | {c[FAIL]} | {c[SKIP]} | {c[MISSING]} | {len(summary['flaky'][name])} |")
-    diffs = summary["differences"]
-    out += ["", f"### Differences ({len(diffs)})", ""]
-    if diffs:
-        out += ["| Target | Node id | reference | candidate | Tolerated |", "|---|---|---|---|---|"]
-        for d in diffs:
-            out.append(f"| `{d['target']}` | `{d['nodeid']}` | {d['reference']} | {d['candidate']} | {d['tolerated'] or 'no'} |")
-    else:
-        out.append("No differences.")
-    if summary["stale_tolerated"]:
-        out += ["", "### Stale tolerated entries (no matching difference; remove them)", ""]
-        out += [f"- `{s['target']}` `{s['nodeid']}` ({s['issue']})" for s in summary["stale_tolerated"]]
-    if summary["incomplete"]:
-        out += ["", "### Incomplete runs (selected node ids without a result)", ""]
-        out += [f"- `{name}`: {len(ids)} missing, first `{ids[0]}`" for name, ids in summary["incomplete"].items()]
-    flaky = [(name, ids) for name, ids in summary["flaky"].items() if ids]
-    if flaky:
-        out += ["", "### Flaky (failed, then passed the single rerun; not a difference)", ""]
-        out += [f"- `{name}`: " + ", ".join(f"`{i}`" for i in ids) for name, ids in flaky]
-    out += ["", "Result: **" + ("FAIL" if failed(summary) else "PASS") + "**", ""]
-    return "\n".join(out)
-
-
-def main(argv=None):
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    sub = parser.add_subparsers(dest="mode", required=True)
-    tgt = sub.add_parser("targets")
-    tgt.add_argument("--config", required=True)
-    env = sub.add_parser("export-env")
-    env.add_argument("--target-json", required=True)
-    fail = sub.add_parser("failed")
-    fail.add_argument("--report", required=True, help="one target's report directory")
-    cmp_ = sub.add_parser("compare")
-    cmp_.add_argument("--targets-json", required=True)
-    cmp_.add_argument("--reports", required=True)
-    cmp_.add_argument("--tolerated", required=True)
-    cmp_.add_argument("--markdown", help="write the summary table here (appended)")
-    cmp_.add_argument("--json", help="write the machine-readable summary here")
-    args = parser.parse_args(argv)
-    try:
-        if args.mode == "targets":
-            print(json.dumps(load_targets(args.config), separators=(",", ":")))
-        elif args.mode == "export-env":
-            target = json.loads(args.target_json)
-            if not isinstance(target, dict):
-                raise InputError("target must be a JSON object")
-            for key, value in sorted(validate_env(target.get("env", {}), "target").items()):
-                print(f"{key}={value}")
-        elif args.mode == "failed":
-            for name in failed_names(args.report):
-                print(name)
-        else:
-            targets = validate_targets(json.loads(args.targets_json))
-            summary = compare(targets, args.reports, args.tolerated)
-            text = render(summary)
-            print(text)
-            if args.markdown:
-                with open(args.markdown, "a", encoding="utf-8") as handle:
-                    handle.write(text + "\n")
-            if args.json:
-                with open(args.json, "w", encoding="utf-8") as handle:
-                    json.dump(summary, handle, indent=2, sort_keys=True)
-                    handle.write("\n")
-            return 1 if failed(summary) else 0
-    except (InputError, json.JSONDecodeError) as exc:
-        print(f"error: {exc}", file=sys.stderr)
-        return 2
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
@@ -1,332 +0,0 @@
-#!/usr/bin/env python3
-# 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.
-"""Contract tests for reference_parity.py: target list, rerun merge, tolerated entries and exit codes."""
-
-import json
-from pathlib import Path
-import subprocess
-import sys
-import tempfile
-import unittest
-
-SCRIPT = Path(__file__).resolve().parent / "reference_parity.py"
-REPO = Path(__file__).resolve().parents[2]
-PREFIX = "s3tests/functional/test_s3.py::"
-CLASSNAME = "s3tests.functional.test_s3"
-TARGETS = [{"name": "reference", "binary": "reference", "env": {}},
-           {"name": "candidate-legacy", "binary": "candidate", "env": {}}]
-ISSUE = "https://github.com/rustfs/rustfs/issues/1"
-
-
-def junit(states):
-    cases = []
-    for name, state in states.items():
-        body = {"pass": "", "fail": "<failure message='x'/>", "error": "<error message='x'/>",
-                "skip": "<skipped/>"}[state]
-        cases.append(f'<testcase classname="{CLASSNAME}" name="{name}">{body}</testcase>')
-    return f'<testsuites><testsuite name="pytest">{"".join(cases)}</testsuite></testsuites>'
-
-
-def run(*args):
-    proc = subprocess.run([sys.executable, str(SCRIPT), *args], capture_output=True, text=True, check=False)
-    return proc.returncode, proc.stdout, proc.stderr
-
-
-class Lane:
-    """A temporary reports directory with one sub-directory per target."""
-
-    def __init__(self, case):
-        self.temp = tempfile.TemporaryDirectory()
-        case.addCleanup(self.temp.cleanup)
-        self.root = Path(self.temp.name)
-        self.reports = self.root / "reports"
-        self.tolerated = self.root / "tolerated.txt"
-        self.tolerated.write_text("# none\n")
-
-    def target(self, name, states, selected=None, rerun=None):
-        directory = self.reports / name
-        directory.mkdir(parents=True)
-        names = selected if selected is not None else list(states)
-        (directory / "selected-nodeids.txt").write_text("".join(PREFIX + n + "\n" for n in names))
-        (directory / "junit.xml").write_text(junit(states))
-        if rerun is not None:
-            (directory / "rerun-junit.xml").write_text(junit(rerun))
-        return directory
-
-    def compare(self, targets=None):
-        summary = self.root / "summary.json"
-        code, out, err = run("compare", "--targets-json", json.dumps(targets or TARGETS),
-                             "--reports", str(self.reports), "--tolerated", str(self.tolerated),
-                             "--json", str(summary))
-        data = json.loads(summary.read_text()) if summary.exists() else None
-        return code, out, err, data
-
-
-BASE = {"test_a": "pass", "test_b": "pass", "test_c": "skip"}
-
-
-class CompareTests(unittest.TestCase):
-    # --- negative cases ---
-
-    def test_pass_versus_fail_is_a_difference(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_a": "fail"})
-        code, out, _, data = lane.compare()
-        self.assertEqual(code, 1)
-        self.assertEqual(data["differences"], [{"target": "candidate-legacy", "nodeid": PREFIX + "test_a",
-                                                "reference": "pass", "candidate": "fail", "tolerated": None}])
-        self.assertIn("Result: **FAIL**", out)
-
-    def test_error_counts_as_fail(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_b": "error"})
-        code, _, _, data = lane.compare()
-        self.assertEqual(code, 1)
-        self.assertEqual(data["differences"][0]["candidate"], "fail")
-
-    def test_reference_fail_candidate_pass_is_also_a_difference(self):
-        lane = Lane(self)
-        lane.target("reference", {**BASE, "test_a": "fail"})
-        lane.target("candidate-legacy", BASE)
-        code, _, _, data = lane.compare()
-        self.assertEqual(code, 1)
-        self.assertEqual(data["differences"][0]["reference"], "fail")
-
-    def test_skip_versus_pass_is_a_difference(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_c": "pass"})
-        code, _, _, data = lane.compare()
-        self.assertEqual(code, 1)
-        self.assertEqual(data["differences"][0]["nodeid"], PREFIX + "test_c")
-
-    def test_case_absent_from_candidate_report_is_missing_and_incomplete(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {"test_a": "pass", "test_c": "skip"}, selected=list(BASE))
-        code, out, _, data = lane.compare()
-        self.assertEqual(code, 1)
-        self.assertEqual(data["differences"][0]["candidate"], "missing")
-        self.assertEqual(data["incomplete"], {"candidate-legacy": [PREFIX + "test_b"]})
-        self.assertIn("Incomplete runs", out)
-
-    def test_case_missing_from_both_reports_still_fails(self):
-        lane = Lane(self)
-        partial = {"test_a": "pass", "test_c": "skip"}
-        lane.target("reference", partial, selected=list(BASE))
-        lane.target("candidate-legacy", partial, selected=list(BASE))
-        code, _, _, data = lane.compare()
-        self.assertEqual(code, 1)
-        self.assertEqual(data["differences"], [])
-        self.assertEqual(set(data["incomplete"]), {"reference", "candidate-legacy"})
-
-    def test_failure_that_also_fails_the_rerun_stays_a_difference(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_a": "fail"}, rerun={"test_a": "fail"})
-        code, _, _, data = lane.compare()
-        self.assertEqual(code, 1)
-        self.assertEqual(data["flaky"]["candidate-legacy"], [])
-
-    def test_rerun_of_a_case_that_did_not_fail_is_rejected(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_a": "fail"}, rerun={"test_b": "pass"})
-        code, _, err, _ = lane.compare()
-        self.assertEqual(code, 2)
-        self.assertIn("rerun without failing first", err)
-
-    def test_missing_target_report_fails_rather_than_skips(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        code, _, err, data = lane.compare()
-        self.assertEqual(code, 2)
-        self.assertIsNone(data)
-        self.assertIn("candidate-legacy: report directory is missing", err)
-
-    def test_missing_junit_fails(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        (lane.target("candidate-legacy", BASE) / "junit.xml").unlink()
-        code, _, err, _ = lane.compare()
-        self.assertEqual(code, 2)
-        self.assertIn("cannot read", err)
-
-    def test_different_selected_lists_are_rejected(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {"test_a": "pass", "test_b": "pass"})
-        code, _, err, _ = lane.compare()
-        self.assertEqual(code, 2)
-        self.assertIn("selected node ids differ", err)
-
-    def test_unselected_case_in_junit_is_rejected(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_extra": "pass"}, selected=list(BASE))
-        code, _, err, _ = lane.compare()
-        self.assertEqual(code, 2)
-        self.assertIn("unselected cases", err)
-
-    def test_stale_tolerated_entry_fails(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", BASE)
-        lane.tolerated.write_text(f"candidate-legacy | {PREFIX}test_a | {ISSUE} | known drift\n")
-        code, out, _, data = lane.compare()
-        self.assertEqual(code, 1)
-        self.assertEqual(data["stale_tolerated"][0]["nodeid"], PREFIX + "test_a")
-        self.assertIn("Stale tolerated entries", out)
-
-    def test_tolerated_entry_for_another_target_does_not_cover_the_difference(self):
-        lane = Lane(self)
-        targets = TARGETS + [{"name": "candidate-gateway", "binary": "candidate", "env": {}}]
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_a": "fail"})
-        lane.target("candidate-gateway", {**BASE, "test_a": "fail"})
-        lane.tolerated.write_text(f"candidate-gateway | {PREFIX}test_a | {ISSUE} | gateway gap\n")
-        code, _, _, data = lane.compare(targets)
-        self.assertEqual(code, 1)
-        untolerated = [d["target"] for d in data["differences"] if not d["tolerated"]]
-        self.assertEqual(untolerated, ["candidate-legacy"])
-
-    def test_tolerated_entry_without_issue_url_is_rejected(self):
-        for line in (f"candidate-legacy | {PREFIX}test_a | rustfs#1 | reason",
-                     f"candidate-legacy | {PREFIX}test_a | {ISSUE} | ",
-                     f"candidate-legacy | {PREFIX}test_a | {ISSUE}",
-                     f"reference | {PREFIX}test_a | {ISSUE} | reason",
-                     f"candidate-legacy | test_a | {ISSUE} | reason"):
-            with self.subTest(line=line):
-                lane = Lane(self)
-                lane.target("reference", BASE)
-                lane.target("candidate-legacy", {**BASE, "test_a": "fail"})
-                lane.tolerated.write_text(line + "\n")
-                code, _, err, _ = lane.compare()
-                self.assertEqual(code, 2, err)
-
-    def test_duplicate_tolerated_entry_is_rejected(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_a": "fail"})
-        entry = f"candidate-legacy | {PREFIX}test_a | {ISSUE} | reason\n"
-        lane.tolerated.write_text(entry * 2)
-        code, _, err, _ = lane.compare()
-        self.assertEqual(code, 2)
-        self.assertIn("duplicate entry", err)
-
-    def test_missing_tolerated_file_fails(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", BASE)
-        lane.tolerated.unlink()
-        code, _, err, _ = lane.compare()
-        self.assertEqual(code, 2)
-        self.assertIn("tolerated-difference file is missing", err)
-
-    # --- positive cases ---
-
-    def test_identical_runs_pass(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", BASE)
-        code, out, _, data = lane.compare()
-        self.assertEqual(code, 0)
-        self.assertEqual(data["counts"]["candidate-legacy"], {"pass": 2, "fail": 0, "skip": 1, "missing": 0})
-        self.assertIn("No differences.", out)
-        self.assertIn("Result: **PASS**", out)
-
-    def test_failure_that_passes_the_rerun_is_flaky_not_a_difference(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_a": "fail"}, rerun={"test_a": "pass"})
-        code, out, _, data = lane.compare()
-        self.assertEqual(code, 0)
-        self.assertEqual(data["flaky"]["candidate-legacy"], [PREFIX + "test_a"])
-        self.assertIn("Flaky", out)
-
-    def test_tolerated_difference_passes_and_is_labelled(self):
-        lane = Lane(self)
-        lane.target("reference", BASE)
-        lane.target("candidate-legacy", {**BASE, "test_a": "fail"})
-        lane.tolerated.write_text(f"# comment\ncandidate-legacy | {PREFIX}test_a | {ISSUE} | known drift\n")
-        code, out, _, data = lane.compare()
-        self.assertEqual(code, 0)
-        self.assertEqual(data["differences"][0]["tolerated"], ISSUE)
-        self.assertIn(ISSUE, out)
-
-
-class TargetTests(unittest.TestCase):
-    def write(self, text):
-        temp = tempfile.TemporaryDirectory()
-        self.addCleanup(temp.cleanup)
-        path = Path(temp.name) / "targets.toml"
-        path.write_text(text)
-        return path
-
-    def test_invalid_target_lists_are_rejected(self):
-        ref = '[[targets]]\nname = "reference"\nbinary = "reference"\n'
-        cand = '[[targets]]\nname = "candidate-legacy"\nbinary = "candidate"\n'
-        for label, text in {
-            "no schema": ref + cand,
-            "only reference": "schema = 1\n" + ref,
-            "two references": "schema = 1\n" + ref + ref.replace('"reference"\nbinary', '"other"\nbinary'),
-            "no reference": "schema = 1\n" + cand + cand.replace("candidate-legacy", "candidate-two"),
-            "duplicate name": "schema = 1\n" + ref + cand + cand,
-            "unknown binary": "schema = 1\n" + ref + cand.replace('binary = "candidate"', 'binary = "main"'),
-            "bad name": "schema = 1\n" + ref + cand.replace("candidate-legacy", "Candidate Legacy"),
-            "foreign env key": "schema = 1\n" + ref + cand + 'env = { PATH = "/tmp" }\n',
-            "env injection": "schema = 1\n" + ref + cand + 'env = { RUSTFS_X = "a\\nB=c" }\n',
-            "unknown key": "schema = 1\n" + ref + cand + 'stack = "gateway"\n',
-        }.items():
-            with self.subTest(label):
-                code, _, _ = run("targets", "--config", str(self.write(text)))
-                self.assertEqual(code, 2)
-
-    def test_missing_target_file_fails(self):
-        code, _, err = run("targets", "--config", "/nonexistent/targets.toml")
-        self.assertEqual(code, 2)
-        self.assertIn("target list is missing", err)
-
-    def test_export_env_rejects_foreign_keys(self):
-        code, _, _ = run("export-env", "--target-json", json.dumps({"env": {"LD_PRELOAD": "x"}}))
-        self.assertEqual(code, 2)
-
-    def test_repository_target_list_is_valid(self):
-        code, out, err = run("targets", "--config", str(REPO / ".config/reference-parity-targets.toml"))
-        self.assertEqual(code, 0, err)
-        self.assertEqual(json.loads(out), TARGETS)
-
-    def test_export_env_prints_validated_lines(self):
-        code, out, _ = run("export-env", "--target-json", json.dumps({"env": {"RUSTFS_S3_STACK": "gateway"}}))
-        self.assertEqual((code, out), (0, "RUSTFS_S3_STACK=gateway\n"))
-
-
-class FailedTests(unittest.TestCase):
-    def test_failed_lists_only_failures_in_test_list_form(self):
-        lane = Lane(self)
-        directory = lane.target("reference", {**BASE, "test_a": "fail", "test_d": "error"})
-        code, out, _ = run("failed", "--report", str(directory))
-        self.assertEqual((code, out), (0, "test_a\ntest_d\n"))
-
-    def test_failed_rejects_a_missing_report(self):
-        code, _, err = run("failed", "--report", "/nonexistent/report")
-        self.assertEqual(code, 2)
-        self.assertIn("report directory is missing", err)
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -1,260 +0,0 @@
-#!/usr/bin/env bash
-# Contract tests for scripts/check_test_count_ratchet.sh.
-#
-# Each case builds a throwaway two-crate cargo workspace (crates `alpha` and
-# `beta`), copies the script under test into it, writes a baseline, and runs
-# the script there, so the real workspace and baseline are never touched. Only
-# `cargo metadata --no-deps` runs; nothing is compiled.
-#
-# Contract under test: the baseline is a floor on tests and a ceiling on
-# #[ignore]; see the header of check_test_count_ratchet.sh.
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SCRIPT_UNDER_TEST="${RATCHET_SCRIPT:-$SCRIPT_DIR/check_test_count_ratchet.sh}"
-TMP_ROOT="$(mktemp -d)"
-trap 'rm -rf "$TMP_ROOT"' EXIT
-
-passed=0
-case_no=0
-FX=""
-OUT=""
-ERR=""
-STATUS=0
-
-fail() {
-    echo "FAIL: $1" >&2
-    exit 1
-}
-
-# new_case <name>: fresh workspace with alpha and beta (members, no tests yet).
-new_case() {
-    case_no=$((case_no + 1))
-    FX="$TMP_ROOT/case$case_no"
-    mkdir -p "$FX/scripts" "$FX/.config"
-    cp "$SCRIPT_UNDER_TEST" "$FX/scripts/check_test_count_ratchet.sh"
-    chmod +x "$FX/scripts/check_test_count_ratchet.sh"
-    printf '[workspace]\nresolver = "2"\nmembers = ["alpha", "beta"]\n' >"$FX/Cargo.toml"
-    make_crate alpha 1 0
-    make_crate beta 0 0
-    : >"$FX/.config/test-count-baseline.txt"
-}
-
-# make_crate <name> <tests> <ignored>: (re)write a member with that many
-# attribute lines.
-make_crate() {
-    local name="$1" tests="$2" ignored="$3" i
-    mkdir -p "$FX/$name/src"
-    printf '[package]\nname = "%s"\nversion = "0.0.0"\nedition = "2021"\n' "$name" >"$FX/$name/Cargo.toml"
-    {
-        for ((i = 0; i < tests; i++)); do printf '#[test]\nfn t%d() {}\n' "$i"; done
-        for ((i = 0; i < ignored; i++)); do printf '#[ignore]\nfn i%d() {}\n' "$i"; done
-        printf 'pub fn anchor() {}\n'
-    } >"$FX/$name/src/lib.rs"
-}
-
-# baseline <package> <tests> <ignored>...: append rows (tab-separated).
-baseline() {
-    printf '%s\t%s\t%s\n' "$1" "$2" "$3" >>"$FX/.config/test-count-baseline.txt"
-}
-
-run() {
-    STATUS=0
-    (cd "$FX" && ./scripts/check_test_count_ratchet.sh "$@") >"$TMP_ROOT/out" 2>"$TMP_ROOT/err" || STATUS=$?
-    OUT="$(cat "$TMP_ROOT/out")"
-    ERR="$(cat "$TMP_ROOT/err")"
-}
-
-expect_pass() {
-    ((STATUS == 0)) || fail "$1: expected exit 0, got $STATUS; stderr: $ERR"
-}
-
-expect_fail() {
-    ((STATUS == 1)) || fail "$1: expected exit 1, got $STATUS; stderr: $ERR"
-}
-
-# stream_text <stdout|stderr>: captured output of the last run.
-stream_text() {
-    if [[ "$1" == stdout ]]; then printf '%s' "$OUT"; else printf '%s' "$ERR"; fi
-}
-
-# expect_in <label> <stdout|stderr> <needle>
-expect_in() {
-    local text
-    text="$(stream_text "$2")"
-    [[ "$text" == *"$3"* ]] || fail "$1: $2 lacks '$3'; got: $text"
-}
-
-expect_not_in() {
-    local text
-    text="$(stream_text "$2")"
-    [[ "$text" != *"$3"* ]] || fail "$1: $2 must not contain '$3'; got: $text"
-}
-
-ok() {
-    passed=$((passed + 1))
-    echo "ok: $1"
-}
-
-# --- positive cases -------------------------------------------------------
-
-name="exact match passes silently"
-new_case
-make_crate alpha 3 1
-baseline alpha 3 1
-baseline beta 0 0
-run
-expect_pass "$name"
-expect_not_in "$name" stdout "above baseline"
-ok "$name"
-
-name="tests above baseline pass with an informational line"
-new_case
-make_crate alpha 5 0
-baseline alpha 3 0
-baseline beta 0 0
-run
-expect_pass "$name"
-expect_in "$name" stdout "note: crate alpha: 5 above baseline 3; run --update to tighten"
-expect_not_in "$name" stderr "alpha"
-ok "$name"
-
-name="ignored below baseline passes with an informational line"
-new_case
-make_crate alpha 3 0
-baseline alpha 3 2
-baseline beta 0 0
-run
-expect_pass "$name"
-expect_in "$name" stdout "note: crate alpha: 0 ignore attributes below baseline 2; run --update to tighten"
-ok "$name"
-
-name="member without a row passes with a notice"
-new_case
-make_crate alpha 3 0
-make_crate beta 2 1
-baseline alpha 3 0
-run
-expect_pass "$name"
-expect_in "$name" stdout "note: crate beta: no baseline row (2 tests, 1 ignore attributes); run --update to add it"
-ok "$name"
-
-name="informational lines never carry a failure shape"
-new_case
-make_crate alpha 5 0
-make_crate beta 1 0
-baseline alpha 3 2
-run
-expect_pass "$name"
-for shape in " < baseline" "ignored >" "not a workspace member" "violated"; do
-    expect_not_in "$name" stdout "$shape"
-done
-ok "$name"
-
-name="--update round-trips: rewrites rows from the tree and the check then passes"
-new_case
-make_crate alpha 4 1
-make_crate beta 2 0
-baseline alpha 9 9
-run --update
-expect_pass "$name"
-grep -qxF "$(printf 'alpha\t4\t1')" "$FX/.config/test-count-baseline.txt" || fail "$name: alpha row not rewritten"
-grep -qxF "$(printf 'beta\t2\t0')" "$FX/.config/test-count-baseline.txt" || fail "$name: beta row not added"
-run
-expect_pass "$name (check after update)"
-expect_not_in "$name" stdout "above baseline"
-ok "$name"
-
-# --- negative cases -------------------------------------------------------
-
-name="tests below baseline fail"
-new_case
-make_crate alpha 1 0
-baseline alpha 3 0
-baseline beta 0 0
-run
-expect_fail "$name"
-expect_in "$name" stderr "crate alpha: 1 < baseline 3"
-ok "$name"
-
-name="a drop in one crate is not hidden by an addition in another"
-new_case
-make_crate alpha 1 0
-make_crate beta 9 0
-baseline alpha 3 0
-baseline beta 2 0
-run
-expect_fail "$name"
-expect_in "$name" stderr "crate alpha: 1 < baseline 3"
-expect_in "$name" stdout "note: crate beta: 9 above baseline 2"
-ok "$name"
-
-name="ignored above baseline fails with the main-branch wording"
-new_case
-make_crate alpha 3 2
-baseline alpha 3 0
-baseline beta 0 0
-run
-expect_fail "$name"
-expect_in "$name" stderr "crate alpha: 2 ignored > baseline 0"
-expect_in "$name" stderr "raise the baseline row"
-expect_in "$name" stderr "PR description"
-expect_not_in "$name" stderr "gateway/integration"
-ok "$name"
-
-name="ignored above fails even when tests are above baseline too"
-new_case
-make_crate alpha 8 1
-baseline alpha 3 0
-baseline beta 0 0
-run
-expect_fail "$name"
-expect_in "$name" stderr "crate alpha: 1 ignored > baseline 0"
-ok "$name"
-
-name="a row for a crate that is no longer a member fails"
-new_case
-make_crate alpha 3 0
-baseline alpha 3 0
-baseline beta 0 0
-baseline gamma 4 0
-run
-expect_fail "$name"
-expect_in "$name" stderr "crate gamma: not a workspace member"
-ok "$name"
-
-name="malformed row fails"
-new_case
-printf 'alpha\tmany\t0\n' >>"$FX/.config/test-count-baseline.txt"
-run
-expect_fail "$name"
-expect_in "$name" stderr "malformed rows"
-ok "$name"
-
-name="duplicate row fails"
-new_case
-baseline alpha 0 0
-baseline alpha 0 0
-baseline beta 0 0
-run
-expect_fail "$name"
-expect_in "$name" stderr "duplicate rows"
-ok "$name"
-
-name="missing baseline file fails"
-new_case
-make_crate alpha 1 0
-rm "$FX/.config/test-count-baseline.txt"
-run
-expect_fail "$name"
-expect_in "$name" stderr "is missing"
-ok "$name"
-
-name="unknown argument is a usage error"
-new_case
-run --bogus
-((STATUS == 2)) || fail "$name: expected exit 2, got $STATUS"
-ok "$name"
-
-echo "check_test_count_ratchet tests passed: $passed cases"
@@ -1,172 +0,0 @@
-#!/usr/bin/env python3
-# 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.
-"""Contract tests for junit_diff.py: exit codes, the difference table and the JSON summary."""
-
-import json
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-SCRIPT = Path(__file__).resolve().parent / "junit_diff.py"
-FIXTURES = Path(__file__).resolve().parent / "tests" / "junit_diff"
-
-
-def run(a, b, *extra):
-    """Run the script on two fixture names; return (exit code, stdout, stderr)."""
-    proc = subprocess.run(
-        [sys.executable, str(SCRIPT), str(FIXTURES / a), str(FIXTURES / b), *extra],
-        capture_output=True, text=True, check=False)
-    return proc.returncode, proc.stdout, proc.stderr
-
-
-class JunitDiffTests(unittest.TestCase):
-    # --- negative cases: differences and bad input ---
-
-    def test_pass_vs_fail_is_difference(self):
-        code, out, _ = run("base.xml", "pass_fail.xml")
-        self.assertEqual(code, 1)
-        self.assertIn("rustfs::s3::alpha", out)
-        self.assertRegex(out, r"rustfs::s3::alpha\s+pass\s+fail")
-
-    def test_pass_vs_error_counts_as_fail(self):
-        code, out, _ = run("base.xml", "pass_error.xml")
-        self.assertEqual(code, 1)
-        self.assertRegex(out, r"rustfs::s3::alpha\s+pass\s+fail")
-
-    def test_pass_vs_skip_is_difference(self):
-        code, out, _ = run("base.xml", "pass_skip.xml")
-        self.assertEqual(code, 1)
-        self.assertRegex(out, r"rustfs::s3::alpha\s+pass\s+skip")
-
-    def test_case_missing_on_b_is_difference(self):
-        code, out, _ = run("base.xml", "missing_case.xml")
-        self.assertEqual(code, 1)
-        self.assertRegex(out, r"rustfs::s3::beta\s+pass\s+missing")
-
-    def test_case_missing_on_a_is_difference(self):
-        code, out, _ = run("missing_case.xml", "base.xml")
-        self.assertEqual(code, 1)
-        self.assertRegex(out, r"rustfs::s3::beta\s+missing\s+pass")
-
-    def test_rerun_failure_final_fail_is_difference(self):
-        code, out, _ = run("base.xml", "rerun_fail.xml")
-        self.assertEqual(code, 1)
-        self.assertRegex(out, r"rustfs::s3::alpha\s+pass\s+fail")
-
-    def test_malformed_xml_exits_2(self):
-        for a, b in (("malformed.xml", "base.xml"), ("base.xml", "malformed.xml")):
-            code, out, err = run(a, b)
-            self.assertEqual(code, 2, (out, err))
-            self.assertNotIn("No differences", out)
-
-    def test_empty_file_exits_2(self):
-        code, _, err = run("base.xml", "empty.xml")
-        self.assertEqual(code, 2)
-        self.assertIn("empty.xml", err)
-
-    def test_report_without_cases_exits_2(self):
-        code, _, _ = run("no_cases.xml", "no_cases.xml")
-        self.assertEqual(code, 2)
-
-    def test_unexpected_root_exits_2(self):
-        code, _, _ = run("wrong_root.xml", "base.xml")
-        self.assertEqual(code, 2)
-
-    def test_nonexistent_file_exits_2(self):
-        code, _, _ = run("base.xml", "does_not_exist.xml")
-        self.assertEqual(code, 2)
-
-    def test_stale_allow_entry_fails_run(self):
-        code, out, _ = run("base.xml", "pass_fail.xml", "--allow", str(FIXTURES / "allow_stale.txt"))
-        self.assertEqual(code, 1)
-        self.assertIn("rustfs::s3::nonexistent", out)
-        self.assertIn("stale", out.lower())
-
-    def test_allow_entry_without_any_difference_is_stale(self):
-        code, out, _ = run("base.xml", "base.xml", "--allow", str(FIXTURES / "allow_ok.txt"))
-        self.assertEqual(code, 1)
-        self.assertIn("stale", out.lower())
-
-    def test_allow_does_not_cover_other_differences(self):
-        code, out, _ = run("base.xml", "missing_case.xml", "--allow", str(FIXTURES / "allow_ok.txt"))
-        self.assertEqual(code, 1)
-
-    def test_unreadable_allow_file_exits_2(self):
-        code, _, _ = run("base.xml", "base.xml", "--allow", str(FIXTURES / "nope.txt"))
-        self.assertEqual(code, 2)
-
-    # --- positive cases ---
-
-    def test_identical_files_exit_0(self):
-        code, out, _ = run("base.xml", "base.xml")
-        self.assertEqual(code, 0)
-        self.assertIn("No differences", out)
-
-    def test_bare_testsuite_root_matches_nested(self):
-        code, _, _ = run("base.xml", "bare_suite.xml")
-        self.assertEqual(code, 0)
-
-    def test_allowed_difference_exits_0(self):
-        code, out, _ = run("base.xml", "pass_fail.xml", "--allow", str(FIXTURES / "allow_ok.txt"))
-        self.assertEqual(code, 0)
-        self.assertIn("allowed", out.lower())
-
-    def test_allowed_missing_case_exits_0(self):
-        code, _, _ = run("base.xml", "missing_case.xml", "--allow", str(FIXTURES / "allow_missing_case.txt"))
-        self.assertEqual(code, 0)
-
-    def test_flaky_pass_listed_not_a_difference(self):
-        code, out, _ = run("base.xml", "flaky_pass.xml")
-        self.assertEqual(code, 0)
-        self.assertIn("rustfs::s3::alpha", out)
-        self.assertIn("flaky", out.lower())
-
-    # --- options and summary ---
-
-    def test_labels_appear_in_table(self):
-        code, out, _ = run("base.xml", "pass_skip.xml", "--label-a", "reference", "--label-b", "candidate")
-        self.assertEqual(code, 1)
-        self.assertIn("reference", out)
-        self.assertIn("candidate", out)
-
-    def test_json_summary(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "out.json"
-            code, _, _ = run("base.xml", "flaky_pass.xml", "--json", str(path),
-                             "--label-a", "reference", "--label-b", "candidate")
-            self.assertEqual(code, 0)
-            data = json.loads(path.read_text())
-        self.assertEqual(data["counts"]["reference"], {"pass": 3, "fail": 0, "skip": 1})
-        self.assertEqual(data["counts"]["candidate"], {"pass": 3, "fail": 0, "skip": 1})
-        self.assertEqual(data["differences"], [])
-        self.assertEqual(data["flaky"]["candidate"], ["rustfs::s3::alpha"])
-        self.assertEqual(data["flaky"]["reference"], [])
-        self.assertEqual(data["stale_allow"], [])
-
-    def test_json_records_differences(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = Path(tmp) / "out.json"
-            code, _, _ = run("base.xml", "missing_case.xml", "--json", str(path))
-            self.assertEqual(code, 1)
-            data = json.loads(path.read_text())
-        self.assertEqual(data["differences"],
-                         [{"case": "rustfs::s3::beta", "a": "pass", "b": "missing", "allowed": False}])
-        self.assertEqual(data["counts"]["b"], {"pass": 2, "fail": 0, "skip": 1})
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -1,157 +0,0 @@
-#!/usr/bin/env python3
-# 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.
-"""Exercise the reference-binary pin resolver and unpacker without network access."""
-
-import hashlib
-from pathlib import Path
-import subprocess
-import sys
-import tempfile
-import unittest
-import zipfile
-
-ROOT = Path(__file__).resolve().parents[1]
-SCRIPT = ROOT / ".github/actions/reference-binary/reference_binary.py"
-PIN = '''schema = 1
-repository = "rustfs/rustfs"
-version = "1.0.5"
-tag = "1.0.5"
-
-[platforms.linux-x86_64-gnu]
-asset = "rustfs-linux-x86_64-gnu-v1.0.5.zip"
-sha256 = "{sha}"
-executable = "rustfs"
-'''
-SHA = "a" * 64
-
-
-def run(*args):
-    proc = subprocess.run([sys.executable, str(SCRIPT), *args], capture_output=True, text=True, check=False)
-    return proc.returncode, proc.stdout, proc.stderr
-
-
-class Base(unittest.TestCase):
-    def setUp(self):
-        temp = tempfile.TemporaryDirectory()
-        self.addCleanup(temp.cleanup)
-        self.root = Path(temp.name)
-
-    def pin(self, text):
-        path = self.root / "pin.toml"
-        path.write_text(text)
-        return path
-
-    def archive(self, members):
-        path = self.root / "rustfs.zip"
-        with zipfile.ZipFile(path, "w") as bundle:
-            for name, data in members.items():
-                bundle.writestr(name, data)
-        return path, hashlib.sha256(path.read_bytes()).hexdigest()
-
-
-class ResolveTests(Base):
-    def test_missing_pin_file_fails(self):
-        code, _, err = run("resolve", "--pin", str(self.root / "absent.toml"), "--platform", "linux-x86_64-gnu")
-        self.assertEqual(code, 1)
-        self.assertIn("reference pin file is missing", err)
-
-    def test_unpinned_platform_fails(self):
-        code, _, err = run("resolve", "--pin", str(self.pin(PIN.format(sha=SHA))), "--platform", "linux-aarch64-gnu")
-        self.assertEqual(code, 1)
-        self.assertIn("no pin for platform", err)
-
-    def test_malformed_pins_fail(self):
-        good = PIN.format(sha=SHA)
-        for label, text in {
-            "short digest": good.replace(SHA, "a" * 63),
-            "uppercase digest": good.replace(SHA, "A" * 64),
-            "no digest": good.replace(f'sha256 = "{SHA}"\n', ""),
-            "path in asset": good.replace('asset = "rustfs-', 'asset = "../rustfs-'),
-            "non-zip asset": good.replace("v1.0.5.zip", "v1.0.5.deb"),
-            "asset of another version": good.replace("v1.0.5.zip", "v1.0.4.zip"),
-            "path in executable": good.replace('executable = "rustfs"', 'executable = "bin/rustfs"'),
-            "wrong schema": good.replace("schema = 1", "schema = 2"),
-            "boolean schema": good.replace("schema = 1", "schema = true"),
-            "no repository": good.replace('repository = "rustfs/rustfs"\n', ""),
-            "unknown key": good + 'url = "https://example.invalid"\n',
-            "not toml": "schema = \n",
-        }.items():
-            with self.subTest(label):
-                code, _, _ = run("resolve", "--pin", str(self.pin(text)), "--platform", "linux-x86_64-gnu")
-                self.assertEqual(code, 1)
-
-    def test_resolves_identity_as_step_outputs(self):
-        code, out, err = run("resolve", "--pin", str(self.pin(PIN.format(sha=SHA))), "--platform", "linux-x86_64-gnu")
-        self.assertEqual(code, 0, err)
-        self.assertEqual(out.splitlines(), ["repository=rustfs/rustfs", "version=1.0.5", "tag=1.0.5",
-                                            "asset=rustfs-linux-x86_64-gnu-v1.0.5.zip", f"sha256={SHA}",
-                                            "executable=rustfs"])
-
-    def test_repository_pin_is_valid(self):
-        code, out, err = run("resolve", "--pin", str(ROOT / ".config/reference-binary.toml"),
-                             "--platform", "linux-x86_64-gnu")
-        self.assertEqual(code, 0, err)
-        self.assertIn("version=1.0.5", out.splitlines())
-
-
-class UnpackTests(Base):
-    def unpack(self, archive, sha):
-        return run("unpack", "--archive", str(archive), "--sha256", sha, "--executable", "rustfs",
-                   "--destination", str(self.root / "out"))
-
-    def test_digest_mismatch_fails_and_extracts_nothing(self):
-        archive, _ = self.archive({"rustfs": b"binary"})
-        code, _, err = self.unpack(archive, SHA)
-        self.assertEqual(code, 1)
-        self.assertIn("does not match the pinned digest", err)
-        self.assertFalse((self.root / "out").exists())
-
-    def test_missing_archive_fails(self):
-        code, _, err = self.unpack(self.root / "absent.zip", SHA)
-        self.assertEqual(code, 1)
-        self.assertIn("missing or unreadable", err)
-
-    def test_archive_without_top_level_executable_fails(self):
-        archive, sha = self.archive({"bin/rustfs": b"binary"})
-        code, _, err = self.unpack(archive, sha)
-        self.assertEqual(code, 1)
-        self.assertIn("exactly one top-level", err)
-
-    def test_empty_executable_fails(self):
-        archive, sha = self.archive({"rustfs": b""})
-        code, _, _ = self.unpack(archive, sha)
-        self.assertEqual(code, 1)
-
-    def test_non_zip_archive_fails(self):
-        archive = self.root / "rustfs.zip"
-        archive.write_bytes(b"not a zip")
-        code, _, err = self.unpack(archive, hashlib.sha256(b"not a zip").hexdigest())
-        self.assertEqual(code, 1)
-        self.assertIn("not a valid zip", err)
-
-    def test_extracts_only_the_executable(self):
-        archive, sha = self.archive({"rustfs": b"binary", "../escape": b"x", "README": b"r"})
-        code, out, err = self.unpack(archive, sha)
-        self.assertEqual(code, 0, err)
-        target = self.root / "out" / "rustfs"
-        self.assertEqual(out.strip(), f"path={target}")
-        self.assertEqual(target.read_bytes(), b"binary")
-        self.assertTrue(target.stat().st_mode & 0o111)
-        self.assertEqual(sorted(p.name for p in (self.root / "out").iterdir()), ["rustfs"])
-        self.assertFalse((self.root / "escape").exists())
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -1 +0,0 @@
-rustfs::s3::beta
@@ -1,3 +0,0 @@
-# tolerated while the gateway lane stabilises
-rustfs::s3::alpha
-
@@ -1,3 +0,0 @@
-rustfs::s3::alpha
-rustfs::s3::nonexistent
-
@@ -1,6 +0,0 @@
-<testsuite name="rustfs" tests="4">
-  <testcase name="alpha" classname="rustfs::s3"/>
-  <testcase name="beta" classname="rustfs::s3"/>
-  <testcase name="gamma" classname="rustfs::s3"><skipped/></testcase>
-  <testcase name="delta" classname="rustfs::iam"/>
-</testsuite>
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<testsuites name="nextest-run">
-  <testsuite name="rustfs" tests="3">
-    <testcase name="alpha" classname="rustfs::s3"/>
-    <testcase name="beta" classname="rustfs::s3"/>
-    <testcase name="gamma" classname="rustfs::s3"><skipped/></testcase>
-  </testsuite>
-  <testsuite name="other" tests="1">
-    <testcase name="delta" classname="rustfs::iam"/>
-  </testsuite>
-</testsuites>
@@ -1,6 +0,0 @@
-<testsuites><testsuite name="rustfs">
-  <testcase name="alpha" classname="rustfs::s3"><flakyFailure message="first try"/></testcase>
-  <testcase name="beta" classname="rustfs::s3"/>
-  <testcase name="gamma" classname="rustfs::s3"><skipped/></testcase>
-  <testcase name="delta" classname="rustfs::iam"/>
-</testsuite></testsuites>
@@ -1 +0,0 @@
-<testsuites><testsuite><testcase name="alpha" classname="x">
@@ -1,5 +0,0 @@
-<testsuites><testsuite name="rustfs">
-  <testcase name="alpha" classname="rustfs::s3"/>
-  <testcase name="gamma" classname="rustfs::s3"><skipped/></testcase>
-  <testcase name="delta" classname="rustfs::iam"/>
-</testsuite></testsuites>
@@ -1 +0,0 @@
-<testsuites><testsuite name="rustfs"/></testsuites>
@@ -1,6 +0,0 @@
-<testsuites><testsuite name="rustfs">
-  <testcase name="alpha" classname="rustfs::s3"><error message="crash"/></testcase>
-  <testcase name="beta" classname="rustfs::s3"/>
-  <testcase name="gamma" classname="rustfs::s3"><skipped/></testcase>
-  <testcase name="delta" classname="rustfs::iam"/>
-</testsuite></testsuites>
@@ -1,6 +0,0 @@
-<testsuites><testsuite name="rustfs">
-  <testcase name="alpha" classname="rustfs::s3"><failure message="boom"/></testcase>
-  <testcase name="beta" classname="rustfs::s3"/>
-  <testcase name="gamma" classname="rustfs::s3"><skipped/></testcase>
-  <testcase name="delta" classname="rustfs::iam"/>
-</testsuite></testsuites>
@@ -1,6 +0,0 @@
-<testsuites><testsuite name="rustfs">
-  <testcase name="alpha" classname="rustfs::s3"><skipped/></testcase>
-  <testcase name="beta" classname="rustfs::s3"/>
-  <testcase name="gamma" classname="rustfs::s3"><skipped/></testcase>
-  <testcase name="delta" classname="rustfs::iam"/>
-</testsuite></testsuites>
@@ -1,6 +0,0 @@
-<testsuites><testsuite name="rustfs">
-  <testcase name="alpha" classname="rustfs::s3"><failure message="boom"/><rerunFailure message="again"/></testcase>
-  <testcase name="beta" classname="rustfs::s3"/>
-  <testcase name="gamma" classname="rustfs::s3"><skipped/></testcase>
-  <testcase name="delta" classname="rustfs::iam"/>
-</testsuite></testsuites>
@@ -1 +0,0 @@
-<html><body/></html>
				`@@ -1 +0,0 @@`
				`<testsuites><testsuite><testcase name="alpha" classname="x">`
				`@@ -1 +0,0 @@`
				`<testsuites><testsuite name="rustfs"/></testsuites>`