Reorganize

crates/service/service-webpage/src/ast/mod.rs

@@ -0,0 +1,5 @@
+mod walk;
+pub use walk::*;
+
+mod walk_mut;
+pub use walk_mut::*;

crates/service/service-webpage/src/ast/walk.rs

@@ -0,0 +1,384 @@
+use markdown::mdast::Node;
+use std::fmt::Debug;
+use std::marker::PhantomPinned;
+
+pub enum AstWalkStep<'a, T> {
+	Enter(&'a T),
+	Exit(&'a T),
+}
+
+impl<T: Debug> Debug for AstWalkStep<'_, T> {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::Enter(x) => f.debug_tuple("AstWalkStep::Enter").field(x).finish(),
+			Self::Exit(x) => f.debug_tuple("AstWalkStep::Exit").field(x).finish(),
+		}
+	}
+}
+
+pub struct AstWalk<'a> {
+	_pin: PhantomPinned,
+	child_stack: Vec<usize>,
+	node_stack: Vec<&'a Node>,
+}
+
+impl<'a> AstWalk<'a> {
+	pub fn new(root: &'a Node) -> Self {
+		let mut res = Self {
+			_pin: PhantomPinned {},
+			node_stack: Vec::with_capacity(32),
+			child_stack: Vec::with_capacity(32),
+		};
+
+		res.node_stack.push(root);
+		return res;
+	}
+
+	fn _next_inner(&mut self) -> Option<AstWalkStep<'a, Node>> {
+		if self.node_stack.is_empty() {
+			return None;
+		}
+
+		let current_node = *self.node_stack.last().unwrap();
+
+		// The index of the next child we should look at.
+		// If `None`, we look at the parent.
+		let current_child = {
+			let n_nodes = self.node_stack.len();
+			let n_childs = self.child_stack.len();
+			match n_nodes - n_childs {
+				2.. => unreachable!(),
+				1 => None,
+				0 => Some(self.child_stack.pop().unwrap()),
+			}
+		};
+
+		match current_child {
+			None => {
+				self.child_stack.push(0);
+				return Some(AstWalkStep::Enter(current_node));
+			}
+
+			Some(current_child) => {
+				let child = current_node
+					.children()
+					.map(|x| x.get(current_child))
+					.flatten();
+
+				match child {
+					None => {
+						self.node_stack.pop();
+						return Some(AstWalkStep::Exit(current_node));
+					}
+
+					Some(x) => {
+						self.child_stack.push(current_child + 1);
+						self.node_stack.push(&x);
+						self.child_stack.push(0);
+						return Some(AstWalkStep::Enter(x));
+					}
+				}
+			}
+		}
+	}
+}
+
+impl<'a> Iterator for AstWalk<'a> {
+	type Item = AstWalkStep<'a, Node>;
+
+	fn next(self: &mut Self) -> Option<Self::Item> {
+		return self._next_inner();
+	}
+}
+
+//
+// MARK: tests
+//
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use markdown::mdast::{Emphasis, Paragraph, Root, Strong, Text};
+
+	#[test]
+	fn single_leaf() {
+		let node = Node::Text(Text {
+			value: "Hello".to_string(),
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		assert_eq!(steps.len(), 2);
+		assert!(matches!(steps[0], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkStep::Exit(_)));
+	}
+
+	#[test]
+	fn single_child() {
+		let node = Node::Paragraph(Paragraph {
+			children: vec![Node::Text(Text {
+				value: "Hello".to_string(),
+				position: None,
+			})],
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Leaf(Text), Exit(Paragraph)
+		assert_eq!(steps.len(), 4);
+		assert!(matches!(steps[0], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[3], AstWalkStep::Exit(_)));
+	}
+
+	#[test]
+	fn multiple_children() {
+		let node = Node::Paragraph(Paragraph {
+			children: vec![
+				Node::Text(Text {
+					value: "Hello".to_string(),
+					position: None,
+				}),
+				Node::Text(Text {
+					value: " ".to_string(),
+					position: None,
+				}),
+				Node::Text(Text {
+					value: "World".to_string(),
+					position: None,
+				}),
+			],
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Leaf(Text1), Leaf(Text2), Leaf(Text3), Exit(Paragraph)
+		assert_eq!(steps.len(), 8);
+		assert!(matches!(steps[0], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[3], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[4], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[5], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[6], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[7], AstWalkStep::Exit(_)));
+	}
+
+	#[test]
+	fn nested_1() {
+		let node = Node::Paragraph(Paragraph {
+			children: vec![Node::Emphasis(Emphasis {
+				children: vec![Node::Text(Text {
+					value: "emphasized".to_string(),
+					position: None,
+				})],
+				position: None,
+			})],
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Enter(Emphasis), Leaf(Text), Exit(Emphasis), Exit(Paragraph)
+		assert_eq!(steps.len(), 6);
+		assert!(matches!(steps[0], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[3], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[4], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[5], AstWalkStep::Exit(_)));
+	}
+
+	#[test]
+	fn nested_2() {
+		// Create: Paragraph -> [Text, Strong -> Text, Text]
+		let node = Node::Paragraph(Paragraph {
+			children: vec![
+				Node::Text(Text {
+					value: "Before ".to_string(),
+					position: None,
+				}),
+				Node::Strong(Strong {
+					children: vec![Node::Text(Text {
+						value: "bold".to_string(),
+						position: None,
+					})],
+					position: None,
+				}),
+				Node::Text(Text {
+					value: " after".to_string(),
+					position: None,
+				}),
+			],
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		// Expected order:
+		// 0: Enter(Paragraph)
+		// 1: Leaf(Text "Before ")
+		// 2: Enter(Strong)
+		// 3: Leaf(Text "bold")
+		// 4: Exit(Strong)
+		// 5: Leaf(Text " after")
+		// 6: Exit(Paragraph)
+		assert_eq!(steps.len(), 10);
+		assert!(matches!(steps[0], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[3], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[4], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[5], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[6], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[7], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[8], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[9], AstWalkStep::Exit(_)));
+	}
+
+	#[test]
+	fn nested_3() {
+		let node = Node::Paragraph(Paragraph {
+			children: vec![Node::Emphasis(Emphasis {
+				children: vec![Node::Strong(Strong {
+					children: vec![Node::Text(Text {
+						value: "deeply nested".to_string(),
+						position: None,
+					})],
+					position: None,
+				})],
+				position: None,
+			})],
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Enter(Emphasis), Enter(Strong), Leaf(Text), Exit(Strong), Exit(Emphasis), Exit(Paragraph)
+		assert_eq!(steps.len(), 8);
+		assert!(matches!(steps[0], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[3], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[4], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[5], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[6], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[7], AstWalkStep::Exit(_)));
+	}
+
+	#[test]
+	fn empty_parent() {
+		let node = Node::Paragraph(Paragraph {
+			children: vec![],
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Exit(Paragraph)
+		assert_eq!(steps.len(), 2);
+		assert!(matches!(steps[0], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkStep::Exit(_)));
+	}
+
+	#[test]
+	fn multiple_paragraphs() {
+		let node = Node::Root(Root {
+			children: vec![
+				Node::Paragraph(Paragraph {
+					children: vec![Node::Text(Text {
+						value: "First".to_string(),
+						position: None,
+					})],
+					position: None,
+				}),
+				Node::Paragraph(Paragraph {
+					children: vec![Node::Text(Text {
+						value: "Second".to_string(),
+						position: None,
+					})],
+					position: None,
+				}),
+			],
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		// Expected order:
+		// 0: Enter(Root)
+		// 1: Enter(Paragraph)
+		// 2: Enter(Text "First")
+		// 2: Exit(Text "First")
+		// 3: Exit(Paragraph)
+		// 4: Enter(Paragraph)
+		// 5: Enter(Text "Second")
+		// 5: Exit(Text "Second")
+		// 6: Exit(Paragraph)
+		// 7: Exit(Root)
+		assert_eq!(steps.len(), 10);
+		assert!(matches!(steps[0], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[3], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[4], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[5], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[6], AstWalkStep::Enter(_)));
+		assert!(matches!(steps[7], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[8], AstWalkStep::Exit(_)));
+		assert!(matches!(steps[9], AstWalkStep::Exit(_)));
+	}
+
+	#[test]
+	fn enter_exit() {
+		let node = Node::Root(Root {
+			children: vec![Node::Paragraph(Paragraph {
+				children: vec![
+					Node::Emphasis(Emphasis {
+						children: vec![Node::Text(Text {
+							value: "a".to_string(),
+							position: None,
+						})],
+						position: None,
+					}),
+					Node::Strong(Strong {
+						children: vec![Node::Text(Text {
+							value: "b".to_string(),
+							position: None,
+						})],
+						position: None,
+					}),
+				],
+				position: None,
+			})],
+			position: None,
+		});
+
+		let walker = AstWalk::new(&node);
+		let steps: Vec<_> = walker.collect();
+
+		let enter_count = steps
+			.iter()
+			.filter(|s| matches!(s, AstWalkStep::Enter(_)))
+			.count();
+		let exit_count = steps
+			.iter()
+			.filter(|s| matches!(s, AstWalkStep::Exit(_)))
+			.count();
+
+		assert_eq!(enter_count, exit_count);
+		assert_eq!(enter_count, 6);
+	}
+}

crates/service/service-webpage/src/ast/walk_mut.rs

@@ -0,0 +1,378 @@
+use markdown::mdast::Node;
+use std::{fmt::Debug, marker::PhantomData};
+
+pub enum AstWalkMutStep<'a, T> {
+	Enter(&'a T),
+	Exit(&'a mut T),
+}
+
+impl<T: Debug> Debug for AstWalkMutStep<'_, T> {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::Enter(x) => f.debug_tuple("AstWalkMutStep::Enter").field(x).finish(),
+			Self::Exit(x) => f.debug_tuple("AstWalkMutStep::Exit").field(x).finish(),
+		}
+	}
+}
+
+pub struct AstWalkMut<'a> {
+	_life: PhantomData<&'a mut Node>,
+	child_stack: Vec<usize>,
+	node_stack: Vec<*mut Node>,
+}
+
+impl<'a> AstWalkMut<'a> {
+	pub fn new(root: &'a mut Node) -> Self {
+		let mut res = Self {
+			_life: PhantomData,
+			node_stack: Vec::with_capacity(32),
+			child_stack: Vec::with_capacity(32),
+		};
+
+		res.node_stack.push(root);
+		return res;
+	}
+
+	fn _next_inner(&mut self) -> Option<AstWalkMutStep<'a, Node>> {
+		if self.node_stack.is_empty() {
+			return None;
+		}
+
+		let current_node = unsafe { &mut **self.node_stack.last().unwrap_unchecked() };
+
+		// The index of the next child we should look at.
+		// If `None`, we look at the parent.
+		let current_child = {
+			let n_nodes = self.node_stack.len();
+			let n_childs = self.child_stack.len();
+			match n_nodes - n_childs {
+				2.. => unreachable!(),
+				1 => None,
+				0 => Some(self.child_stack.pop().unwrap()),
+			}
+		};
+
+		match current_child {
+			None => {
+				self.child_stack.push(0);
+				return Some(AstWalkMutStep::Enter(current_node));
+			}
+
+			Some(current_child) => {
+				if current_node.children().is_none()
+					|| current_child >= current_node.children().unwrap().len()
+				{
+					self.node_stack.pop();
+					return Some(AstWalkMutStep::Exit(current_node));
+				}
+
+				let child = &mut current_node.children_mut().unwrap()[current_child];
+
+				self.child_stack.push(current_child + 1);
+				self.node_stack.push(child);
+				self.child_stack.push(0);
+				return Some(AstWalkMutStep::Enter(child));
+			}
+		}
+	}
+}
+
+impl<'a> Iterator for AstWalkMut<'a> {
+	type Item = AstWalkMutStep<'a, Node>;
+
+	fn next(self: &mut Self) -> Option<Self::Item> {
+		return self._next_inner();
+	}
+}
+
+//
+// MARK: tests
+//
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use markdown::mdast::{Emphasis, Paragraph, Root, Strong, Text};
+
+	#[test]
+	fn single_leaf() {
+		let mut node = Node::Text(Text {
+			value: "Hello".to_string(),
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		assert_eq!(steps.len(), 2);
+		assert!(matches!(steps[0], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkMutStep::Exit(_)));
+	}
+
+	#[test]
+	fn single_child() {
+		let mut node = Node::Paragraph(Paragraph {
+			children: vec![Node::Text(Text {
+				value: "Hello".to_string(),
+				position: None,
+			})],
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Leaf(Text), Exit(Paragraph)
+		assert_eq!(steps.len(), 4);
+		assert!(matches!(steps[0], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[3], AstWalkMutStep::Exit(_)));
+	}
+
+	#[test]
+	fn multiple_children() {
+		let mut node = Node::Paragraph(Paragraph {
+			children: vec![
+				Node::Text(Text {
+					value: "Hello".to_string(),
+					position: None,
+				}),
+				Node::Text(Text {
+					value: " ".to_string(),
+					position: None,
+				}),
+				Node::Text(Text {
+					value: "World".to_string(),
+					position: None,
+				}),
+			],
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Leaf(Text1), Leaf(Text2), Leaf(Text3), Exit(Paragraph)
+		assert_eq!(steps.len(), 8);
+		assert!(matches!(steps[0], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[3], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[4], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[5], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[6], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[7], AstWalkMutStep::Exit(_)));
+	}
+
+	#[test]
+	fn nested_1() {
+		let mut node = Node::Paragraph(Paragraph {
+			children: vec![Node::Emphasis(Emphasis {
+				children: vec![Node::Text(Text {
+					value: "emphasized".to_string(),
+					position: None,
+				})],
+				position: None,
+			})],
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Enter(Emphasis), Leaf(Text), Exit(Emphasis), Exit(Paragraph)
+		assert_eq!(steps.len(), 6);
+		assert!(matches!(steps[0], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[3], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[4], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[5], AstWalkMutStep::Exit(_)));
+	}
+
+	#[test]
+	fn nested_2() {
+		// Create: Paragraph -> [Text, Strong -> Text, Text]
+		let mut node = Node::Paragraph(Paragraph {
+			children: vec![
+				Node::Text(Text {
+					value: "Before ".to_string(),
+					position: None,
+				}),
+				Node::Strong(Strong {
+					children: vec![Node::Text(Text {
+						value: "bold".to_string(),
+						position: None,
+					})],
+					position: None,
+				}),
+				Node::Text(Text {
+					value: " after".to_string(),
+					position: None,
+				}),
+			],
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		// Expected order:
+		// 0: Enter(Paragraph)
+		// 1: Leaf(Text "Before ")
+		// 2: Enter(Strong)
+		// 3: Leaf(Text "bold")
+		// 4: Exit(Strong)
+		// 5: Leaf(Text " after")
+		// 6: Exit(Paragraph)
+		assert_eq!(steps.len(), 10);
+		assert!(matches!(steps[0], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[3], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[4], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[5], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[6], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[7], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[8], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[9], AstWalkMutStep::Exit(_)));
+	}
+
+	#[test]
+	fn nested_3() {
+		let mut node = Node::Paragraph(Paragraph {
+			children: vec![Node::Emphasis(Emphasis {
+				children: vec![Node::Strong(Strong {
+					children: vec![Node::Text(Text {
+						value: "deeply nested".to_string(),
+						position: None,
+					})],
+					position: None,
+				})],
+				position: None,
+			})],
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Enter(Emphasis), Enter(Strong), Leaf(Text), Exit(Strong), Exit(Emphasis), Exit(Paragraph)
+		assert_eq!(steps.len(), 8);
+		assert!(matches!(steps[0], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[3], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[4], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[5], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[6], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[7], AstWalkMutStep::Exit(_)));
+	}
+
+	#[test]
+	fn empty_parent() {
+		let mut node = Node::Paragraph(Paragraph {
+			children: vec![],
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		// Should be: Enter(Paragraph), Exit(Paragraph)
+		assert_eq!(steps.len(), 2);
+		assert!(matches!(steps[0], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkMutStep::Exit(_)));
+	}
+
+	#[test]
+	fn multiple_paragraphs() {
+		let mut node = Node::Root(Root {
+			children: vec![
+				Node::Paragraph(Paragraph {
+					children: vec![Node::Text(Text {
+						value: "First".to_string(),
+						position: None,
+					})],
+					position: None,
+				}),
+				Node::Paragraph(Paragraph {
+					children: vec![Node::Text(Text {
+						value: "Second".to_string(),
+						position: None,
+					})],
+					position: None,
+				}),
+			],
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		// Expected order:
+		// 0: Enter(Root)
+		// 1: Enter(Paragraph)
+		// 2: Enter(Text "First")
+		// 2: Exit(Text "First")
+		// 3: Exit(Paragraph)
+		// 4: Enter(Paragraph)
+		// 5: Enter(Text "Second")
+		// 5: Exit(Text "Second")
+		// 6: Exit(Paragraph)
+		// 7: Exit(Root)
+		assert_eq!(steps.len(), 10);
+		assert!(matches!(steps[0], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[1], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[2], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[3], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[4], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[5], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[6], AstWalkMutStep::Enter(_)));
+		assert!(matches!(steps[7], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[8], AstWalkMutStep::Exit(_)));
+		assert!(matches!(steps[9], AstWalkMutStep::Exit(_)));
+	}
+
+	#[test]
+	fn enter_exit() {
+		let mut node = Node::Root(Root {
+			children: vec![Node::Paragraph(Paragraph {
+				children: vec![
+					Node::Emphasis(Emphasis {
+						children: vec![Node::Text(Text {
+							value: "a".to_string(),
+							position: None,
+						})],
+						position: None,
+					}),
+					Node::Strong(Strong {
+						children: vec![Node::Text(Text {
+							value: "b".to_string(),
+							position: None,
+						})],
+						position: None,
+					}),
+				],
+				position: None,
+			})],
+			position: None,
+		});
+
+		let walker = AstWalkMut::new(&mut node);
+		let steps: Vec<_> = walker.collect();
+
+		let enter_count = steps
+			.iter()
+			.filter(|s| matches!(s, AstWalkMutStep::Enter(_)))
+			.count();
+		let exit_count = steps
+			.iter()
+			.filter(|s| matches!(s, AstWalkMutStep::Exit(_)))
+			.count();
+
+		assert_eq!(enter_count, exit_count);
+		assert_eq!(enter_count, 6);
+	}
+}

crates/service/service-webpage/src/components/base.rs

@@ -0,0 +1,87 @@
+use macro_sass::sass;
+use maud::{DOCTYPE, Markup, PreEscaped, Render, html};
+
+use crate::components::misc::FarLink;
+
+pub struct PageMetadata {
+	pub title: String,
+	pub author: Option<String>,
+	pub description: Option<String>,
+	pub image: Option<String>,
+}
+
+impl Render for PageMetadata {
+	fn render(&self) -> Markup {
+		let empty = String::new();
+		let title = &self.title;
+		let author = &self.author.as_ref().unwrap_or(&empty);
+		let description = &self.description.as_ref().unwrap_or(&empty);
+		let image = &self.image.as_ref().unwrap_or(&empty);
+
+		html!(
+			meta property="og:site_name" content=(title) {}
+			meta name="title" content=(title) {}
+			meta property="og:title" content=(title) {}
+			meta property="twitter:title" content=(title) {}
+
+			meta name="author" content=(author) {}
+
+			meta name="description" content=(description) {}
+			meta property="og:description" content=(description) {}
+			meta property="twitter:description" content=(description) {}
+
+
+			meta content=(image) property="og:image" {}
+			link rel="shortcut icon" href=(image) type="image/x-icon" {}
+		)
+	}
+}
+
+const CSS: &str = sass!("css/main.scss");
+
+pub struct BasePage<T: Render>(pub PageMetadata, pub T);
+
+impl<T: Render> Render for BasePage<T> {
+	fn render(&self) -> Markup {
+		let meta = &self.0;
+
+		html! {
+			(DOCTYPE)
+			html {
+				head {
+					meta charset="UTF" {}
+					meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no" {}
+					meta content="text/html; charset=UTF-8" http-equiv="content-type" {}
+					meta property="og:type" content="website" {}
+
+					(meta)
+					title { (PreEscaped(meta.title.clone())) }
+					style { (PreEscaped(CSS)) }
+				}
+
+				body {
+					div class="wrapper" {
+						main { (self.1) }
+
+						footer {
+							hr class = "footline" {}
+							div class = "footContainer" {
+								p {
+									"This site was built by hand using "
+									(FarLink("https://rust-lang.org", "Rust"))
+									", "
+									(FarLink("https://maud.lambda.xyz", "Maud"))
+									", "
+									(FarLink("https://github.com/connorskees/grass", "Grass"))
+									", and "
+									(FarLink("https://docs.rs/axum/latest/axum", "Axum"))
+									"."
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

crates/service/service-webpage/src/components/fa.rs

@@ -0,0 +1,56 @@
+use maud::{Markup, Render, html};
+
+#[expect(clippy::allow_attributes)]
+#[allow(dead_code)]
+pub enum FAIcon {
+	Github,
+	Git,
+	Python,
+	Rust,
+	Discord,
+	Instagram,
+
+	Link,
+	Envelope,
+	At,
+	Key,
+	SStar,
+	RStar,
+	Leaf,
+
+	Lock,
+	Fire,
+	Pen,
+	Pencil,
+}
+
+impl Render for FAIcon {
+	fn render(&self) -> Markup {
+		let classes = match self {
+			Self::Github => "fa-brands fa-github",
+			Self::Git => "fa-brands fa-git-alt",
+			Self::Python => "fa-brands fa-python",
+			Self::Rust => "fa-brands fa-rust",
+			Self::Discord => "fa-brands fa-discord",
+			Self::Instagram => "fa-brands fa-instagram",
+			Self::Link => "fa-solid fa-link",
+			Self::Envelope => "fa-solid fa-envelope",
+			Self::At => "fa-solid fa-at",
+			Self::Key => "fa-solid fa-key",
+			Self::SStar => "fa-solid fa-star",
+			Self::RStar => "fa-regular fa-star",
+			Self::Leaf => "fa-regular fa-leaf",
+			Self::Lock => "fa-solid fa-lock",
+			Self::Fire => "fa-solid fa-fire",
+			Self::Pen => "fa-solid fa-pen-nib",
+			Self::Pencil => "fa-solid fa-pencil",
+		};
+
+		html!(
+			i
+				class=(classes)
+				style="margin-right:5pt" // TODO: configure, color
+				{}
+		)
+	}
+}

crates/service/service-webpage/src/components/mangle.rs

@@ -0,0 +1,39 @@
+use maud::{Markup, Render, html};
+
+pub struct MangledBetaEmail {}
+
+impl Render for MangledBetaEmail {
+	fn render(&self) -> Markup {
+		html!(
+			span class="eobf eobf-beta" {
+				i id="eobf-en" class="fas fa-envelope" style="margin-right: 5pt" {}
+				i id="eobf-kb" class="fas fa-keyboard" style="margin-right: 5pt" {}
+				span
+					data-b="kra"
+					data-a="c.ipula"
+					data-h="Type this manually"
+					style="unicode-bidi: bidi-override; direction: rtl;"
+					{}
+			}
+		)
+	}
+}
+
+pub struct MangledGoogleEmail {}
+
+impl Render for MangledGoogleEmail {
+	fn render(&self) -> Markup {
+		html!(
+			span class="eobf eobf-goog" {
+				i id="eobf-en" class="fas fa-envelope" style="margin-right: 5pt" {}
+				i id="eobf-kb" class="fas fa-keyboard" style="margin-right: 5pt" {}
+				span
+					data-c="kra"
+					data-b="rmn"
+					data-a="c.lia"
+					data-h="Type this manually"
+					{}
+			}
+		)
+	}
+}

crates/service/service-webpage/src/components/md.rs

@@ -0,0 +1,106 @@
+use markdown::{CompileOptions, Constructs, LineEnding, Options, ParseOptions};
+use maud::{Markup, PreEscaped, Render};
+
+pub struct Markdown<'a>(pub &'a str);
+
+const OPTS: Options = Options {
+	parse: ParseOptions {
+		constructs: Constructs {
+			attention: true,
+			autolink: false,
+			block_quote: true,
+			character_escape: true,
+			character_reference: true,
+			code_indented: false,
+			code_fenced: true,
+			code_text: true,
+			definition: true,
+			frontmatter: false,
+			gfm_autolink_literal: true,
+			gfm_footnote_definition: false,
+			gfm_label_start_footnote: false,
+			gfm_strikethrough: false,
+			gfm_table: false,
+			gfm_task_list_item: false,
+			hard_break_escape: false,
+			hard_break_trailing: false,
+			heading_atx: true,
+			heading_setext: false,
+			label_start_image: false,
+			label_start_link: true,
+			label_end: true,
+			list_item: true,
+			math_flow: false,
+			math_text: false,
+			mdx_esm: false,
+			thematic_break: false,
+
+			// INLINE HTML
+			html_flow: false,
+			html_text: false,
+
+			// INLINE {}
+			mdx_expression_flow: true,
+			mdx_expression_text: true,
+
+			// INLINE HTML (alternative)
+			mdx_jsx_flow: false,
+			mdx_jsx_text: false,
+		},
+
+		gfm_strikethrough_single_tilde: false,
+		math_text_single_dollar: false,
+		mdx_expression_parse: None,
+		mdx_esm_parse: None,
+	},
+
+	compile: CompileOptions {
+		allow_any_img_src: false,
+		allow_dangerous_html: false,
+		allow_dangerous_protocol: false,
+		default_line_ending: LineEnding::LineFeed,
+		gfm_footnote_back_label: None,
+		gfm_footnote_clobber_prefix: None,
+		gfm_footnote_label_attributes: None,
+		gfm_footnote_label_tag_name: None,
+		gfm_footnote_label: None,
+		gfm_task_list_item_checkable: false,
+		gfm_tagfilter: false,
+	},
+};
+
+impl Render for Markdown<'_> {
+	fn render(&self) -> Markup {
+		/*
+		let mut ast = markdown::to_mdast(MD_A, &opts.parse).unwrap();
+		let walk = AstWalkMut::new(&mut ast);
+
+		for i in walk {
+			match i {
+				AstWalkMutStep::Exit(node) => {
+					match node {
+						Node::MdxTextExpression(x) => {
+							println!("{x:?}");
+						}
+						Node::MdxFlowExpression(x) => {
+							println!("{x:?}");
+						}
+						_ => continue,
+					}
+
+					*node = Node::Text(Text {
+						value: "LOL".to_owned(),
+						position: node.position().cloned(),
+					})
+				}
+				_ => {}
+			}
+		}
+
+		println!("{ast:?}");
+		*/
+
+		let md = markdown::to_html_with_options(self.0, &OPTS).unwrap();
+		return PreEscaped(md);
+	}
+}

crates/service/service-webpage/src/components/misc.rs

@@ -0,0 +1,17 @@
+use maud::{Markup, Render, html};
+
+/// Shorthand for an `<a>` link that opens a new tab
+/// Values are (url, text)
+pub struct FarLink<'a, T: Render>(pub &'a str, pub T);
+
+impl<T: Render> Render for FarLink<'_, T> {
+	fn render(&self) -> Markup {
+		html!(
+			a
+			target="_blank"
+			rel="noopener noreferrer"
+			href=(self.0)
+			{ (self.1) }
+		)
+	}
+}

crates/service/service-webpage/src/components/mod.rs

@@ -0,0 +1,5 @@
+pub mod base;
+pub mod fa;
+pub mod mangle;
+pub mod md;
+pub mod misc;

crates/service/service-webpage/src/lib.rs

@@ -0,0 +1,33 @@
+use axum::Router;
+use libservice::ToService;
+use utoipa::OpenApi;
+
+mod ast;
+mod components;
+mod routes;
+
+pub struct WebpageService {}
+
+impl WebpageService {
+	#[inline]
+	pub fn new() -> Self {
+		Self {}
+	}
+}
+
+impl ToService for WebpageService {
+	#[inline]
+	fn make_router(&self) -> Option<Router<()>> {
+		Some(routes::router())
+	}
+
+	#[inline]
+	fn make_openapi(&self) -> utoipa::openapi::OpenApi {
+		routes::Api::openapi()
+	}
+
+	#[inline]
+	fn service_name(&self) -> Option<String> {
+		Some("webpage".to_owned())
+	}
+}

crates/service/service-webpage/src/routes/assets.rs

@@ -0,0 +1,94 @@
+use assetserver::Asset;
+use macro_assets::assets;
+
+assets! {
+	prefix: "/assets"
+	router: asset_router()
+
+	//
+	// MARK: images
+	//
+
+	Image_Cover {
+		source: "../../assets/images/cover-small.jpg",
+		target: "/img/face.jpg"
+	}
+
+	Image_Betalupi {
+		source: "../../assets/images/betalupi-map.png",
+		target: "/img/betalupi.png"
+	}
+
+	Image_Icon {
+		source: "../../assets/images/icon.png",
+		target: "/img/icon.png"
+	}
+
+	//
+	// MARK:fonts
+	//
+
+	FiraCode_Bold_woff2 {
+		source: "../../assets/fonts/fira/FiraCode-Bold.woff2",
+		target: "/fonts/FiraCode-Bold.woff2"
+	}
+
+	FiraCode_Light_woff2 {
+		source: "../../assets/fonts/fira/FiraCode-Light.woff2",
+		target: "/fonts/FiraCode-Light.woff2"
+	}
+
+	FiraCode_Medium_woff2 {
+		source: "../../assets/fonts/fira/FiraCode-Medium.woff2",
+		target: "/fonts/FiraCode-Medium.woff2"
+	}
+
+	FiraCode_Regular_woff2 {
+		source: "../../assets/fonts/fira/FiraCode-Regular.woff2",
+		target: "/fonts/FiraCode-Regular.woff2"
+	}
+
+	FiraCode_SemiBold_woff2 {
+		source: "../../assets/fonts/fira/FiraCode-SemiBold.woff2",
+		target: "/fonts/FiraCode-SemiBold.woff2"
+	}
+
+	FiraCode_VF_woff2 {
+		source: "../../assets/fonts/fira/FiraCode-VF.woff2",
+		target: "/fonts/FiraCode-VF.woff2"
+	}
+
+	//
+	// MARK: icons
+	//
+
+	Fa_Brands_woff2 {
+		source: "../../assets/fonts/fa/fa-brands-400.woff2",
+		target: "/fonts/fa/fa-brands-400.woff2"
+	}
+
+	Fa_Regular_woff2 {
+		source: "../../assets/fonts/fa/fa-regular-400.woff2",
+		target: "/fonts/fa/fa-regular-400.woff2"
+	}
+
+	Fa_Solid_woff2 {
+		source: "../../assets/fonts/fa/fa-solid-900.woff2",
+		target: "/fonts/fa/fa-solid-900.woff2"
+	}
+
+	Fa_Brands_ttf {
+		source: "../../assets/fonts/fa/fa-brands-400.ttf",
+		target: "/fonts/fa/fa-brands-400.ttf"
+	}
+
+	Fa_Regular_ttf {
+		source: "../../assets/fonts/fa/fa-regular-400.ttf",
+		target: "/fonts/fa/fa-regular-400.ttf"
+	}
+
+	Fa_Solid_ttf {
+		source: "../../assets/fonts/fa/fa-solid-900.ttf",
+		target: "/fonts/fa/fa-solid-900.ttf"
+	}
+}

crates/service/service-webpage/src/routes/betalupi.rs

@@ -0,0 +1,65 @@
+use assetserver::Asset;
+use maud::{Markup, html};
+
+use crate::{
+	components::{
+		base::{BasePage, PageMetadata},
+		md::Markdown,
+	},
+	routes::assets::{Image_Betalupi, Image_Icon},
+};
+
+pub async fn betalupi() -> Markup {
+	let meta = PageMetadata {
+		title: "What's a \"betalupi?\"".into(),
+		author: Some("Mark".into()),
+		description: None,
+		image: Some(Image_Icon::URL.into()),
+	};
+
+	html! {
+		(BasePage(
+			meta,
+			html!(
+				// TODO: no metadata class, generate backlink array
+				div {
+					a href="/" style="padding-left:4pt;padding-right:4pt;" {"home"}
+					"/"
+					span class="metaData" style="padding-left:4pt;padding-right:4pt;" { "whats-a-betalupi" }
+				}
+
+				(Markdown(MD_A))
+
+				br {}
+
+				(Markdown(MD_B))
+
+				br {}
+
+				img alt="betalupi map" class="image" src=(Image_Betalupi::URL) {}
+			)
+		))
+	}
+}
+
+const MD_A: &str = r#"[es]: https://github.com/endless-sky/endless-sky
+[*Stellaris*]: https://www.paradoxinteractive.com/games/stellaris/about
+[Arabic]: https://en.wikipedia.org/wiki/List_of_Arabic_star_names
+[wiki-betalupi]: https://en.wikipedia.org/wiki/Beta_Lupi
+
+# What's a "betalupi?"
+
+Beta Lupi is a solar system on the [_Endless Sky_][es] galaxy map,
+which is the first place I look whenever I need to name a server.
+
+Stellar names (especially those of [Arabic] origin) make pretty good hostnames: they're meaningless (in English), they sound interesting, and the "hyperlanes" that connect them in titles like [_Endless Sky_][es] and [*Stellaris*] look a lot like a network topology.
+
+Beta Lupi also happens to be a real star in the southern constellation of Lupus ([wiki][wiki-betalupi]), but that's not particularly important.
+
+A snippet of the [_Endless Sky_][es] map is below."#;
+
+const MD_B: &str = r#"**In other words:** Try finding a `.com` domain that...
+
+- Isn't already taken
+- Doesn't sound awful
+- Isn't owned by a scalper that's selling it for $300"#;

crates/service/service-webpage/src/routes/index.rs

@@ -0,0 +1,248 @@
+use assetserver::Asset;
+use maud::{Markup, html};
+
+use crate::{
+	components::{
+		base::{BasePage, PageMetadata},
+		fa::FAIcon,
+		mangle::{MangledBetaEmail, MangledGoogleEmail},
+		md::Markdown,
+		misc::FarLink,
+	},
+	routes::assets::{Image_Cover, Image_Icon},
+};
+
+pub async fn index() -> Markup {
+	let meta = PageMetadata {
+		title: "Betalupi: About".into(),
+		author: Some("Mark".into()),
+		description: Some("Description".into()),
+		image: Some(Image_Icon::URL.into()),
+	};
+
+	html! {
+		(BasePage(
+			meta,
+			html!(
+				h2 id="about" { "About" }
+
+				div {
+					img
+						src=(Image_Cover::URL)
+						style="float:left;margin:10px 10px 10px 10px;display:block;width:25%;"
+						{}
+
+					div style="margin:2ex 1ex 2ex 1ex;display:inline-block;overflow:hidden;width:60%;" {
+						"Welcome, you've reached Mark's main page. Here you'll find"
+						" links to various projects I've worked on."
+
+						ul {
+							li { (MangledBetaEmail {}) }
+							li { (MangledGoogleEmail {}) }
+
+							li {
+								(
+									FarLink(
+										"https://github.com/rm-dr",
+										html!(
+											(FAIcon::Github)
+											"rm-dr"
+										)
+									)
+								)
+							}
+
+							li {
+								(
+									FarLink(
+										"https://git.betalupi.com",
+										html!(
+											(FAIcon::Git)
+											"git.betalupi.com"
+										)
+									)
+								)
+							}
+						}
+					}
+					br style="clear:both;" {}
+				}
+
+				"Also see "
+				a href="/whats-a-betalupi" { "what's a \"betalupi?\"" }
+
+
+				(Markdown(concat!(
+					"## Pages\n",
+					" - [Handouts](/handouts): Math circle lessons I've written\n",
+					" - [Links](/links): Interesting parts of the internet"
+				)))
+
+				hr style="margin-top: 6rem; margin-bottom: 6rem" {}
+
+				h2 { "Projects" }
+				ul {
+					li {
+						p {
+							b { "RedoxOS" }
+							", a general-purpose, microkernel-based operating system written in Rust. "
+
+							em { span style="color: var(--grey);" {"[enthusiast]"} }
+						}
+
+						ul {
+							li {
+								span style="color: var(--grey);" {"Status: "}
+								span style="color: var(--yellow);" {"Passive"}
+							}
+
+
+							li {
+								span style="color: var(--grey);" {"Website: "}
+								(
+									FarLink(
+										"https://www.redox-os.org",
+										html!(
+											(FAIcon::Link)
+											"redox-os.org"
+										)
+									)
+								)
+							}
+						}
+					}
+
+					li {
+						p {
+							b { "Tectonic" }
+							", the LaTeX engine that is pleasant to use. Experimental, but fully functional. "
+
+							em { span style="color: var(--grey);" {"[co-maintainer]"} }
+						}
+
+						ul {
+							li {
+								span style="color: var(--grey);" {"Status: "}
+								span style="color: var(--yellow);" {"Passive. "}
+								(FarLink("https://github.com/typst/typst", "Typst"))
+								" is better."
+							}
+
+
+							li {
+								span style="color: var(--grey);" {"Main Repo: "}
+								(
+									FarLink(
+										"https://github.com/tectonic-typesetting/tectonic",
+										html!( (FAIcon::Github) "Tectonic" )
+									)
+								)
+							}
+
+							li {
+								span style="color: var(--grey);" {"Bundle Tools: "}
+								(
+									FarLink(
+										"https://github.com/tectonic-typesetting/tectonic-texlive-bundles",
+										html!( (FAIcon::Github) "tectonic-texlive-bundles" )
+									)
+								)
+							}
+						}
+					}
+
+
+					li {
+						p {
+							b { "Daisy" }
+							", a pretty TUI scientific calculator. "
+
+							em { span style="color: var(--grey);" {"[author]"} }
+						}
+
+						ul {
+							li {
+								span style="color: var(--grey);" {"Status: "}
+								span style="color: var(--orange);" {"Done. "}
+								"Used this to learn Rust. "
+								(FarLink("https://numbat.dev", "Numbat"))
+								" is better."
+							}
+
+							li {
+								span style="color: var(--grey);" {"Repository: "}
+								(
+									FarLink(
+										"https://github.com/rm-dr/daisy",
+										html!( (FAIcon::Github) "rm-dr/daisy" )
+									)
+								)
+							}
+
+							li {
+								span style="color: var(--grey);" {"Website: "}
+								(
+									FarLink(
+										"https://daisy.betalupi.com",
+										html!(
+											(FAIcon::Link)
+											"daisy.betalupi.com"
+										)
+									)
+								)
+								" (WASM demo)"
+							}
+						}
+					}
+
+					li {
+						p {
+							b { "Lamb" }
+							", a lambda calculus engine. "
+
+							em { span style="color: var(--grey);" {"[author]"} }
+						}
+
+						ul {
+							li {
+								span style="color: var(--grey);" {"Status: "}
+								span style="color: var(--orange);" {"Done. "}
+								"Fun little project."
+							}
+
+							li {
+								span style="color: var(--grey);" {"Repository: "}
+								(
+									FarLink(
+										"https://github.com/rm-dr/lamb",
+										html!( (FAIcon::Github) "rm-dr/lamb" )
+									)
+								)
+							}
+
+							li {
+								span style="color: var(--grey);" {"PyPi: "}
+								(
+									FarLink(
+										"https://pypi.org/project/lamb-engine",
+										html!(
+											(FAIcon::Python)
+											"lamb-engine"
+										)
+									)
+								)
+							}
+						}
+					}
+
+
+				}
+
+
+
+
+
+			)
+		))
+	}
+}

crates/service/service-webpage/src/routes/links.rs

@@ -0,0 +1,174 @@
+use assetserver::Asset;
+use maud::{Markup, html};
+
+use crate::{
+	components::{
+		base::{BasePage, PageMetadata},
+		md::Markdown,
+	},
+	routes::assets::Image_Icon,
+};
+
+pub async fn links() -> Markup {
+	let meta = PageMetadata {
+		title: "Links".into(),
+		author: Some("Mark".into()),
+		description: None,
+		image: Some(Image_Icon::URL.into()),
+	};
+
+	html! {
+		(BasePage(
+			meta,
+			html!(
+				// TODO: no metadata class, generate backlink array
+				div {
+					a href="/" style="padding-left:4pt;padding-right:4pt;" {"home"}
+					"/"
+					span class="metaData" style="padding-left:4pt;padding-right:4pt;" { "links" }
+				}
+
+				(Markdown(MD_A))
+
+				hr style="margin-top: 8rem; margin-bottom: 8rem" {}
+
+				(Markdown(MD_B))
+
+				hr style="margin-top: 8rem; margin-bottom: 8rem" {}
+
+				(Markdown(MD_C))
+
+				hr style="margin-top: 8rem; margin-bottom: 8rem" {}
+
+				(Markdown(MD_D))
+			)
+		))
+	}
+}
+
+/*
+Dead links:
+
+https://www.commitstrip.com/en/
+http://www.3dprintmath.com/
+*/
+
+const MD_A: &str = r#"# Bookmarks
+
+This is a heavily opinionated bookmarks toolbar."#;
+
+const MD_B: &str = r#"## Podcasts
+
+- :star: [Darknet Diaries](https://darknetdiaries.com/): A perennial classic.
+- [Art of Manliness](https://www.artofmanliness.com/podcast/): Philosophy, literaure, psychology.
+- [The Overanalyzers](https://www.theoveranalyzers.com/): Amateur podcasters talk amateur psychology. This is a complement---they're _very_ good!
+- [Rust in Production](https://corrode.dev/podcast/): Operations, Rust, and modern tech.
+- :star: [On the Metal](https://onthemetal.transistor.fm/): Quality stories from quality engineers.
+- [Security Cryptography Whatever](https://securitycryptographywhatever.com/): Modern cryptography, for those who understand the underlying theory.
+
+## Essays
+
+- [Real Programmers don't use Pascal](https://www.ee.torontomu.ca/~elf/hack/realmen.html)
+- [A Mathematician's Lament](/files/lockhart.pdf)
+- :star: [The Jargon File](http://www.catb.org/jargon/)
+
+## Textbooks
+
+- :star: [OpenLogic](https://openlogicproject.org/): The gold standard
+- [Operating Systems: from 0 to 1](https://github.com/tuhdo/os01)
+- [Operating Systems: Three Easy Pieces](https://pages.cs.wisc.edu/~remzi/OSTEP/)
+- [Crafting Interpreters](https://craftinginterpreters.com/contents.html)
+- [An Introduction to Mathematical Cryptography](https://link.springer.com/book/10.1007/978-0-387-77993-5)
+- [Stories about Maxima and Minima](https://archive.org/details/storiesaboutmaxi0000tikh)
+
+## Miscellanea
+
+- [Hackaday](https://hackaday.com/)
+- [Grumpy Website](https://grumpy.website/): Daily design crimes
+- :star: [ZSA Voyager](https://www.zsa.io/voyager): World's best keyboard
+- [Nikita Prokopov](https://tonsky.me/)
+- [Faster Than Lime](https://fasterthanli.me/)
+- [Pepper & Carrot](https://www.peppercarrot.com/): The open-source webcomic
+- [User Friendly](https://en.wikipedia.org/wiki/User_Friendly): Old-school. Offline and archived.
+- [PhD Comics](https://phdcomics.com/): Quality academic humor. Discontinued.
+- :star: [Spintronics](https://store.upperstory.com/collections/spintronics/products/spintronics-act-one): Mechanical circuits. Very clever toy.
+- :star: [Turing Tumble](https://store.upperstory.com/collections/turing-tumble-game/products/turing-tumble): Modern Dr. Nim"#;
+
+const MD_C: &str = r#"## Tools
+
+- :star: [Numbat](https://numbat.dev/)
+- [MxToolbox](https://mxtoolbox.com/)
+- [Brainfuck Interpreter](https://copy.sh/brainfuck/)
+- [Compiler Explorer](https://godbolt.org/)
+- [Monkeytype](https://monkeytype.com/)
+- :star: [TLDR](https://tldr.sh/)
+- [TOS;DR](https://tosdr.org/)
+- [Regexr](https://regexr.com/)
+- [Choose a License](https://choosealicense.com/)
+- [DeepL](https://www.deepl.com/translator)
+- [ShuffleCake](https://shufflecake.net/)
+- [Zola](https://www.getzola.org/): Static site generator
+- [Presenterm](https://github.com/mfontanini/presenterm)
+- [mprocs](https://github.com/pvolok/mprocs): Simpler tmux
+- [mask](https://github.com/jacobdeichert/mask)
+- [gitui](https://github.com/gitui-org/gitui): git tui
+- [tokei](https://github.com/XAMPPRocky/tokei): count lines of code
+- [delta](https://github.com/dandavison/delta): pretty pager for diffs
+- [dust](https://github.com/dandavison/delta): `du`, but better
+
+## Math Resources
+
+- [Quantum Quest](https://www.quantum-quest.org/)
+- [The Natural Number Game](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/)
+- [Intro to Lambda Calculus](https://www.driverlesscrocodile.com/technology/lambda-calculus-for-people-a-step-behind-me-1/)
+- [FSM Simulator](https://ivanzuzak.info/noam/webapps/fsm_simulator/)
+- [Euclidea](https://www.euclidea.xyz/)
+- [Problems.ru](https://problems.ru/)
+
+## OS Dev Resources
+
+- [OS Dev Wiki](https://wiki.osdev.org/Expanded_Main_Page)
+- [Nand2Tetris](https://www.nand2tetris.org/course)
+- :star: [Writing an OS in Rust](https://os.phil-opp.com/)
+- [x86 Assembly Guide](https://www.cs.virginia.edu/~evans/cs216/guides/x86.html)
+- [Writing a simple x86 Bootloader](https://www.alanfoster.me/posts/writing-a-bootloader/)
+- [FDC Programming](http://www.brokenthorn.com/Resources/OSDev20.html)
+- [CS77 at Bristol College](http://www.c-jump.com/CIS77/CIS77syllabus.htm)
+
+## Misc Resources
+
+- [Learn OpenGL](https://learnopengl.com/)
+- [Learn WGPU](https://sotrh.github.io/learn-wgpu)
+- [WGPU Fundamentals](https://webgpufundamentals.org/)
+- [Acko](https://acko.net/)
+- [Bezier Info](https://pomax.github.io/bezierinfo/)
+- [SHA256 Algorithm](https://sha256algorithm.com/)
+- [ML Playground](https://ml-playground.com/)
+- [Learn you some Erlang](https://learnyousomeerlang.com/)
+- [Learn you a Haskell](https://learnyouahaskell.github.io/)
+- [Teach yourself CS](https://teachyourselfcs.com/)
+- [The Architecture of Open Source Applications](http://aosabook.org/en/index.html)
+- [wtfjs](https://github.com/denysdovhan/wtfjs): js [wat](https://www.destroyallsoftware.com/talks/wat)s
+
+## Reference
+
+- [DevHints](https://devhints.io/)
+- [OverAPI](https://overapi.com/)
+- [TSConfig Cheat Sheet](https://www.totaltypescript.com/tsconfig-cheat-sheet)
+- [Makefile Tutorial](https://makefiletutorial.com/)
+- [The Pinouts Book](https://pinouts.org/)
+- [Laws of UX](https://lawsofux.com/)
+
+## Rust
+- [Understanding Memory Ordering in Rust](https://emschwartz.me/understanding-memory-ordering-in-rust/)
+- [Unfair Rust Quiz](https://this.quiz.is.fckn.gay/): wtfjs, but in Rust."#;
+
+const MD_D: &str = r#"## Misc
+
+- [Slide Rule Collection](https://www.followingtherules.info/)
+- [MK-61 Command Reference](http://www.thimet.de/CalcCollection/Calculators/Elektronika-MK-61/CmdRef.html)
+- [Why Privacy Matters](https://www.ted.com/talks/glenn_greenwald_why_privacy_matters)
+- [Papers we Love](https://paperswelove.org/)
+- [Grug Brain Dev](https://grugbrain.dev/)
+- [Zen of Python](https://peps.python.org/pep-0020/)
+- [The XY Problem](https://xyproblem.info/)"#;

crates/service/service-webpage/src/routes/mod.rs

@@ -0,0 +1,24 @@
+use axum::Router;
+use axum::routing::get;
+use tracing::info;
+use utoipa::OpenApi;
+
+mod assets;
+mod betalupi;
+mod index;
+mod links;
+
+#[derive(OpenApi)]
+#[openapi(tags(), paths(), components(schemas()))]
+pub(super) struct Api;
+
+pub(super) fn router() -> Router<()> {
+	let (asset_prefix, asset_router) = assets::asset_router();
+	info!("Serving assets at {asset_prefix}");
+
+	Router::new()
+		.route("/", get(index::index))
+		.route("/whats-a-betalupi", get(betalupi::betalupi))
+		.route("/links", get(links::links))
+		.nest(asset_prefix, asset_router)
+}