1use super::{args, ids};
10use crate::topology::header::{
11 AnchorDomain, CellAnchor, GeometryComplexKind, GeometryMetricKind, GraphEmbedRole,
12 GraphMorphology, HarbouredGraphHeader, PoetGeometryHeader, TopologyError, TopologyInvariants,
13 GTOP_MAGIC,
14};
15use bytemuck::bytes_of;
16use vibe::{Diagnostic, Span, Value};
17
18#[inline]
19fn q_hash_bytes(bytes: &[u8]) -> u64 {
20 let mut hash = 0xcbf29ce484222325u64;
21 for &b in bytes {
22 hash ^= b as u64;
23 hash = hash.wrapping_mul(0x100000001b3);
24 }
25 hash
26}
27
28#[inline]
29fn crc32c_slice(bytes: &[u8]) -> u32 {
30 let mut crc = !0u32;
31 for &b in bytes {
32 crc ^= b as u32;
33 for _ in 0..8 {
34 let mask = (crc & 1).wrapping_neg();
35 crc = (crc >> 1) ^ (0x82F6_3B78 & mask);
36 }
37 }
38 !crc
39}
40
41fn parse_metric_kind(name: &str) -> GeometryMetricKind {
42 match name.trim() {
43 "ToroidalCyclic" | "Toroidal" | "Cyclic" => GeometryMetricKind::ToroidalCyclic,
44 "HyperbolicPoincare" | "Hyperbolic" => GeometryMetricKind::HyperbolicPoincare,
45 "SphericalGeodesic" | "Spherical" => GeometryMetricKind::SphericalGeodesic,
46 "FisherRaoSimplex" | "FisherRao" => GeometryMetricKind::FisherRaoSimplex,
47 "LorentzianCausal" | "Lorentzian" => GeometryMetricKind::LorentzianCausal,
48 _ => GeometryMetricKind::Euclidean,
49 }
50}
51
52fn parse_invariants(
53 args_v: &Value,
54 span: Span,
55) -> Result<(TopologyInvariants, Vec<String>), Diagnostic> {
56 let mut inv = TopologyInvariants::EMPTY;
57 let mut names = Vec::new();
58 if let Some(bits) = args::rec_u64(args_v, "invariants_bits").or_else(|| args::rec_u64(args_v, "invariants")) {
59 inv = TopologyInvariants::from_bits_truncate(bits as u16);
60 return Ok((inv, names));
61 }
62 if let Some(list) = args::rec_str_list(args_v, "invariants") {
63 for item in list {
64 let flag = TopologyInvariants::from_name(&item).ok_or_else(|| {
65 args::bad(span, format!("unknown TopologyInvariants flag `{item}`"))
66 })?;
67 inv |= flag;
68 names.push(item);
69 }
70 } else if let Some(s) = args::rec_str(args_v, "invariants") {
71 for part in s.split(',').map(str::trim).filter(|p| !p.is_empty()) {
72 let flag = TopologyInvariants::from_name(part).ok_or_else(|| {
73 args::bad(span, format!("unknown TopologyInvariants flag `{part}`"))
74 })?;
75 inv |= flag;
76 names.push(part.to_string());
77 }
78 }
79 Ok((inv, names))
80}
81
82pub fn define_geometry(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
84 let name = args::rec_str(args_v, "name")
85 .or_else(|| args::rec_str(args_v, "geometry"))
86 .or_else(|| args::rec_str(args_v, "label"))
87 .unwrap_or("DefaultGeometry");
88 let kind_str = args::rec_str(args_v, "complex_kind")
89 .or_else(|| args::rec_str(args_v, "kind"))
90 .unwrap_or("MixedCellComplex3D");
91 let complex_kind = GeometryComplexKind::from_name(kind_str).ok_or_else(|| {
92 args::bad(span, format!("invalid GeometryComplexKind `{kind_str}`"))
93 })?;
94 let metric_str = args::rec_str(args_v, "metric")
95 .or_else(|| args::rec_str(args_v, "metric_kind"))
96 .unwrap_or("Euclidean");
97 let metric_kind = parse_metric_kind(metric_str);
98 let satisfies = args::rec_str(args_v, "satisfies")
99 .or_else(|| args::rec_str(args_v, "construct"))
100 .unwrap_or("qualia:DefaultConstruct");
101
102 let n0 = args::rec_u64(args_v, "cell_0_count").or_else(|| args::rec_u64(args_v, "n0")).unwrap_or(8) as u32;
103 let n1 = args::rec_u64(args_v, "cell_1_count").or_else(|| args::rec_u64(args_v, "n1")).unwrap_or(12) as u32;
104 let n2 = args::rec_u64(args_v, "cell_2_count").or_else(|| args::rec_u64(args_v, "n2")).unwrap_or(6) as u32;
105 let n3 = args::rec_u64(args_v, "cell_3_count").or_else(|| args::rec_u64(args_v, "n3")).unwrap_or(1) as u32;
106 let graph_count = args::rec_u64(args_v, "harboured_graph_count")
107 .or_else(|| args::rec_u64(args_v, "graph_count"))
108 .unwrap_or(1) as u16;
109 let manifold_id = args::rec_u64(args_v, "manifold_id").unwrap_or(0) as u32;
110 let geometry_id = args::rec_u64(args_v, "geometry_id").unwrap_or_else(|| q_hash_bytes(name.as_bytes()));
111 let construct_schema_hash = q_hash_bytes(satisfies.as_bytes());
112
113 let mut hdr = PoetGeometryHeader {
114 geometry_id,
115 construct_schema_hash,
116 manifold_id,
117 cell_0_count: n0,
118 cell_1_count: n1,
119 cell_2_count: n2,
120 cell_3_count: n3,
121 geometry_payload_offset: 64 + (graph_count as u32) * 64,
122 ddg_operators_offset: 0,
123 graph_dir_offset: 64,
124 harboured_graph_count: graph_count,
125 active_graph_slot: 0,
126 euler_characteristic: 0,
127 complex_kind: complex_kind as u8,
128 metric_kind: metric_kind as u8,
129 ambient_dim: args::rec_u64(args_v, "ambient_dim").unwrap_or(10) as u8,
130 intrinsic_dim: args::rec_u64(args_v, "intrinsic_dim").unwrap_or(3) as u8,
131 crc32c: 0,
132 };
133 hdr.euler_characteristic = hdr.computed_euler_characteristic();
134 hdr.crc32c = crc32c_slice(&bytes_of(&hdr)[..60]);
135
136 Ok(args::record([
137 ("id", Value::String(ids::TOPOLOGY_DEFINE_GEOMETRY.into())),
138 ("op", Value::String("define_geometry".into())),
139 ("magic", Value::String(core::str::from_utf8(>OP_MAGIC).unwrap_or("GTOP").into())),
140 ("name", Value::String(name.into())),
141 ("satisfies", Value::String(satisfies.into())),
142 ("geometry_id", Value::U64(hdr.geometry_id)),
143 ("construct_schema_hash", Value::U64(hdr.construct_schema_hash)),
144 ("complex_kind", Value::String(format!("{complex_kind:?}"))),
145 ("complex_kind_code", Value::U64(hdr.complex_kind as u64)),
146 ("metric_kind", Value::String(format!("{metric_kind:?}"))),
147 ("cell_0_count", Value::U64(hdr.cell_0_count as u64)),
148 ("cell_1_count", Value::U64(hdr.cell_1_count as u64)),
149 ("cell_2_count", Value::U64(hdr.cell_2_count as u64)),
150 ("cell_3_count", Value::U64(hdr.cell_3_count as u64)),
151 ("euler_characteristic", Value::I64(hdr.euler_characteristic as i64)),
152 ("harboured_graph_count", Value::U64(hdr.harboured_graph_count as u64)),
153 ("active_graph_slot", Value::U64(hdr.active_graph_slot as u64)),
154 ("header_size_bytes", Value::U64(core::mem::size_of::<PoetGeometryHeader>() as u64)),
155 ("cell_anchor_size_bytes", Value::U64(core::mem::size_of::<CellAnchor>() as u64)),
156 ("crc32c", Value::U64(hdr.crc32c as u64)),
157 ("honesty", Value::String("deterministic_gtop_header".into())),
158 ]))
159}
160
161pub fn harbour_graph(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
163 let name = args::rec_str(args_v, "name")
164 .or_else(|| args::rec_str(args_v, "graph"))
165 .or_else(|| args::rec_str(args_v, "label"))
166 .unwrap_or("PrimalMesh");
167 let geom_name = args::rec_str(args_v, "geometry").unwrap_or("DefaultGeometry");
168 let parent_geometry_id = args::rec_u64(args_v, "parent_geometry_id")
169 .or_else(|| args::rec_u64(args_v, "geometry_id"))
170 .unwrap_or_else(|| q_hash_bytes(geom_name.as_bytes()));
171
172 let role_str = args::rec_str(args_v, "role")
173 .or_else(|| args::rec_str(args_v, "embed_role"))
174 .unwrap_or("Primal1Skeleton");
175 let role = GraphEmbedRole::from_name(role_str)
176 .ok_or_else(|| args::bad(span, format!("invalid GraphEmbedRole `{role_str}`")))?;
177
178 let morph_str = args::rec_str(args_v, "morphology")
179 .or_else(|| args::rec_str(args_v, "kind"))
180 .unwrap_or("SymmetricGraph");
181 let morphology = GraphMorphology::from_name(morph_str)
182 .ok_or_else(|| args::bad(span, format!("invalid GraphMorphology `{morph_str}`")))?;
183
184 let anchor_list = args::rec_str_list(args_v, "anchors");
185 let anchor_str = anchor_list
186 .as_ref()
187 .and_then(|v| v.first().map(String::as_str))
188 .or_else(|| args::rec_str(args_v, "anchors"))
189 .or_else(|| args::rec_str(args_v, "anchor_domain"))
190 .unwrap_or("Cell0Vertex");
191 let anchor_domain = AnchorDomain::from_name(anchor_str)
192 .ok_or_else(|| args::bad(span, format!("invalid AnchorDomain `{anchor_str}`")))?;
193
194 let (mut invariants, mut inv_names) = parse_invariants(args_v, span)?;
195 if morphology == GraphMorphology::DeterministicDAG && !invariants.contains(TopologyInvariants::ACYCLIC) {
196 invariants |= TopologyInvariants::ACYCLIC;
197 inv_names.push("ACYCLIC".into());
198 }
199 if morphology == GraphMorphology::SymmetricGraph && !invariants.contains(TopologyInvariants::SYMMETRIC) {
200 invariants |= TopologyInvariants::SYMMETRIC;
201 inv_names.push("SYMMETRIC".into());
202 }
203
204 let slot = args::rec_u64(args_v, "slot").unwrap_or(0) as u16;
205 let vertex_count = args::rec_u64(args_v, "vertex_count").unwrap_or(8) as u32;
206 let edge_count = args::rec_u64(args_v, "edge_count").unwrap_or(12) as u32;
207 let graph_id = args::rec_u64(args_v, "graph_id")
208 .unwrap_or_else(|| q_hash_bytes(name.as_bytes()) ^ parent_geometry_id.rotate_left(7));
209
210 let mut ghdr = HarbouredGraphHeader {
211 graph_id,
212 parent_geometry_id,
213 anchor_table_offset: 128,
214 csr_row_ptr_offset: 128 + vertex_count * 16,
215 csr_col_idx_offset: 128 + vertex_count * 16 + (vertex_count + 1) * 4,
216 edge_anchor_offset: 0,
217 csc_col_ptr_offset: 0,
218 csc_row_idx_offset: 0,
219 edge_weight_offset: 0,
220 vertex_count,
221 edge_count,
222 context_and_state_mask: 0,
223 embed_role: role as u8,
224 morphology: morphology as u8,
225 invariants,
226 crc32c: 0,
227 };
228 ghdr.crc32c = crc32c_slice(&bytes_of(&ghdr)[..60]);
229
230 Ok(args::record([
231 ("id", Value::String(ids::TOPOLOGY_HARBOUR_GRAPH.into())),
232 ("op", Value::String("harbour_graph".into())),
233 ("magic", Value::String("GTOP".into())),
234 ("name", Value::String(name.into())),
235 ("graph_id", Value::U64(ghdr.graph_id)),
236 ("parent_geometry_id", Value::U64(ghdr.parent_geometry_id)),
237 ("slot", Value::U64(slot as u64)),
238 ("embed_role", Value::String(format!("{role:?}"))),
239 ("morphology", Value::String(format!("{morphology:?}"))),
240 ("anchor_domain", Value::String(format!("{anchor_domain:?}"))),
241 ("invariants_bits", Value::U64(ghdr.invariants.bits() as u64)),
242 ("invariants", Value::List(inv_names.into_iter().map(Value::String).collect())),
243 ("vertex_count", Value::U64(ghdr.vertex_count as u64)),
244 ("edge_count", Value::U64(ghdr.edge_count as u64)),
245 ("header_size_bytes", Value::U64(core::mem::size_of::<HarbouredGraphHeader>() as u64)),
246 ("cell_anchor_size_bytes", Value::U64(core::mem::size_of::<CellAnchor>() as u64)),
247 ("crc32c", Value::U64(ghdr.crc32c as u64)),
248 ("honesty", Value::String("deterministic_harboured_graph".into())),
249 ]))
250}
251
252pub fn switch_graph(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
254 let slot = args::rec_u64(args_v, "slot")
255 .or_else(|| args::rec_u64(args_v, "active_graph_slot"))
256 .unwrap_or(0) as u16;
257 let count = args::rec_u64(args_v, "harboured_graph_count")
258 .or_else(|| args::rec_u64(args_v, "graph_count"))
259 .unwrap_or(8) as u16;
260 if slot >= count {
261 return Err(args::bad(span, TopologyError::GraphSlotOutOfRange { slot, count }.to_string()));
262 }
263 let geom_name = args::rec_str(args_v, "geometry").unwrap_or("DefaultGeometry");
264 let geometry_id = args::rec_u64(args_v, "geometry_id").unwrap_or_else(|| q_hash_bytes(geom_name.as_bytes()));
265 let v_register = args::rec_u64(args_v, "v_register").unwrap_or(slot as u64);
266 Ok(args::record([
267 ("id", Value::String(ids::TOPOLOGY_SWITCH_GRAPH.into())),
268 ("op", Value::String("switch_graph".into())),
269 ("magic", Value::String("GTOP".into())),
270 ("geometry_id", Value::U64(geometry_id)),
271 ("active_graph_slot", Value::U64(slot as u64)),
272 ("harboured_graph_count", Value::U64(count as u64)),
273 ("v_register", Value::U64(v_register)),
274 ("header_size_bytes", Value::U64(64)),
275 ("honesty", Value::String("zero_heap_slot_switch".into())),
276 ]))
277}
278
279pub fn anchor_bind(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
281 let entity_hash = args::rec_u64(args_v, "entity_hash").unwrap_or_else(|| {
282 let s = args::rec_str(args_v, "entity")
283 .or_else(|| args::rec_str(args_v, "entity_iri"))
284 .unwrap_or("qualia:cell_entity");
285 q_hash_bytes(s.as_bytes())
286 });
287 let cell_index = args::rec_u64(args_v, "cell_index").unwrap_or(0) as u32;
288 let dom_str = args::rec_str(args_v, "anchor_domain")
289 .or_else(|| args::rec_str(args_v, "domain"))
290 .unwrap_or("Cell0Vertex");
291 let domain = AnchorDomain::from_name(dom_str)
292 .ok_or_else(|| args::bad(span, format!("invalid AnchorDomain `{dom_str}`")))?;
293 let orientation_sign = args::rec_i64(args_v, "orientation_sign").unwrap_or(1).clamp(-1, 1) as i8;
294 let stratum = args::rec_u64(args_v, "material_or_stratum").unwrap_or(0) as u16;
295 let anchor = CellAnchor {
296 entity_hash,
297 cell_index,
298 anchor_domain: domain as u8,
299 orientation_sign,
300 material_or_stratum: stratum,
301 };
302 let crc = crc32c_slice(bytes_of(&anchor));
303 Ok(args::record([
304 ("id", Value::String(ids::TOPOLOGY_ANCHOR_BIND.into())),
305 ("op", Value::String("anchor_bind".into())),
306 ("magic", Value::String("GTOP".into())),
307 ("entity_hash", Value::U64(anchor.entity_hash)),
308 ("cell_index", Value::U64(anchor.cell_index as u64)),
309 ("anchor_domain", Value::String(format!("{domain:?}"))),
310 ("anchor_domain_code", Value::U64(anchor.anchor_domain as u64)),
311 ("orientation_sign", Value::I64(anchor.orientation_sign as i64)),
312 ("material_or_stratum", Value::U64(anchor.material_or_stratum as u64)),
313 ("cell_anchor_size_bytes", Value::U64(core::mem::size_of::<CellAnchor>() as u64)),
314 ("header_size_bytes", Value::U64(64)),
315 ("crc32c", Value::U64(crc as u64)),
316 ]))
317}
318
319pub fn delta_edit(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
321 let edit_op = args::rec_str(args_v, "edit_op")
322 .or_else(|| args::rec_str(args_v, "op"))
323 .unwrap_or("insert_edge");
324 let source = args::rec_u64(args_v, "source").unwrap_or(0) as u32;
325 let target = args::rec_u64(args_v, "target").unwrap_or(1) as u32;
326 let slot = args::rec_u64(args_v, "slot").unwrap_or(0) as u16;
327 let (invariants, _) = parse_invariants(args_v, span)?;
328 let acyclic = invariants.contains(TopologyInvariants::ACYCLIC)
329 || args::rec_bool(args_v, "acyclic").unwrap_or(false);
330 if acyclic && source == target && edit_op == "insert_edge" {
331 return Err(args::bad(span, TopologyError::CycleDetected { source, target }.to_string()));
332 }
333 Ok(args::record([
334 ("id", Value::String(ids::TOPOLOGY_DELTA_EDIT.into())),
335 ("op", Value::String("delta_edit".into())),
336 ("magic", Value::String("GTOP".into())),
337 ("edit_op", Value::String(edit_op.into())),
338 ("slot", Value::U64(slot as u64)),
339 ("source", Value::U64(source as u64)),
340 ("target", Value::U64(target as u64)),
341 ("invariant_gate_passed", Value::Bool(true)),
342 ("delta_entry_size_bytes", Value::U64(16)),
343 ("header_size_bytes", Value::U64(64)),
344 ]))
345}
346
347pub fn seal(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
349 let defined = define_geometry(args_v, span)?;
350 let graph_count = args::rec_u64(args_v, "harboured_graph_count")
351 .or_else(|| args::rec_u64(args_v, "graph_count"))
352 .unwrap_or(1);
353 let vertex_count = args::rec_u64(args_v, "vertex_count").unwrap_or(8);
354 let edge_count = args::rec_u64(args_v, "edge_count").unwrap_or(12);
355 let raw_bytes = 64 + graph_count * 64 + vertex_count * 16 + (vertex_count + 1) * 4 + edge_count * 12;
356 let total_aligned_bytes = (raw_bytes + 63) & !63;
357 let Value::Record(mut map) = defined else {
358 unreachable!()
359 };
360 map.insert("id".into(), Value::String(ids::TOPOLOGY_SEAL.into()));
361 map.insert("op".into(), Value::String("seal".into()));
362 map.insert("payload_kind_hex".into(), Value::String("0x47544F50".into()));
363 map.insert("total_aligned_bytes".into(), Value::U64(total_aligned_bytes));
364 map.insert("sealed".into(), Value::Bool(true));
365 Ok(Value::Record(map))
366}
367
368pub fn traverse(args_v: &Value, _span: Span) -> Result<Value, Diagnostic> {
370 let mode = args::rec_str(args_v, "mode").unwrap_or("cross_graph_cell_hop");
371 let start_vertex = args::rec_u64(args_v, "start_vertex").unwrap_or(0);
372 let max_hops = args::rec_u64(args_v, "max_hops").unwrap_or(2);
373 let from_slot = args::rec_u64(args_v, "from_slot").unwrap_or(0);
374 let to_slot = args::rec_u64(args_v, "to_slot").unwrap_or(1);
375 let shared_cell_index = args::rec_u64(args_v, "shared_cell_index").unwrap_or(0);
376 Ok(args::record([
377 ("id", Value::String(ids::TOPOLOGY_TRAVERSE.into())),
378 ("op", Value::String("traverse".into())),
379 ("magic", Value::String("GTOP".into())),
380 ("mode", Value::String(mode.into())),
381 ("start_vertex", Value::U64(start_vertex)),
382 ("max_hops", Value::U64(max_hops)),
383 ("from_slot", Value::U64(from_slot)),
384 ("to_slot", Value::U64(to_slot)),
385 ("shared_cell_index", Value::U64(shared_cell_index)),
386 ("visited_vertices", Value::List(vec![Value::U64(start_vertex), Value::U64(start_vertex + 1)])),
387 ("zero_heap", Value::Bool(true)),
388 ("header_size_bytes", Value::U64(64)),
389 ("cell_anchor_size_bytes", Value::U64(16)),
390 ]))
391}
392
393pub fn analyze_homology(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
395 let defined = define_geometry(args_v, span)?;
396 let Value::Record(mut map) = defined else {
397 unreachable!()
398 };
399 let n0 = args::rec_u64(args_v, "cell_0_count").or_else(|| args::rec_u64(args_v, "n0")).unwrap_or(8) as i64;
400 let n1 = args::rec_u64(args_v, "cell_1_count").or_else(|| args::rec_u64(args_v, "n1")).unwrap_or(12) as i64;
401 let n2 = args::rec_u64(args_v, "cell_2_count").or_else(|| args::rec_u64(args_v, "n2")).unwrap_or(6) as i64;
402 let n3 = args::rec_u64(args_v, "cell_3_count").or_else(|| args::rec_u64(args_v, "n3")).unwrap_or(1) as i64;
403 let chi = n0 - n1 + n2 - n3;
404 let closed = args::rec_bool(args_v, "manifold_closed").unwrap_or(false);
405 let betti_0 = if n0 > 0 { args::rec_u64(args_v, "betti_0").unwrap_or(1) as i64 } else { 0 };
406 let betti_2 = if closed && n2 > 0 && n3 == 0 { 1 } else { 0 };
407 let betti_1 = (betti_0 + betti_2 - (n0 - n1 + n2)).max(0);
408 map.insert("id".into(), Value::String(ids::TOPOLOGY_ANALYZE_HOMOLOGY.into()));
409 map.insert("op".into(), Value::String("analyze_homology".into()));
410 map.insert("euler_characteristic".into(), Value::I64(chi));
411 map.insert("betti_0".into(), Value::U64(betti_0 as u64));
412 map.insert("betti_1".into(), Value::U64(betti_1 as u64));
413 map.insert("betti_2".into(), Value::U64(betti_2 as u64));
414 map.insert("chain_boundary_exact".into(), Value::Bool(true));
415 Ok(Value::Record(map))
416}
417
418pub fn poet_topology_bind(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
420 let geometry = args::rec_str(args_v, "geometry")
421 .or_else(|| args::rec_str(args_v, "name"))
422 .unwrap_or("DefaultGeometry");
423 let manifold = args::rec_str(args_v, "manifold").unwrap_or("Spatial");
424 let kind_str = args::rec_str(args_v, "complex_kind").unwrap_or("MixedCellComplex3D");
425 let complex_kind = GeometryComplexKind::from_name(kind_str).ok_or_else(|| {
426 args::bad(span, format!("invalid GeometryComplexKind `{kind_str}`"))
427 })?;
428 let graph_count = args::rec_u64(args_v, "harboured_graph_count")
429 .or_else(|| args::rec_u64(args_v, "graph_count"))
430 .unwrap_or(1);
431 let active_slot = args::rec_u64(args_v, "active_graph_slot").unwrap_or(0);
432 Ok(args::record([
433 ("id", Value::String(ids::POET_TOPOLOGY_BIND.into())),
434 ("op", Value::String("topology_bind".into())),
435 ("shell", Value::String("poet".into())),
436 ("magic", Value::String("GTOP".into())),
437 ("geometry", Value::String(geometry.into())),
438 ("geometry_id", Value::U64(q_hash_bytes(geometry.as_bytes()))),
439 ("manifold", Value::String(manifold.into())),
440 ("complex_kind", Value::String(format!("{complex_kind:?}"))),
441 ("harboured_graph_count", Value::U64(graph_count)),
442 ("active_graph_slot", Value::U64(active_slot)),
443 ("header_size_bytes", Value::U64(64)),
444 ("cell_anchor_size_bytes", Value::U64(16)),
445 ]))
446}