tapirus 1.2.1

Embedded multi-model database with SQL, vector search and local AI memory
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
//! Write-Ahead Log (WAL) implementation for TapirusDB.
//!
//! Committed page recovery via a dedicated `.tapir-wal` file. Native sessions
//! serialize access; this module does not provide snapshot isolation or MVCC.

use super::fault::{IoPoint, StorageIo};
use crate::error::{Error, Result};
use crate::pager::PageId;
use crc32fast::Hasher;
use std::collections::HashMap;
use std::fs::{File, OpenOptions};
use std::io::{BufWriter, Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};

/// Magic bytes identifying a TapirusDB WAL file: `b"TAPIRWAL"`
pub const WAL_MAGIC: [u8; 8] = *b"TAPIRWAL";

/// WAL file format version
pub const WAL_VERSION: u32 = 1;

/// Fixed size of the WAL header in bytes
pub const WAL_HEADER_SIZE: usize = 32;

/// Fixed size of each WAL frame header in bytes
pub const WAL_FRAME_HEADER_SIZE: usize = 24;

/// Default checkpoint threshold in frames (1,000 pages = 4MB)
pub const DEFAULT_CHECKPOINT_THRESHOLD: usize = 1000;

/// 32-byte Header located at the beginning of every `.tapir-wal` file
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WalHeader {
    /// Magic string: `b"TAPIRWAL"`
    pub magic: [u8; 8],
    /// File format version
    pub version: u32,
    /// Page size in bytes (e.g. 4096)
    pub page_size: u32,
    /// Checkpoint sequence number incremented on each checkpoint
    pub checkpoint_seq: u32,
    /// Salt-1 for frame verification
    pub salt_1: u32,
    /// Salt-2 for frame verification
    pub salt_2: u32,
    /// Checksum over header bytes 0..27
    pub header_crc32: u32,
}

impl WalHeader {
    /// Create a new WAL header
    pub fn new(page_size: u32) -> Self {
        let mut header = Self {
            magic: WAL_MAGIC,
            version: WAL_VERSION,
            page_size,
            checkpoint_seq: 1,
            salt_1: 0x1A2B3C4D,
            salt_2: 0x5E6F7A8B,
            header_crc32: 0,
        };
        header.header_crc32 = header.calculate_crc();
        header
    }

    /// Calculate CRC32 checksum over the first 28 bytes of the WAL header
    pub fn calculate_crc(&self) -> u32 {
        let mut hasher = Hasher::new();
        hasher.update(&self.magic);
        hasher.update(&self.version.to_le_bytes());
        hasher.update(&self.page_size.to_le_bytes());
        hasher.update(&self.checkpoint_seq.to_le_bytes());
        hasher.update(&self.salt_1.to_le_bytes());
        hasher.update(&self.salt_2.to_le_bytes());
        hasher.finalize()
    }

    /// Serialize header to 32-byte buffer
    pub fn to_bytes(&self) -> [u8; WAL_HEADER_SIZE] {
        let mut buf = [0u8; WAL_HEADER_SIZE];
        buf[0..8].copy_from_slice(&self.magic);
        buf[8..12].copy_from_slice(&self.version.to_le_bytes());
        buf[12..16].copy_from_slice(&self.page_size.to_le_bytes());
        buf[16..20].copy_from_slice(&self.checkpoint_seq.to_le_bytes());
        buf[20..24].copy_from_slice(&self.salt_1.to_le_bytes());
        buf[24..28].copy_from_slice(&self.salt_2.to_le_bytes());
        buf[28..32].copy_from_slice(&self.header_crc32.to_le_bytes());
        buf
    }

    /// Deserialize header from 32-byte slice and verify CRC32
    pub fn from_bytes(slice: &[u8]) -> Result<Self> {
        if slice.len() < WAL_HEADER_SIZE {
            return Err(Error::Corrupted(
                "WAL header slice too short (<32 bytes)".into(),
            ));
        }

        let mut magic = [0u8; 8];
        magic.copy_from_slice(&slice[0..8]);
        if magic != WAL_MAGIC {
            return Err(Error::InvalidMagic);
        }

        let version = u32::from_le_bytes([slice[8], slice[9], slice[10], slice[11]]);
        let page_size = u32::from_le_bytes([slice[12], slice[13], slice[14], slice[15]]);
        let checkpoint_seq = u32::from_le_bytes([slice[16], slice[17], slice[18], slice[19]]);
        let salt_1 = u32::from_le_bytes([slice[20], slice[21], slice[22], slice[23]]);
        let salt_2 = u32::from_le_bytes([slice[24], slice[25], slice[26], slice[27]]);
        let header_crc32 = u32::from_le_bytes([slice[28], slice[29], slice[30], slice[31]]);

        let header = Self {
            magic,
            version,
            page_size,
            checkpoint_seq,
            salt_1,
            salt_2,
            header_crc32,
        };

        if header.version != WAL_VERSION
            || !header.page_size.is_power_of_two()
            || !(512..=65536).contains(&header.page_size)
        {
            return Err(Error::Corrupted(
                "Unsupported WAL version or page size".into(),
            ));
        }

        let expected_crc = header.calculate_crc();
        if header.header_crc32 != expected_crc {
            return Err(Error::PageCorrupted(0, expected_crc, header.header_crc32));
        }

        Ok(header)
    }
}

/// 24-byte Frame Header preceding every page image in the WAL file
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WalFrameHeader {
    /// Target page ID in the database
    pub page_id: PageId,
    /// Size of database in pages after this transaction commit (0 if non-commit frame)
    pub db_size_in_pages: u32,
    /// Monotonic commit sequence number
    pub commit_seq: u32,
    /// Salt-1 matching active WAL header
    pub salt_1: u32,
    /// Salt-2 matching active WAL header
    pub salt_2: u32,
    /// CRC32 checksum over frame header (0..20) and page image
    pub frame_crc32: u32,
}

impl WalFrameHeader {
    /// Calculate CRC32 checksum over frame header fields and page payload
    pub fn calculate_crc(&self, page_data: &[u8]) -> u32 {
        let mut hasher = Hasher::new();
        hasher.update(&self.page_id.to_le_bytes());
        hasher.update(&self.db_size_in_pages.to_le_bytes());
        hasher.update(&self.commit_seq.to_le_bytes());
        hasher.update(&self.salt_1.to_le_bytes());
        hasher.update(&self.salt_2.to_le_bytes());
        hasher.update(page_data);
        hasher.finalize()
    }

    /// Serialize frame header to 24-byte buffer
    pub fn to_bytes(&self) -> [u8; WAL_FRAME_HEADER_SIZE] {
        let mut buf = [0u8; WAL_FRAME_HEADER_SIZE];
        buf[0..4].copy_from_slice(&self.page_id.to_le_bytes());
        buf[4..8].copy_from_slice(&self.db_size_in_pages.to_le_bytes());
        buf[8..12].copy_from_slice(&self.commit_seq.to_le_bytes());
        buf[12..16].copy_from_slice(&self.salt_1.to_le_bytes());
        buf[16..20].copy_from_slice(&self.salt_2.to_le_bytes());
        buf[20..24].copy_from_slice(&self.frame_crc32.to_le_bytes());
        buf
    }

    /// Deserialize frame header from 24-byte slice
    pub fn from_bytes(slice: &[u8]) -> Result<Self> {
        if slice.len() < WAL_FRAME_HEADER_SIZE {
            return Err(Error::Corrupted(
                "WAL frame header slice too short (<24 bytes)".into(),
            ));
        }

        let page_id = u32::from_le_bytes([slice[0], slice[1], slice[2], slice[3]]);
        let db_size_in_pages = u32::from_le_bytes([slice[4], slice[5], slice[6], slice[7]]);
        let commit_seq = u32::from_le_bytes([slice[8], slice[9], slice[10], slice[11]]);
        let salt_1 = u32::from_le_bytes([slice[12], slice[13], slice[14], slice[15]]);
        let salt_2 = u32::from_le_bytes([slice[16], slice[17], slice[18], slice[19]]);
        let frame_crc32 = u32::from_le_bytes([slice[20], slice[21], slice[22], slice[23]]);

        Ok(Self {
            page_id,
            db_size_in_pages,
            commit_seq,
            salt_1,
            salt_2,
            frame_crc32,
        })
    }
}

/// A stored in-memory frame record
#[derive(Debug, Clone)]
struct InMemoryFrame {
    header: WalFrameHeader,
    page_data: Vec<u8>,
}

/// The Write-Ahead Log (WAL) coordinator
#[derive(Debug)]
pub struct Wal {
    header: WalHeader,
    writer: Option<BufWriter<File>>,
    _path: Option<PathBuf>,
    page_size: usize,
    /// In-memory index mapping PageId -> 0-based frame index
    index: HashMap<PageId, usize>,
    /// In-memory frame storage for memory mode or fast lookups
    frames: Vec<InMemoryFrame>,
    current_commit_seq: u32,
    io: StorageIo,
    io_failed: bool,
    checkpoint_error: Option<String>,
}

/// Storage maintenance state after a successful commit or an I/O failure.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct StorageHealth {
    /// The WAL must be reopened before further mutations.
    pub reopen_required: bool,
    /// Last deferred/explicit checkpoint failure, if any.
    pub checkpoint_error: Option<String>,
    /// Valid frames retained in the WAL.
    pub wal_frames: usize,
}

pub(crate) type CommittedWalSnapshot = (u32, HashMap<PageId, Vec<u8>>);

impl Wal {
    /// Open an existing WAL file or create a new one
    pub fn open<P: AsRef<Path>>(wal_path: P, page_size: u32) -> Result<Self> {
        let path = wal_path.as_ref().to_path_buf();
        let exists = path.exists();

        let mut file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .truncate(false)
            .open(&path)?;

        let header = if exists && file.metadata()?.len() >= WAL_HEADER_SIZE as u64 {
            let mut buf = [0u8; WAL_HEADER_SIZE];
            file.seek(SeekFrom::Start(0))?;
            file.read_exact(&mut buf)?;
            WalHeader::from_bytes(&buf)?
        } else {
            let header = WalHeader::new(page_size);
            file.seek(SeekFrom::Start(0))?;
            file.write_all(&header.to_bytes())?;
            file.sync_data()?;
            header
        };
        if header.page_size != page_size {
            return Err(Error::Corrupted(
                "WAL page size does not match the database".into(),
            ));
        }

        let mut wal = Self {
            header,
            writer: None,
            _path: Some(path),
            page_size: page_size as usize,
            index: HashMap::new(),
            frames: Vec::new(),
            current_commit_seq: 0,
            io: StorageIo::default(),
            io_failed: false,
            checkpoint_error: None,
        };

        // Replay existing frames into in-memory index
        wal.rebuild_index_from_file(&mut file)?;
        file.seek(SeekFrom::End(0))?;
        wal.writer = Some(BufWriter::with_capacity(128 * 1024, file));
        // Never expose a valid but uncommitted tail after a process restart.
        wal.discard_uncommitted_tail()?;
        Ok(wal)
    }

    /// Open an in-memory WAL
    pub fn open_in_memory(page_size: u32) -> Self {
        Self {
            header: WalHeader::new(page_size),
            writer: None,
            _path: None,
            page_size: page_size as usize,
            index: HashMap::new(),
            frames: Vec::new(),
            current_commit_seq: 0,
            io: StorageIo::default(),
            io_failed: false,
            checkpoint_error: None,
        }
    }

    /// Total number of valid frames currently in the WAL
    pub fn frame_count(&self) -> usize {
        self.frames.len()
    }

    /// Observe deferred checkpoint errors and whether reopen is required.
    pub fn health(&self) -> StorageHealth {
        StorageHealth {
            reopen_required: self.io_failed,
            checkpoint_error: self.checkpoint_error.clone(),
            wal_frames: self.frames.len(),
        }
    }
    pub(crate) fn requires_reopen(&self) -> bool {
        self.io_failed
    }
    #[cfg(not(target_arch = "wasm32"))]
    pub(crate) fn storage_io(&self) -> StorageIo {
        self.io.clone()
    }

    /// Install/clear deterministic faults for this WAL only.
    #[cfg(feature = "fault-injection")]
    pub fn set_io_fault(&self, plan: Option<super::fault::IoFaultPlan>) -> Result<()> {
        self.io.configure(plan)
    }

    /// Read the last committed image without modifying the WAL or base file.
    /// Used to recover a torn base header before credentials/replay are applied.
    pub(crate) fn read_committed_page(path: &Path, wanted: PageId) -> Result<Option<Vec<u8>>> {
        let mut file = File::open(path)?;
        let length = file.metadata()?.len();
        if length < WAL_HEADER_SIZE as u64 {
            return Ok(None);
        }
        let mut bytes = [0; WAL_HEADER_SIZE];
        file.read_exact(&mut bytes)?;
        let header = WalHeader::from_bytes(&bytes)?;
        let mut payload = vec![0; header.page_size as usize];
        let mut pending = None;
        let mut committed = None;
        while file.stream_position()? + WAL_FRAME_HEADER_SIZE as u64 + payload.len() as u64
            <= length
        {
            let mut raw = [0; WAL_FRAME_HEADER_SIZE];
            file.read_exact(&mut raw)?;
            let frame = WalFrameHeader::from_bytes(&raw)?;
            file.read_exact(&mut payload)?;
            if frame.salt_1 != header.salt_1
                || frame.salt_2 != header.salt_2
                || frame.page_id == 0
                || frame.frame_crc32 != frame.calculate_crc(&payload)
            {
                break;
            }
            if frame.page_id == wanted {
                pending = Some(payload.clone());
            }
            if frame.db_size_in_pages > 0 {
                committed = pending.clone();
            }
        }
        Ok(committed)
    }

    /// Inspect WAL header metadata and file length as an O(1) commit fingerprint.
    pub(crate) fn read_file_fingerprint(path: &Path) -> Result<(u64, u32, u32, u32)> {
        let mut file = match File::open(path) {
            Ok(f) => f,
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok((0, 0, 0, 0)),
            Err(e) => return Err(e.into()),
        };
        let len = file.metadata()?.len();
        if len < WAL_HEADER_SIZE as u64 {
            return Ok((len, 0, 0, 0));
        }
        let mut bytes = [0u8; WAL_HEADER_SIZE];
        file.read_exact(&mut bytes)?;
        let header = WalHeader::from_bytes(&bytes)?;
        Ok((len, header.checkpoint_seq, header.salt_1, header.salt_2))
    }

    /// Read all committed page images currently present in the WAL without modifying it.
    ///
    /// Returns `Ok(Some((db_size_in_pages, committed_pages)))` up to the latest valid commit
    /// frame (`db_size_in_pages > 0`), or `Ok(None)` if the WAL is absent or has no commits.
    pub(crate) fn read_all_committed_pages(path: &Path) -> Result<Option<CommittedWalSnapshot>> {
        let mut file = match File::open(path) {
            Ok(f) => f,
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
            Err(e) => return Err(e.into()),
        };
        let length = file.metadata()?.len();
        if length < WAL_HEADER_SIZE as u64 {
            return Ok(None);
        }
        let mut bytes = [0u8; WAL_HEADER_SIZE];
        file.read_exact(&mut bytes)?;
        let header = WalHeader::from_bytes(&bytes)?;
        let mut payload = vec![0u8; header.page_size as usize];
        let mut pending: HashMap<PageId, Vec<u8>> = HashMap::new();
        let mut committed: HashMap<PageId, Vec<u8>> = HashMap::new();
        let mut committed_db_size: u32 = 0;

        while file.stream_position()? + WAL_FRAME_HEADER_SIZE as u64 + payload.len() as u64
            <= length
        {
            let mut raw = [0u8; WAL_FRAME_HEADER_SIZE];
            if file.read_exact(&mut raw).is_err() {
                break;
            }
            let frame = match WalFrameHeader::from_bytes(&raw) {
                Ok(f) => f,
                Err(_) => break,
            };
            if file.read_exact(&mut payload).is_err() {
                break;
            }
            if frame.salt_1 != header.salt_1
                || frame.salt_2 != header.salt_2
                || frame.page_id == 0
                || frame.frame_crc32 != frame.calculate_crc(&payload)
            {
                break;
            }
            pending.insert(frame.page_id, payload.clone());
            if frame.db_size_in_pages > 0 {
                for (pid, data) in pending.drain() {
                    committed.insert(pid, data);
                }
                committed_db_size = frame.db_size_in_pages;
            }
        }

        if committed_db_size == 0 || committed.is_empty() {
            Ok(None)
        } else {
            Ok(Some((committed_db_size, committed)))
        }
    }

    /// Check if a page is currently cached in the WAL
    pub fn has_page(&self, page_id: PageId) -> bool {
        self.index.contains_key(&page_id)
    }

    /// Export all valid frames currently recorded in the WAL for replication
    pub fn export_frames(&self) -> Vec<(PageId, Vec<u8>)> {
        self.frames
            .iter()
            .map(|f| (f.header.page_id, f.page_data.clone()))
            .collect()
    }

    /// Rebuild in-memory index from file frames
    fn rebuild_index_from_file(&mut self, file: &mut File) -> Result<()> {
        let file_len = file.metadata()?.len();
        let frame_size = (WAL_FRAME_HEADER_SIZE + self.page_size) as u64;

        let mut offset = WAL_HEADER_SIZE as u64;
        let mut frame_idx = 0;

        while offset + frame_size <= file_len {
            file.seek(SeekFrom::Start(offset))?;

            let mut header_buf = [0u8; WAL_FRAME_HEADER_SIZE];
            file.read_exact(&mut header_buf)?;
            let frame_header = WalFrameHeader::from_bytes(&header_buf)?;

            let mut page_data = vec![0u8; self.page_size];
            file.read_exact(&mut page_data)?;

            // Verify CRC32 checksum
            let expected_crc = frame_header.calculate_crc(&page_data);
            if frame_header.frame_crc32 != expected_crc
                || frame_header.page_id == 0
                || frame_header.salt_1 != self.header.salt_1
                || frame_header.salt_2 != self.header.salt_2
            {
                // Truncate corrupted or torn frame
                break;
            }

            if frame_header.commit_seq > self.current_commit_seq {
                self.current_commit_seq = frame_header.commit_seq;
            }

            self.index.insert(frame_header.page_id, frame_idx);
            self.frames.push(InMemoryFrame {
                header: frame_header,
                page_data,
            });

            offset += frame_size;
            frame_idx += 1;
        }
        // Remove torn/corrupt bytes before the next append, including partial frames.
        file.set_len(offset)?;
        Ok(())
    }

    fn discard_uncommitted_tail(&mut self) -> Result<()> {
        let committed = self
            .frames
            .iter()
            .rposition(|f| f.header.db_size_in_pages > 0)
            .map_or(0, |i| i + 1);
        self.rollback_to(committed)
    }

    /// Read the latest version of a page from the WAL if present
    pub fn read_page(&self, page_id: PageId) -> Option<Vec<u8>> {
        let &frame_idx = self.index.get(&page_id)?;
        self.frames.get(frame_idx).map(|f| f.page_data.clone())
    }

    /// Append a page frame to the WAL
    pub fn write_frame(
        &mut self,
        page_id: PageId,
        page_data: &[u8],
        is_commit: bool,
        db_size_in_pages: u32,
    ) -> Result<()> {
        if self.io_failed {
            return Err(Error::TransactionError(
                "WAL requires reopen or successful rollback after I/O failure".into(),
            ));
        }
        if page_data.len() != self.page_size {
            return Err(Error::Corrupted("Page data size mismatch in WAL".into()));
        }

        let commit_seq = if is_commit {
            self.current_commit_seq
                .checked_add(1)
                .ok_or_else(|| Error::TransactionError("WAL commit sequence exhausted".into()))?
        } else {
            self.current_commit_seq
        };

        let mut frame_header = WalFrameHeader {
            page_id,
            db_size_in_pages: if is_commit { db_size_in_pages } else { 0 },
            commit_seq,
            salt_1: self.header.salt_1,
            salt_2: self.header.salt_2,
            frame_crc32: 0,
        };

        frame_header.frame_crc32 = frame_header.calculate_crc(page_data);

        // Append to buffered writer if disk-backed
        let written = (|| -> Result<()> {
            if let Some(writer) = &mut self.writer {
                self.io
                    .write(IoPoint::WalWrite, writer, &frame_header.to_bytes())?;
                self.io.write(IoPoint::WalWrite, writer, page_data)?;
                if is_commit {
                    self.io.before(IoPoint::WalFlush)?;
                    writer.flush()?;
                    self.io.before(IoPoint::WalSync)?;
                    writer.get_mut().sync_data()?;
                }
            }
            Ok(())
        })();
        if let Err(error) = written {
            self.io_failed = true;
            return Err(error);
        }
        self.current_commit_seq = commit_seq;

        let frame_idx = self.frames.len();
        self.index.insert(page_id, frame_idx);
        self.frames.push(InMemoryFrame {
            header: frame_header,
            page_data: page_data.to_vec(),
        });

        Ok(())
    }

    /// Flush any pending uncommitted WAL frames to durable physical disk storage
    pub fn sync(&mut self) -> Result<()> {
        let result = (|| -> Result<()> {
            if let Some(writer) = &mut self.writer {
                self.io.before(IoPoint::WalFlush)?;
                writer.flush()?;
                self.io.before(IoPoint::WalSync)?;
                writer.get_mut().sync_data()?;
            }
            Ok(())
        })();
        if result.is_err() {
            self.io_failed = true;
        }
        result
    }

    /// Checkpoint all committed pages back into the base database file,
    /// then truncate and reset the WAL file.
    pub fn checkpoint(
        &mut self,
        base_file: &mut Option<File>,
        base_in_memory: &mut HashMap<PageId, Vec<u8>>,
    ) -> Result<usize> {
        let result = if self.io_failed {
            Err(Error::TransactionError(
                "WAL requires reopen before checkpoint".into(),
            ))
        } else {
            self.checkpoint_inner(base_file, base_in_memory)
        };
        self.checkpoint_error = result.as_ref().err().map(ToString::to_string);
        result
    }

    fn checkpoint_inner(
        &mut self,
        base_file: &mut Option<File>,
        base_in_memory: &mut HashMap<PageId, Vec<u8>>,
    ) -> Result<usize> {
        if self
            .frames
            .last()
            .is_some_and(|f| f.header.db_size_in_pages == 0)
        {
            return Err(Error::TransactionError(
                "Cannot checkpoint an uncommitted WAL tail".into(),
            ));
        }
        let page_size = self.page_size;
        let num_pages_to_flush = self.index.len();

        if num_pages_to_flush == 0 {
            return Ok(0);
        }

        // 1. Write latest page versions to base database in sequential PageId order
        let mut sorted_page_ids: Vec<PageId> = self.index.keys().copied().collect();
        sorted_page_ids.sort_unstable();

        for page_id in sorted_page_ids {
            let frame_idx = self.index[&page_id];
            let page_data = &self.frames[frame_idx].page_data;

            if let Some(file) = base_file {
                let offset = (page_id as u64 - 1) * page_size as u64;
                file.seek(SeekFrom::Start(offset))?;
                self.io.write(IoPoint::CheckpointWrite, file, page_data)?;
            }

            if base_file.is_none() {
                base_in_memory.insert(page_id, page_data.clone());
            }
        }

        if let Some(file) = base_file {
            self.io.before(IoPoint::CheckpointSync)?;
            file.sync_all()?;
        }

        // 2. Reset WAL file
        self.header.checkpoint_seq += 1;
        self.header.header_crc32 = self.header.calculate_crc();

        let reset = (|| -> Result<()> {
            if let Some(writer) = &mut self.writer {
                self.io.before(IoPoint::WalFlush)?;
                writer.flush()?;
                let file = writer.get_mut();
                self.io.before(IoPoint::WalTruncate)?;
                file.set_len(0)?;
                file.seek(SeekFrom::Start(0))?;
                self.io
                    .write(IoPoint::WalReset, file, &self.header.to_bytes())?;
                self.io.before(IoPoint::WalSync)?;
                file.sync_all()?;
                file.seek(SeekFrom::End(0))?;
            }
            Ok(())
        })();
        if let Err(error) = reset {
            self.io_failed = true;
            return Err(error);
        }

        self.index.clear();
        self.frames.clear();

        Ok(num_pages_to_flush)
    }

    /// Recover database from existing WAL on startup (replaying committed frames)
    pub fn recover(
        &mut self,
        base_file: &mut Option<File>,
        base_in_memory: &mut HashMap<PageId, Vec<u8>>,
    ) -> Result<usize> {
        self.discard_uncommitted_tail()?;
        if self.frames.is_empty() {
            return Ok(0);
        }

        // Find last valid commit frame index
        let mut last_commit_idx = None;
        for (idx, frame) in self.frames.iter().enumerate() {
            if frame.header.db_size_in_pages > 0 {
                last_commit_idx = Some(idx);
            }
        }

        let max_safe_frame = match last_commit_idx {
            Some(idx) => idx,
            None => {
                // No committed transaction found in WAL, discard all frames
                self.index.clear();
                self.frames.clear();
                return Ok(0);
            }
        };

        // Replay up to last_commit_idx
        let mut recovered_count = 0;
        for frame in &self.frames[..=max_safe_frame] {
            let page_id = frame.header.page_id;
            let page_data = &frame.page_data;

            if let Some(file) = base_file {
                let offset = (page_id as u64 - 1) * self.page_size as u64;
                file.seek(SeekFrom::Start(offset))?;
                self.io.write(IoPoint::CheckpointWrite, file, page_data)?;
            }

            if base_file.is_none() {
                base_in_memory.insert(page_id, page_data.clone());
            }
            recovered_count += 1;
        }

        if let Some(file) = base_file {
            self.io.before(IoPoint::CheckpointSync)?;
            file.sync_all()?;
        }

        Ok(recovered_count)
    }

    /// Truncate WAL back to a given frame count (used during rollback)
    pub fn rollback_to(&mut self, frame_count: usize) -> Result<()> {
        let frame_count = frame_count.min(self.frames.len());
        let truncate = (|| -> Result<()> {
            if let Some(writer) = &mut self.writer {
                let offset = WAL_HEADER_SIZE as u64
                    + frame_count as u64 * (WAL_FRAME_HEADER_SIZE + self.page_size) as u64;
                if !self.io_failed
                    && writer.buffer().is_empty()
                    && writer.get_ref().metadata()?.len() == offset
                    && frame_count == self.frames.len()
                {
                    return Ok(());
                }
                self.io.before(IoPoint::WalFlush)?;
                writer.flush()?;
                let file = writer.get_mut();
                self.io.before(IoPoint::WalTruncate)?;
                file.set_len(offset)?;
                self.io.before(IoPoint::WalSync)?;
                file.sync_data()?;
                file.seek(SeekFrom::End(0))?;
            }
            Ok(())
        })();
        if let Err(error) = truncate {
            self.io_failed = true;
            return Err(error);
        }
        self.io_failed = false;
        self.frames.truncate(frame_count);
        self.index.clear();
        for (i, frame) in self.frames.iter().enumerate() {
            self.index.insert(frame.header.page_id, i);
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_wal_header_roundtrip() {
        let header = WalHeader::new(4096);
        let bytes = header.to_bytes();
        let parsed = WalHeader::from_bytes(&bytes).expect("Parse header");
        assert_eq!(header, parsed);
    }

    #[test]
    fn test_wal_frame_header_crc_validation() {
        let page_data = vec![0xABu8; 4096];
        let mut frame_header = WalFrameHeader {
            page_id: 42,
            db_size_in_pages: 10,
            commit_seq: 1,
            salt_1: 0x11223344,
            salt_2: 0x55667788,
            frame_crc32: 0,
        };
        frame_header.frame_crc32 = frame_header.calculate_crc(&page_data);

        // Verification passes with identical data
        assert_eq!(
            frame_header.frame_crc32,
            frame_header.calculate_crc(&page_data)
        );

        // Verification fails if data is altered by even 1 bit
        let mut corrupted = page_data.clone();
        corrupted[100] ^= 0x01;
        assert_ne!(
            frame_header.frame_crc32,
            frame_header.calculate_crc(&corrupted)
        );
    }

    #[test]
    fn test_in_memory_wal_write_and_checkpoint() {
        let mut wal = Wal::open_in_memory(4096);
        let mut in_memory_pages = HashMap::new();

        let page1 = vec![1u8; 4096];
        let page2 = vec![2u8; 4096];

        wal.write_frame(1, &page1, false, 0).expect("Write frame 1");
        wal.write_frame(2, &page2, true, 2).expect("Commit frame 2");

        assert_eq!(wal.frame_count(), 2);
        assert!(wal.has_page(1));
        assert!(wal.has_page(2));

        // Read through WAL
        assert_eq!(wal.read_page(1).unwrap(), page1);
        assert_eq!(wal.read_page(2).unwrap(), page2);

        // Checkpoint to base
        let mut base_file = None;
        let flushed = wal
            .checkpoint(&mut base_file, &mut in_memory_pages)
            .expect("Checkpoint");
        assert_eq!(flushed, 2);
        assert_eq!(wal.frame_count(), 0);
        assert_eq!(in_memory_pages.get(&1).unwrap(), &page1);
        assert_eq!(in_memory_pages.get(&2).unwrap(), &page2);

        // Overwrite an existing page and checkpoint again; base_in_memory must reflect the new image.
        let page2_v2 = vec![9u8; 4096];
        wal.write_frame(2, &page2_v2, true, 2)
            .expect("Overwrite frame 2");
        let flushed2 = wal
            .checkpoint(&mut base_file, &mut in_memory_pages)
            .expect("Second checkpoint");
        assert_eq!(flushed2, 1);
        assert_eq!(in_memory_pages.get(&2).unwrap(), &page2_v2);
    }
}