[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10,"_11":12},"actionData","errors","root",{"_179":-5,"_182":183,"_184":185},"routes/shell",{"_41":42,"_178":-5,"_179":-5,"_180":181},"routes/repo",{"_34":-7,"_35":36,"_37":38,"_39":40,"_41":42,"_43":32,"_44":32,"_45":32,"_46":32,"_47":32,"_48":32,"_49":50,"_51":50,"_52":32,"_53":-7,"_54":-7,"_55":56,"_57":58,"_59":60,"_61":-5,"_62":63,"_64":65,"_66":67,"_68":69},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":-5,"_26":27,"_28":29,"_29":30,"_31":32,"_33":14},"ref","main","path","crates/ltx/src/wal.rs","oid","57a60873200a324b32883e9da429103b433e2798","size",24602,"commit","90b43017241f81189453d326d05948f388b34652","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","//! wal.rs — SQLite WAL header/frame parsing + cumulative SQLite checksums.\n//!\n//! Ported from litestream@v0.5.11 wal_reader.go:14-295 (read path) and the\n//! `WALChecksum` helper in litestream@v0.5.11 litestream.go:110-119 (re-exported\n//! from the crate root as [`crate::wal_checksum`]).\n//!\n//! A [`WalReader`] wraps a byte buffer and parses SQLite WAL frames, verifying\n//! salt and cumulative-checksum integrity as it reads. It does **not** enforce\n//! transaction boundaries (it may return uncommitted frames); honoring commit\n//! records is the caller's responsibility (see [`WalReader::page_map`]).\n//!\n//! ## Byte format (read straight from the SQLite WAL spec; see wal_reader.go)\n//!\n//! WAL header (32 bytes, all fields big-endian at fixed offsets):\n//! ```text\n//! [0..4] magic 0x377f0682 => checksums LITTLE-endian\n//! 0x377f0683 => checksums BIG-endian\n//! [4..8] version must equal 3007000\n//! [8..12] page size\n//! [12..16] checkpoint sequence number\n//! [16..20] salt-1\n//! [20..24] salt-2\n//! [24..28] checksum-1 (cumulative checksum of bytes [0..24])\n//! [28..32] checksum-2\n//! ```\n//!\n//! WAL frame header (24 bytes, all fields big-endian):\n//! ```text\n//! [0..4] page number\n//! [4..8] commit size in pages for a commit record, else 0\n//! [8..12] salt-1 (must match the header salt-1)\n//! [12..16] salt-2 (must match the header salt-2)\n//! [16..20] checksum-1 (cumulative checksum through this frame's data)\n//! [20..24] checksum-2\n//! ```\n//!\n//! A frame is `pageSize + 24` bytes. The cumulative checksum is seeded with the\n//! header checksum and rolled forward over each frame's 8-byte header prefix and\n//! then its page data, in the byte order chosen by the magic.\n\nuse std::collections::{HashMap, HashSet};\n\nuse crate::{wal_checksum, WAL_FRAME_HEADER_SIZE, WAL_HEADER_SIZE};\n\n/// Required WAL format version (`3007000`), as found at header offset 4.\n///\n/// Ported from litestream@v0.5.11 wal_reader.go:118.\nconst WAL_VERSION: u32 = 3_007_000;\n\n/// WAL header magic indicating checksums are computed **little-endian**.\n///\n/// Ported from litestream@v0.5.11 wal_reader.go:101.\nconst WAL_MAGIC_LITTLE_ENDIAN: u32 = 0x377f_0682;\n\n/// WAL header magic indicating checksums are computed **big-endian**.\n///\n/// Ported from litestream@v0.5.11 wal_reader.go:103.\nconst WAL_MAGIC_BIG_ENDIAN: u32 = 0x377f_0683;\n\n// ── Errors ────────────────────────────────────────────────────────────────────\n\n/// Errors returned by [`WalReader`].\n///\n/// The Go reader leans on `io.EOF` as a control-flow sentinel: it signals the\n/// clean end of the *valid* WAL, but also a short/partial read, a salt mismatch,\n/// or a checksum mismatch — all of which mean \"stop reading here, the rest of the\n/// file is not a valid continuation.\" We model that single sentinel as\n/// [`WalError::Eof`] so callers can branch on it exactly like Go's\n/// `errors.Is(err, io.EOF)` (see [`WalError::is_eof`]). Non-EOF variants carry\n/// the same human-readable messages as the Go `fmt.Errorf` strings.\n#[derive(Debug, Clone, PartialEq, Eq)]\npub enum WalError {\n /// End of the valid WAL.\n ///\n /// Mirrors every `return ..., io.EOF` in wal_reader.go: a partial header, a\n /// failed header checksum, a short frame read, a salt mismatch, or a frame\n /// checksum mismatch. In all of these the WAL has no further valid frames.\n Eof,\n\n /// `invalid wal header magic: ` — the magic was neither\n /// `0x377f0682` nor `0x377f0683`.\n ///\n /// Ported from litestream@v0.5.11 wal_reader.go:106.\n InvalidMagic(u32),\n\n /// `unsupported wal version: ` — header version field was not `3007000`.\n ///\n /// Ported from litestream@v0.5.11 wal_reader.go:119.\n UnsupportedVersion(u32),\n\n /// `WALReader.ReadFrame(): buffer size () must match page size ()`.\n ///\n /// Ported from litestream@v0.5.11 wal_reader.go:139.\n BufferSize {\n /// Length of the buffer the caller supplied.\n got: usize,\n /// The WAL's page size.\n want: u32,\n },\n\n /// `offset () must be greater than the wal header size ()` — passed to\n /// [`WalReader::new_with_offset`] with an offset at or before the header.\n ///\n /// Ported from litestream@v0.5.11 wal_reader.go:48.\n OffsetTooSmall {\n /// The requested offset.\n offset: i64,\n /// The WAL header size.\n header_size: i64,\n },\n\n /// `unaligned wal offset for page size ` — the offset does not land on\n /// a frame boundary.\n ///\n /// Ported from litestream@v0.5.11 wal_reader.go:64.\n UnalignedOffset {\n /// The requested offset.\n offset: i64,\n /// The WAL's page size.\n page_size: u32,\n },\n\n /// The previous frame at the seek offset could not be re-read (its salt or\n /// checksum did not match). **Load-bearing**: `DB.sync` catches this and\n /// falls back to a full snapshot (db.go:1571-1577).\n ///\n /// Ported from `PrevFrameMismatchError` in litestream@v0.5.11\n /// wal_reader.go:284-294.\n PrevFrameMismatch,\n}\n\nimpl WalError {\n /// Returns `true` for the [`WalError::Eof`] sentinel.\n ///\n /// This is the analog of Go's `errors.Is(err, io.EOF)`, which upstream\n /// callers such as `PageMap` use to detect the end of the WAL.\n #[inline]\n pub fn is_eof(&self) -> bool {\n matches!(self, WalError::Eof)\n }\n}\n\nimpl std::fmt::Display for WalError {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n match self {\n // Matches the Go string \"EOF\" (io.EOF.Error()).\n WalError::Eof => f.write_str(\"EOF\"),\n // Go: fmt.Errorf(\"invalid wal header magic: %x\", magic) — lowercase\n // hex, no leading zeros (matches Go's %x for a uint32).\n WalError::InvalidMagic(magic) => write!(f, \"invalid wal header magic: {magic:x}\"),\n WalError::UnsupportedVersion(v) => write!(f, \"unsupported wal version: {v}\"),\n WalError::BufferSize { got, want } => write!(\n f,\n \"WALReader.ReadFrame(): buffer size ({got}) must match page size ({want})\"\n ),\n WalError::OffsetTooSmall {\n offset,\n header_size,\n } => write!(\n f,\n \"offset ({offset}) must be greater than the wal header size ({header_size})\"\n ),\n WalError::UnalignedOffset { offset, page_size } => {\n write!(f, \"unaligned wal offset {offset} for page size {page_size}\")\n }\n WalError::PrevFrameMismatch => f.write_str(\"previous frame mismatch\"),\n }\n }\n}\n\nimpl std::error::Error for WalError {}\n\nimpl From for crate::Error {\n /// Lifts a [`WalError`] into the crate-wide error type for callers that work\n /// in terms of [`crate::Error`]. EOF and the structured WAL errors become\n /// `Error::Other` carrying the same message.\n fn from(e: WalError) -> Self {\n crate::Error::Other(Box::new(e))\n }\n}\n\n/// `WalReader`'s `Result` alias.\ntype WalResult = std::result::Result;\n\n// ── WalReader ───────────────────────────────────────────────────────────────\n\n/// Reads SQLite WAL frames from an in-memory byte buffer, verifying salts and\n/// the cumulative SQLite checksum as it goes.\n///\n/// This is the faithful analog of Go's `WALReader` (wal_reader.go:19-31). Go\n/// wraps an `io.ReaderAt`; this implementation wraps a borrowed `&[u8]` and emulates\n/// `ReadAt` semantics directly: a read whose requested length runs past the end\n/// of the buffer yields fewer bytes, which the algorithm treats as `io.EOF`\n/// exactly as Go does.\n///\n/// Ported from litestream@v0.5.11 wal_reader.go:19-187.\n#[derive(Debug)]\npub struct WalReader<'a> {\n /// Backing WAL bytes: the whole file (as the Go `io.ReaderAt`) when\n /// `tail_base` is 0, otherwise the 32-byte header followed by the file's\n /// bytes from `tail_base` onward — the shape a tail read produces without\n /// a file-sized buffer between the header and the tail.\n data: &'a [u8],\n /// The file offset of `data[WAL_HEADER_SIZE..]`, or 0 for a whole-file\n /// image. See [`WalReader::new_with_offset_over_tail`].\n tail_base: usize,\n /// Index of the *next* frame to read (0-based). Go field `frameN`.\n frame_n: i64,\n\n /// `true` when checksums are big-endian (magic `0x377f0683`),\n /// `false` when little-endian (magic `0x377f0682`). Go field `bo`.\n big_endian: bool,\n /// Page size from the header. Go field `pageSize`.\n page_size: u32,\n /// Header salt-1 / salt-2; frames must match these. Go fields `salt1/salt2`.\n salt1: u32,\n salt2: u32,\n /// Running cumulative checksum. Seeded from the header checksum, then rolled\n /// forward frame by frame. Go fields `chksum1/chksum2`.\n chksum1: u32,\n chksum2: u32,\n}\n\nimpl<'a> WalReader<'a> {\n /// Creates a new reader over `data`, parsing the WAL header immediately.\n ///\n /// Returns [`WalError::Eof`] if the buffer is too short to hold a header or\n /// the header checksum does not validate (a partial WAL-header write during\n /// checkpointing). Returns [`WalError::InvalidMagic`] /\n /// [`WalError::UnsupportedVersion`] for a malformed header.\n ///\n /// Ported from `NewWALReader` in litestream@v0.5.11 wal_reader.go:34-40.\n pub fn new(data: &'a [u8]) -> WalResult {\n let mut r = WalReader {\n data,\n tail_base: 0,\n frame_n: 0,\n big_endian: false,\n page_size: 0,\n salt1: 0,\n salt2: 0,\n chksum1: 0,\n chksum2: 0,\n };\n r.read_header()?;\n Ok(r)\n }\n\n /// Creates a new reader positioned at `offset`, loading the running checksum\n /// from the *previous* frame so reading can resume mid-WAL.\n ///\n /// `salt1`/`salt2` are the expected salts of the segment being resumed; they\n /// override the header salts in case the start of the file was overwritten by\n /// a later transaction. Returns:\n /// - [`WalError::OffsetTooSmall`] if `offset <= WAL_HEADER_SIZE` (we must be\n /// able to read a previous frame),\n /// - [`WalError::UnalignedOffset`] if `offset` is not on a frame boundary,\n /// - [`WalError::PrevFrameMismatch`] if the previous frame cannot be re-read\n /// (salt/checksum mismatch) — the caller falls back to a full snapshot.\n ///\n /// Ported from `NewWALReaderWithOffset` in litestream@v0.5.11\n /// wal_reader.go:42-75.\n pub fn new_with_offset(data: &'a [u8], offset: i64, salt1: u32, salt2: u32) -> WalResult {\n // Must not start on the first page — we need to read the previous frame.\n if offset <= WAL_HEADER_SIZE as i64 {\n return Err(WalError::OffsetTooSmall {\n offset,\n header_size: WAL_HEADER_SIZE as i64,\n });\n }\n let mut r = Self::new_with_offset_inner(data, 0)?;\n r.seek_to_offset(offset, salt1, salt2)?;\n Ok(r)\n }\n\n /// A reader over `data` with its header parsed and its tail base set;\n /// the two offset constructors share it and then seek.\n fn new_with_offset_inner(data: &'a [u8], tail_base: usize) -> WalResult {\n let mut r = WalReader {\n data,\n tail_base,\n frame_n: 0,\n big_endian: false,\n page_size: 0,\n salt1: 0,\n salt2: 0,\n chksum1: 0,\n chksum2: 0,\n };\n // Read header to determine page size & byte order.\n r.read_header()?;\n Ok(r)\n }\n\n /// Positions the reader at `offset` and seeds its running checksum from\n /// the previous frame (wal_reader.go:42-75): the salts override the\n /// header's in case the beginning of the file was overwritten, the offset\n /// must land on a frame start, and a previous frame that does not match\n /// is [`WalError::PrevFrameMismatch`] — the caller falls back to a full\n /// snapshot.\n fn seek_to_offset(&mut self, offset: i64, salt1: u32, salt2: u32) -> WalResult<()> {\n self.salt1 = salt1;\n self.salt2 = salt2;\n\n let frame_size = self.page_size as i64 + WAL_FRAME_HEADER_SIZE as i64;\n if (offset - WAL_HEADER_SIZE as i64) % frame_size != 0 {\n return Err(WalError::UnalignedOffset {\n offset,\n page_size: self.page_size,\n });\n }\n self.frame_n = (offset - WAL_HEADER_SIZE as i64) / frame_size;\n\n // Read the previous frame to load the running checksum. Any failure here\n // (salt/checksum mismatch surfaces as WalError::Eof from read_frame_inner)\n // means the previous frame doesn't match what we expect → mismatch.\n self.frame_n -= 1;\n let mut buf = vec![0u8; self.page_size as usize];\n if self.read_frame_inner(&mut buf, false).is_err() {\n return Err(WalError::PrevFrameMismatch);\n }\n Ok(())\n }\n\n /// Returns the page size from the header.\n ///\n /// Ported from `PageSize` in litestream@v0.5.11 wal_reader.go:78.\n #[inline]\n pub fn page_size(&self) -> u32 {\n self.page_size\n }\n\n /// Returns the header salt pair `(salt1, salt2)`.\n #[inline]\n pub fn salt(&self) -> (u32, u32) {\n (self.salt1, self.salt2)\n }\n\n /// Returns the file offset of the last frame read, or `0` if no frame has\n /// been read yet.\n ///\n /// Ported from `Offset` in litestream@v0.5.11 wal_reader.go:82-87.\n pub fn offset(&self) -> i64 {\n if self.frame_n == 0 {\n return 0;\n }\n WAL_HEADER_SIZE as i64\n + ((self.frame_n - 1) * (WAL_FRAME_HEADER_SIZE as i64 + self.page_size as i64))\n }\n\n /// Reads `n` bytes at absolute `offset`, returning `None` (the `io.EOF`\n /// case) when fewer than `n` bytes are available — exactly the behavior of\n /// Go's `io.ReaderAt.ReadAt` over a `bytes.Reader` short read, which the\n /// upstream code converts to `io.EOF`.\n fn read_at(&self, offset: i64, n: usize) -> Option<&'a [u8]> {\n if offset < 0 {\n return None;\n }\n let offset = offset as usize;\n let start = if self.tail_base == 0 || offset < WAL_HEADER_SIZE {\n offset\n } else {\n // A tail image holds nothing between the header and the tail;\n // an offset in that gap is a short read, exactly as a whole-file\n // image shorter than the offset would be.\n WAL_HEADER_SIZE + offset.checked_sub(self.tail_base)?\n };\n let end = start.checked_add(n)?;\n if end > self.data.len() {\n return None;\n }\n Some(&self.data[start..end])\n }\n\n /// A reader positioned at `offset` over a tail image: `data` is the\n /// 32-byte WAL header followed by the file's bytes from `tail_base`\n /// onward, so a sync that resumes at `offset` reads a buffer the size of\n /// the tail rather than of the file. `offset` must lie in the tail, and\n /// the previous frame (which the offset reader re-reads to seed its\n /// checksum) must too — the caller starts the tail one frame early.\n pub fn new_with_offset_over_tail(\n data: &'a [u8],\n tail_base: i64,\n offset: i64,\n salt1: u32,\n salt2: u32,\n ) -> WalResult {\n if tail_base < WAL_HEADER_SIZE as i64 || offset < tail_base {\n return Err(WalError::OffsetTooSmall {\n offset,\n header_size: WAL_HEADER_SIZE as i64,\n });\n }\n let mut r = Self::new_with_offset_inner(data, tail_base as usize)?;\n r.seek_to_offset(offset, salt1, salt2)?;\n Ok(r)\n }\n\n /// Reads and validates the WAL header into `self`.\n ///\n /// Ported from `readHeader` in litestream@v0.5.11 wal_reader.go:90-129.\n fn read_header(&mut self) -> WalResult<()> {\n // If we have a partial WAL, mark WAL as done (io.EOF).\n let hdr = match self.read_at(0, WAL_HEADER_SIZE) {\n Some(b) => b,\n None => return Err(WalError::Eof),\n };\n\n // Determine byte order of checksums from the magic (always read\n // big-endian, like Go's binary.BigEndian.Uint32(hdr[0:])).\n let magic = be_u32(&hdr[0..]);\n self.big_endian = match magic {\n WAL_MAGIC_LITTLE_ENDIAN => false,\n WAL_MAGIC_BIG_ENDIAN => true,\n _ => return Err(WalError::InvalidMagic(magic)),\n };\n\n // If the header checksum doesn't match then we may have failed with a\n // partial WAL header write during checkpointing => io.EOF.\n let chksum1 = be_u32(&hdr[24..]);\n let chksum2 = be_u32(&hdr[28..]);\n let (v0, v1) = wal_checksum(self.big_endian, 0, 0, &hdr[..24]);\n if v0 != chksum1 || v1 != chksum2 {\n return Err(WalError::Eof);\n }\n\n // Verify version is correct.\n let version = be_u32(&hdr[4..]);\n if version != WAL_VERSION {\n return Err(WalError::UnsupportedVersion(version));\n }\n\n self.page_size = be_u32(&hdr[8..]);\n self.salt1 = be_u32(&hdr[16..]);\n self.salt2 = be_u32(&hdr[20..]);\n self.chksum1 = chksum1;\n self.chksum2 = chksum2;\n\n Ok(())\n }\n\n /// Reads the next frame into `data` and returns `(pgno, commit)`.\n ///\n /// Returns [`WalError::Eof`] at the end of the valid WAL (including on a\n /// salt or checksum mismatch, which terminate the valid region). `data` must\n /// be exactly `page_size` bytes or [`WalError::BufferSize`] is returned.\n ///\n /// Ported from `ReadFrame` in litestream@v0.5.11 wal_reader.go:131-135.\n pub fn read_frame(&mut self, data: &mut [u8]) -> WalResult<(u32, u32)> {\n self.read_frame_inner(data, true)\n }\n\n /// Frame-read core shared by [`Self::read_frame`] and the offset constructor.\n ///\n /// When `verify_checksum` is `false`, the running checksum is *set* from the\n /// frame's stored checksum rather than verified against a rolling value —\n /// used when seeking to an offset without checksumming from the beginning.\n ///\n /// Ported from `readFrame` in litestream@v0.5.11 wal_reader.go:137-187.\n fn read_frame_inner(\n &mut self,\n data: &mut [u8],\n verify_checksum: bool,\n ) -> WalResult<(u32, u32)> {\n if data.len() != self.page_size as usize {\n return Err(WalError::BufferSize {\n got: data.len(),\n want: self.page_size,\n });\n }\n\n let frame_size = self.page_size as i64 + WAL_FRAME_HEADER_SIZE as i64;\n let offset = WAL_HEADER_SIZE as i64 + (self.frame_n * frame_size);\n\n // Read WAL frame header. A short read is io.EOF.\n let hdr = match self.read_at(offset, WAL_FRAME_HEADER_SIZE) {\n Some(b) => b,\n None => return Err(WalError::Eof),\n };\n\n // Read WAL page data. A short read is io.EOF.\n let page = match self.read_at(offset + WAL_FRAME_HEADER_SIZE as i64, data.len()) {\n Some(b) => b,\n None => return Err(WalError::Eof),\n };\n data.copy_from_slice(page);\n\n // Verify salt matches the salt in the header; otherwise end of valid WAL.\n let salt1 = be_u32(&hdr[8..]);\n let salt2 = be_u32(&hdr[12..]);\n if self.salt1 != salt1 || self.salt2 != salt2 {\n return Err(WalError::Eof);\n }\n\n // Verify the cumulative checksum. If verification is disabled, it is\n // because we are jumping to an offset and not checksumming from the\n // beginning, so we simply adopt the frame's stored checksum.\n let chksum1 = be_u32(&hdr[16..]);\n let chksum2 = be_u32(&hdr[20..]);\n if verify_checksum {\n let (c0, c1) = wal_checksum(self.big_endian, self.chksum1, self.chksum2, &hdr[..8]);\n let (c0, c1) = wal_checksum(self.big_endian, c0, c1, data);\n self.chksum1 = c0;\n self.chksum2 = c1;\n if self.chksum1 != chksum1 || self.chksum2 != chksum2 {\n return Err(WalError::Eof);\n }\n } else {\n self.chksum1 = chksum1;\n self.chksum2 = chksum2;\n }\n\n let pgno = be_u32(&hdr[0..]);\n let commit = be_u32(&hdr[4..]);\n\n self.frame_n += 1;\n\n Ok((pgno, commit))\n }\n\n /// Reads all committed frames to end-of-file and returns a map of page\n /// number → byte offset of the latest committed version of that page, the\n /// max offset of the WAL segment read, and the final database size in pages.\n ///\n /// Pages above the final commit size are dropped (handles a DB that shrank,\n /// e.g. via `VACUUM`, between transactions).\n ///\n /// Ported from `PageMap` in litestream@v0.5.11 wal_reader.go:189-244.\n pub fn page_map(&mut self) -> WalResult<(HashMap, i64, u32)> {\n let mut m: HashMap = HashMap::new();\n let mut tx_map: HashMap = HashMap::new();\n let mut commit: u32 = 0;\n let mut data = vec![0u8; self.page_size as usize];\n\n loop {\n let (pgno, fcommit) = match self.read_frame(&mut data) {\n Ok(v) => v,\n Err(e) if e.is_eof() => break,\n Err(e) => return Err(e),\n };\n\n // Update latest offset for this page within the current transaction.\n // Not promoted to the full map until the txn commits.\n let offset = self.offset();\n tx_map.insert(pgno, offset);\n\n // On a commit record, transfer the txn offsets into the full map and\n // record the new DB size.\n if fcommit != 0 {\n for (p, o) in tx_map.drain() {\n m.insert(p, o);\n }\n commit = fcommit;\n }\n }\n\n // Remove pages that exceed the final commit size (DB shrank mid-WAL).\n m.retain(|&pgno, _| pgno <= commit);\n\n // No complete transactions => original (zero) offset.\n if m.is_empty() {\n return Ok((m, 0, 0));\n }\n\n // Highest page offset, extended to the end of that frame.\n let mut end: i64 = 0;\n for &offset in m.values() {\n if end == 0 || offset > end {\n end = offset;\n }\n }\n end += WAL_FRAME_HEADER_SIZE as i64 + self.page_size as i64;\n\n Ok((m, end, commit))\n }\n\n /// Returns the set of unique frame salt pairs in the WAL, scanning until the\n /// `until` salt pair is seen or end-of-file is reached.\n ///\n /// Unlike frame reading, this does **not** verify checksums or that frame\n /// salts match the header — it deliberately collects *every* distinct salt,\n /// including those from superseded transactions.\n ///\n /// Ported from `FrameSaltsUntil` in litestream@v0.5.11 wal_reader.go:246-270.\n pub fn frame_salts_until(&self, until: (u32, u32)) -> HashSet<(u32, u32)> {\n let mut m = HashSet::new();\n let step = WAL_FRAME_HEADER_SIZE as i64 + self.page_size as i64;\n let mut offset = WAL_HEADER_SIZE as i64;\n // The loop ends either when a frame-header read runs short (the Go\n // `n != len(hdr)` => break) or when we reach the `until` salt below.\n while let Some(hdr) = self.read_at(offset, WAL_FRAME_HEADER_SIZE) {\n let salt1 = be_u32(&hdr[8..]);\n let salt2 = be_u32(&hdr[12..]);\n\n // Track unique salts.\n m.insert((salt1, salt2));\n\n // Stop once we've seen the salt we were asked to read up to.\n if salt1 == until.0 && salt2 == until.1 {\n break;\n }\n\n offset += step;\n }\n m\n }\n}\n\n/// Reads a big-endian `u32` from the first four bytes of `b`.\n///\n/// All WAL header/frame scalar fields are big-endian regardless of the checksum\n/// byte order (Go uses `binary.BigEndian.Uint32`). Panics if `b.len() < 4`,\n/// which never happens for the fixed-offset accesses in this module.\n#[inline]\nfn be_u32(b: &[u8]) -> u32 {\n u32::from_be_bytes([b[0], b[1], b[2], b[3]])\n}\n","editable",false,"branch","documentNavigation","repo","denoland/celld","repoId","a23b8a10-92cf-4dc4-a7ab-a04e58298dde","ownerId","org:42048915","site","nexthub","private","admin","settings","maintainer","triage","starred","stars",1,"watchers","watching","pinned","notify","views",[134,135,136,137,138,139,140,141,142,143,144,145,146],"navigation",{"_55":56,"_91":92,"_93":94,"_95":96,"_97":98,"_99":100,"_101":102},"sources",[],"viewer","meta",{"_83":84,"_85":86,"_87":88,"_43":32,"_89":14,"_90":32,"_49":50,"_51":50},"branches",[14],"tags",[70,71,72,73,74,75,76,77,78,79,80,81,82],"cloneUrl","https://git.nexthub.sh/denoland/celld.git","v0.0.1","v0.0.2","v0.1.0","v0.2.0","v0.2.1","v0.3.0","v0.4.0","v0.4.1","v0.5.0","v0.5.1","v0.6.0","v0.6.1","v0.6.2","description","self-hosted, distributed Durable Objects","owner","denoland","section","","head","empty","pins",[116,117,118],"documents",{"_111":112,"_113":114},"code",{"_108":109,"_110":104},"automations",{"_106":50,"_107":-5},"delivery",{"_103":104,"_105":-5},"tag","7gTA52Z9a1vO6FP6eCQPix9zO4O","releases",0,"applications","workflows","deployments","commits",13,"changes","counts",{"_115":114},"total",38,"issue",{"_119":110,"_121":132,"_15":110,"_123":133,"_53":125,"_126":32,"_127":125,"_128":104},{"_119":129,"_121":130,"_15":129,"_123":131,"_53":125,"_126":32,"_127":125,"_128":104},{"_119":120,"_121":122,"_15":120,"_123":124,"_53":125,"_126":32,"_127":125,"_128":114},"id","issues","name","Issues","filters",{},true,"saved","pinnable","count","tasks","Tasks",{},"Changes",{},{"_119":110,"_121":132,"_15":110,"_123":177,"_53":125,"_126":32,"_127":125},{"_119":129,"_121":130,"_15":129,"_123":176,"_53":125,"_126":32,"_127":125},{"_119":120,"_121":122,"_15":120,"_123":175,"_53":125,"_126":32,"_127":125},{"_119":172,"_121":173,"_15":172,"_123":174,"_53":32,"_126":32,"_127":125},{"_119":169,"_121":170,"_15":169,"_123":171,"_53":32,"_126":32,"_127":125},{"_119":106,"_121":167,"_15":97,"_123":168,"_53":32,"_126":32,"_127":125},{"_119":107,"_121":164,"_15":165,"_123":166,"_53":32,"_126":32,"_127":125},{"_119":103,"_121":162,"_15":103,"_123":163,"_53":32,"_126":32,"_127":125},{"_119":158,"_121":159,"_15":160,"_123":161,"_53":32,"_126":32,"_127":125},{"_119":93,"_121":156,"_15":93,"_123":157,"_53":32,"_126":32,"_127":32},{"_119":153,"_121":154,"_15":153,"_123":155,"_53":32,"_126":32,"_127":32},{"_119":150,"_121":151,"_15":150,"_123":152,"_53":32,"_126":32,"_127":32},{"_119":147,"_121":148,"_15":147,"_123":149,"_53":32,"_126":32,"_127":32},"decisions","Decisions",{},"changelog","Changelog",{},"roadmap","Roadmap",{},"Documents",{},"activity","Activity","insights",{},"Releases",{},"Deployments","automations/deployments",{},"Workflows",{},"discussions","Discussions",{},"goals","Goals",{},{},{},{},"groups","user","agents",[],"now",1794472750624,"sidebar","expanded"]