qualia_core_db/bundle/stream/formats/
m64.rs1use 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};
14pub 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}