refactor: consolidate ecstore owner module layout (#3934)

* refactor: shrink ecstore root owner facades

* refactor: remove ecstore core store root shims

* refactor: move ecstore erasure owner modules

* refactor: remove ecstore root rpc facade

* refactor: move ecstore services domain modules

crates/ecstore/src/erasure/coding/bitrot.rs

@@ -0,0 +1,642 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use bytes::Bytes;
+use pin_project_lite::pin_project;
+use rustfs_utils::HashAlgorithm;
+use std::io::IoSlice;
+use std::time::Duration;
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+use tracing::error;
+use uuid::Uuid;
+
+pin_project! {
+    /// BitrotReader reads (hash+data) blocks from an async reader and verifies hash integrity.
+    pub struct BitrotReader<R> {
+        #[pin]
+        inner: R,
+        hash_algo: HashAlgorithm,
+        shard_size: usize,
+        buf: Vec<u8>,
+        hash_buf: Vec<u8>,
+        skip_verify: bool,
+        last_verify_duration: Duration,
+        id: Uuid,
+    }
+}
+
+impl<R> BitrotReader<R>
+where
+    R: AsyncRead + Unpin + Send + Sync,
+{
+    /// Create a new BitrotReader.
+    pub fn new(inner: R, shard_size: usize, algo: HashAlgorithm, skip_verify: bool) -> Self {
+        let hash_size = algo.size();
+        Self {
+            inner,
+            hash_algo: algo,
+            shard_size,
+            buf: Vec::new(),
+            hash_buf: vec![0u8; hash_size],
+            skip_verify,
+            last_verify_duration: Duration::ZERO,
+            id: Uuid::new_v4(),
+        }
+    }
+
+    pub(crate) fn last_verify_duration(&self) -> Duration {
+        self.last_verify_duration
+    }
+
+    /// Read a single (hash+data) block, verify hash, and return the number of bytes read into `out`.
+    /// Returns an error if hash verification fails or data exceeds shard_size.
+    pub async fn read(&mut self, out: &mut [u8]) -> std::io::Result<usize> {
+        self.last_verify_duration = Duration::ZERO;
+        if out.len() > self.shard_size {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("data size {} exceeds shard size {}", out.len(), self.shard_size),
+            ));
+        }
+
+        let hash_size = self.hash_algo.size();
+        // Read hash
+
+        if hash_size > 0 {
+            self.inner.read_exact(&mut self.hash_buf).await.map_err(|e| {
+                error!("bitrot reader read hash error: {}", e);
+                e
+            })?;
+        }
+
+        // Read data
+        let mut data_len = 0;
+        while data_len < out.len() {
+            let n = self.inner.read(&mut out[data_len..]).await.map_err(|e| {
+                error!("bitrot reader read data error: {}", e);
+                e
+            })?;
+            if n == 0 {
+                break;
+            }
+            data_len += n;
+        }
+
+        if hash_size > 0 && !self.skip_verify {
+            let verify_start = std::time::Instant::now();
+            let actual_hash = self.hash_algo.hash_encode(&out[..data_len]);
+            self.last_verify_duration = verify_start.elapsed();
+            if actual_hash.as_ref() != self.hash_buf.as_slice() {
+                error!("bitrot reader hash mismatch, id={} data_len={}, out_len={}", self.id, data_len, out.len());
+                return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bitrot hash mismatch"));
+            }
+        }
+        Ok(data_len)
+    }
+}
+
+pin_project! {
+    /// BitrotWriter writes (hash+data) blocks to an async writer.
+    pub struct BitrotWriter<W> {
+        #[pin]
+        inner: W,
+        hash_algo: HashAlgorithm,
+        shard_size: usize,
+        finished: bool,
+    }
+}
+
+impl<W> BitrotWriter<W>
+where
+    W: AsyncWrite + Unpin + Send + Sync,
+{
+    /// Create a new BitrotWriter.
+    pub fn new(inner: W, shard_size: usize, algo: HashAlgorithm) -> Self {
+        let hash_algo = algo;
+        Self {
+            inner,
+            hash_algo,
+            shard_size,
+            finished: false,
+        }
+    }
+
+    pub fn into_inner(self) -> W {
+        self.inner
+    }
+
+    /// Write a (hash+data) block. Returns the number of data bytes written.
+    /// Returns an error if called after a short write or if data exceeds shard_size.
+    pub async fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        if buf.is_empty() {
+            return Ok(0);
+        }
+
+        if self.finished {
+            return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, "bitrot writer already finished"));
+        }
+
+        if buf.len() > self.shard_size {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("data size {} exceeds shard size {}", buf.len(), self.shard_size),
+            ));
+        }
+
+        if buf.len() < self.shard_size {
+            self.finished = true;
+        }
+
+        let hash_algo = &self.hash_algo;
+
+        if hash_algo.size() > 0 {
+            let hash = hash_algo.hash_encode(buf);
+            if hash.as_ref().is_empty() {
+                error!("bitrot writer write hash error: hash is empty");
+                return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, "hash is empty"));
+            }
+            write_all_vectored(&mut self.inner, hash.as_ref(), buf).await?;
+        } else {
+            self.inner.write_all(buf).await?;
+        }
+
+        let n = buf.len();
+
+        Ok(n)
+    }
+
+    pub async fn shutdown(&mut self) -> std::io::Result<()> {
+        self.inner.flush().await?;
+        self.inner.shutdown().await
+    }
+}
+
+async fn write_all_vectored<W>(writer: &mut W, hash: &[u8], data: &[u8]) -> std::io::Result<()>
+where
+    W: AsyncWrite + Unpin,
+{
+    let mut hash_offset = 0;
+    let mut data_offset = 0;
+
+    while hash_offset < hash.len() || data_offset < data.len() {
+        let slices = [IoSlice::new(&hash[hash_offset..]), IoSlice::new(&data[data_offset..])];
+        let written = writer.write_vectored(&slices).await?;
+        if written == 0 {
+            return Err(std::io::Error::new(std::io::ErrorKind::WriteZero, "failed to write hash and data"));
+        }
+
+        let hash_remaining = hash.len() - hash_offset;
+        if written < hash_remaining {
+            hash_offset += written;
+            continue;
+        }
+
+        hash_offset = hash.len();
+        data_offset += written - hash_remaining;
+    }
+
+    Ok(())
+}
+
+pub fn bitrot_shard_file_size(size: usize, shard_size: usize, algo: HashAlgorithm) -> usize {
+    if algo != HashAlgorithm::HighwayHash256S && algo != HashAlgorithm::HighwayHash256SLegacy {
+        return size;
+    }
+    size.div_ceil(shard_size) * algo.size() + size
+}
+
+pub async fn bitrot_verify<R: AsyncRead + Unpin + Send>(
+    mut r: R,
+    want_size: usize,
+    part_size: usize,
+    algo: HashAlgorithm,
+    _want: Bytes, // FIXME: useless parameter?
+    mut shard_size: usize,
+) -> std::io::Result<()> {
+    let mut hash_buf = vec![0; algo.size()];
+    let mut left = want_size;
+
+    if left != bitrot_shard_file_size(part_size, shard_size, algo.clone()) {
+        return Err(std::io::Error::other("bitrot shard file size mismatch"));
+    }
+
+    while left > 0 {
+        let n = r.read_exact(&mut hash_buf).await?;
+        left -= n;
+
+        if left < shard_size {
+            shard_size = left;
+        }
+
+        let mut buf = vec![0; shard_size];
+        let read = r.read_exact(&mut buf).await?;
+
+        let actual_hash = algo.hash_encode(&buf);
+        if actual_hash.as_ref() != &hash_buf[0..n] {
+            return Err(std::io::Error::other("bitrot hash mismatch"));
+        }
+
+        left -= read;
+    }
+
+    Ok(())
+}
+
+/// Custom writer enum that supports inline buffer storage
+pub enum CustomWriter {
+    /// Inline buffer writer - stores data in memory
+    InlineBuffer(Vec<u8>),
+    /// Disk-based writer using tokio file
+    Other(Box<dyn AsyncWrite + Unpin + Send + Sync>),
+}
+
+impl CustomWriter {
+    /// Create a new inline buffer writer
+    pub fn new_inline_buffer() -> Self {
+        Self::InlineBuffer(Vec::new())
+    }
+
+    /// Create a new disk writer from any AsyncWrite implementation
+    pub fn new_tokio_writer<W>(writer: W) -> Self
+    where
+        W: AsyncWrite + Unpin + Send + Sync + 'static,
+    {
+        Self::Other(Box::new(writer))
+    }
+
+    /// Get the inline buffer data if this is an inline buffer writer
+    pub fn get_inline_data(&self) -> Option<&[u8]> {
+        match self {
+            Self::InlineBuffer(data) => Some(data),
+            Self::Other(_) => None,
+        }
+    }
+
+    /// Extract the inline buffer data, consuming the writer
+    pub fn into_inline_data(self) -> Option<Vec<u8>> {
+        match self {
+            Self::InlineBuffer(data) => Some(data),
+            Self::Other(_) => None,
+        }
+    }
+}
+
+impl AsyncWrite for CustomWriter {
+    fn poll_write(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &[u8],
+    ) -> std::task::Poll<std::io::Result<usize>> {
+        match self.get_mut() {
+            Self::InlineBuffer(data) => {
+                data.extend_from_slice(buf);
+                std::task::Poll::Ready(Ok(buf.len()))
+            }
+            Self::Other(writer) => {
+                let pinned_writer = std::pin::Pin::new(writer.as_mut());
+                pinned_writer.poll_write(cx, buf)
+            }
+        }
+    }
+
+    fn poll_flush(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<std::io::Result<()>> {
+        match self.get_mut() {
+            Self::InlineBuffer(_) => std::task::Poll::Ready(Ok(())),
+            Self::Other(writer) => {
+                let pinned_writer = std::pin::Pin::new(writer.as_mut());
+                pinned_writer.poll_flush(cx)
+            }
+        }
+    }
+
+    fn poll_shutdown(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<std::io::Result<()>> {
+        match self.get_mut() {
+            Self::InlineBuffer(_) => std::task::Poll::Ready(Ok(())),
+            Self::Other(writer) => {
+                let pinned_writer = std::pin::Pin::new(writer.as_mut());
+                pinned_writer.poll_shutdown(cx)
+            }
+        }
+    }
+
+    fn poll_write_vectored(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> std::task::Poll<std::io::Result<usize>> {
+        match self.get_mut() {
+            Self::InlineBuffer(data) => {
+                let total = bufs.iter().map(|buf| buf.len()).sum::<usize>();
+                for buf in bufs {
+                    data.extend_from_slice(buf);
+                }
+                std::task::Poll::Ready(Ok(total))
+            }
+            Self::Other(writer) => {
+                let pinned_writer = std::pin::Pin::new(writer.as_mut());
+                pinned_writer.poll_write_vectored(cx, bufs)
+            }
+        }
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        match self {
+            Self::InlineBuffer(_) => true,
+            Self::Other(writer) => writer.is_write_vectored(),
+        }
+    }
+}
+
+/// Wrapper around BitrotWriter that uses our custom writer
+pub struct BitrotWriterWrapper {
+    bitrot_writer: BitrotWriter<CustomWriter>,
+    writer_type: WriterType,
+}
+
+/// Enum to track the type of writer we're using
+enum WriterType {
+    InlineBuffer,
+    Other,
+}
+
+impl std::fmt::Debug for BitrotWriterWrapper {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BitrotWriterWrapper")
+            .field(
+                "writer_type",
+                &match self.writer_type {
+                    WriterType::InlineBuffer => "InlineBuffer",
+                    WriterType::Other => "Other",
+                },
+            )
+            .finish()
+    }
+}
+
+impl BitrotWriterWrapper {
+    /// Create a new BitrotWriterWrapper with custom writer
+    pub fn new(writer: CustomWriter, shard_size: usize, checksum_algo: HashAlgorithm) -> Self {
+        let writer_type = match &writer {
+            CustomWriter::InlineBuffer(_) => WriterType::InlineBuffer,
+            CustomWriter::Other(_) => WriterType::Other,
+        };
+
+        Self {
+            bitrot_writer: BitrotWriter::new(writer, shard_size, checksum_algo),
+            writer_type,
+        }
+    }
+
+    /// Write data to the bitrot writer
+    pub async fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.bitrot_writer.write(buf).await
+    }
+
+    pub async fn shutdown(&mut self) -> std::io::Result<()> {
+        self.bitrot_writer.shutdown().await
+    }
+
+    /// Extract the inline buffer data, consuming the wrapper
+    pub fn into_inline_data(self) -> Option<Vec<u8>> {
+        match self.writer_type {
+            WriterType::InlineBuffer => {
+                let writer = self.bitrot_writer.into_inner();
+                writer.into_inline_data()
+            }
+            WriterType::Other => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::BitrotReader;
+    use super::BitrotWriter;
+    use rustfs_utils::HashAlgorithm;
+    use std::io::{Cursor, IoSlice};
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+    use std::task::{Context, Poll};
+    use tokio::io::AsyncWrite;
+
+    #[derive(Default)]
+    struct VectoredCountingWriter {
+        vectored_writes: Arc<AtomicUsize>,
+        writes: Vec<u8>,
+    }
+
+    impl AsyncWrite for VectoredCountingWriter {
+        fn poll_write(self: std::pin::Pin<&mut Self>, _cx: &mut Context<'_>, _buf: &[u8]) -> Poll<std::io::Result<usize>> {
+            Poll::Ready(Err(std::io::Error::other("poll_write should not be used")))
+        }
+
+        fn poll_flush(self: std::pin::Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+
+        fn poll_shutdown(self: std::pin::Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+
+        fn poll_write_vectored(
+            mut self: std::pin::Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            bufs: &[IoSlice<'_>],
+        ) -> Poll<std::io::Result<usize>> {
+            self.vectored_writes.fetch_add(1, Ordering::SeqCst);
+            let total = bufs.iter().map(|buf| buf.len()).sum::<usize>();
+            for buf in bufs {
+                self.writes.extend_from_slice(buf);
+            }
+            Poll::Ready(Ok(total))
+        }
+
+        fn is_write_vectored(&self) -> bool {
+            true
+        }
+    }
+
+    #[derive(Default)]
+    struct CountingWriter {
+        flushes: Arc<AtomicUsize>,
+        shutdowns: Arc<AtomicUsize>,
+        writes: Vec<u8>,
+    }
+
+    impl AsyncWrite for CountingWriter {
+        fn poll_write(mut self: std::pin::Pin<&mut Self>, _cx: &mut Context<'_>, buf: &[u8]) -> Poll<std::io::Result<usize>> {
+            self.writes.extend_from_slice(buf);
+            Poll::Ready(Ok(buf.len()))
+        }
+
+        fn poll_flush(self: std::pin::Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            self.flushes.fetch_add(1, Ordering::SeqCst);
+            Poll::Ready(Ok(()))
+        }
+
+        fn poll_shutdown(self: std::pin::Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            self.shutdowns.fetch_add(1, Ordering::SeqCst);
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    #[tokio::test]
+    async fn test_bitrot_read_write_ok() {
+        let data = b"hello world! this is a test shard.";
+        let data_size = data.len();
+        let shard_size = 8;
+
+        let buf: Vec<u8> = Vec::new();
+        let writer = Cursor::new(buf);
+        let mut bitrot_writer = BitrotWriter::new(writer, shard_size, HashAlgorithm::HighwayHash256);
+
+        let mut n = 0;
+        for chunk in data.chunks(shard_size) {
+            n += bitrot_writer.write(chunk).await.unwrap();
+        }
+        assert_eq!(n, data.len());
+
+        // Read
+        let reader = bitrot_writer.into_inner();
+        let reader = Cursor::new(reader.into_inner());
+        let mut bitrot_reader = BitrotReader::new(reader, shard_size, HashAlgorithm::HighwayHash256, false);
+        let mut out = Vec::new();
+        let mut n = 0;
+        while n < data_size {
+            let mut buf = vec![0u8; shard_size];
+            let m = bitrot_reader.read(&mut buf).await.unwrap();
+            assert_eq!(&buf[..m], &data[n..n + m]);
+
+            out.extend_from_slice(&buf[..m]);
+            n += m;
+        }
+
+        assert_eq!(n, data_size);
+        assert_eq!(data, &out[..]);
+    }
+
+    #[tokio::test]
+    async fn test_bitrot_read_hash_mismatch() {
+        let data = b"test data for bitrot";
+        let data_size = data.len();
+        let shard_size = 8;
+        let buf: Vec<u8> = Vec::new();
+        let writer = Cursor::new(buf);
+        let mut bitrot_writer = BitrotWriter::new(writer, shard_size, HashAlgorithm::HighwayHash256);
+        for chunk in data.chunks(shard_size) {
+            let _ = bitrot_writer.write(chunk).await.unwrap();
+        }
+        let mut written = bitrot_writer.into_inner().into_inner();
+        // change the last byte to make hash mismatch
+        let pos = written.len() - 1;
+        written[pos] ^= 0xFF;
+        let reader = Cursor::new(written);
+        let mut bitrot_reader = BitrotReader::new(reader, shard_size, HashAlgorithm::HighwayHash256, false);
+
+        let count = data_size.div_ceil(shard_size);
+
+        let mut idx = 0;
+        let mut n = 0;
+        while n < data_size {
+            let mut buf = vec![0u8; shard_size];
+            let res = bitrot_reader.read(&mut buf).await;
+
+            if idx == count - 1 {
+                // The last chunk should trigger an error
+                assert!(res.is_err());
+                assert_eq!(res.unwrap_err().kind(), std::io::ErrorKind::InvalidData);
+                break;
+            }
+
+            let m = res.unwrap();
+
+            assert_eq!(&buf[..m], &data[n..n + m]);
+
+            n += m;
+            idx += 1;
+        }
+    }
+
+    #[tokio::test]
+    async fn test_bitrot_read_write_none_hash() {
+        let data = b"bitrot none hash test data!";
+        let data_size = data.len();
+        let shard_size = 8;
+
+        let buf: Vec<u8> = Vec::new();
+        let writer = Cursor::new(buf);
+        let mut bitrot_writer = BitrotWriter::new(writer, shard_size, HashAlgorithm::None);
+
+        let mut n = 0;
+        for chunk in data.chunks(shard_size) {
+            n += bitrot_writer.write(chunk).await.unwrap();
+        }
+        assert_eq!(n, data.len());
+
+        let reader = bitrot_writer.into_inner();
+        let reader = Cursor::new(reader.into_inner());
+        let mut bitrot_reader = BitrotReader::new(reader, shard_size, HashAlgorithm::None, false);
+        let mut out = Vec::new();
+        let mut n = 0;
+        while n < data_size {
+            let mut buf = vec![0u8; shard_size];
+            let m = bitrot_reader.read(&mut buf).await.unwrap();
+            assert_eq!(&buf[..m], &data[n..n + m]);
+            out.extend_from_slice(&buf[..m]);
+            n += m;
+        }
+        assert_eq!(n, data_size);
+        assert_eq!(data, &out[..]);
+    }
+
+    #[tokio::test]
+    async fn test_bitrot_writer_flushes_once_on_shutdown() {
+        let flushes = Arc::new(AtomicUsize::new(0));
+        let shutdowns = Arc::new(AtomicUsize::new(0));
+        let writer = CountingWriter {
+            flushes: flushes.clone(),
+            shutdowns: shutdowns.clone(),
+            writes: Vec::new(),
+        };
+        let mut bitrot_writer = BitrotWriter::new(writer, 8, HashAlgorithm::None);
+
+        bitrot_writer.write(b"12345678").await.unwrap();
+        bitrot_writer.write(b"abc").await.unwrap();
+
+        assert_eq!(flushes.load(Ordering::SeqCst), 0);
+        assert_eq!(shutdowns.load(Ordering::SeqCst), 0);
+
+        bitrot_writer.shutdown().await.unwrap();
+
+        assert_eq!(flushes.load(Ordering::SeqCst), 1);
+        assert_eq!(shutdowns.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn test_bitrot_writer_uses_vectored_write_for_hash_and_data() {
+        let vectored_writes = Arc::new(AtomicUsize::new(0));
+        let writer = VectoredCountingWriter {
+            vectored_writes: vectored_writes.clone(),
+            writes: Vec::new(),
+        };
+        let mut bitrot_writer = BitrotWriter::new(writer, 8, HashAlgorithm::HighwayHash256);
+
+        bitrot_writer.write(b"payload").await.unwrap();
+
+        assert!(vectored_writes.load(Ordering::SeqCst) > 0);
+    }
+}

crates/ecstore/src/erasure/coding/decode_reader.rs

@@ -0,0 +1,738 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::diagnostics::get::{
+    GET_OBJECT_PATH_CODEC_STREAMING, GET_READER_BUFFER_OUTPUT, GET_READER_BUFFER_PREFETCH, GET_READER_POLL_PENDING,
+    GET_READER_POLL_READY_DATA, GET_READER_POLL_READY_EMPTY, GET_READER_POLL_READY_ERROR, GET_READER_PREFETCH_DIRECT,
+    GET_READER_PREFETCH_EOF, GET_READER_PREFETCH_ERROR_DEFERRED, GET_READER_PREFETCH_ERROR_IMMEDIATE, GET_READER_PREFETCH_STORED,
+    GET_STAGE_DECODE, GET_STAGE_EMIT, GET_STAGE_FILL, GET_STAGE_OUTPUT_LOCK_WAIT, GET_STAGE_OUTPUT_POLL, GET_STAGE_RECONSTRUCT,
+    GET_STAGE_STRIPE_READ,
+};
+use crate::disk::error::Error as DiskError;
+use crate::erasure::codec::bridge::ErasureDecodeEngine;
+use crate::set_disk::shard_source::{ShardStripeSource, StripeReadState};
+use std::io;
+use std::io::ErrorKind;
+use std::pin::Pin;
+use std::sync::Mutex;
+use std::task::{Context, Poll, ready};
+use std::time::Instant;
+use tokio::io::{AsyncRead, ReadBuf};
+use tokio::task::JoinHandle;
+
+type FillTask<S, W> = JoinHandle<FillResult<S, W>>;
+
+struct FillResult<S, W> {
+    source: S,
+    workspace: W,
+    result: io::Result<Option<Vec<u8>>>,
+}
+
+pub(crate) struct ErasureDecodeReader<S, E>
+where
+    E: ErasureDecodeEngine,
+{
+    source: Option<S>,
+    engine: E,
+    workspace: Option<E::Workspace>,
+    output_buf: Vec<u8>,
+    output_pos: usize,
+    prefetched_buf: Option<Vec<u8>>,
+    prefetch_error: Option<io::Error>,
+    prefetch_wait_started_at: Option<Instant>,
+    remaining: usize,
+    // Bounded lookahead: at most one background stripe read/decode is in flight.
+    fill: Option<FillTask<S, E::Workspace>>,
+}
+
+impl<S, E> ErasureDecodeReader<S, E>
+where
+    S: ShardStripeSource + Send + 'static,
+    E: ErasureDecodeEngine + Clone + Send + Sync + 'static,
+{
+    pub(crate) fn new(source: S, engine: E, total_length: usize) -> io::Result<Self> {
+        if engine.data_shards() == 0 {
+            return Err(io::Error::new(ErrorKind::InvalidInput, "erasure reader requires data shards"));
+        }
+        if engine.block_size() == 0 {
+            return Err(io::Error::new(ErrorKind::InvalidInput, "erasure reader requires non-zero block size"));
+        }
+
+        let shard_len = engine.block_size().div_ceil(engine.data_shards());
+        let workspace = engine.prepare_workspace(shard_len)?;
+
+        Ok(Self {
+            source: Some(source),
+            engine,
+            workspace: Some(workspace),
+            output_buf: Vec::new(),
+            output_pos: 0,
+            prefetched_buf: None,
+            prefetch_error: None,
+            prefetch_wait_started_at: None,
+            remaining: total_length,
+            fill: None,
+        })
+    }
+
+    fn poll_fill_result(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<Option<Vec<u8>>>> {
+        if self.fill.is_none() {
+            let Some(mut source) = self.source.take() else {
+                return Poll::Ready(Err(io::Error::new(ErrorKind::BrokenPipe, "erasure reader source missing")));
+            };
+            let Some(mut workspace) = self.workspace.take() else {
+                self.source = Some(source);
+                return Poll::Ready(Err(io::Error::new(ErrorKind::BrokenPipe, "erasure reader workspace missing")));
+            };
+
+            let engine = self.engine.clone();
+            let remaining = self.remaining;
+            self.fill = Some(tokio::spawn(async move {
+                let fill_stage_start = Instant::now();
+                let stripe_read_stage_start = Instant::now();
+                let state = source.read_next_stripe().await;
+                rustfs_io_metrics::record_get_object_stage_duration(
+                    GET_OBJECT_PATH_CODEC_STREAMING,
+                    GET_STAGE_STRIPE_READ,
+                    stripe_read_stage_start.elapsed().as_secs_f64(),
+                );
+                let decode_stage_start = Instant::now();
+                let result = decode_stripe(&engine, &mut workspace, state, remaining);
+                rustfs_io_metrics::record_get_object_stage_duration(
+                    GET_OBJECT_PATH_CODEC_STREAMING,
+                    GET_STAGE_DECODE,
+                    decode_stage_start.elapsed().as_secs_f64(),
+                );
+                rustfs_io_metrics::record_get_object_stage_duration(
+                    GET_OBJECT_PATH_CODEC_STREAMING,
+                    GET_STAGE_FILL,
+                    fill_stage_start.elapsed().as_secs_f64(),
+                );
+                FillResult {
+                    source,
+                    workspace,
+                    result,
+                }
+            }));
+        }
+
+        let fill = self
+            .fill
+            .as_mut()
+            .ok_or_else(|| io::Error::new(ErrorKind::BrokenPipe, "erasure reader fill future missing"))?;
+        let fill_result = ready!(Pin::new(fill).poll(cx));
+        let FillResult {
+            source,
+            workspace,
+            result,
+        } = match fill_result {
+            Ok(result) => result,
+            Err(err) => {
+                self.fill = None;
+                return Poll::Ready(Err(io::Error::other(format!("erasure reader fill task failed: {err}"))));
+            }
+        };
+
+        self.source = Some(source);
+        self.workspace = Some(workspace);
+        self.fill = None;
+
+        match result {
+            Ok(Some(buf)) => {
+                if buf.is_empty() && self.remaining > 0 {
+                    return Poll::Ready(Err(DiskError::LessData.into()));
+                }
+                rustfs_io_metrics::record_get_object_reader_stripe(GET_OBJECT_PATH_CODEC_STREAMING);
+                rustfs_io_metrics::record_get_object_reader_bytes(GET_OBJECT_PATH_CODEC_STREAMING, buf.len());
+                self.remaining -= buf.len();
+                Poll::Ready(Ok(Some(buf)))
+            }
+            Ok(None) => {
+                if self.remaining == 0 {
+                    Poll::Ready(Ok(None))
+                } else {
+                    Poll::Ready(Err(DiskError::LessData.into()))
+                }
+            }
+            Err(err) => Poll::Ready(Err(err)),
+        }
+    }
+
+    fn poll_prefetch(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        if self.prefetched_buf.is_some() || self.prefetch_error.is_some() || self.remaining == 0 {
+            return Poll::Ready(Ok(()));
+        }
+
+        if self.prefetch_wait_started_at.is_none() {
+            self.prefetch_wait_started_at = Some(Instant::now());
+        }
+
+        let fill = match self.poll_fill_result(cx) {
+            Poll::Ready(result) => {
+                if let Some(started_at) = self.prefetch_wait_started_at.take() {
+                    rustfs_io_metrics::record_get_object_reader_prefetch_wait(
+                        GET_OBJECT_PATH_CODEC_STREAMING,
+                        started_at.elapsed().as_secs_f64(),
+                    );
+                }
+                result
+            }
+            Poll::Pending => return Poll::Pending,
+        };
+
+        match fill {
+            Ok(Some(buf)) => {
+                if self.output_pos < self.output_buf.len() {
+                    rustfs_io_metrics::record_get_object_reader_prefetch(
+                        GET_OBJECT_PATH_CODEC_STREAMING,
+                        GET_READER_PREFETCH_STORED,
+                    );
+                    rustfs_io_metrics::record_get_object_reader_buffer(
+                        GET_OBJECT_PATH_CODEC_STREAMING,
+                        GET_READER_BUFFER_PREFETCH,
+                        buf.len(),
+                    );
+                    self.prefetched_buf = Some(buf);
+                } else {
+                    rustfs_io_metrics::record_get_object_reader_prefetch(
+                        GET_OBJECT_PATH_CODEC_STREAMING,
+                        GET_READER_PREFETCH_DIRECT,
+                    );
+                    rustfs_io_metrics::record_get_object_reader_buffer(
+                        GET_OBJECT_PATH_CODEC_STREAMING,
+                        GET_READER_BUFFER_OUTPUT,
+                        buf.len(),
+                    );
+                    self.output_buf = buf;
+                    self.output_pos = 0;
+                }
+                Poll::Ready(Ok(()))
+            }
+            Ok(None) => {
+                rustfs_io_metrics::record_get_object_reader_prefetch(GET_OBJECT_PATH_CODEC_STREAMING, GET_READER_PREFETCH_EOF);
+                Poll::Ready(Ok(()))
+            }
+            Err(err) => {
+                if self.output_pos < self.output_buf.len() {
+                    rustfs_io_metrics::record_get_object_reader_prefetch(
+                        GET_OBJECT_PATH_CODEC_STREAMING,
+                        GET_READER_PREFETCH_ERROR_DEFERRED,
+                    );
+                    self.prefetch_error = Some(err);
+                    Poll::Ready(Ok(()))
+                } else {
+                    rustfs_io_metrics::record_get_object_reader_prefetch(
+                        GET_OBJECT_PATH_CODEC_STREAMING,
+                        GET_READER_PREFETCH_ERROR_IMMEDIATE,
+                    );
+                    Poll::Ready(Err(err))
+                }
+            }
+        }
+    }
+}
+
+impl<S, E> Drop for ErasureDecodeReader<S, E>
+where
+    E: ErasureDecodeEngine,
+{
+    fn drop(&mut self) {
+        if let Some(fill) = self.fill.take() {
+            fill.abort();
+        }
+    }
+}
+
+impl<S, E> Unpin for ErasureDecodeReader<S, E> where E: ErasureDecodeEngine {}
+
+impl<S, E> AsyncRead for ErasureDecodeReader<S, E>
+where
+    S: ShardStripeSource + Send + 'static,
+    E: ErasureDecodeEngine + Clone + Send + Sync + 'static,
+{
+    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
+        loop {
+            if self.output_pos < self.output_buf.len() {
+                if self.prefetched_buf.is_none()
+                    && self.prefetch_error.is_none()
+                    && self.remaining > 0
+                    && let Poll::Ready(result) = self.poll_prefetch(cx)
+                {
+                    result?;
+                }
+
+                let available = &self.output_buf[self.output_pos..];
+                let read_buf_remaining_before = buf.remaining();
+                let output_remaining_before = available.len();
+                let copy_len = available.len().min(buf.remaining());
+                let copy_start = Instant::now();
+                buf.put_slice(&available[..copy_len]);
+                self.output_pos += copy_len;
+                if copy_len > 0 {
+                    rustfs_io_metrics::record_get_object_reader_copy(
+                        GET_OBJECT_PATH_CODEC_STREAMING,
+                        copy_len,
+                        read_buf_remaining_before,
+                        output_remaining_before,
+                        copy_start.elapsed().as_secs_f64(),
+                    );
+                }
+                return Poll::Ready(Ok(()));
+            }
+
+            if let Some(next_buf) = self.prefetched_buf.take() {
+                rustfs_io_metrics::record_get_object_reader_buffer(
+                    GET_OBJECT_PATH_CODEC_STREAMING,
+                    GET_READER_BUFFER_OUTPUT,
+                    next_buf.len(),
+                );
+                self.output_buf = next_buf;
+                self.output_pos = 0;
+                continue;
+            }
+
+            if let Some(err) = self.prefetch_error.take() {
+                return Poll::Ready(Err(err));
+            }
+
+            if self.remaining == 0 {
+                return Poll::Ready(Ok(()));
+            }
+
+            ready!(self.poll_prefetch(cx))?;
+        }
+    }
+}
+
+pub(crate) struct SyncErasureDecodeReader<R> {
+    inner: Mutex<R>,
+}
+
+impl<R> SyncErasureDecodeReader<R> {
+    pub(crate) fn new(inner: R) -> Self {
+        Self {
+            inner: Mutex::new(inner),
+        }
+    }
+}
+
+impl<R> AsyncRead for SyncErasureDecodeReader<R>
+where
+    R: AsyncRead + Unpin + Send,
+{
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
+        let lock_wait_start = Instant::now();
+        let mut inner = match self.inner.lock() {
+            Ok(inner) => {
+                rustfs_io_metrics::record_get_object_stage_duration(
+                    GET_OBJECT_PATH_CODEC_STREAMING,
+                    GET_STAGE_OUTPUT_LOCK_WAIT,
+                    lock_wait_start.elapsed().as_secs_f64(),
+                );
+                inner
+            }
+            Err(_) => {
+                rustfs_io_metrics::record_get_object_stage_duration(
+                    GET_OBJECT_PATH_CODEC_STREAMING,
+                    GET_STAGE_OUTPUT_LOCK_WAIT,
+                    lock_wait_start.elapsed().as_secs_f64(),
+                );
+                return Poll::Ready(Err(io::Error::other("erasure decode reader lock poisoned")));
+            }
+        };
+        let read_buf_remaining_before = buf.remaining();
+        let filled_before = buf.filled().len();
+        let poll_start = Instant::now();
+        let result = Pin::new(&mut *inner).poll_read(cx, buf);
+        let poll_duration = poll_start.elapsed().as_secs_f64();
+        let filled_bytes = buf.filled().len().saturating_sub(filled_before);
+        let poll_outcome = match &result {
+            Poll::Ready(Ok(())) if filled_bytes > 0 => GET_READER_POLL_READY_DATA,
+            Poll::Ready(Ok(())) => GET_READER_POLL_READY_EMPTY,
+            Poll::Ready(Err(_)) => GET_READER_POLL_READY_ERROR,
+            Poll::Pending => GET_READER_POLL_PENDING,
+        };
+        rustfs_io_metrics::record_get_object_stage_duration(
+            GET_OBJECT_PATH_CODEC_STREAMING,
+            GET_STAGE_OUTPUT_POLL,
+            poll_duration,
+        );
+        rustfs_io_metrics::record_get_object_reader_poll(
+            GET_OBJECT_PATH_CODEC_STREAMING,
+            poll_outcome,
+            read_buf_remaining_before,
+            filled_bytes,
+            poll_duration,
+        );
+        result
+    }
+}
+
+fn decode_stripe<E>(
+    engine: &E,
+    workspace: &mut E::Workspace,
+    state: StripeReadState,
+    remaining: usize,
+) -> io::Result<Option<Vec<u8>>>
+where
+    E: ErasureDecodeEngine,
+{
+    if state.slots().is_empty() {
+        return Ok(None);
+    }
+    if !state.can_decode() {
+        return Err(DiskError::ErasureReadQuorum.into());
+    }
+
+    let reconstruct_stage_start = Instant::now();
+    if state.data_shards_complete(engine.data_shards()) {
+        rustfs_io_metrics::record_get_object_stage_duration(
+            GET_OBJECT_PATH_CODEC_STREAMING,
+            GET_STAGE_RECONSTRUCT,
+            reconstruct_stage_start.elapsed().as_secs_f64(),
+        );
+        let emit_stage_start = Instant::now();
+        let output = emit_data_shards(&state, engine.data_shards(), engine.block_size(), remaining)?;
+        rustfs_io_metrics::record_get_object_stage_duration(
+            GET_OBJECT_PATH_CODEC_STREAMING,
+            GET_STAGE_EMIT,
+            emit_stage_start.elapsed().as_secs_f64(),
+        );
+        return Ok(Some(output));
+    }
+
+    let (mut shards, _errs) = state.into_parts();
+    if let Err(err) = engine.reconstruct_into(&mut shards, workspace) {
+        rustfs_io_metrics::record_get_object_stage_duration(
+            GET_OBJECT_PATH_CODEC_STREAMING,
+            GET_STAGE_RECONSTRUCT,
+            reconstruct_stage_start.elapsed().as_secs_f64(),
+        );
+        return Err(err);
+    }
+    rustfs_io_metrics::record_get_object_stage_duration(
+        GET_OBJECT_PATH_CODEC_STREAMING,
+        GET_STAGE_RECONSTRUCT,
+        reconstruct_stage_start.elapsed().as_secs_f64(),
+    );
+
+    if shards.len() < engine.data_shards() {
+        return Err(io::Error::new(
+            ErrorKind::UnexpectedEof,
+            "decoded stripe has fewer shards than data shard count",
+        ));
+    }
+
+    let emit_stage_start = Instant::now();
+    let mut output = Vec::with_capacity(engine.block_size().min(remaining));
+    for shard in shards.iter().take(engine.data_shards()) {
+        if output.len() >= remaining {
+            break;
+        }
+        let Some(shard) = shard else {
+            return Err(io::Error::new(ErrorKind::UnexpectedEof, "decoded stripe is missing a data shard"));
+        };
+        let copy_len = shard.len().min(remaining - output.len());
+        output.extend_from_slice(&shard[..copy_len]);
+    }
+    rustfs_io_metrics::record_get_object_stage_duration(
+        GET_OBJECT_PATH_CODEC_STREAMING,
+        GET_STAGE_EMIT,
+        emit_stage_start.elapsed().as_secs_f64(),
+    );
+
+    Ok(Some(output))
+}
+
+fn emit_data_shards(state: &StripeReadState, data_shards: usize, block_size: usize, remaining: usize) -> io::Result<Vec<u8>> {
+    let mut output = Vec::with_capacity(block_size.min(remaining));
+    for index in 0..data_shards {
+        if output.len() >= remaining {
+            break;
+        }
+        let Some(slot) = state.slot_by_index(index) else {
+            return Err(io::Error::new(ErrorKind::UnexpectedEof, "decoded stripe is missing a data shard"));
+        };
+        let Some(shard) = slot.data_bytes() else {
+            return Err(io::Error::new(ErrorKind::UnexpectedEof, "decoded stripe is missing a data shard"));
+        };
+        let copy_len = shard.len().min(remaining - output.len());
+        output.extend_from_slice(&shard[..copy_len]);
+    }
+    Ok(output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::erasure::codec::bridge::{
+        CodecStreamingDecodeEngine, ErasureDecodeEngine, LegacyEcDecodeEngine, RustfsCodecDecodeEngine,
+    };
+    use crate::erasure::coding::Erasure;
+    use crate::set_disk::shard_source::{ShardSlot, StripeReadState};
+    use std::collections::VecDeque;
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use tokio::io::AsyncReadExt;
+    use tokio::task::yield_now;
+    use tokio::time::{Duration, timeout};
+
+    struct VecStripeSource {
+        stripes: VecDeque<StripeReadState>,
+        read_quorum: usize,
+        read_count: Option<Arc<AtomicUsize>>,
+    }
+
+    #[async_trait::async_trait]
+    impl ShardStripeSource for VecStripeSource {
+        async fn read_next_stripe(&mut self) -> StripeReadState {
+            if let Some(read_count) = &self.read_count {
+                read_count.fetch_add(1, Ordering::SeqCst);
+            }
+            self.stripes
+                .pop_front()
+                .unwrap_or_else(|| StripeReadState::new(Vec::new(), self.read_quorum))
+        }
+    }
+
+    fn source_from_data(erasure: &Erasure, data: &[u8], missing_indexes: &[usize]) -> VecStripeSource {
+        let read_quorum = erasure.data_shards;
+        let stripes = data
+            .chunks(erasure.block_size)
+            .map(|chunk| {
+                let shards = erasure
+                    .encode_data(chunk)
+                    .expect("test stripe should encode")
+                    .into_iter()
+                    .enumerate()
+                    .map(|(index, shard)| {
+                        if missing_indexes.contains(&index) {
+                            None
+                        } else {
+                            Some(shard.to_vec())
+                        }
+                    })
+                    .collect();
+                StripeReadState::from_parts(shards, Vec::new(), read_quorum)
+            })
+            .collect();
+
+        VecStripeSource {
+            stripes,
+            read_quorum,
+            read_count: None,
+        }
+    }
+
+    async fn decode_all_with_engine<E>(
+        erasure: &Erasure,
+        engine: E,
+        data: &[u8],
+        missing_indexes: &[usize],
+    ) -> io::Result<Vec<u8>>
+    where
+        E: ErasureDecodeEngine + Clone + Send + Sync + 'static,
+    {
+        let source = source_from_data(erasure, data, missing_indexes);
+        let mut reader = ErasureDecodeReader::new(source, engine, data.len())?;
+        let mut decoded = Vec::new();
+        reader.read_to_end(&mut decoded).await?;
+        Ok(decoded)
+    }
+
+    async fn decode_all(erasure: Erasure, data: &[u8], missing_indexes: &[usize]) -> io::Result<Vec<u8>> {
+        let engine = LegacyEcDecodeEngine::new(erasure.clone());
+        decode_all_with_engine(&erasure, engine, data, missing_indexes).await
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_reads_single_stripe() {
+        let erasure = Erasure::new(4, 2, 64);
+        let data = b"single stripe decode reader output";
+
+        let decoded = decode_all(erasure, data, &[])
+            .await
+            .expect("single stripe reader should decode");
+
+        assert_eq!(decoded, data);
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_reads_multiple_stripes() {
+        let erasure = Erasure::new(4, 2, 32);
+        let data = (0..150u16).map(|value| value.to_le_bytes()[0]).collect::<Vec<_>>();
+
+        let decoded = decode_all(erasure, &data, &[])
+            .await
+            .expect("multi stripe reader should decode");
+
+        assert_eq!(decoded, data);
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_stops_at_eof_for_empty_object() {
+        let erasure = Erasure::new(4, 2, 32);
+        let source = source_from_data(&erasure, &[], &[]);
+        let engine = LegacyEcDecodeEngine::new(erasure);
+        let mut reader = ErasureDecodeReader::new(source, engine, 0).expect("empty reader should be constructed");
+        let mut decoded = Vec::new();
+
+        let read = reader
+            .read_to_end(&mut decoded)
+            .await
+            .expect("empty reader should finish without reading stripes");
+
+        assert_eq!(read, 0);
+        assert!(decoded.is_empty());
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_reconstructs_missing_data_shard() {
+        let erasure = Erasure::new(4, 2, 32);
+        let data = (0..120u16)
+            .map(|value| value.wrapping_mul(17).to_le_bytes()[0])
+            .collect::<Vec<_>>();
+
+        let decoded = decode_all(erasure, &data, &[1])
+            .await
+            .expect("reader should reconstruct one missing data shard");
+
+        assert_eq!(decoded, data);
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_rustfs_engine_matches_legacy_with_missing_data() {
+        let erasure = Erasure::new(4, 2, 32);
+        let data = b"rustfs codec reader output must match legacy reader output exactly";
+        let legacy = LegacyEcDecodeEngine::new(erasure.clone());
+        let rustfs = RustfsCodecDecodeEngine::new(&erasure).expect("engine should be created");
+
+        let legacy_decoded = decode_all_with_engine(&erasure, legacy, data, &[1])
+            .await
+            .expect("legacy reader should decode");
+        let rustfs_decoded = decode_all_with_engine(&erasure, rustfs, data, &[1])
+            .await
+            .expect("rustfs codec reader should decode");
+
+        assert_eq!(rustfs_decoded, legacy_decoded);
+        assert_eq!(rustfs_decoded, data);
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_rustfs_engine_handles_empty_object() {
+        let erasure = Erasure::new(4, 2, 32);
+        let engine = RustfsCodecDecodeEngine::new(&erasure).expect("engine should be created");
+
+        let decoded = decode_all_with_engine(&erasure, engine, b"", &[])
+            .await
+            .expect("empty object should decode");
+
+        assert!(decoded.is_empty());
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_codec_streaming_engine_enum_matches_legacy() {
+        let erasure = Erasure::new(4, 2, 32);
+        let data = b"selected codec streaming engine preserves reader output";
+        let legacy = CodecStreamingDecodeEngine::legacy(erasure.clone());
+        let rustfs = CodecStreamingDecodeEngine::rustfs(&erasure).expect("engine should be created");
+
+        let legacy_decoded = decode_all_with_engine(&erasure, legacy, data, &[2])
+            .await
+            .expect("legacy enum reader should decode");
+        let rustfs_decoded = decode_all_with_engine(&erasure, rustfs, data, &[2])
+            .await
+            .expect("rustfs enum reader should decode");
+
+        assert_eq!(rustfs_decoded, legacy_decoded);
+        assert_eq!(rustfs_decoded, data);
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_reads_when_only_parity_shards_are_missing() {
+        let erasure = Erasure::new(4, 2, 32);
+        let data = (0..120u16)
+            .map(|value| value.wrapping_mul(11).to_le_bytes()[0])
+            .collect::<Vec<_>>();
+
+        let decoded = decode_all(erasure, &data, &[4, 5])
+            .await
+            .expect("reader should emit complete data shards without parity reconstruction");
+
+        assert_eq!(decoded, data);
+    }
+
+    #[test]
+    fn emit_data_shards_preserves_output_order_for_out_of_order_slots() {
+        let state = StripeReadState::new(
+            vec![
+                ShardSlot::data(1, b"cd".to_vec()),
+                ShardSlot::data(0, b"ab".to_vec()),
+                ShardSlot::data(2, b"ef".to_vec()),
+            ],
+            2,
+        );
+
+        let output = emit_data_shards(&state, 3, 6, 5).expect("out-of-order data slots should emit by shard index");
+
+        assert_eq!(output, b"abcde");
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_reports_short_source() {
+        let erasure = Erasure::new(4, 2, 32);
+        let source = VecStripeSource {
+            stripes: VecDeque::new(),
+            read_quorum: erasure.data_shards,
+            read_count: None,
+        };
+        let engine = LegacyEcDecodeEngine::new(erasure);
+        let mut reader = ErasureDecodeReader::new(source, engine, 1).expect("reader should be constructed");
+        let mut decoded = Vec::new();
+
+        let err = reader
+            .read_to_end(&mut decoded)
+            .await
+            .expect_err("reader should reject EOF before requested length");
+
+        assert_eq!(err.kind(), ErrorKind::Other);
+        assert!(decoded.is_empty());
+    }
+
+    #[tokio::test]
+    async fn erasure_decode_reader_prefetches_next_stripe_while_output_remains() {
+        let erasure = Erasure::new(4, 2, 32);
+        let data = (0..96u16)
+            .map(|value| value.wrapping_mul(3).to_le_bytes()[0])
+            .collect::<Vec<_>>();
+        let read_count = Arc::new(AtomicUsize::new(0));
+        let mut source = source_from_data(&erasure, &data, &[]);
+        source.read_count = Some(Arc::clone(&read_count));
+        let engine = LegacyEcDecodeEngine::new(erasure);
+        let mut reader = ErasureDecodeReader::new(source, engine, data.len()).expect("reader should be constructed");
+        let mut first_read = [0u8; 1];
+
+        let read = reader.read(&mut first_read).await.expect("first read should succeed");
+
+        assert_eq!(read, first_read.len());
+        assert_eq!(first_read[0], data[0]);
+        timeout(Duration::from_secs(1), async {
+            while read_count.load(Ordering::SeqCst) < 2 {
+                yield_now().await;
+            }
+        })
+        .await
+        .expect("reader should start reading the next stripe before the current output buffer is fully consumed");
+    }
+}

crates/ecstore/src/erasure/coding/encode.rs

@@ -0,0 +1,949 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::disk::error::Error;
+use crate::disk::error_reduce::{
+    OBJECT_OP_IGNORED_ERRS, WriteQuorumFailureSummary, build_write_quorum_failure_summary, reduce_write_quorum_errs,
+};
+use crate::erasure::coding::BitrotWriterWrapper;
+use crate::erasure::coding::Erasure;
+use crate::runtime::sources as runtime_sources;
+use bytes::{Bytes, BytesMut};
+use futures::StreamExt;
+use futures::stream::FuturesUnordered;
+use std::sync::Arc;
+use std::time::Instant;
+use std::vec;
+use tokio::io::AsyncRead;
+use tokio::runtime::RuntimeFlavor;
+use tokio::sync::mpsc;
+use tracing::error;
+
+const ENV_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BYTES: &str = "RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BYTES";
+const ENV_RUSTFS_ERASURE_ENCODE_BATCH_BLOCKS: &str = "RUSTFS_ERASURE_ENCODE_BATCH_BLOCKS";
+const ENV_RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST: &str = "RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST";
+const DEFAULT_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BYTES: usize = 32 * 1024 * 1024;
+const DEFAULT_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BLOCKS: usize = 32;
+const DEFAULT_RUSTFS_ERASURE_ENCODE_BATCH_BLOCKS: usize = 4;
+const DEFAULT_RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST: bool = false;
+
+/// Cached value of `RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BYTES` env var.
+/// Read once at first use via `OnceLock` to avoid per-encode syscall.
+static CACHED_MAX_INFLIGHT_BYTES: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
+static CACHED_BATCH_BLOCKS: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
+static CACHED_BYTESMUT_INGEST: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+
+#[inline(always)]
+fn stage_timer_if_enabled() -> Option<Instant> {
+    rustfs_io_metrics::put_stage_metrics_enabled().then(Instant::now)
+}
+
+#[inline(always)]
+fn record_internal_stage_if_enabled(stage: &'static str, started_at: Option<Instant>) {
+    if let Some(started_at) = started_at {
+        rustfs_io_metrics::record_stage_duration(stage, started_at.elapsed().as_secs_f64() * 1000.0);
+    }
+}
+
+fn encode_channel_capacity(expanded_block_bytes: usize, max_inflight_bytes: usize) -> usize {
+    if expanded_block_bytes == 0 {
+        return 1;
+    }
+
+    max_inflight_bytes
+        .saturating_div(expanded_block_bytes)
+        .clamp(1, DEFAULT_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BLOCKS)
+}
+
+fn encode_batch_block_count() -> usize {
+    *CACHED_BATCH_BLOCKS.get_or_init(|| {
+        rustfs_utils::get_env_usize(ENV_RUSTFS_ERASURE_ENCODE_BATCH_BLOCKS, DEFAULT_RUSTFS_ERASURE_ENCODE_BATCH_BLOCKS)
+            .clamp(1, DEFAULT_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BLOCKS)
+    })
+}
+
+fn erasure_encode_max_inflight_bytes() -> usize {
+    *CACHED_MAX_INFLIGHT_BYTES.get_or_init(|| {
+        rustfs_utils::get_env_usize(
+            ENV_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BYTES,
+            DEFAULT_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BYTES,
+        )
+    })
+}
+
+fn use_bytesmut_ingest() -> bool {
+    *CACHED_BYTESMUT_INGEST.get_or_init(|| {
+        rustfs_utils::get_env_bool(ENV_RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST, DEFAULT_RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST)
+    })
+}
+fn queued_block_bytes(block: &[Bytes]) -> usize {
+    block.iter().map(Bytes::len).sum()
+}
+
+async fn drain_queued_inflight_bytes(rx: &mut mpsc::Receiver<Vec<Bytes>>) {
+    while let Some(block) = rx.recv().await {
+        rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_block_bytes(&block));
+    }
+}
+
+fn queued_batch_bytes(batch: &[Vec<Bytes>]) -> usize {
+    batch.iter().map(|block| queued_block_bytes(block)).sum()
+}
+
+async fn drain_queued_batched_inflight_bytes(rx: &mut mpsc::Receiver<Vec<Vec<Bytes>>>) {
+    while let Some(batch) = rx.recv().await {
+        rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_batch_bytes(&batch));
+    }
+}
+
+fn dominant_error_summary_label(summary: &WriteQuorumFailureSummary) -> &'static str {
+    summary.dominant_error_label
+}
+
+fn format_write_quorum_failure(summary: &WriteQuorumFailureSummary) -> String {
+    format!(
+        "erasure write quorum (required={}, achieved={}, failed={}, total={}, offline-disks={}/{}, retryable-failures={}, dominant-error={})",
+        summary.required,
+        summary.achieved,
+        summary.failed,
+        summary.total,
+        summary.offline_disks,
+        summary.total,
+        summary.retryable_failures,
+        dominant_error_summary_label(summary)
+    )
+}
+
+fn quorum_dominant_error_metric_label(summary: &WriteQuorumFailureSummary) -> &'static str {
+    dominant_error_summary_label(summary)
+}
+
+pub(crate) struct MultiWriter<'a> {
+    writers: &'a mut [Option<BitrotWriterWrapper>],
+    write_quorum: usize,
+    errs: Vec<Option<Error>>,
+}
+
+impl<'a> MultiWriter<'a> {
+    pub fn new(writers: &'a mut [Option<BitrotWriterWrapper>], write_quorum: usize) -> Self {
+        let length = writers.len();
+        MultiWriter {
+            writers,
+            write_quorum,
+            errs: vec![None; length],
+        }
+    }
+
+    async fn write_shard(writer_opt: &mut Option<BitrotWriterWrapper>, err: &mut Option<Error>, shard: &Bytes) {
+        match writer_opt {
+            Some(writer) => {
+                match writer.write(shard).await {
+                    Ok(n) => {
+                        if n < shard.len() {
+                            *err = Some(Error::ShortWrite);
+                            *writer_opt = None; // Mark as failed
+                        } else {
+                            *err = None;
+                        }
+                    }
+                    Err(e) => {
+                        *err = Some(Error::from(e));
+                    }
+                }
+            }
+            None => {
+                *err = Some(Error::DiskNotFound);
+            }
+        }
+    }
+
+    pub async fn write(&mut self, data: Vec<Bytes>) -> std::io::Result<()> {
+        assert_eq!(data.len(), self.writers.len());
+
+        {
+            let mut futures = FuturesUnordered::new();
+            for ((writer_opt, err), shard) in self.writers.iter_mut().zip(self.errs.iter_mut()).zip(data.iter()) {
+                if err.is_some() {
+                    continue; // Skip if we already have an error for this writer
+                }
+                futures.push(Self::write_shard(writer_opt, err, shard));
+            }
+            while let Some(()) = futures.next().await {}
+        }
+
+        let nil_count = self.errs.iter().filter(|&e| e.is_none()).count();
+        if nil_count >= self.write_quorum {
+            return Ok(());
+        }
+
+        if let Some(write_err) = reduce_write_quorum_errs(&self.errs, OBJECT_OP_IGNORED_ERRS, self.write_quorum) {
+            let summary = build_write_quorum_failure_summary(&self.errs, OBJECT_OP_IGNORED_ERRS, self.write_quorum);
+            let summary_text = format_write_quorum_failure(&summary);
+            runtime_sources::record_erasure_write_quorum_failure("write", quorum_dominant_error_metric_label(&summary));
+            error!(
+                required = summary.required,
+                achieved = summary.achieved,
+                failed = summary.failed,
+                total = summary.total,
+                offline_disks = summary.offline_disks,
+                retryable_failures = summary.retryable_failures,
+                dominant_error = summary.dominant_error_label,
+                returned_error = %write_err,
+                errs = ?self.errs,
+                "Erasure encode write quorum unavailable: {summary_text}"
+            );
+            return Err(std::io::Error::other(format!("Failed to write data: {summary_text}")));
+        }
+
+        let summary = build_write_quorum_failure_summary(&self.errs, OBJECT_OP_IGNORED_ERRS, self.write_quorum);
+        Err(std::io::Error::other(format!(
+            "Failed to write data: {}: {}",
+            format_write_quorum_failure(&summary),
+            self.errs
+                .iter()
+                .map(|e| e.as_ref().map_or_else(|| "<nil>".to_string(), |e| e.to_string()))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )))
+    }
+
+    async fn shutdown_writer(writer_opt: &mut Option<BitrotWriterWrapper>, err: &mut Option<Error>) {
+        match writer_opt {
+            Some(writer) => match writer.shutdown().await {
+                Ok(()) => {
+                    *err = None;
+                }
+                Err(e) => {
+                    *err = Some(Error::from(e));
+                    *writer_opt = None;
+                }
+            },
+            None => {
+                *err = Some(Error::DiskNotFound);
+            }
+        }
+    }
+
+    pub async fn shutdown(&mut self) -> std::io::Result<()> {
+        {
+            let mut futures = FuturesUnordered::new();
+            for (writer_opt, err) in self.writers.iter_mut().zip(self.errs.iter_mut()) {
+                if err.is_some() {
+                    continue;
+                }
+                futures.push(Self::shutdown_writer(writer_opt, err));
+            }
+            while let Some(()) = futures.next().await {}
+        }
+
+        let nil_count = self.errs.iter().filter(|&e| e.is_none()).count();
+        if nil_count >= self.write_quorum {
+            return Ok(());
+        }
+
+        if let Some(write_err) = reduce_write_quorum_errs(&self.errs, OBJECT_OP_IGNORED_ERRS, self.write_quorum) {
+            let summary = build_write_quorum_failure_summary(&self.errs, OBJECT_OP_IGNORED_ERRS, self.write_quorum);
+            let summary_text = format_write_quorum_failure(&summary);
+            runtime_sources::record_erasure_write_quorum_failure("shutdown", quorum_dominant_error_metric_label(&summary));
+            error!(
+                required = summary.required,
+                achieved = summary.achieved,
+                failed = summary.failed,
+                total = summary.total,
+                offline_disks = summary.offline_disks,
+                retryable_failures = summary.retryable_failures,
+                dominant_error = summary.dominant_error_label,
+                returned_error = %write_err,
+                errs = ?self.errs,
+                "Erasure encode shutdown quorum unavailable: {summary_text}"
+            );
+            return Err(std::io::Error::other(format!("Failed to shutdown writers: {summary_text}")));
+        }
+
+        let summary = build_write_quorum_failure_summary(&self.errs, OBJECT_OP_IGNORED_ERRS, self.write_quorum);
+        Err(std::io::Error::other(format!(
+            "Failed to shutdown writers: {}: {}",
+            format_write_quorum_failure(&summary),
+            self.errs
+                .iter()
+                .map(|e| e.as_ref().map_or_else(|| "<nil>".to_string(), |e| e.to_string()))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )))
+    }
+}
+
+impl Erasure {
+    async fn encode_block(self: Arc<Self>, encode_buf: Vec<u8>, len: usize) -> std::io::Result<(Vec<Bytes>, Vec<u8>)> {
+        let encode_stage_start = stage_timer_if_enabled();
+        let encode_once = move || {
+            let res = self.encode_data(&encode_buf[..len]);
+            (res, encode_buf)
+        };
+
+        let (res, returned_buf) = match tokio::runtime::Handle::current().runtime_flavor() {
+            RuntimeFlavor::MultiThread => tokio::task::block_in_place(encode_once),
+            RuntimeFlavor::CurrentThread => tokio::task::spawn_blocking(encode_once)
+                .await
+                .map_err(|err| std::io::Error::other(format!("EC encode task failed: {err}")))?,
+            _ => tokio::task::spawn_blocking(encode_once)
+                .await
+                .map_err(|err| std::io::Error::other(format!("EC encode task failed: {err}")))?,
+        };
+
+        record_internal_stage_if_enabled("erasure_encode_cpu", encode_stage_start);
+        Ok((res?, returned_buf))
+    }
+
+    async fn encode_block_bytes_mut(self: Arc<Self>, encode_buf: BytesMut, len: usize) -> std::io::Result<Vec<Bytes>> {
+        let encode_stage_start = stage_timer_if_enabled();
+        let encode_once = move || self.encode_data_bytes_mut(encode_buf, len);
+
+        let res = match tokio::runtime::Handle::current().runtime_flavor() {
+            RuntimeFlavor::MultiThread => tokio::task::block_in_place(encode_once),
+            RuntimeFlavor::CurrentThread => tokio::task::spawn_blocking(encode_once)
+                .await
+                .map_err(|err| std::io::Error::other(format!("EC encode task failed: {err}")))?,
+            _ => tokio::task::spawn_blocking(encode_once)
+                .await
+                .map_err(|err| std::io::Error::other(format!("EC encode task failed: {err}")))?,
+        };
+
+        record_internal_stage_if_enabled("erasure_encode_cpu", encode_stage_start);
+        res
+    }
+
+    async fn encode_small_direct<R>(
+        self: Arc<Self>,
+        mut reader: R,
+        writers: &mut [Option<BitrotWriterWrapper>],
+        quorum: usize,
+        require_single_block: bool,
+    ) -> std::io::Result<(R, usize)>
+    where
+        R: AsyncRead + Send + Sync + Unpin,
+    {
+        use tokio::io::AsyncReadExt;
+
+        let mut buf = Vec::with_capacity(self.block_size);
+        let total = if require_single_block {
+            let read_limit = self
+                .block_size
+                .checked_add(1)
+                .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidInput, "erasure block_size is too large"))?;
+            let read_limit = u64::try_from(read_limit)
+                .map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidInput, "erasure block_size exceeds u64"))?;
+            (&mut reader).take(read_limit).read_to_end(&mut buf).await?
+        } else {
+            reader.read_to_end(&mut buf).await?
+        };
+
+        if total == 0 {
+            return Ok((reader, 0));
+        }
+
+        if require_single_block && total > self.block_size {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "single-block non-inline fast path expects total <= block_size",
+            ));
+        }
+
+        let shards = self.encode_data_owned(buf)?;
+        let mut mw = MultiWriter::new(writers, quorum);
+        mw.write(shards).await?;
+        mw.shutdown().await?;
+        Ok((reader, total))
+    }
+
+    pub async fn encode<R>(
+        self: Arc<Self>,
+        mut reader: R,
+        writers: &mut [Option<BitrotWriterWrapper>],
+        quorum: usize,
+    ) -> std::io::Result<(R, usize)>
+    where
+        R: AsyncRead + Send + Sync + Unpin + 'static,
+    {
+        if self.block_size == 0 {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "erasure block_size must be non-zero",
+            ));
+        }
+
+        // Bound queued encoded blocks by memory budget to avoid per-request spikes.
+        let expanded_block_bytes = self.shard_size().saturating_mul(self.total_shard_count());
+        let max_inflight_bytes = erasure_encode_max_inflight_bytes();
+        let inflight_blocks = encode_channel_capacity(expanded_block_bytes, max_inflight_bytes);
+        let (tx, mut rx) = mpsc::channel::<Vec<Bytes>>(inflight_blocks);
+
+        let task = tokio::spawn(async move {
+            let block_size = self.block_size;
+            let use_bytesmut_ingest = use_bytesmut_ingest();
+            let mut total = 0;
+            if use_bytesmut_ingest {
+                let mut buf = BytesMut::with_capacity(block_size);
+                buf.resize(block_size, 0);
+                loop {
+                    match rustfs_utils::read_full_or_eof(&mut reader, &mut buf[..]).await {
+                        Ok(Some(n)) => {
+                            debug_assert!(n > 0, "non-zero block_size prevents zero-length reads");
+                            total += n;
+                            let encode_buf = buf;
+                            let res = self.clone().encode_block_bytes_mut(encode_buf, n).await?;
+                            buf = BytesMut::with_capacity(block_size);
+                            buf.resize(block_size, 0);
+                            let queued_bytes = queued_block_bytes(&res);
+                            rustfs_io_metrics::add_ec_encode_inflight_bytes(queued_bytes);
+                            let send_wait_stage_start = stage_timer_if_enabled();
+                            if let Err(err) = tx.send(res).await {
+                                rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_bytes);
+                                return Err(std::io::Error::other(format!("Failed to send encoded data : {err}")));
+                            }
+                            record_internal_stage_if_enabled("erasure_encode_send_wait", send_wait_stage_start);
+                        }
+                        Ok(None) => break,
+                        Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
+                            if let Some(inner) = e.get_ref()
+                                && rustfs_rio::is_checksum_mismatch(inner)
+                            {
+                                return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string()));
+                            }
+                            return Err(e);
+                        }
+                        Err(e) => return Err(e),
+                    }
+                }
+            } else {
+                let mut buf = vec![0u8; block_size];
+                loop {
+                    match rustfs_utils::read_full_or_eof(&mut reader, &mut buf).await {
+                        Ok(Some(n)) => {
+                            debug_assert!(n > 0, "non-zero block_size prevents zero-length reads");
+                            total += n;
+                            let encode_buf = std::mem::take(&mut buf);
+                            let (res, returned_buf) = self.clone().encode_block(encode_buf, n).await?;
+                            buf = returned_buf;
+                            let queued_bytes = queued_block_bytes(&res);
+                            rustfs_io_metrics::add_ec_encode_inflight_bytes(queued_bytes);
+                            let send_wait_stage_start = stage_timer_if_enabled();
+                            if let Err(err) = tx.send(res).await {
+                                rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_bytes);
+                                return Err(std::io::Error::other(format!("Failed to send encoded data : {err}")));
+                            }
+                            record_internal_stage_if_enabled("erasure_encode_send_wait", send_wait_stage_start);
+                        }
+                        Ok(None) => {
+                            break;
+                        }
+                        Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
+                            // Check if the inner error is a checksum mismatch - if so, propagate it
+                            if let Some(inner) = e.get_ref()
+                                && rustfs_rio::is_checksum_mismatch(inner)
+                            {
+                                return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string()));
+                            }
+                            return Err(e);
+                        }
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    }
+                }
+            }
+
+            Ok((reader, total))
+        });
+
+        let mut writers = MultiWriter::new(writers, quorum);
+
+        let mut write_err = None;
+
+        loop {
+            let recv_wait_stage_start = stage_timer_if_enabled();
+            let Some(block) = rx.recv().await else {
+                break;
+            };
+            record_internal_stage_if_enabled("erasure_encode_recv_wait", recv_wait_stage_start);
+            if block.is_empty() {
+                break;
+            }
+            let queued_bytes = queued_block_bytes(&block);
+            rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_bytes);
+            let write_stage_start = stage_timer_if_enabled();
+            if let Err(err) = writers.write(block).await {
+                write_err = Some(err);
+                break;
+            }
+            record_internal_stage_if_enabled("erasure_encode_write", write_stage_start);
+        }
+
+        if let Some(err) = write_err {
+            task.abort();
+            let _ = task.await;
+            drain_queued_inflight_bytes(&mut rx).await;
+            let shutdown_stage_start = stage_timer_if_enabled();
+            if let Err(shutdown_err) = writers.shutdown().await {
+                error!("failed to shutdown erasure writers after write error: {:?}", shutdown_err);
+            }
+            record_internal_stage_if_enabled("erasure_encode_shutdown", shutdown_stage_start);
+            return Err(err);
+        }
+
+        let (reader, total) = task.await??;
+        let shutdown_stage_start = stage_timer_if_enabled();
+        writers.shutdown().await?;
+        record_internal_stage_if_enabled("erasure_encode_shutdown", shutdown_stage_start);
+        Ok((reader, total))
+    }
+
+    pub async fn encode_batched<R>(
+        self: Arc<Self>,
+        mut reader: R,
+        writers: &mut [Option<BitrotWriterWrapper>],
+        quorum: usize,
+    ) -> std::io::Result<(R, usize)>
+    where
+        R: AsyncRead + Send + Sync + Unpin + 'static,
+    {
+        if self.block_size == 0 {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "erasure block_size must be non-zero",
+            ));
+        }
+
+        let expanded_block_bytes = self.shard_size().saturating_mul(self.total_shard_count());
+        let max_inflight_bytes = erasure_encode_max_inflight_bytes();
+        let inflight_blocks = encode_channel_capacity(expanded_block_bytes, max_inflight_bytes);
+        let batch_blocks = encode_batch_block_count().min(inflight_blocks);
+        let channel_capacity = inflight_blocks.div_ceil(batch_blocks).max(1);
+        let (tx, mut rx) = mpsc::channel::<Vec<Vec<Bytes>>>(channel_capacity);
+
+        let task = tokio::spawn(async move {
+            let block_size = self.block_size;
+            let mut total = 0;
+            let mut buf = vec![0u8; block_size];
+            let mut pending_batch = Vec::with_capacity(batch_blocks);
+            let mut pending_batch_bytes = 0usize;
+            loop {
+                match rustfs_utils::read_full_or_eof(&mut reader, &mut buf).await {
+                    Ok(Some(n)) => {
+                        debug_assert!(n > 0, "non-zero block_size prevents zero-length reads");
+                        total += n;
+                        let encode_buf = std::mem::take(&mut buf);
+                        let (res, returned_buf) = self.clone().encode_block(encode_buf, n).await?;
+                        buf = returned_buf;
+                        let queued_bytes = queued_block_bytes(&res);
+                        pending_batch_bytes = pending_batch_bytes.saturating_add(queued_bytes);
+                        pending_batch.push(res);
+
+                        if pending_batch.len() >= batch_blocks {
+                            rustfs_io_metrics::add_ec_encode_inflight_bytes(pending_batch_bytes);
+                            let send_wait_stage_start = stage_timer_if_enabled();
+                            if let Err(err) = tx.send(pending_batch).await {
+                                rustfs_io_metrics::remove_ec_encode_inflight_bytes(pending_batch_bytes);
+                                return Err(std::io::Error::other(format!("Failed to send encoded data : {err}")));
+                            }
+                            record_internal_stage_if_enabled("erasure_encode_batched_send_wait", send_wait_stage_start);
+                            pending_batch = Vec::with_capacity(batch_blocks);
+                            pending_batch_bytes = 0;
+                        }
+                    }
+                    Ok(None) => {
+                        break;
+                    }
+                    Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
+                        if let Some(inner) = e.get_ref()
+                            && rustfs_rio::is_checksum_mismatch(inner)
+                        {
+                            return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string()));
+                        }
+                        return Err(e);
+                    }
+                    Err(e) => {
+                        return Err(e);
+                    }
+                }
+            }
+
+            if !pending_batch.is_empty() {
+                rustfs_io_metrics::add_ec_encode_inflight_bytes(pending_batch_bytes);
+                let send_wait_stage_start = stage_timer_if_enabled();
+                if let Err(err) = tx.send(pending_batch).await {
+                    rustfs_io_metrics::remove_ec_encode_inflight_bytes(pending_batch_bytes);
+                    return Err(std::io::Error::other(format!("Failed to send encoded data : {err}")));
+                }
+                record_internal_stage_if_enabled("erasure_encode_batched_send_wait", send_wait_stage_start);
+            }
+
+            Ok((reader, total))
+        });
+
+        let mut writers = MultiWriter::new(writers, quorum);
+        let mut write_err = None;
+
+        loop {
+            let recv_wait_stage_start = stage_timer_if_enabled();
+            let Some(batch) = rx.recv().await else {
+                break;
+            };
+            record_internal_stage_if_enabled("erasure_encode_batched_recv_wait", recv_wait_stage_start);
+            rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_batch_bytes(&batch));
+            let write_stage_start = stage_timer_if_enabled();
+            for block in batch {
+                if let Err(err) = writers.write(block).await {
+                    write_err = Some(err);
+                    break;
+                }
+            }
+            record_internal_stage_if_enabled("erasure_encode_batched_write", write_stage_start);
+            if write_err.is_some() {
+                break;
+            }
+        }
+
+        if let Some(err) = write_err {
+            task.abort();
+            let _ = task.await;
+            drain_queued_batched_inflight_bytes(&mut rx).await;
+            let shutdown_stage_start = stage_timer_if_enabled();
+            if let Err(shutdown_err) = writers.shutdown().await {
+                error!("failed to shutdown erasure writers after write error: {:?}", shutdown_err);
+            }
+            record_internal_stage_if_enabled("erasure_encode_batched_shutdown", shutdown_stage_start);
+            return Err(err);
+        }
+
+        let (reader, total) = task.await??;
+        let shutdown_stage_start = stage_timer_if_enabled();
+        writers.shutdown().await?;
+        record_internal_stage_if_enabled("erasure_encode_batched_shutdown", shutdown_stage_start);
+        Ok((reader, total))
+    }
+
+    /// Fast path for small inline objects: skip tokio::spawn + mpsc channel.
+    /// Reads all data, encodes directly, writes shards sequentially.
+    pub async fn encode_inline_small<R>(
+        self: Arc<Self>,
+        reader: R,
+        writers: &mut [Option<BitrotWriterWrapper>],
+        quorum: usize,
+    ) -> std::io::Result<(R, usize)>
+    where
+        R: AsyncRead + Send + Sync + Unpin,
+    {
+        self.encode_small_direct(reader, writers, quorum, false).await
+    }
+
+    /// Fast path for single-block non-inline objects: avoids the producer/consumer
+    /// pipeline in `encode()` while keeping the same writer/quorum/shutdown semantics.
+    pub async fn encode_single_block_non_inline<R>(
+        self: Arc<Self>,
+        reader: R,
+        writers: &mut [Option<BitrotWriterWrapper>],
+        quorum: usize,
+    ) -> std::io::Result<(R, usize)>
+    where
+        R: AsyncRead + Send + Sync + Unpin,
+    {
+        self.encode_small_direct(reader, writers, quorum, true).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::erasure::coding::{BitrotWriterWrapper, CustomWriter};
+    use rustfs_rio::HardLimitReader;
+    use rustfs_utils::HashAlgorithm;
+    use std::io::Cursor;
+    use std::pin::Pin;
+    use std::sync::{Arc, Mutex};
+    use std::task::{Context, Poll};
+    use tokio::io::AsyncWrite;
+
+    #[derive(Clone, Default)]
+    struct DeferredCommitWriter {
+        buffered: Vec<u8>,
+        committed: Arc<Mutex<Vec<u8>>>,
+    }
+
+    impl DeferredCommitWriter {
+        fn new(committed: Arc<Mutex<Vec<u8>>>) -> Self {
+            Self {
+                buffered: Vec::new(),
+                committed,
+            }
+        }
+    }
+
+    impl AsyncWrite for DeferredCommitWriter {
+        fn poll_write(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, buf: &[u8]) -> Poll<std::io::Result<usize>> {
+            self.buffered.extend_from_slice(buf);
+            Poll::Ready(Ok(buf.len()))
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            Poll::Ready(Ok(()))
+        }
+
+        fn poll_shutdown(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+            let buffered = std::mem::take(&mut self.buffered);
+            let mut committed = self.committed.lock().unwrap();
+            committed.extend_from_slice(&buffered);
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    #[tokio::test]
+    async fn encode_shutdowns_writers_after_small_shards() {
+        let committed = Arc::new(Mutex::new(Vec::new()));
+        let writer = DeferredCommitWriter::new(committed.clone());
+        let mut writers = vec![Some(BitrotWriterWrapper::new(
+            CustomWriter::new_tokio_writer(writer),
+            16,
+            HashAlgorithm::HighwayHash256S,
+        ))];
+
+        let erasure = Arc::new(Erasure::new(1, 0, 16));
+        let reader = tokio::io::BufReader::new(Cursor::new(b"small payload".to_vec()));
+        let (_reader, written) = erasure.encode(reader, &mut writers, 1).await.unwrap();
+
+        assert_eq!(written, b"small payload".len());
+        assert!(!committed.lock().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn encode_returns_unexpected_eof_for_truncated_limited_reader() {
+        let committed = Arc::new(Mutex::new(Vec::new()));
+        let writer = DeferredCommitWriter::new(committed);
+        let mut writers = vec![Some(BitrotWriterWrapper::new(
+            CustomWriter::new_tokio_writer(writer),
+            16,
+            HashAlgorithm::HighwayHash256S,
+        ))];
+
+        let erasure = Arc::new(Erasure::new(1, 0, 16));
+        let truncated = HardLimitReader::new(Cursor::new(b"short".to_vec()), 10);
+
+        let err = match erasure.encode(truncated, &mut writers, 1).await {
+            Ok(_) => panic!("truncated input must fail"),
+            Err(err) => err,
+        };
+
+        assert_eq!(err.kind(), std::io::ErrorKind::UnexpectedEof);
+    }
+
+    #[tokio::test]
+    async fn encode_rejects_zero_block_size() {
+        let committed = Arc::new(Mutex::new(Vec::new()));
+        let writer = DeferredCommitWriter::new(committed);
+        let mut writers = vec![Some(BitrotWriterWrapper::new(
+            CustomWriter::new_tokio_writer(writer),
+            16,
+            HashAlgorithm::HighwayHash256S,
+        ))];
+
+        let erasure = Arc::new(Erasure::new(1, 0, 0));
+        let reader = tokio::io::BufReader::new(Cursor::new(b"payload".to_vec()));
+        let err = erasure
+            .encode(reader, &mut writers, 1)
+            .await
+            .expect_err("zero block size must be rejected");
+
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
+        assert!(err.to_string().contains("block_size"));
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn encode_works_on_current_thread_runtime() {
+        let committed = Arc::new(Mutex::new(Vec::new()));
+        let writer = DeferredCommitWriter::new(committed);
+        let mut writers = vec![Some(BitrotWriterWrapper::new(
+            CustomWriter::new_tokio_writer(writer),
+            16,
+            HashAlgorithm::HighwayHash256S,
+        ))];
+
+        let erasure = Arc::new(Erasure::new(1, 0, 16));
+        let reader = tokio::io::BufReader::new(Cursor::new(b"current-thread payload".to_vec()));
+        let (_reader, written) = erasure.encode(reader, &mut writers, 1).await.unwrap();
+
+        assert_eq!(written, b"current-thread payload".len());
+    }
+
+    /// encode_inline_small: empty reader returns (reader, 0) without writing to any shard.
+    #[tokio::test]
+    async fn encode_inline_small_empty_stream_returns_zero() {
+        let committed = Arc::new(Mutex::new(Vec::new()));
+        let writer = DeferredCommitWriter::new(committed.clone());
+        // 1 data shard, 0 parity shards, block_size = 16
+        let mut writers = vec![Some(BitrotWriterWrapper::new(
+            CustomWriter::new_tokio_writer(writer),
+            16,
+            HashAlgorithm::HighwayHash256S,
+        ))];
+
+        let erasure = Arc::new(Erasure::new(1, 0, 16));
+        let reader = tokio::io::BufReader::new(Cursor::new(Vec::<u8>::new()));
+        let (_reader, total) = erasure.encode_inline_small(reader, &mut writers, 1).await.unwrap();
+
+        assert_eq!(total, 0);
+        // No shutdown was called, so nothing should be committed
+        assert!(committed.lock().unwrap().is_empty());
+    }
+
+    /// encode_inline_small: small payload is encoded into the correct number of shards
+    /// and each writer receives data after shutdown.
+    #[tokio::test]
+    async fn encode_inline_small_payload_writes_all_shards() {
+        const DATA_SHARDS: usize = 2;
+        const PARITY_SHARDS: usize = 2;
+        const TOTAL_SHARDS: usize = DATA_SHARDS + PARITY_SHARDS;
+        const BLOCK_SIZE: usize = 64;
+
+        let committed: Vec<Arc<Mutex<Vec<u8>>>> = (0..TOTAL_SHARDS).map(|_| Arc::new(Mutex::new(Vec::new()))).collect();
+
+        let mut writers: Vec<Option<BitrotWriterWrapper>> = committed
+            .iter()
+            .map(|c| {
+                Some(BitrotWriterWrapper::new(
+                    CustomWriter::new_tokio_writer(DeferredCommitWriter::new(c.clone())),
+                    BLOCK_SIZE / DATA_SHARDS,
+                    HashAlgorithm::HighwayHash256S,
+                ))
+            })
+            .collect();
+
+        let payload = b"hello inline small";
+        let erasure = Arc::new(Erasure::new(DATA_SHARDS, PARITY_SHARDS, BLOCK_SIZE));
+        let reader = tokio::io::BufReader::new(Cursor::new(payload.to_vec()));
+        let (_reader, total) = erasure.encode_inline_small(reader, &mut writers, DATA_SHARDS).await.unwrap();
+
+        assert_eq!(total, payload.len());
+        // All shards must have received data (shutdown flushed the bitrot header + shard bytes)
+        for (i, c) in committed.iter().enumerate() {
+            assert!(!c.lock().unwrap().is_empty(), "shard {i} should have received data");
+        }
+    }
+
+    #[tokio::test]
+    async fn encode_single_block_non_inline_payload_writes_all_shards() {
+        const DATA_SHARDS: usize = 2;
+        const PARITY_SHARDS: usize = 2;
+        const TOTAL_SHARDS: usize = DATA_SHARDS + PARITY_SHARDS;
+        const BLOCK_SIZE: usize = 64;
+
+        let committed: Vec<Arc<Mutex<Vec<u8>>>> = (0..TOTAL_SHARDS).map(|_| Arc::new(Mutex::new(Vec::new()))).collect();
+
+        let mut writers: Vec<Option<BitrotWriterWrapper>> = committed
+            .iter()
+            .map(|c| {
+                Some(BitrotWriterWrapper::new(
+                    CustomWriter::new_tokio_writer(DeferredCommitWriter::new(c.clone())),
+                    BLOCK_SIZE / DATA_SHARDS,
+                    HashAlgorithm::HighwayHash256S,
+                ))
+            })
+            .collect();
+
+        let payload = b"hello single block";
+        let erasure = Arc::new(Erasure::new(DATA_SHARDS, PARITY_SHARDS, BLOCK_SIZE));
+        let reader = tokio::io::BufReader::new(Cursor::new(payload.to_vec()));
+        let (_reader, total) = erasure
+            .encode_single_block_non_inline(reader, &mut writers, DATA_SHARDS)
+            .await
+            .unwrap();
+
+        assert_eq!(total, payload.len());
+        for (i, c) in committed.iter().enumerate() {
+            assert!(!c.lock().unwrap().is_empty(), "shard {i} should have received data");
+        }
+    }
+
+    #[tokio::test]
+    async fn encode_single_block_non_inline_rejects_multi_block_payload() {
+        const DATA_SHARDS: usize = 2;
+        const PARITY_SHARDS: usize = 2;
+        const TOTAL_SHARDS: usize = DATA_SHARDS + PARITY_SHARDS;
+        const BLOCK_SIZE: usize = 64;
+
+        let committed: Vec<Arc<Mutex<Vec<u8>>>> = (0..TOTAL_SHARDS).map(|_| Arc::new(Mutex::new(Vec::new()))).collect();
+
+        let mut writers: Vec<Option<BitrotWriterWrapper>> = committed
+            .iter()
+            .map(|c| {
+                Some(BitrotWriterWrapper::new(
+                    CustomWriter::new_tokio_writer(DeferredCommitWriter::new(c.clone())),
+                    BLOCK_SIZE / DATA_SHARDS,
+                    HashAlgorithm::HighwayHash256S,
+                ))
+            })
+            .collect();
+
+        let payload = vec![1u8; BLOCK_SIZE + 1];
+        let erasure = Arc::new(Erasure::new(DATA_SHARDS, PARITY_SHARDS, BLOCK_SIZE));
+        let reader = tokio::io::BufReader::new(Cursor::new(payload));
+        let err = erasure
+            .encode_single_block_non_inline(reader, &mut writers, DATA_SHARDS)
+            .await
+            .expect_err("single-block fast path must reject oversized readers");
+
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
+        assert!(err.to_string().contains("single-block non-inline fast path"));
+        for c in committed {
+            assert!(c.lock().unwrap().is_empty());
+        }
+    }
+
+    #[test]
+    fn encode_channel_capacity_never_returns_zero() {
+        assert_eq!(encode_channel_capacity(0, 1024), 1);
+        assert_eq!(encode_channel_capacity(4096, 0), 1);
+        assert_eq!(encode_channel_capacity(4096, 1024), 1);
+    }
+
+    #[test]
+    fn write_quorum_failure_summary_uses_stable_dominant_error_label() {
+        let err = Error::from(rustfs_rio::new_test_internode_http_io_error(
+            rustfs_rio::InternodeHttpErrorKind::ConnectionReset,
+        ));
+        let summary = WriteQuorumFailureSummary {
+            required: 2,
+            achieved: 0,
+            failed: 2,
+            total: 2,
+            offline_disks: 0,
+            ignored_failures: 0,
+            retryable_failures: 2,
+            dominant_error: Some(err),
+            dominant_error_label: "connection_reset",
+        };
+        let text = format_write_quorum_failure(&summary);
+
+        assert!(text.contains("dominant-error=connection_reset"));
+        assert!(!text.contains("/rustfs/rpc/put_file_stream"));
+        assert!(!text.contains("PUT "));
+    }
+
+    #[test]
+    fn encode_channel_capacity_respects_budget_and_hard_cap() {
+        assert_eq!(encode_channel_capacity(4 * 1024 * 1024, 32 * 1024 * 1024), 8);
+        assert_eq!(encode_channel_capacity(1536 * 1024, 32 * 1024 * 1024), 21);
+        assert_eq!(encode_channel_capacity(16 * 1024 * 1024, 32 * 1024 * 1024), 2);
+        assert_eq!(encode_channel_capacity(1, usize::MAX), DEFAULT_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BLOCKS);
+    }
+}

crates/ecstore/src/erasure/coding/heal.rs

@@ -0,0 +1,232 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::disk::error::{Error, Result};
+use crate::erasure::coding::BitrotReader;
+use crate::erasure::coding::BitrotWriterWrapper;
+use crate::erasure::coding::decode::ParallelReader;
+use crate::erasure::coding::encode::MultiWriter;
+use bytes::Bytes;
+use tokio::io::AsyncRead;
+use tracing::{info, warn};
+
+impl super::Erasure {
+    pub async fn heal<R>(
+        &self,
+        writers: &mut [Option<BitrotWriterWrapper>],
+        readers: Vec<Option<BitrotReader<R>>>,
+        total_length: usize,
+        _prefer: &[bool],
+    ) -> Result<()>
+    where
+        R: AsyncRead + Unpin + Send + Sync,
+    {
+        info!(
+            "Erasure heal, writers len: {}, readers len: {}, total_length: {}",
+            writers.len(),
+            readers.len(),
+            total_length
+        );
+        if writers.len() != self.parity_shards + self.data_shards {
+            return Err(Error::other("invalid argument"));
+        }
+        let mut reader = ParallelReader::new(readers, self.clone(), 0, total_length);
+
+        let start_block = 0;
+        let mut end_block = total_length / self.block_size;
+        if !total_length.is_multiple_of(self.block_size) {
+            end_block += 1;
+        }
+
+        let available_writers = writers.iter().filter(|w| w.is_some()).count();
+        let write_quorum = available_writers.max(1);
+        let mut writers = MultiWriter::new(writers, write_quorum);
+
+        for _ in start_block..end_block {
+            let (mut shards, errs) = reader.read().await;
+
+            // Check if we have enough shards to reconstruct data
+            // We need at least data_shards available shards (data + parity combined)
+            let available_shards = errs.iter().filter(|e| e.is_none()).count();
+            if available_shards < self.data_shards {
+                warn!(
+                    required_data_shards = self.data_shards,
+                    available_shards,
+                    total_shards = errs.len(),
+                    errors = ?errs,
+                    "Erasure heal read quorum unavailable"
+                );
+                return Err(Error::ErasureReadQuorum);
+            }
+
+            if self.parity_shards > 0 {
+                self.decode_data_and_parity(&mut shards)?;
+            }
+
+            let shards = shards
+                .into_iter()
+                .map(|s| Bytes::from(s.unwrap_or_default()))
+                .collect::<Vec<_>>();
+
+            writers.write(shards).await?;
+        }
+
+        writers.shutdown().await?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::erasure::coding::{CustomWriter, Erasure};
+    use rustfs_utils::HashAlgorithm;
+    use std::io::Cursor;
+
+    #[tokio::test]
+    async fn heal_reconstructs_missing_parity_shard() {
+        let erasure = Erasure::new(2, 2, 64);
+        let data = b"heal should write a rebuilt parity shard";
+        let encoded = erasure.encode_data(data).expect("encode should succeed");
+        let missing_parity = erasure.data_shards;
+
+        let readers = encoded
+            .iter()
+            .enumerate()
+            .map(|(index, shard)| {
+                if index == missing_parity {
+                    None
+                } else {
+                    Some(BitrotReader::new(
+                        Cursor::new(shard.to_vec()),
+                        erasure.shard_size(),
+                        HashAlgorithm::None,
+                        false,
+                    ))
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let mut writers = (0..erasure.total_shard_count())
+            .map(|index| {
+                if index == missing_parity {
+                    Some(BitrotWriterWrapper::new(
+                        CustomWriter::new_inline_buffer(),
+                        erasure.shard_size(),
+                        HashAlgorithm::None,
+                    ))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+
+        erasure
+            .heal(&mut writers, readers, data.len(), &[])
+            .await
+            .expect("heal should rebuild parity");
+
+        let healed = writers[missing_parity]
+            .take()
+            .expect("parity writer should remain")
+            .into_inline_data()
+            .expect("inline writer should retain data");
+        assert_eq!(healed, encoded[missing_parity].to_vec());
+    }
+
+    #[tokio::test]
+    async fn heal_reconstructs_missing_data_shard_across_multiple_blocks() {
+        let erasure = Erasure::new(3, 2, 96);
+        let data = (0..erasure.block_size * 2 + 17)
+            .map(|index| (index % 251) as u8)
+            .collect::<Vec<_>>();
+        let encoded = erasure.encode_data(&data).expect("encode should succeed");
+        let missing_data = 1;
+
+        let readers = encoded
+            .iter()
+            .enumerate()
+            .map(|(index, shard)| {
+                if index == missing_data {
+                    None
+                } else {
+                    Some(BitrotReader::new(
+                        Cursor::new(shard.to_vec()),
+                        erasure.shard_size(),
+                        HashAlgorithm::None,
+                        false,
+                    ))
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let mut writers = (0..erasure.total_shard_count())
+            .map(|index| {
+                if index == missing_data {
+                    Some(BitrotWriterWrapper::new(
+                        CustomWriter::new_inline_buffer(),
+                        erasure.shard_size(),
+                        HashAlgorithm::None,
+                    ))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+
+        erasure
+            .heal(&mut writers, readers, data.len(), &[])
+            .await
+            .expect("heal should rebuild data");
+
+        let healed = writers[missing_data]
+            .take()
+            .expect("data writer should remain")
+            .into_inline_data()
+            .expect("inline writer should retain data");
+        assert_eq!(healed, encoded[missing_data].to_vec());
+    }
+
+    #[tokio::test]
+    async fn heal_returns_read_quorum_when_available_shards_are_insufficient() {
+        let erasure = Erasure::new(3, 2, 64);
+        let data = b"heal should fail before decode when too few shards are readable";
+        let encoded = erasure.encode_data(data).expect("encode should succeed");
+
+        let readers = encoded
+            .iter()
+            .enumerate()
+            .map(|(index, shard)| {
+                if index < 2 {
+                    Some(BitrotReader::new(
+                        Cursor::new(shard.to_vec()),
+                        erasure.shard_size(),
+                        HashAlgorithm::None,
+                        false,
+                    ))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        let mut writers = (0..erasure.total_shard_count()).map(|_| None).collect::<Vec<_>>();
+
+        let err = erasure
+            .heal(&mut writers, readers, data.len(), &[])
+            .await
+            .expect_err("heal should fail when available shards are below data shards");
+
+        assert!(matches!(err, Error::ErasureReadQuorum));
+    }
+}

crates/ecstore/src/erasure/coding/mod.rs

@@ -0,0 +1,23 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+mod bitrot;
+pub mod decode;
+pub mod decode_reader;
+pub mod encode;
+pub mod erasure;
+pub mod heal;
+pub use bitrot::*;
+
+pub use erasure::{Erasure, ReedSolomonEncoder, calc_shard_size, calc_shard_size_legacy};