refactor(segment): use the borrowed positional-read helper for metadata

Segment header/footer/index reads only borrow their file handle, so
they were hand-rolling the same read-until-complete loop that
read_exact_at already implements. Replace them with the
read_exact_at_borrowed macro to remove the duplication.

Author: farhan-syah

CHANGELOG.md

@@ -29,7 +29,9 @@ version, since none exists yet.
 - **Cross-platform VFS** — Linux (`io_uring`), Windows (IOCP), macOS/iOS
   (Grand Central Dispatch), Android, WASM/OPFS, and WASI backends, plus a
   tokio thread-pool fallback and an in-memory backend, with format-bit identity
-  across targets.
+  across targets. Backends may complete a positional read or write in several
+  calls; PageDB finishes the caller's whole buffer before treating authenticated
+  metadata as present or durable.
 - **Snapshots** — `snapshot_to`, `restore_from`, and incremental apply, each
   authenticated against the exact state its manifest describes. Destinations
   must be empty; malformed or incomplete artifacts fail closed.

src/segment/authenticated_metadata.rs

@@ -11,7 +11,7 @@ use crate::pager::format::data_page::{body, extract_page_header_ids, open_data_p
 use crate::pager::format::page_kind::PageKind;
 use crate::pager::format::segment_footer::{SegmentFooterFields, decode_segment_footer};
 use crate::pager::format::structural_header::{SegmentHeaderFields, decode_segment_header};
-use crate::vfs::{Vfs, VfsFile, checked_read_progress};
+use crate::vfs::{Vfs, VfsFile, read_exact_at_borrowed};
 
 use super::types::{EXTENT_INDEX_ENTRY_LEN, ExtentIndexEntry};
 use super::writer::{live_path, staging_path};
@@ -84,24 +84,12 @@ pub(crate) async fn authenticate_segment_metadata<V: Vfs + Clone>(
     let master_key = pager.mk_for(meta.mk_epoch, cipher_id)?;
     let hk = derive_hk(&master_key)?;
     let mut header_bytes = vec![0u8; page_size];
-    let mut header_offset = 0;
-    let mut header_remaining = &mut header_bytes[..];
-    while !header_remaining.is_empty() {
-        let read = file.read_at(header_offset, header_remaining).await?;
-        checked_read_progress(&mut header_offset, read, header_remaining.len())?;
-        header_remaining = header_remaining.split_at_mut(read).1;
-    }
+    read_exact_at_borrowed!(file, 0, &mut header_bytes[..])?;
     let header = decode_segment_header(&header_bytes, &hk, page_size)?;
     validate_header(&header, meta, parent_file_id, page_size)?;
 
     let mut footer_bytes = vec![0u8; page_size];
-    let mut next_footer_offset = footer_offset;
-    let mut footer_remaining = &mut footer_bytes[..];
-    while !footer_remaining.is_empty() {
-        let read = file.read_at(next_footer_offset, footer_remaining).await?;
-        checked_read_progress(&mut next_footer_offset, read, footer_remaining.len())?;
-        footer_remaining = footer_remaining.split_at_mut(read).1;
-    }
+    read_exact_at_borrowed!(file, footer_offset, &mut footer_bytes[..])?;
     let (footer, manifest) = {
         let mut lru = pager.dek_lru().lock();
         let cipher = lru.get_or_derive(meta.realm_id, meta.mk_epoch, cipher_id, &master_key)?;
@@ -337,13 +325,7 @@ async fn collect_and_decode_index_page<V: Vfs + Clone>(
         .checked_mul(page_size_u64)
         .ok_or_else(|| PagedbError::segment_geometry_invalid("index.offset"))?;
     let mut page = vec![0u8; context.page_size];
-    let mut read_offset = offset;
-    let mut remaining = &mut page[..];
-    while !remaining.is_empty() {
-        let read = context.file.read_at(read_offset, remaining).await?;
-        checked_read_progress(&mut read_offset, read, remaining.len())?;
-        remaining = remaining.split_at_mut(read).1;
-    }
+    read_exact_at_borrowed!(context.file, offset, &mut page[..])?;
     let (cipher_id, mk_epoch) = extract_page_header_ids(&page)?;
     if cipher_id != context.cipher_id {
         return Err(PagedbError::segment_metadata_mismatch(

src/segment/reader.rs

@@ -14,7 +14,7 @@ use crate::pager::Pager;
 use crate::pager::format::data_page::{body, extract_page_header_ids, open_data_page};
 use crate::pager::format::page_kind::PageKind;
 use crate::vfs::types::OpenMode;
-use crate::vfs::{Vfs, VfsFile, checked_read_progress};
+use crate::vfs::{Vfs, VfsFile, read_exact_at_borrowed};
 
 use super::authenticated_metadata::{
     ExtentIndexDecodeContext, authenticate_segment_metadata, decode_extent_index,
@@ -228,13 +228,7 @@ impl<V: Vfs + Clone> SegmentReader<V> {
             .checked_mul(page_size)
             .ok_or_else(|| PagedbError::arithmetic_overflow("segment page offset"))?;
         let mut buf = vec![0u8; self.page_size];
-        let mut read_offset = offset;
-        let mut remaining = &mut buf[..];
-        while !remaining.is_empty() {
-            let read = self.file.read_at(read_offset, remaining).await?;
-            checked_read_progress(&mut read_offset, read, remaining.len())?;
-            remaining = remaining.split_at_mut(read).1;
-        }
+        read_exact_at_borrowed!(self.file, offset, &mut buf[..])?;
 
         // Try each segment page kind; AAD binding rejects wrong ones.
         let try_kinds = [