Skip to main content

qualia_core_db/bundle/stream/formats/
m64.rs

1use super::{
2    range::{extent, nonoverlap, overlap},
3    AuthenticatedRange, FormatError as E, FormatLimits, PayloadInterval,
4};
5use crate::q42::{
6    chunk_integrity::{verify_blake3_trailer, BLAKE3_TRAILER_BYTES},
7    m64_matter::{
8        M64ChunkDirectoryEntry, M64Header, M64LocalMetricHeader, M64PhaseJunctureRecord,
9        M64ShellRecord, M64StrataColumnRecord, LRM3_BLOCK_BYTES, M64_CODEC_BLAKE3_FULL,
10        M64_FLAG_3D_BRICK_16X16X16, M64_FLAG_LOCAL_METRIC_LRM3, M64_MODE_HOLO,
11        M64_MODE_PHASE_JUNCTURE, M64_MODE_POINT, M64_MODE_SHELL, M64_MODE_STRATA,
12    },
13};
14/// M64/E64 full-digest v1/v2 selective directory view. V3 raster metadata has a
15/// distinct closure and refuses here until that complete closure is supplied.
16pub struct M64DirectoryView<'a> {
17    header: M64Header,
18    directory: AuthenticatedRange<'a>,
19    lrm3: Option<M64LocalMetricHeader>,
20    limits: FormatLimits,
21}
22pub struct M64ChunkView<'a> {
23    entry: M64ChunkDirectoryEntry,
24    records: &'a [u8],
25}
26impl<'a> M64ChunkView<'a> {
27    pub const fn entry(&self) -> &M64ChunkDirectoryEntry {
28        &self.entry
29    }
30    pub fn records(&self) -> &'a [u8] {
31        self.records
32    }
33    pub fn record(&self, index: usize) -> Option<&'a [u8]> {
34        let start = index.checked_mul(64)?;
35        self.records.get(start..start.checked_add(64)?)
36    }
37}
38impl<'a> M64DirectoryView<'a> {
39    pub fn admit(
40        header: AuthenticatedRange<'a>,
41        directory: AuthenticatedRange<'a>,
42        local_metric: Option<AuthenticatedRange<'a>>,
43        limits: FormatLimits,
44        max_records: u64,
45        scratch: &mut [PayloadInterval],
46    ) -> Result<Self, E> {
47        if !cfg!(target_endian = "little") {
48            return Err(E::Unsupported);
49        }
50        if !header.same_entry(&directory) {
51            return Err(E::Identity);
52        }
53        if header.offset() != 0 || header.bytes().len() != 64 {
54            return Err(E::Bounds);
55        }
56        if header.selected().logical_length() > limits.max_entry_bytes {
57            return Err(E::Limit);
58        }
59        let h: M64Header = bytemuck::pod_read_unaligned(header.bytes());
60        h.validate().map_err(|_| E::Integrity)?;
61        if !matches!(h.version, 1 | 2)
62            || h.container_flags
63                & !((M64_FLAG_LOCAL_METRIC_LRM3 | M64_FLAG_3D_BRICK_16X16X16) as u32)
64                != 0
65        {
66            return Err(E::Unsupported);
67        }
68        if h.total_file_size != header.selected().logical_length() {
69            return Err(E::Geometry);
70        }
71        let count = usize::try_from(h.chunk_count).map_err(|_| E::Limit)?;
72        if count > limits.max_rows || count > 4096 {
73            return Err(E::Limit);
74        }
75        if scratch.len() < count {
76            return Err(E::Capacity);
77        }
78        let bytes = count.checked_mul(64).ok_or(E::Bounds)?;
79        let mut metadata_bytes = 64usize.checked_add(bytes).ok_or(E::Bounds)?;
80        let mut metadata_end = u64::from(h.header_size);
81        let lrm3 = if h.container_flags & M64_FLAG_LOCAL_METRIC_LRM3 as u32 != 0 {
82            let metric = local_metric.ok_or(E::Bounds)?;
83            if !header.same_entry(&metric) {
84                return Err(E::Identity);
85            }
86            if metric.offset() != metadata_end || metric.bytes().len() != LRM3_BLOCK_BYTES {
87                return Err(E::Bounds);
88            }
89            let block: M64LocalMetricHeader = bytemuck::pod_read_unaligned(metric.bytes());
90            block.validate().map_err(|_| E::Integrity)?;
91            metadata_bytes = metadata_bytes
92                .checked_add(LRM3_BLOCK_BYTES)
93                .ok_or(E::Bounds)?;
94            metadata_end = extent(metadata_end, LRM3_BLOCK_BYTES as u64, h.total_file_size)?;
95            Some(block)
96        } else {
97            if local_metric.is_some() {
98                return Err(E::Unsupported);
99            }
100            None
101        };
102        if metadata_bytes > limits.max_metadata_bytes {
103            return Err(E::Limit);
104        }
105        let dstart = h.chunk_table_offset;
106        let dend = extent(dstart, bytes as u64, h.total_file_size)?;
107        if dstart < metadata_end
108            || dstart % 64 != 0
109            || directory.offset() != dstart
110            || directory.bytes().len() != bytes
111        {
112            return Err(E::Geometry);
113        }
114        let mut records = 0u64;
115        for (i, raw) in directory.bytes().chunks_exact(64).enumerate() {
116            let row: M64ChunkDirectoryEntry = bytemuck::pod_read_unaligned(raw);
117            row.validate().map_err(|_| E::Integrity)?;
118            if !matches!(
119                row.chunk_record_mode,
120                M64_MODE_POINT
121                    | M64_MODE_HOLO
122                    | M64_MODE_STRATA
123                    | M64_MODE_SHELL
124                    | M64_MODE_PHASE_JUNCTURE
125            ) {
126                return Err(E::Unsupported);
127            }
128            if row.compression_flags != M64_CODEC_BLAKE3_FULL || row.bao_root_hash_prefix != [0; 12]
129            {
130                return Err(E::Integrity);
131            }
132            let length = u64::from(row.record_count)
133                .checked_mul(64)
134                .and_then(|n| n.checked_add(BLAKE3_TRAILER_BYTES as u64))
135                .ok_or(E::Bounds)?;
136            if row.record_count == 0 || length != u64::from(row.byte_length) {
137                return Err(E::Geometry);
138            }
139            records = records
140                .checked_add(u64::from(row.record_count))
141                .ok_or(E::Bounds)?;
142            if records > max_records {
143                return Err(E::Limit);
144            }
145            let end = extent(row.byte_offset, length, h.total_file_size)?;
146            if row.byte_offset < metadata_end
147                || row.byte_offset % 64 != 0
148                || overlap(row.byte_offset, end, dstart, dend)
149            {
150                return Err(E::Geometry);
151            }
152            scratch[i] = PayloadInterval {
153                start: row.byte_offset,
154                end,
155            };
156        }
157        nonoverlap(&mut scratch[..count])?;
158        Ok(Self {
159            header: h,
160            directory,
161            lrm3,
162            limits,
163        })
164    }
165    pub const fn header(&self) -> &M64Header {
166        &self.header
167    }
168    pub const fn local_metric(&self) -> Option<&M64LocalMetricHeader> {
169        self.lrm3.as_ref()
170    }
171    pub fn selected_chunk(
172        &self,
173        index: usize,
174        payload: AuthenticatedRange<'a>,
175    ) -> Result<M64ChunkView<'a>, E> {
176        if !self.directory.same_entry(&payload) {
177            return Err(E::Identity);
178        }
179        let start = index.checked_mul(64).ok_or(E::Bounds)?;
180        let raw = self
181            .directory
182            .bytes()
183            .get(start..start.checked_add(64).ok_or(E::Bounds)?)
184            .ok_or(E::Bounds)?;
185        let row: M64ChunkDirectoryEntry = bytemuck::pod_read_unaligned(raw);
186        let length = usize::try_from(row.byte_length).map_err(|_| E::Limit)?;
187        if length > self.limits.max_chunk_bytes {
188            return Err(E::Limit);
189        }
190        if payload.offset() != row.byte_offset || payload.bytes().len() != length {
191            return Err(E::Bounds);
192        }
193        let split = length.checked_sub(BLAKE3_TRAILER_BYTES).ok_or(E::Bounds)?;
194        let (records, trailer) = payload.bytes().split_at(split);
195        if !verify_blake3_trailer(records, trailer) {
196            return Err(E::Integrity);
197        }
198        for raw in records.chunks_exact(64) {
199            let valid = match row.chunk_record_mode {
200                M64_MODE_STRATA => {
201                    bytemuck::pod_read_unaligned::<M64StrataColumnRecord>(raw).validate()
202                }
203                M64_MODE_SHELL => bytemuck::pod_read_unaligned::<M64ShellRecord>(raw).validate(),
204                M64_MODE_PHASE_JUNCTURE => {
205                    bytemuck::pod_read_unaligned::<M64PhaseJunctureRecord>(raw).validate()
206                }
207                M64_MODE_POINT | M64_MODE_HOLO => Ok(()),
208                _ => return Err(E::Unsupported),
209            };
210            valid.map_err(|_| E::Integrity)?;
211        }
212        Ok(M64ChunkView {
213            entry: row,
214            records,
215        })
216    }
217}