{"messages":[{"content":"You are a constitutional council ranking individual git commits for ownership allocation.\n\nCompare these two commits. Decide which contributed more lasting value to the project.\n\nJudge substance, not spectacle:\n- Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise.\n- Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one.\n- Do not favor a side merely because its patch is longer or noisier.\n- Weight what the change does for the project, not the contributor's name.\n\nReturn ONLY a JSON object: {\"winner\": \"A\" or \"B\", \"ratio\": \"N:M\", \"explanation\": \"...\"}\nThe explanation must cite concrete differences in the patches (1-3 sentences).\n\nSide A — contributor: tommy-mor\nSide A — commit message:\n[08565bea] Tokenize prose refs for garden URL links (#147)\n\n* Tokenize prose refs for garden URL links\n\nCo-authored-by: tommy <thmorriss@gmail.com>\n\n* Stop prose URLs at line boundaries\n\nCo-authored-by: tommy <thmorriss@gmail.com>\n\n* Require braced DSL item bodies\n\nCo-authored-by: tommy <thmorriss@gmail.com>\n\n---------\n\nCo-authored-by: Cursor Agent <cursoragent@cursor.com>\n\nSide A — unified diff (full patch):\ndiff --git a/server/src/dsl.rs b/server/src/dsl.rs\nindex 4203c2f59dd8825d7a91513c4023f3ccd37f1efc..b3c785674560a0b42a7f4c3aa13d80cd350f485b 100644\n--- a/server/src/dsl.rs\n+++ b/server/src/dsl.rs\n@@ -1,7 +1,5 @@\n use std::collections::HashMap;\n \n-use rand::Rng;\n-\n /// Parsed DSL document.\n #[derive(Debug, Clone, PartialEq, Eq)]\n pub struct Document {\n@@ -39,31 +37,57 @@ pub enum DslError {\n /// Matches the legacy Python parser behavior:\n /// - Supports toggle markers (open == close), e.g. ```...```\n /// - Supports nested markers (open != close), e.g. { ... { ... } ... }\n+#[derive(Debug, Clone, Copy, PartialEq, Eq)]\n+pub enum BlockKind {\n+    CodeFence,\n+    DoubleBrace,\n+    Brace,\n+}\n+\n+#[derive(Debug, Clone, PartialEq, Eq)]\n+struct MaskedBlock {\n+    kind: BlockKind,\n+}\n+\n #[derive(Debug, Default, Clone)]\n pub struct BlockMasker {\n     pub replacements: HashMap<String, String>,\n+    blocks: HashMap<String, MaskedBlock>,\n+    next_id: u32,\n }\n \n impl BlockMasker {\n     pub fn new() -> Self {\n         Self {\n             replacements: HashMap::new(),\n+            blocks: HashMap::new(),\n+            next_id: 0,\n         }\n     }\n \n-    fn new_token(&mut self) -> String {\n-        let mut rng = rand::thread_rng();\n-        let n: u32 = rng.gen();\n-        let token = format!(\"__BLOCK_{:08x}__\", n);\n-        // Extremely unlikely collision; if it happens, regenerate.\n-        if self.replacements.contains_key(&token) {\n-            return self.new_token();\n+    fn new_token(&mut self, haystack: &str) -> String {\n+        loop {\n+            let token = format!(\"__BLOCK_{:08x}__\", self.next_id);\n+            self.next_id = self.next_id.wrapping_add(1);\n+            if !self.replacements.contains_key(&token) && !haystack.contains(&token) {\n+                return token;\n+            }\n         }\n-        token\n     }\n \n     /// Replace outermost balanced blocks with tokens.\n     pub fn mask(&mut self, text: &str, open_marker: &str, close_marker: &str) -> String {\n+        self.mask_kind(text, open_marker, close_marker, BlockKind::Brace)\n+    }\n+\n+    /// Replace outermost balanced blocks with typed deterministic tokens.\n+    pub fn mask_kind(\n+        &mut self,\n+        text: &str,\n+        open_marker: &str,\n+        close_marker: &str,\n+        kind: BlockKind,\n+    ) -> String {\n         if text.is_empty() {\n             return text.to_string();\n         }\n@@ -97,9 +121,10 @@ impl BlockMasker {\n                     // Found end of outermost block\n                     let s = start_idx.max(0) as usize;\n                     let original_block = &text[s..i];\n-                    let token = self.new_token();\n+                    let token = self.new_token(text);\n                     self.replacements\n                         .insert(token.clone(), original_block.to_string());\n+                    self.blocks.insert(token.clone(), MaskedBlock { kind });\n                     result_parts.push(token);\n                     current_idx = i;\n                 }\n@@ -176,13 +201,22 @@ impl BlockMasker {\n         }\n         token.to_string()\n     }\n+\n+    pub fn block_kind(&self, token: &str) -> Option<BlockKind> {\n+        self.blocks.get(token).map(|b| b.kind)\n+    }\n }\n \n fn mask_all(mut masker: BlockMasker, text: &str) -> (BlockMasker, String) {\n     // Mask hierarchy: Code -> Double Brace -> Single Brace.\n-    let t = masker.mask(text, \"```\", \"```\");\n-    let t = masker.mask(&t, \"{{\", \"}}\");\n-    let t = masker.mask(&t, \"{\", \"}\");\n+    let t = masker.mask_kind(text, \"```\", \"```\", BlockKind::CodeFence);\n+    let t = masker.mask_kind(&t, \"{{\", \"}}\", BlockKind::DoubleBrace);\n+    let t = masker.mask_kind(&t, \"{\", \"}\", BlockKind::Brace);\n+    (masker, t)\n+}\n+\n+fn mask_code_fences(mut masker: BlockMasker, text: &str) -> (BlockMasker, String) {\n+    let t = masker.mask_kind(text, \"```\", \"```\", BlockKind::CodeFence);\n     (masker, t)\n }\n \n@@ -253,7 +287,34 @@ fn skip_ws(s: &str, mut i: usize) -> usize {\n     i\n }\n \n-fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n+#[derive(Debug, Clone, PartialEq, Eq)]\n+pub enum ProseToken {\n+    Text(String),\n+    ItemRef(String),\n+}\n+\n+fn trim_prose_item_ref_end(s: &str, mut end: usize) -> usize {\n+    while end > 0 {\n+        let Some((idx, c)) = s[..end].char_indices().next_back() else {\n+            break;\n+        };\n+        if matches!(\n+            c,\n+            '.' | ',' | ';' | ':' | '!' | '?' | ')' | ']' | '}' | '\"' | '\\''\n+        ) {\n+            end = idx;\n+        } else {\n+            break;\n+        }\n+    }\n+    end\n+}\n+\n+fn parse_item_name_at_with_mode(\n+    s: &str,\n+    i: usize,\n+    trim_trailing_punctuation: bool,\n+) -> Option<(String, usize)> {\n     let bytes = s.as_bytes();\n     if i >= bytes.len() {\n         return None;\n@@ -263,6 +324,9 @@ fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n     if s[i..].starts_with(\"https://\") || s[i..].starts_with(\"http://\") {\n         let mut j = i;\n         while j < bytes.len() {\n+            if trim_trailing_punctuation && bytes[j] == b'\\n' {\n+                break;\n+            }\n             if bytes[j..].starts_with(b\"__BLOCK_\") || is_ws_byte(bytes[j]) {\n                 break;\n             }\n@@ -271,6 +335,12 @@ fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n         if j <= i {\n             return None;\n         }\n+        if trim_trailing_punctuation {\n+            j = trim_prose_item_ref_end(s, j);\n+            if j <= i {\n+                return None;\n+            }\n+        }\n         return Some((s[i..j].to_string(), j));\n     }\n \n@@ -296,6 +366,12 @@ fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n         if j <= i + 2 {\n             return None;\n         }\n+        if trim_trailing_punctuation {\n+            j = trim_prose_item_ref_end(s, j);\n+            if j <= i + 2 {\n+                return None;\n+            }\n+        }\n         let raw = &s[i..j];\n         if !is_item_name(raw) {\n             return None;\n@@ -336,6 +412,46 @@ fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n     Some((format!(\"~/{}\", name), j))\n }\n \n+fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n+    parse_item_name_at_with_mode(s, i, false)\n+}\n+\n+pub fn parse_prose_item_ref_at(s: &str, i: usize) -> Option<(String, usize)> {\n+    parse_item_name_at_with_mode(s, i, true)\n+}\n+\n+pub fn tokenize_prose_item_refs(text: &str) -> Vec<ProseToken> {\n+    if text.is_empty() {\n+        return Vec::new();\n+    }\n+    let (masker, masked) = mask_code_fences(BlockMasker::new(), text);\n+    let mut tokens = Vec::new();\n+    let mut text_start = 0usize;\n+    let mut i = 0usize;\n+\n+    while i < masked.len() {\n+        if let Some((raw, end)) = parse_prose_item_ref_at(&masked, i) {\n+            if text_start < i {\n+                tokens.push(ProseToken::Text(masker.unmask(&masked[text_start..i])));\n+            }\n+            tokens.push(ProseToken::ItemRef(masker.unmask(&raw)));\n+            i = end;\n+            text_start = i;\n+            continue;\n+        }\n+\n+        let Some((_, c)) = masked[i..].char_indices().next() else {\n+            break;\n+        };\n+        i += c.len_utf8();\n+    }\n+\n+    if text_start < masked.len() {\n+        tokens.push(ProseToken::Text(masker.unmask(&masked[text_start..])));\n+    }\n+    tokens\n+}\n+\n fn parse_block_token_at(s: &str, i: usize) -> Option<(String, usize)> {\n     let bytes = s.as_bytes();\n     if i >= bytes.len() {\n@@ -401,6 +517,12 @@ fn parse_block_prefixed_statement(\n     tail: &str,\n     masker: &BlockMasker,\n ) -> Result<Stmt, DslError> {\n+    if masker.block_kind(block_token) == Some(BlockKind::CodeFence) {\n+        return Err(DslError::Parse(\n+            \"vote explanations must use `{ ... }`; code fences belong inside body blocks\"\n+                .to_string(),\n+        ));\n+    }\n     // vote: block item_ref comparison item_ref\n     let s = tail.trim_start();\n     if s.is_empty() {\n@@ -462,6 +584,11 @@ fn parse_item_definition_statement(stripped: &str, masker: &BlockMasker) -> Resu\n     }\n \n     if let Some((tok, end)) = parse_block_token_at(stripped, i) {\n+        if masker.block_kind(&tok) == Some(BlockKind::CodeFence) {\n+            return Err(DslError::Parse(\n+                \"item bodies must use `{ ... }`; code fences belong inside body blocks\".to_string(),\n+            ));\n+        }\n         let body = masker.extract_body(&tok);\n         let tail = stripped[end..].trim();\n         if !tail.is_empty() {\n@@ -572,6 +699,10 @@ pub fn parse_full(text: &str) -> Result<Document, DslError> {\n \n             if let Some((tok, end)) = parse_block_token_at(stripped, 0) {\n                 if stripped[end..].trim().is_empty() {\n+                    if masker.block_kind(&tok) == Some(BlockKind::CodeFence) {\n+                        prose_buffer.push(line);\n+                        continue;\n+                    }\n                     pending_block = Some(tok);\n                     continue;\n                 }\n@@ -619,6 +750,70 @@ mod tests {\n         assert_eq!(roundtrip, input);\n     }\n \n+    #[test]\n+    fn blockmasker_tokens_are_deterministic_and_typed() {\n+        let input = \"x ```code``` y {body}\";\n+        let (masker, masked) = mask_all(BlockMasker::new(), input);\n+        assert!(masked.contains(\"__BLOCK_00000000__\"));\n+        assert!(masked.contains(\"__BLOCK_00000001__\"));\n+        assert_eq!(\n+            masker.block_kind(\"__BLOCK_00000000__\"),\n+            Some(BlockKind::CodeFence)\n+        );\n+        assert_eq!(\n+            masker.block_kind(\"__BLOCK_00000001__\"),\n+            Some(BlockKind::Brace)\n+        );\n+        assert_eq!(masker.unmask(&masked), input);\n+    }\n+\n+    #[test]\n+    fn prose_tokenizer_finds_tilde_dash_and_raw_url_refs() {\n+        let tokens =\n+            tokenize_prose_item_refs(\"see ~/a/b then -/example.com/x and https://Example.com/A/B.\");\n+        assert_eq!(\n+            tokens,\n+            vec![\n+                ProseToken::Text(\"see \".to_string()),\n+                ProseToken::ItemRef(\"~/a/b\".to_string()),\n+                ProseToken::Text(\" then \".to_string()),\n+                ProseToken::ItemRef(\"-/example.com/x\".to_string()),\n+                ProseToken::Text(\" and \".to_string()),\n+                ProseToken::ItemRef(\"https://Example.com/A/B\".to_string()),\n+                ProseToken::Text(\".\".to_string()),\n+            ]\n+        );\n+    }\n+\n+    #[test]\n+    fn prose_tokenizer_stops_raw_urls_at_newlines() {\n+        let tokens = tokenize_prose_item_refs(\"https://example.com/a/b.\\n-/example.com/a/b\");\n+        assert_eq!(\n+            tokens,\n+            vec![\n+                ProseToken::ItemRef(\"https://example.com/a/b\".to_string()),\n+                ProseToken::Text(\".\\n\".to_string()),\n+                ProseToken::ItemRef(\"-/example.com/a/b\".to_string()),\n+            ]\n+        );\n+    }\n+\n+    #[test]\n+    fn prose_tokenizer_does_not_linkify_inside_code_fences() {\n+        let tokens = tokenize_prose_item_refs(\n+            \"before ```json\\n{\\\"url\\\":\\\"https://example.com\\\"}\\n``` after ~/x\",\n+        );\n+        assert_eq!(\n+            tokens,\n+            vec![\n+                ProseToken::Text(\n+                    \"before ```json\\n{\\\"url\\\":\\\"https://example.com\\\"}\\n``` after \".to_string()\n+                ),\n+                ProseToken::ItemRef(\"~/x\".to_string()),\n+            ]\n+        );\n+    }\n+\n     #[test]\n     fn parse_item_with_body_strips_outer_braces() {\n         let input = \"~/rust { Systems language }\";\n@@ -633,8 +828,8 @@ mod tests {\n     }\n \n     #[test]\n-    fn parse_item_with_fenced_json_body_preserves_braces() {\n-        let input = \"~/item/in/url ```json\\n{\\\"test\\\": true}\\n```\";\n+    fn parse_item_with_braced_fenced_json_body_preserves_braces() {\n+        let input = \"~/item/in/url {\\n```json\\n{\\\"test\\\": true}\\n```\\n}\";\n         let doc = parse_full(input).unwrap();\n         assert_eq!(\n             doc.statements,\n@@ -645,6 +840,51 @@ mod tests {\n         );\n     }\n \n+    #[test]\n+    fn parse_rejects_singleton_fenced_json_item_body() {\n+        let input = \"~/item/in/url ```json\\n{\\\"test\\\": true}\\n```\";\n+        let err = parse_full(input).unwrap_err().to_string();\n+        assert!(\n+            err.contains(\"item bodies must use\"),\n+            \"unexpected error: {err}\"\n+        );\n+    }\n+\n+    #[test]\n+    fn parse_keeps_standalone_code_fence_as_prose() {\n+        let input = \"```json\\n{\\\"test\\\": true}\\n```\";\n+        let doc = parse_full(input).unwrap();\n+        assert_eq!(\n+            doc.statements,\n+            vec![Stmt::Prose {\n+                text: input.to_string(),\n+            }]\n+        );\n+    }\n+\n+    #[test]\n+    fn parse_rejects_code_fence_vote_explanation() {\n+        let input = \"```json\\n{\\\"why\\\": true}\\n```\\n~/a 2:1 ~/b\";\n+        let err = parse_full(input).unwrap_err().to_string();\n+        assert!(\n+            err.contains(\"vote explanations must start\"),\n+            \"unexpected error: {err}\"\n+        );\n+    }\n+\n+    #[test]\n+    fn parse_raw_url_item_with_braced_fenced_json_body() {\n+        let input = \"https://example.com/itembody/slug {\\n```json\\n{\\\"test\\\": true}\\n```\\n}\";\n+        let doc = parse_full(input).unwrap();\n+        assert_eq!(\n+            doc.statements,\n+            vec![Stmt::Item {\n+                title: \"https://example.com/itembody/slug\".to_string(),\n+                body: Some(\"```json\\n{\\\"test\\\": true}\\n```\".to_string()),\n+            }]\n+        );\n+    }\n+\n     #[test]\n     fn parse_vote_ratio_and_symbols() {\n         let d1 = parse_full(\"{because}\\n~/a 3:1 ~/b\").unwrap();\ndiff --git a/server/src/external_resolver.rs b/server/src/external_resolver.rs\nindex 8481f1fbff1c4265da182a225f539f97d6829002..04bc3de32b6df1aefe197d942db67de2cbdbde4f 100644\n--- a/server/src/external_resolver.rs\n+++ b/server/src/external_resolver.rs\n@@ -256,7 +256,7 @@ fn children_to_dsl(children: &[ResolvedChild]) -> String {\n             .filter(|s| !s.trim().is_empty())\n             .unwrap_or(child.title.as_str());\n         if body.trim_start().starts_with(\"```\") {\n-            out.push_str(&format!(\"{} {}\\n\\n\", child.url, body.trim()));\n+            out.push_str(&format!(\"{} {{\\n{}\\n}}\\n\\n\", child.url, body.trim()));\n         } else {\n             out.push_str(&format!(\n                 \"{} {{\\n{}\\n}}\\n\\n\",\n@@ -378,7 +378,8 @@ mod tests {\n             title: \"#1 title\".into(),\n             body: Some(\"```json\\n{\\\"test\\\": true}\\n```\".into()),\n         }]);\n-        assert!(dsl.contains(\"https://github.com/o/r/issues/1 ```json\"));\n+        assert!(dsl.contains(\"https://github.com/o/r/issues/1 {\\n```json\"));\n         assert!(dsl.contains(\"{\\\"test\\\": true}\"));\n+        assert!(dsl.contains(\"```\\n}\\n\"));\n     }\n }\ndiff --git a/server/src/html/breadcrumb_path.rs b/server/src/html/breadcrumb_path.rs\nindex 3e949ce2cb70de3f024f46af773a93f3f8852260..e48612d7d3c4df52c161499a11865d4caca607aa 100644\n--- a/server/src/html/breadcrumb_path.rs\n+++ b/server/src/html/breadcrumb_path.rs\n@@ -88,16 +88,12 @@ impl ExternalOntologyPath {\n             .filter(|x| !x.is_empty())\n             .map(|x| x.to_string())\n             .collect();\n-        let segments = if segments == [\".\"] {\n-            vec![]\n-        } else {\n-            segments\n-        };\n+        let segments = if segments == [\".\"] { vec![] } else { segments };\n         Self { item, segments }\n     }\n \n     pub(super) fn is_root(&self) -> bool {\n-        self.segments.len() <= 1\n+        self.segments.is_empty()\n     }\n \n     pub(super) fn segments(&self) -> &[String] {\n@@ -108,3 +104,28 @@ impl ExternalOntologyPath {\n         self.item.as_str()\n     }\n }\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+\n+    #[test]\n+    fn external_root_and_host_paths_are_distinct() {\n+        let root = ExternalOntologyPath::from_input(\"\");\n+        assert!(root.is_root());\n+        assert!(root.segments().is_empty());\n+\n+        let host = ExternalOntologyPath::from_input(\"example.com\");\n+        assert!(!host.is_root());\n+        assert_eq!(host.segments(), &[\"example.com\".to_string()]);\n+    }\n+\n+    #[test]\n+    fn external_path_keeps_each_url_segment_for_breadcrumbs() {\n+        let path = ExternalOntologyPath::from_input(\"https://example.com/a/b\");\n+        assert_eq!(\n+            path.segments(),\n+            &[\"example.com\".to_string(), \"a\".to_string(), \"b\".to_string()]\n+        );\n+    }\n+}\ndiff --git a/server/src/html/mod.rs b/server/src/html/mod.rs\nindex 8876a1a00a16ee3bf7a371f7a5ca27b5862b62cc..d5877eeb3632ed5d770f23a04cb4d1881209bc74 100644\n--- a/server/src/html/mod.rs\n+++ b/server/src/html/mod.rs\n@@ -20,27 +20,30 @@ mod search;\n pub mod ui_action;\n use breadcrumb_path::{ExternalOntologyPath, OntologyPath};\n \n-pub use auth::{auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment, choose_username_page};\n+pub use auth::{\n+    auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment,\n+    choose_username_page,\n+};\n pub use editor::{editor_check, editor_page};\n pub use forum::{\n     home, room_page, room_thread_post_view, room_thread_view, thread_feed_html,\n     thread_feed_html_for_room, thread_feed_region_markup, thread_post_view, thread_view, ThreadNav,\n };\n \n+pub use forum::user_profile_page;\n pub(crate) use forum::{\n     fragment_new_thread_slot, login_to_post_hint_markup, room_members_section_markup,\n     thread_ui_collapse_redacted_post, thread_ui_expand_post_full, thread_ui_expand_redacted_post,\n     user_can_post_room, user_can_view_room,\n };\n+pub(crate) use garden::{encode_pin_cookie_value, vote_compare_post_success_js, GARDEN_PIN_COOKIE};\n pub use garden::{\n     external_garden_index, external_ontology_path, garden_index, ontology_path,\n-    room_external_garden_index, room_external_ontology_path, room_garden_index,\n-    room_ontology_path, room_vote_compare_page, vote_compare_page,\n+    room_external_garden_index, room_external_ontology_path, room_garden_index, room_ontology_path,\n+    room_vote_compare_page, vote_compare_page,\n };\n-pub(crate) use garden::{encode_pin_cookie_value, vote_compare_post_success_js, GARDEN_PIN_COOKIE};\n pub use routing::RouteContext;\n pub use search::{search_page, search_results_fragment};\n-pub use forum::user_profile_page;\n pub use ui_action::{parse_html_ui_from_form, HtmlUiAction, HtmlUiParseError, UI_RPC_FIELD};\n \n /// Public profile URL path for a stored username (no `@`).\n@@ -107,8 +110,8 @@ pub struct ThemeForm {\n pub async fn post_theme(Form(form): Form<ThemeForm>) -> impl IntoResponse {\n     let theme = normalize_theme(&form.theme);\n     let next = sanitize_theme_next(form.next.as_deref());\n-    let loc = HeaderValue::try_from(next.as_str())\n-        .unwrap_or_else(|_| HeaderValue::from_static(\"/\"));\n+    let loc =\n+        HeaderValue::try_from(next.as_str()).unwrap_or_else(|_| HeaderValue::from_static(\"/\"));\n     Response::builder()\n         .status(StatusCode::SEE_OTHER)\n         .header(header::LOCATION, loc)\n@@ -179,7 +182,9 @@ pub(crate) struct JsQueryBuilder {\n \n impl JsBuilder {\n     pub(crate) fn new() -> Self {\n-        Self { snippets: Vec::new() }\n+        Self {\n+            snippets: Vec::new(),\n+        }\n     }\n \n     pub(crate) fn morph_selector(self, selector: &str, markup: Markup) -> Self {\n@@ -195,7 +200,12 @@ impl JsBuilder {\n         self.qs(selector).morph_inner(markup)\n     }\n \n-    pub(crate) fn morph_expr(mut self, expr: &str, markup: Markup, morph_style: Option<&str>) -> Self {\n+    pub(crate) fn morph_expr(\n+        mut self,\n+        expr: &str,\n+        markup: Markup,\n+        morph_style: Option<&str>,\n+    ) -> Self {\n         let html = js_string_literal(&markup.into_string());\n         let opts = morph_style\n             .map(|style| format!(\", {{morphStyle: {}}}\", js_string_literal(style)))\n@@ -217,7 +227,11 @@ impl JsBuilder {\n         self.qs(&format!(\"#{id}\"))\n     }\n \n-    pub(crate) fn if_current_path_matches(mut self, path: &str, f: impl FnOnce(JsBuilder) -> JsBuilder) -> Self {\n+    pub(crate) fn if_current_path_matches(\n+        mut self,\n+        path: &str,\n+        f: impl FnOnce(JsBuilder) -> JsBuilder,\n+    ) -> Self {\n         let inner = f(JsBuilder::new()).build();\n         self.snippets.push(format!(\n             \"var __slugHere = window.location.pathname + window.location.search; var __slugPath = {path}; if (__slugHere === __slugPath || __slugHere.indexOf(__slugPath + '?') === 0) {{ {inner} }}\",\n@@ -226,7 +240,11 @@ impl JsBuilder {\n         self\n     }\n \n-    pub(crate) fn if_current_path_not_matches(mut self, path: &str, f: impl FnOnce(JsBuilder) -> JsBuilder) -> Self {\n+    pub(crate) fn if_current_path_not_matches(\n+        mut self,\n+        path: &str,\n+        f: impl FnOnce(JsBuilder) -> JsBuilder,\n+    ) -> Self {\n         let inner = f(JsBuilder::new()).build();\n         self.snippets.push(format!(\n             \"var __slugHere = window.location.pathname + window.location.search; var __slugPath = {path}; if (!(__slugHere === __slugPath || __slugHere.indexOf(__slugPath + '?') === 0)) {{ {inner} }}\",\n@@ -301,7 +319,17 @@ pub(super) fn layout(\n     garden_room_wire: Option<&str>,\n     garden_path_prefix: Option<&str>,\n ) -> Markup {\n-    layout_embed_controls(title, view, body, views, theme, theme_next, garden_room_wire, garden_path_prefix, true)\n+    layout_embed_controls(\n+        title,\n+        view,\n+        body,\n+        views,\n+        theme,\n+        theme_next,\n+        garden_room_wire,\n+        garden_path_prefix,\n+        true,\n+    )\n }\n \n /// Minimal document shell: no bottom controls, no garden HUD data attributes (`data-garden-room` /\n@@ -315,15 +343,7 @@ pub(super) fn layout_full_bleed_chromeless(\n     theme_next: &str,\n ) -> Markup {\n     layout_embed_controls(\n-        title,\n-        view,\n-        body,\n-        views,\n-        theme,\n-        theme_next,\n-        None,\n-        None,\n-        false,\n+        title, view, body, views, theme, theme_next, None, None, false,\n     )\n }\n \n@@ -545,7 +565,58 @@ fn item_body_title_snippet(body: &str) -> Option<String> {\n     Some(format!(\"{truncated}{ellipsis}\"))\n }\n \n-/// Replace ~/path slugs in raw text with clickable links.\n+fn garden_href_for_item_ref(\n+    raw_ref: &str,\n+    garden_prefix: &str,\n+) -> Option<(crate::path_types::ItemId, String)> {\n+    let key = slug_types::canonicalize_item(raw_ref);\n+    let id = crate::path_types::ItemId::parse(&key)?;\n+    let href = if let Some(tail) = id.tilde_tail() {\n+        if tail.is_empty() {\n+            garden_prefix.trim_end_matches('/').to_string()\n+        } else {\n+            format!(\"{}/{}\", garden_prefix.trim_end_matches('/'), tail)\n+        }\n+    } else if id.as_str().starts_with(\"https://\") || id.as_str().starts_with(\"http://\") {\n+        let display = id.display_path();\n+        let rest = display.strip_prefix(\"-/\").unwrap_or(display.as_str());\n+        let ext_prefix = format!(\"{}-\", garden_prefix.trim_end_matches('~'));\n+        format!(\"{}/{}\", ext_prefix, rest)\n+    } else {\n+        return None;\n+    };\n+    Some((id, href))\n+}\n+\n+fn push_item_ref_anchor(\n+    out: &mut String,\n+    raw_ref: &str,\n+    garden_prefix: &str,\n+    item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n+) -> bool {\n+    let Some((id, href)) = garden_href_for_item_ref(raw_ref, garden_prefix) else {\n+        return false;\n+    };\n+    out.push_str(r#\"<a href=\"\"#);\n+    out.push_str(&escape_html(&href));\n+    out.push('\"');\n+    out.push_str(r#\" class=\"pre-link\"\"#);\n+    if let Some(bodies) = item_bodies {\n+        if let Some(body) = bodies.get(&id) {\n+            if let Some(snippet) = item_body_title_snippet(body) {\n+                out.push_str(r#\" title=\"\"#);\n+                out.push_str(&escape_html(&snippet));\n+                out.push('\"');\n+            }\n+        }\n+    }\n+    out.push('>');\n+    out.push_str(&escape_html(raw_ref));\n+    out.push_str(\"</a>\");\n+    true\n+}\n+\n+/// Replace item refs in raw prose with clickable garden links.\n ///\n /// When `item_bodies` is set, matching ontology items get a `title` attribute with a truncated\n /// body preview for native browser tooltips (forum posts, item pages).\n@@ -554,53 +625,16 @@ pub(super) fn linkify_slugs_with_prefix(\n     garden_prefix: &str,\n     item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n ) -> String {\n-    let escaped = escape_html(raw);\n-    let mut out = String::with_capacity(escaped.len() + 64);\n-    let mut i = 0;\n-    let s = escaped.as_str();\n-    while i < s.len() {\n-        let rest = &s[i..];\n-        if let Some(after_tilde) = rest.strip_prefix(\"~/\") {\n-            let path_len = after_tilde\n-                .chars()\n-                .take_while(|c| c.is_ascii_alphanumeric() || *c == '_' || *c == '-' || *c == '/')\n-                .map(|c| c.len_utf8())\n-                .sum::<usize>();\n-            if path_len > 0 {\n-                let path = &after_tilde[..path_len];\n-                out.push_str(r#\"<a href=\"\"#);\n-                out.push_str(&escape_html(garden_prefix.trim_end_matches('/')));\n-                out.push('/');\n-                out.push_str(path);\n-                out.push('\"');\n-                out.push_str(r#\" class=\"pre-link\"\"#);\n-                if let Some(bodies) = item_bodies {\n-                    let tilde_ref = format!(\"~/{}\", path);\n-                    let key = slug_types::canonicalize_item(&tilde_ref);\n-                    if let Some(id) = crate::path_types::ItemId::parse(&key) {\n-                        if let Some(body) = bodies.get(&id) {\n-                            if let Some(snippet) = item_body_title_snippet(body) {\n-                                out.push_str(r#\" title=\"\"#);\n-                                out.push_str(&escape_html(&snippet));\n-                                out.push('\"');\n-                            }\n-                        }\n-                    }\n+    let mut out = String::with_capacity(raw.len() + 64);\n+    for token in crate::dsl::tokenize_prose_item_refs(raw) {\n+        match token {\n+            crate::dsl::ProseToken::Text(text) => out.push_str(&escape_html(&text)),\n+            crate::dsl::ProseToken::ItemRef(raw_ref) => {\n+                if !push_item_ref_anchor(&mut out, &raw_ref, garden_prefix, item_bodies) {\n+                    out.push_str(&escape_html(&raw_ref));\n                 }\n-                out.push('>');\n-                out.push_str(\"~/\");\n-                out.push_str(path);\n-                out.push_str(\"</a>\");\n-                i += 2 + path_len;\n-                continue;\n             }\n         }\n-        if let Some((j, c)) = rest.char_indices().next() {\n-            out.push(c);\n-            i += j + c.len_utf8();\n-        } else {\n-            break;\n-        }\n     }\n     out\n }\n@@ -638,7 +672,13 @@ fn spotify_embed_src(url: &str) -> Option<EmbedFrame> {\n     if !(host == \"open.spotify.com\" || host == \"www.open.spotify.com\") {\n         return None;\n     }\n-    let path = tail.split('#').next().unwrap_or(tail).split('?').next().unwrap_or(tail);\n+    let path = tail\n+        .split('#')\n+        .next()\n+        .unwrap_or(tail)\n+        .split('?')\n+        .next()\n+        .unwrap_or(tail);\n     let mut segs: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();\n     if segs.first().is_some_and(|s| s.starts_with(\"intl-\")) {\n         segs.remove(0);\n@@ -670,8 +710,16 @@ fn youtube_embed_src(url: &str) -> Option<EmbedFrame> {\n     let host = host.to_lowercase();\n \n     let video_id = if host == \"youtu.be\" || host == \"www.youtu.be\" {\n-        clean_media_id(tail.split(['?', '#']).next().unwrap_or(tail).trim_matches('/'))\n-    } else if matches!(host.as_str(), \"youtube.com\" | \"www.youtube.com\" | \"m.youtube.com\" | \"music.youtube.com\") {\n+        clean_media_id(\n+            tail.split(['?', '#'])\n+                .next()\n+                .unwrap_or(tail)\n+                .trim_matches('/'),\n+        )\n+    } else if matches!(\n+        host.as_str(),\n+        \"youtube.com\" | \"www.youtube.com\" | \"m.youtube.com\" | \"music.youtube.com\"\n+    ) {\n         let path = format!(\"/{}\", tail.split('#').next().unwrap_or(tail));\n         if path.starts_with(\"/watch\") {\n             clean_media_id(&query_param(url, \"v\")?)\n@@ -745,10 +793,7 @@ pub(super) fn render_linkified_with_embeds_in_scope(\n /// CLI strings are embedded in a single-quoted JS literal; they must never need escaping.\n fn assert_cli_panel_cmd_js_single_quote_safe(s: &str) {\n     assert!(\n-        !s.contains('\\\\')\n-            && !s.contains('\\'')\n-            && !s.contains('\\n')\n-            && !s.contains('\\r'),\n+        !s.contains('\\\\') && !s.contains('\\'') && !s.contains('\\n') && !s.contains('\\r'),\n         \"cli_panel cmd must not contain `\\\\`, `'`, or newlines (got {s:?})\"\n     );\n }\n@@ -805,15 +850,40 @@ mod linkify_title_tests {\n         let mut bodies = HashMap::new();\n         let key = ItemId::parse(&slug_types::canonicalize_item(\"~/foo/bar\")).unwrap();\n         bodies.insert(key, \"Hello  world\\nline\".to_string());\n-        let html = linkify_slugs_with_prefix(\n-            \"see ~/foo/bar ok\",\n-            \"/r/x/~\",\n-            Some(&bodies),\n-        );\n+        let html = linkify_slugs_with_prefix(\"see ~/foo/bar ok\", \"/r/x/~\", Some(&bodies));\n         assert!(html.contains(\"title=\\\"Hello world line\\\"\"));\n         assert!(html.contains(\"href=\\\"/r/x/~/foo/bar\\\"\"));\n     }\n \n+    #[test]\n+    fn raw_url_links_to_public_external_garden_page() {\n+        let html = linkify_slugs_with_prefix(\"see https://example.com/z.\", \"/~\", None);\n+        assert!(html\n+            .contains(r#\"<a href=\"/-/example.com/z\" class=\"pre-link\">https://example.com/z</a>.\"#));\n+    }\n+\n+    #[test]\n+    fn dash_ref_links_to_room_external_garden_page_with_title() {\n+        let mut bodies = HashMap::new();\n+        let key = ItemId::parse(&slug_types::canonicalize_item(\"-/example.com/z\")).unwrap();\n+        bodies.insert(key, \"External body\\npreview\".to_string());\n+        let html =\n+            linkify_slugs_with_prefix(\"see -/example.com/z\", \"/r/9ab12cdroom/~\", Some(&bodies));\n+        assert!(html.contains(r#\"href=\"/r/9ab12cdroom/-/example.com/z\"\"#));\n+        assert!(html.contains(r#\"title=\"External body preview\"\"#));\n+    }\n+\n+    #[test]\n+    fn code_fence_urls_are_not_linkified() {\n+        let html = linkify_slugs_with_prefix(\n+            \"```json\\n{\\\"url\\\":\\\"https://example.com/z\\\"}\\n```\\nthen https://example.com/a\",\n+            \"/~\",\n+            None,\n+        );\n+        assert!(!html.contains(r#\"href=\"/-/example.com/z\"\"#));\n+        assert!(html.contains(r#\"href=\"/-/example.com/a\"\"#));\n+    }\n+\n     #[test]\n     fn no_title_when_body_missing_or_empty() {\n         let html = linkify_slugs_with_prefix(\"x ~/a/b y\", \"/~\", Some(&HashMap::new()));\n\n\nSide B — contributor: tommy-mor\nSide B — commit message:\n[15e1037a] url stuff\n\nSide B — unified diff (full patch):\ndiff --git a/server/src/url_rules/graph.rs b/server/src/url_rules/graph.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..f7ac0f9a551a1727cb2f9294778c283b9885b147\n--- /dev/null\n+++ b/server/src/url_rules/graph.rs\n@@ -0,0 +1,831 @@\n+//! Semantic URL graph: DFA traversal on host + path, query in context, generic fallback.\n+\n+use std::collections::HashMap;\n+use std::sync::OnceLock;\n+\n+use url::Url;\n+\n+use super::graph_builder::GraphBuilder;\n+use super::parse::{normalize_match_host, strip_tracking_query, UrlParts};\n+\n+#[derive(Debug, Clone, Default)]\n+pub struct Context {\n+    pub vars: HashMap<String, String>,\n+    pub query: HashMap<String, String>,\n+}\n+\n+pub type CanonicalFn = fn(&Context) -> Option<String>;\n+\n+#[derive(Clone, Copy)]\n+pub enum EdgePattern {\n+    Literal(&'static str),\n+    Variable(&'static str),\n+    /// Absorb any trailing segment without leaving this node (e.g. post title slug).\n+    AbsorbAny,\n+    /// Absorb segment when `cond(seg)` (e.g. subreddit listing suffix).\n+    AbsorbIf(fn(&str) -> bool),\n+}\n+\n+pub struct Edge {\n+    pub pattern: EdgePattern,\n+    pub target: &'static str,\n+}\n+\n+pub struct Node {\n+    pub edges: Vec<Edge>,\n+    pub canonical: CanonicalFn,\n+    pub parent: Option<&'static str>,\n+}\n+\n+impl Node {\n+    pub(crate) fn empty() -> Self {\n+        Self {\n+            edges: Vec::new(),\n+            canonical: |_| None,\n+            parent: None,\n+        }\n+    }\n+}\n+\n+pub struct Graph {\n+    pub nodes: HashMap<&'static str, Node>,\n+}\n+\n+static GRAPH: OnceLock<Graph> = OnceLock::new();\n+\n+pub fn graph() -> &'static Graph {\n+    GRAPH.get_or_init(build_graph)\n+}\n+\n+impl Graph {\n+    pub fn resolve_canonical(&self, parts: &UrlParts) -> Option<String> {\n+        let mut query = parts.query.clone();\n+        strip_tracking_query(&mut query);\n+        let mut ctx = Context {\n+            vars: HashMap::new(),\n+            query,\n+        };\n+\n+        if let Some(node_id) = self.traverse(parts, &mut ctx) {\n+            if let Some(canon) = (self.nodes.get(node_id)?.canonical)(&ctx) {\n+                return Some(canon);\n+            }\n+        }\n+        Some(generic_canonical(parts))\n+    }\n+\n+    pub fn breadcrumbs(&self, parts: &UrlParts) -> Vec<String> {\n+        let mut query = parts.query.clone();\n+        strip_tracking_query(&mut query);\n+        let mut ctx = Context {\n+            vars: HashMap::new(),\n+            query,\n+        };\n+\n+        if let Some(mut node_id) = self.traverse(parts, &mut ctx) {\n+            let mut paths = Vec::new();\n+            loop {\n+                let node = match self.nodes.get(node_id) {\n+                    Some(n) => n,\n+                    None => break,\n+                };\n+                if let Some(url) = (node.canonical)(&ctx) {\n+                    if paths.last() != Some(&url) {\n+                        paths.push(url);\n+                    }\n+                }\n+                match node.parent {\n+                    Some(p) => node_id = p,\n+                    None => break,\n+                }\n+            }\n+            paths.reverse();\n+            if !paths.is_empty() {\n+                return paths;\n+            }\n+        }\n+        generic_breadcrumbs(parts)\n+    }\n+\n+    fn traverse(&self, parts: &UrlParts, ctx: &mut Context) -> Option<&'static str> {\n+        let host = parts.match_host();\n+        let mut node_id = match host.as_str() {\n+            \"reddit.com\" => \"reddit_root\",\n+            \"youtube.com\" => \"youtube_root\",\n+            \"youtu.be\" => \"youtu_be_entry\",\n+            _ => return None,\n+        };\n+\n+        let segs: Vec<&str> = parts.path_segments.iter().map(String::as_str).collect();\n+        let mut i = 0;\n+        while i < segs.len() {\n+            let seg = segs[i];\n+            match self.follow_edge(node_id, seg, ctx) {\n+                Ok(next) => {\n+                    node_id = next;\n+                    i += 1;\n+                }\n+                Err(()) => {\n+                    if self.try_absorb(node_id, seg) {\n+                        i += 1;\n+                        continue;\n+                    }\n+                    return None;\n+                }\n+            }\n+        }\n+        Some(node_id)\n+    }\n+\n+    fn follow_edge(\n+        &self,\n+        node_id: &'static str,\n+        seg: &str,\n+        ctx: &mut Context,\n+    ) -> Result<&'static str, ()> {\n+        let node = self.nodes.get(node_id).ok_or(())?;\n+        for edge in &node.edges {\n+            match edge.pattern {\n+                EdgePattern::Literal(lit) if lit == seg => return Ok(edge.target),\n+                EdgePattern::Variable(name) => {\n+                    ctx.vars.insert(name.to_string(), seg.to_string());\n+                    return Ok(edge.target);\n+                }\n+                EdgePattern::AbsorbAny\n+                | EdgePattern::AbsorbIf(_)\n+                | EdgePattern::Literal(_)\n+                | EdgePattern::Variable(_) => {}\n+            }\n+        }\n+        Err(())\n+    }\n+\n+    fn try_absorb(&self, node_id: &'static str, seg: &str) -> bool {\n+        let node = match self.nodes.get(node_id) {\n+            Some(n) => n,\n+            None => return false,\n+        };\n+        for edge in &node.edges {\n+            match edge.pattern {\n+                EdgePattern::AbsorbAny => return true,\n+                EdgePattern::AbsorbIf(cond) if cond(seg) => return true,\n+                EdgePattern::AbsorbIf(_) | EdgePattern::Literal(_) | EdgePattern::Variable(_) => {}\n+            }\n+        }\n+        false\n+    }\n+\n+    /// Test hook: terminal graph node and captured context after traversal.\n+    #[cfg(test)]\n+    pub fn traverse_terminal(&self, parts: &UrlParts) -> Option<(&'static str, Context)> {\n+        let mut query = parts.query.clone();\n+        strip_tracking_query(&mut query);\n+        let mut ctx = Context {\n+            vars: HashMap::new(),\n+            query,\n+        };\n+        let node = self.traverse(parts, &mut ctx)?;\n+        Some((node, ctx))\n+    }\n+}\n+\n+fn is_reddit_listing_suffix(seg: &str) -> bool {\n+    matches!(seg, \"hot\" | \"top\" | \"new\" | \"rising\" | \"controversial\")\n+}\n+\n+/// Percent-encode a path or query fragment so `&`, `?`, etc. cannot break URL structure.\n+fn enc(s: &str) -> String {\n+    urlencoding::encode(s).into_owned()\n+}\n+\n+// --- Canonical formatters ---\n+\n+fn canon_reddit_root(_: &Context) -> Option<String> {\n+    Some(\"https://reddit.com\".to_string())\n+}\n+\n+fn canon_reddit_r_hub(_: &Context) -> Option<String> {\n+    Some(\"https://reddit.com/r\".to_string())\n+}\n+\n+fn canon_reddit_subreddit(ctx: &Context) -> Option<String> {\n+    let sub = ctx.vars.get(\"subreddit\")?;\n+    Some(format!(\n+        \"https://reddit.com/r/{}\",\n+        enc(&sub.to_ascii_lowercase())\n+    ))\n+}\n+\n+fn canon_reddit_post(ctx: &Context) -> Option<String> {\n+    let sub = ctx.vars.get(\"subreddit\")?.to_ascii_lowercase();\n+    let id = ctx.vars.get(\"post_id\")?;\n+    Some(format!(\n+        \"https://reddit.com/r/{}/comments/{}\",\n+        enc(&sub),\n+        enc(id)\n+    ))\n+}\n+\n+fn canon_youtube_root(_: &Context) -> Option<String> {\n+    Some(\"https://youtube.com\".to_string())\n+}\n+\n+fn canon_youtube_watch(ctx: &Context) -> Option<String> {\n+    let v = ctx\n+        .query\n+        .get(\"v\")\n+        .or_else(|| ctx.vars.get(\"video_id\"))?;\n+    Some(format!(\"https://youtube.com/watch?v={}\", enc(v)))\n+}\n+\n+fn canon_youtu_be(ctx: &Context) -> Option<String> {\n+    let v = ctx.vars.get(\"vid_id\")?;\n+    Some(format!(\"https://youtube.com/watch?v={}\", enc(v)))\n+}\n+\n+pub fn build_graph() -> Graph {\n+    GraphBuilder::new()\n+        .node(\"reddit_root\")\n+        .canonical(canon_reddit_root)\n+        .edge(EdgePattern::Literal(\"r\"), \"reddit_r_hub\")\n+        .node(\"reddit_r_hub\")\n+        .parent(\"reddit_root\")\n+        .canonical(canon_reddit_r_hub)\n+        .edge(EdgePattern::Variable(\"subreddit\"), \"reddit_subreddit\")\n+        .node(\"reddit_subreddit\")\n+        .parent(\"reddit_r_hub\")\n+        .canonical(canon_reddit_subreddit)\n+        .edge(\n+            EdgePattern::AbsorbIf(is_reddit_listing_suffix),\n+            \"reddit_subreddit\",\n+        )\n+        .edge(EdgePattern::Literal(\"comments\"), \"reddit_comments_gate\")\n+        .node(\"reddit_comments_gate\")\n+        .parent(\"reddit_subreddit\")\n+        .canonical(canon_reddit_subreddit)\n+        .edge(EdgePattern::Variable(\"post_id\"), \"reddit_post\")\n+        .node(\"reddit_post\")\n+        .parent(\"reddit_subreddit\")\n+        .canonical(canon_reddit_post)\n+        .edge(EdgePattern::AbsorbAny, \"reddit_post\")\n+        .node(\"youtube_root\")\n+        .canonical(canon_youtube_root)\n+        .edge(EdgePattern::Literal(\"watch\"), \"youtube_watch\")\n+        .edge(EdgePattern::Literal(\"shorts\"), \"youtube_shorts_gate\")\n+        .node(\"youtube_watch\")\n+        .parent(\"youtube_root\")\n+        .canonical(canon_youtube_watch)\n+        .node(\"youtube_shorts_gate\")\n+        .parent(\"youtube_root\")\n+        .canonical(canon_youtube_root)\n+        .edge(EdgePattern::Variable(\"video_id\"), \"youtube_watch\")\n+        .node(\"youtu_be_entry\")\n+        .canonical(canon_youtube_root)\n+        .edge(EdgePattern::Variable(\"vid_id\"), \"youtu_be_video\")\n+        .node(\"youtu_be_video\")\n+        .parent(\"youtube_root\")\n+        .canonical(canon_youtu_be)\n+        .build()\n+}\n+\n+// --- Generic internet fallback ---\n+\n+pub fn generic_canonical(parts: &UrlParts) -> String {\n+    let host = normalize_match_host(&parts.host);\n+    let path_segments: Vec<String> = parts.path_segments.clone();\n+    let mut query = parts.query.clone();\n+    strip_tracking_query(&mut query);\n+\n+    let mut url = if path_segments.is_empty() {\n+        Url::parse(&format!(\"https://{host}\"))\n+            .unwrap_or_else(|_| Url::parse(\"https://invalid\").unwrap())\n+    } else {\n+        let path = format!(\"/{}\", path_segments.join(\"/\"));\n+        Url::parse(&format!(\"https://{host}{path}\"))\n+            .unwrap_or_else(|_| Url::parse(\"https://invalid\").unwrap())\n+    };\n+\n+    if !query.is_empty() {\n+        let mut pairs: Vec<_> = query.iter().collect();\n+        pairs.sort_by(|a, b| a.0.cmp(b.0));\n+        url.query_pairs_mut().clear();\n+        for (k, v) in pairs {\n+            url.query_pairs_mut().append_pair(k, v);\n+        }\n+    }\n+\n+    let mut s = url.to_string();\n+    if path_segments.is_empty() {\n+        s = s.trim_end_matches('/').to_string();\n+    }\n+    s\n+}\n+\n+pub fn generic_breadcrumbs(parts: &UrlParts) -> Vec<String> {\n+    let host = normalize_match_host(&parts.host);\n+    let n = parts.path_segments.len();\n+    let mut out = Vec::new();\n+\n+    let base = generic_canonical(&UrlParts {\n+        scheme: \"https\".to_string(),\n+        host: host.clone(),\n+        path_segments: vec![],\n+        query: HashMap::new(),\n+    });\n+    out.push(base);\n+\n+    for i in 0..n {\n+        let segs: Vec<String> = parts.path_segments[..=i].to_vec();\n+        let url = generic_canonical(&UrlParts {\n+            scheme: \"https\".to_string(),\n+            host: host.clone(),\n+            path_segments: segs,\n+            query: HashMap::new(),\n+        });\n+        if out.last() != Some(&url) {\n+            out.push(url);\n+        }\n+    }\n+    out\n+}\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+    use crate::url_rules::parse::test_parts;\n+\n+    fn g() -> &'static Graph {\n+        graph()\n+    }\n+\n+    fn canon(parts: &UrlParts) -> String {\n+        g().resolve_canonical(parts).unwrap()\n+    }\n+\n+    fn crumbs(parts: &UrlParts) -> Vec<String> {\n+        g().breadcrumbs(parts)\n+    }\n+\n+    fn terminal(parts: &UrlParts) -> Option<&'static str> {\n+        g().traverse_terminal(parts).map(|(n, _)| n)\n+    }\n+\n+    fn vars(parts: &UrlParts) -> HashMap<String, String> {\n+        g().traverse_terminal(parts)\n+            .map(|(_, c)| c.vars)\n+            .unwrap_or_default()\n+    }\n+\n+    #[test]\n+    fn youtu_be_malicious_segment_encoded_not_injected() {\n+        let p = test_parts(\"youtu.be\", &[\"abc&t=1\"], &[]);\n+        assert_eq!(canon(&p), \"https://youtube.com/watch?v=abc%26t%3D1\");\n+        assert!(!canon(&p).contains(\"abc&t=1\"));\n+    }\n+\n+    #[test]\n+    fn youtube_query_v_encoded() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"a&b=c\")]);\n+        assert_eq!(canon(&p), \"https://youtube.com/watch?v=a%26b%3Dc\");\n+    }\n+\n+    #[test]\n+    fn absorb_patterns_live_on_edges_not_in_engine() {\n+        let g = build_graph();\n+        let sub = g.nodes.get(\"reddit_subreddit\").unwrap();\n+        assert!(sub\n+            .edges\n+            .iter()\n+            .any(|e| matches!(e.pattern, EdgePattern::AbsorbIf(_))));\n+        let post = g.nodes.get(\"reddit_post\").unwrap();\n+        assert!(post\n+            .edges\n+            .iter()\n+            .any(|e| matches!(e.pattern, EdgePattern::AbsorbAny)));\n+    }\n+\n+    #[test]\n+    fn builder_rejects_missing_parent() {\n+        let result = std::panic::catch_unwind(|| {\n+            GraphBuilder::new()\n+                .node(\"orphan\")\n+                .parent(\"nonexistent_parent\")\n+                .build();\n+        });\n+        assert!(result.is_err());\n+    }\n+\n+    #[test]\n+    fn generic_canonical_forces_https_and_strips_www() {\n+        let p = test_parts(\"www.example.com\", &[\"blog\", \"post\"], &[]);\n+        assert_eq!(canon(&p), \"https://example.com/blog/post\");\n+    }\n+\n+    #[test]\n+    fn generic_canonical_sorts_query_keys() {\n+        let p = test_parts(\"example.com\", &[\"search\"], &[(\"q\", \"rust\"), (\"page\", \"2\")]);\n+        assert_eq!(canon(&p), \"https://example.com/search?page=2&q=rust\");\n+    }\n+\n+    #[test]\n+    fn generic_canonical_strips_tracking_from_query() {\n+        let p = test_parts(\n+            \"news.ycombinator.com\",\n+            &[\"item\"],\n+            &[(\"id\", \"1\"), (\"utm_medium\", \"social\")],\n+        );\n+        assert_eq!(canon(&p), \"https://news.ycombinator.com/item?id=1\");\n+    }\n+\n+    #[test]\n+    fn generic_breadcrumbs_cumulative_path() {\n+        let p = test_parts(\"paulgraham.com\", &[\"articles\", \"lisp.html\"], &[]);\n+        assert_eq!(\n+            crumbs(&p),\n+            vec![\n+                \"https://paulgraham.com\",\n+                \"https://paulgraham.com/articles\",\n+                \"https://paulgraham.com/articles/lisp.html\"\n+            ]\n+        );\n+    }\n+\n+    #[test]\n+    fn generic_breadcrumbs_domain_only() {\n+        let p = test_parts(\"example.com\", &[], &[]);\n+        assert_eq!(crumbs(&p), vec![\"https://example.com\"]);\n+    }\n+\n+    #[test]\n+    fn unknown_host_uses_generic_not_graph() {\n+        let p = test_parts(\"hackernews.com\", &[\"item\", \"123\"], &[]);\n+        assert_eq!(terminal(&p), None);\n+        assert_eq!(canon(&p), \"https://hackernews.com/item/123\");\n+    }\n+\n+    #[test]\n+    fn traverse_captures_subreddit_variable() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"Rust\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_subreddit\"));\n+        assert_eq!(vars(&p).get(\"subreddit\").map(String::as_str), Some(\"Rust\"));\n+    }\n+\n+    #[test]\n+    fn traverse_captures_post_id() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"aww\", \"comments\", \"abc123\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_post\"));\n+        assert_eq!(vars(&p).get(\"post_id\").map(String::as_str), Some(\"abc123\"));\n+    }\n+\n+    #[test]\n+    fn traverse_absorbs_listing_suffix_stays_on_subreddit() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"rust\", \"hot\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_subreddit\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust\");\n+    }\n+\n+    #[test]\n+    fn traverse_absorbs_all_listing_suffixes() {\n+        for suffix in [\"hot\", \"top\", \"new\", \"rising\", \"controversial\"] {\n+            let p = test_parts(\"reddit.com\", &[\"r\", \"test\", suffix], &[]);\n+            assert_eq!(terminal(&p), Some(\"reddit_subreddit\"), \"suffix {suffix}\");\n+            assert_eq!(canon(&p), \"https://reddit.com/r/test\", \"suffix {suffix}\");\n+        }\n+    }\n+\n+    #[test]\n+    fn traverse_absorbs_post_title_slug() {\n+        let p = test_parts(\n+            \"reddit.com\",\n+            &[\"r\", \"rust\", \"comments\", \"aaa\", \"my_great_post_title\"],\n+            &[],\n+        );\n+        assert_eq!(terminal(&p), Some(\"reddit_post\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust/comments/aaa\");\n+    }\n+\n+    #[test]\n+    fn traverse_unknown_segment_falls_back_to_generic() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"rust\", \"wiki\", \"faq\"], &[]);\n+        assert_eq!(terminal(&p), None);\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust/wiki/faq\");\n+    }\n+\n+    #[test]\n+    fn traverse_youtube_watch_requires_v_in_query() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"xyz\")]);\n+        assert_eq!(terminal(&p), Some(\"youtube_watch\"));\n+    }\n+\n+    #[test]\n+    fn traverse_youtu_be_captures_vid_id() {\n+        let p = test_parts(\"youtu.be\", &[\"dQw4w9WgXcQ\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"youtu_be_video\"));\n+        assert_eq!(vars(&p).get(\"vid_id\").map(String::as_str), Some(\"dQw4w9WgXcQ\"));\n+    }\n+\n+    #[test]\n+    fn traverse_shorts_sets_video_id_var() {\n+        let p = test_parts(\"youtube.com\", &[\"shorts\", \"abc99\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"youtube_watch\"));\n+        assert_eq!(vars(&p).get(\"video_id\").map(String::as_str), Some(\"abc99\"));\n+    }\n+\n+    #[test]\n+    fn reddit_domain_canonical() {\n+        let p = test_parts(\"reddit.com\", &[], &[]);\n+        assert_eq!(canon(&p), \"https://reddit.com\");\n+    }\n+\n+    #[test]\n+    fn reddit_r_hub_canonical() {\n+        let p = test_parts(\"reddit.com\", &[\"r\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_r_hub\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r\");\n+    }\n+\n+    #[test]\n+    fn reddit_subreddit_lowercases_name() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"AmITheAsshole\"], &[]);\n+        assert_eq!(canon(&p), \"https://reddit.com/r/amitheasshole\");\n+    }\n+\n+    #[test]\n+    fn reddit_host_aliases_old_new_www() {\n+        for host in [\"old.reddit.com\", \"new.reddit.com\", \"www.reddit.com\"] {\n+            let p = test_parts(host, &[\"r\", \"rust\"], &[]);\n+            assert_eq!(canon(&p), \"https://reddit.com/r/rust\", \"host {host}\");\n+        }\n+    }\n+\n+    #[test]\n+    fn reddit_post_strips_slug_and_query() {\n+        let p = test_parts(\n+            \"old.reddit.com\",\n+            &[\"r\", \"Rust\", \"comments\", \"1abc\", \"title_slug_here\"],\n+            &[(\"sort\", \"new\")],\n+        );\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust/comments/1abc\");\n+    }\n+\n+    #[test]\n+    fn reddit_post_multiple_slugs_absorbed() {\n+        let p = test_parts(\n+            \"reddit.com\",\n+            &[\"r\", \"x\", \"comments\", \"id1\", \"slug1\", \"extra\"],\n+            &[],\n+        );\n+        assert_eq!(canon(&p), \"https://reddit.com/r/x/comments/id1\");\n+    }\n+\n+    #[test]\n+    fn reddit_listing_with_query_only() {\n+        let p = test_parts(\"www.reddit.com\", &[\"r\", \"programming\"], &[(\"sort\", \"top\")]);\n+        assert_eq!(canon(&p), \"https://reddit.com/r/programming\");\n+    }\n+\n+    #[test]\n+    fn reddit_subreddit_breadcrumbs_include_r_hub() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"movies\"], &[]);\n+        assert_eq!(\n+            crumbs(&p),\n+            vec![\n+                \"https://reddit.com\",\n+                \"https://reddit.com/r\",\n+                \"https://reddit.com/r/movies\"\n+            ]\n+        );\n+    }\n+\n+    #[test]\n+    fn reddit_post_breadcrumbs_skip_comments_node() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"aww\", \"comments\", \"1trnvdl\"], &[]);\n+        let c = crumbs(&p);\n+        assert!(!c.iter().any(|u| u.ends_with(\"/comments\")));\n+        assert_eq!(\n+            c.last().map(String::as_str),\n+            Some(\"https://reddit.com/r/aww/comments/1trnvdl\")\n+        );\n+        assert!(c.contains(&\"https://reddit.com/r/aww\".to_string()));\n+    }\n+\n+    #[test]\n+    fn reddit_post_parent_is_subreddit_not_comments() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"aww\", \"comments\", \"1trnvdl\"], &[]);\n+        let c = crumbs(&p);\n+        let parent = c.get(c.len() - 2).unwrap();\n+        assert_eq!(parent, \"https://reddit.com/r/aww\");\n+    }\n+\n+    #[test]\n+    fn reddit_domain_parent_is_none_in_breadcrumb_chain() {\n+        let p = test_parts(\"reddit.com\", &[], &[]);\n+        assert_eq!(crumbs(&p), vec![\"https://reddit.com\"]);\n+    }\n+\n+    #[test]\n+    fn youtube_watch_canonical_uses_v_only() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"abc\"), (\"t\", \"99\")]);\n+        assert_eq!(canon(&p), \"https://youtube.com/watch?v=abc\");\n+    }\n+\n+    #[test]\n+    fn youtube_query_order_independent() {\n+        let a = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"abc\"), (\"t\", \"4\")]);\n+        let b = test_parts(\"youtube.com\", &[\"watch\"], &[(\"t\", \"4\"), (\"v\", \"abc\")]);\n+        assert_eq!(canon(&a), canon(&b));\n+    }\n+\n+    #[test]\n+    fn youtube_host_aliases() {\n+        for host in [\"www.youtube.com\", \"m.youtube.com\"] {\n+            let p = test_parts(host, &[\"watch\"], &[(\"v\", \"x\")]);\n+            assert_eq!(canon(&p), \"https://youtube.com/watch?v=x\", \"host {host}\");\n+        }\n+    }\n+\n+    #[test]\n+    fn youtube_shorts_canonical_matches_watch() {\n+        let shorts = test_parts(\"youtube.com\", &[\"shorts\", \"vid123\"], &[]);\n+        let watch = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"vid123\")]);\n+        assert_eq!(canon(&shorts), canon(&watch));\n+        assert_eq!(canon(&shorts), \"https://youtube.com/watch?v=vid123\");\n+    }\n+\n+    #[test]\n+    fn youtu_be_matches_youtube_watch() {\n+        let be = test_parts(\"youtu.be\", &[\"dQw4w9WgXcQ\"], &[]);\n+        let watch = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"dQw4w9WgXcQ\")]);\n+        assert_eq!(canon(&be), canon(&watch));\n+    }\n+\n+    #[test]\n+    fn youtube_breadcrumbs_domain_then_watch() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"abc\")]);\n+        assert_eq!(\n+            crumbs(&p),\n+            vec![\"https://youtube.com\", \"https://youtube.com/watch?v=abc\"]\n+        );\n+    }\n+\n+    #[test]\n+    fn youtu_be_breadcrumbs_include_youtube_domain() {\n+        let p = test_parts(\"youtu.be\", &[\"abc\"], &[]);\n+        let c = crumbs(&p);\n+        assert_eq!(c.first().map(String::as_str), Some(\"https://youtube.com\"));\n+        assert_eq!(\n+            c.last().map(String::as_str),\n+            Some(\"https://youtube.com/watch?v=abc\")\n+        );\n+    }\n+\n+    #[test]\n+    fn parsed_urls_match_hand_built_parts() {\n+        let raw = \"https://www.reddit.com/r/rust/comments/aaa/title/?utm=x\";\n+        let parsed = UrlParts::parse(raw).unwrap();\n+        let hand = test_parts(\n+            \"www.reddit.com\",\n+            &[\"r\", \"rust\", \"comments\", \"aaa\", \"title\"],\n+            &[(\"utm\", \"x\")],\n+        );\n+        assert_eq!(canon(&parsed), canon(&hand));\n+    }\n+\n+    #[test]\n+    fn equivalence_cluster_youtube_formats() {\n+        let urls = [\n+            \"https://youtu.be/abc123\",\n+            \"https://www.youtube.com/watch?v=abc123\",\n+            \"https://youtube.com/watch?v=abc123&t=1\",\n+            \"https://m.youtube.com/watch?t=1&v=abc123\",\n+        ];\n+        let canonical: Vec<_> = urls\n+            .iter()\n+            .map(|u| canon(&UrlParts::parse(u).unwrap()))\n+            .collect();\n+        assert!(canonical.iter().all(|c| *c == \"https://youtube.com/watch?v=abc123\"));\n+    }\n+\n+    #[test]\n+    fn equivalence_cluster_reddit_post_formats() {\n+        let urls = [\n+            \"https://old.reddit.com/r/Rust/comments/aaa/slug/\",\n+            \"reddit.com/r/rust/comments/aaa/other_slug\",\n+            \"https://reddit.com/r/RUST/comments/aaa\",\n+        ];\n+        let canonical: Vec<_> = urls\n+            .iter()\n+            .map(|u| canon(&UrlParts::parse(u).unwrap()))\n+            .collect();\n+        assert!(\n+            canonical\n+                .iter()\n+                .all(|c| *c == \"https://reddit.com/r/rust/comments/aaa\")\n+        );\n+    }\n+\n+    #[test]\n+    fn graph_nodes_all_have_valid_parent_links() {\n+        let g = build_graph();\n+        for (id, node) in &g.nodes {\n+            if let Some(parent) = node.parent {\n+                assert!(g.nodes.contains_key(parent), \"node {id} parent {parent}\");\n+            }\n+        }\n+    }\n+\n+    #[test]\n+    fn graph_terminal_canonical_always_succeeds_for_reddit_paths() {\n+        let cases: &[(&[&str], &str)] = &[\n+            (&[\"r\", \"rust\"], \"https://reddit.com/r/rust\"),\n+            (\n+                &[\"r\", \"rust\", \"comments\", \"x\"],\n+                \"https://reddit.com/r/rust/comments/x\",\n+            ),\n+        ];\n+        for (segs, want) in cases {\n+            let p = test_parts(\"reddit.com\", segs, &[]);\n+            assert_eq!(canon(&p), *want);\n+        }\n+    }\n+\n+    #[test]\n+    fn breadcrumb_parent_walk_matches_parent_url_semantics() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"aww\", \"comments\", \"id1\"], &[]);\n+        let c = crumbs(&p);\n+        assert_eq!(c.len(), 4);\n+        assert_eq!(\n+            c.get(c.len() - 2).map(String::as_str),\n+            Some(\"https://reddit.com/r/aww\")\n+        );\n+    }\n+\n+    #[test]\n+    fn youtube_watch_without_v_falls_back_to_generic() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"youtube_watch\"));\n+        assert_eq!(canon(&p), \"https://youtube.com/watch\");\n+    }\n+\n+    #[test]\n+    fn reddit_only_comments_path_stops_at_gate() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"rust\", \"comments\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_comments_gate\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust\");\n+    }\n+\n+    #[test]\n+    fn generic_deep_path_many_segments() {\n+        let segs: Vec<&str> = (0..10)\n+            .map(|i| match i {\n+                0 => \"a\",\n+                1 => \"b\",\n+                2 => \"c\",\n+                3 => \"d\",\n+                4 => \"e\",\n+                5 => \"f\",\n+                6 => \"g\",\n+                7 => \"h\",\n+                8 => \"i\",\n+                _ => \"j\",\n+            })\n+            .collect();\n+        let p = test_parts(\"site.com\", &segs, &[]);\n+        assert_eq!(crumbs(&p).len(), 11);\n+    }\n+\n+    #[test]\n+    fn traverse_literal_r_required_for_subreddit() {\n+        let p = test_parts(\"reddit.com\", &[\"rust\"], &[]);\n+        assert_eq!(terminal(&p), None);\n+    }\n+\n+    #[test]\n+    fn http_scheme_upgraded_via_generic_fallback_host() {\n+        let parsed = UrlParts::parse(\"http://example.com/page\").unwrap();\n+        assert_eq!(canon(&parsed), \"https://example.com/page\");\n+    }\n+\n+    #[test]\n+    fn each_graph_node_canonical_is_invokable() {\n+        let g = build_graph();\n+        let empty = Context::default();\n+        for (id, node) in &g.nodes {\n+            let _ = (node.canonical)(&empty);\n+            let _ = id;\n+        }\n+    }\n+\n+    #[test]\n+    fn reddit_double_listing_suffix_both_absorbed() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"rust\", \"hot\", \"new\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_subreddit\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust\");\n+    }\n+\n+    #[test]\n+    fn youtu_be_empty_path_stays_at_entry() {\n+        let p = test_parts(\"youtu.be\", &[], &[]);\n+        assert_eq!(terminal(&p), Some(\"youtu_be_entry\"));\n+    }\n+}\ndiff --git a/server/src/url_rules/graph_builder.rs b/server/src/url_rules/graph_builder.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..243204ad5ca514fff459057956080cacb5bf38e2\n--- /dev/null\n+++ b/server/src/url_rules/graph_builder.rs\n@@ -0,0 +1,73 @@\n+//! Declarative construction of the URL graph with build-time link validation.\n+\n+use std::collections::HashMap;\n+\n+use super::graph::{CanonicalFn, Edge, EdgePattern, Graph, Node};\n+\n+pub struct GraphBuilder {\n+    nodes: HashMap<&'static str, Node>,\n+    current: Option<&'static str>,\n+}\n+\n+impl GraphBuilder {\n+    pub fn new() -> Self {\n+        Self {\n+            nodes: HashMap::new(),\n+            current: None,\n+        }\n+    }\n+\n+    pub fn node(mut self, id: &'static str) -> Self {\n+        self.nodes.entry(id).or_insert_with(Node::empty);\n+        self.current = Some(id);\n+        self\n+    }\n+\n+    pub fn canonical(mut self, f: CanonicalFn) -> Self {\n+        let id = self.current.expect(\"canonical() without node()\");\n+        self.nodes.get_mut(id).expect(\"node missing\").canonical = f;\n+        self\n+    }\n+\n+    pub fn parent(mut self, parent_id: &'static str) -> Self {\n+        let id = self.current.expect(\"parent() without node()\");\n+        self.nodes.get_mut(id).expect(\"node missing\").parent = Some(parent_id);\n+        self\n+    }\n+\n+    pub fn edge(mut self, pattern: EdgePattern, target: &'static str) -> Self {\n+        let id = self.current.expect(\"edge() without node()\");\n+        self.nodes\n+            .get_mut(id)\n+            .expect(\"node missing\")\n+            .edges\n+            .push(Edge { pattern, target });\n+        self\n+    }\n+\n+    pub fn build(self) -> Graph {\n+        for (id, node) in &self.nodes {\n+            if let Some(parent) = node.parent {\n+                assert!(\n+                    self.nodes.contains_key(parent),\n+                    \"node {id}: parent {parent} does not exist\"\n+                );\n+            }\n+            for edge in &node.edges {\n+                if !matches!(\n+                    edge.pattern,\n+                    EdgePattern::AbsorbAny | EdgePattern::AbsorbIf(_)\n+                ) {\n+                    assert!(\n+                        self.nodes.contains_key(edge.target),\n+                        \"node {id}: edge target {} does not exist\",\n+                        edge.target\n+                    );\n+                }\n+            }\n+        }\n+        Graph {\n+            nodes: self.nodes,\n+        }\n+    }\n+}\ndiff --git a/server/src/url_rules/mod.rs b/server/src/url_rules/mod.rs\nindex 9e1445346ce77a49dd6a7e7713bf9c57aef353cc..ba4ac662acc7bd4d50ee34613eb7eb6fccbfb17b 100644\n--- a/server/src/url_rules/mod.rs\n+++ b/server/src/url_rules/mod.rs\n@@ -1,6 +1,7 @@\n //! URL canonicalization and hierarchy via a semantic graph (DFA + generic fallback).\n \n mod graph;\n+mod graph_builder;\n mod parse;\n mod registry;\n \ndiff --git a/server/src/url_rules/parse.rs b/server/src/url_rules/parse.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..19d0c82feb718817168b8b445fcbfa39cf6aa6ba\n--- /dev/null\n+++ b/server/src/url_rules/parse.rs\n@@ -0,0 +1,169 @@\n+//! Parse raw strings into host, path segments, and query (order-independent).\n+\n+use std::collections::HashMap;\n+\n+use url::Url;\n+\n+#[derive(Debug, Clone)]\n+pub struct UrlParts {\n+    pub scheme: String,\n+    pub host: String,\n+    pub path_segments: Vec<String>,\n+    pub query: HashMap<String, String>,\n+}\n+\n+impl UrlParts {\n+    pub fn parse(raw: &str) -> Option<Self> {\n+        let trimmed = raw.trim();\n+        if trimmed.is_empty() {\n+            return None;\n+        }\n+\n+        let with_scheme = if trimmed.contains(\"://\") {\n+            trimmed.to_string()\n+        } else if trimmed.starts_with(\"r/\") || trimmed.starts_with(\"/r/\") {\n+            let rest = trimmed.trim_start_matches('/').trim_start_matches(\"r/\");\n+            format!(\"https://reddit.com/r/{rest}\")\n+        } else if trimmed.contains('.') && !trimmed.starts_with('/') {\n+            format!(\"https://{trimmed}\")\n+        } else {\n+            trimmed.to_string()\n+        };\n+\n+        let url = Url::parse(&with_scheme).ok()?;\n+        let host = url.host_str()?.to_string();\n+        let path_segments: Vec<String> = url\n+            .path_segments()\n+            .map(|segs| segs.filter(|s| !s.is_empty()).map(str::to_string).collect())\n+            .unwrap_or_default();\n+\n+        let mut query = HashMap::new();\n+        for (k, v) in url.query_pairs() {\n+            query.insert(k.into_owned(), v.into_owned());\n+        }\n+\n+        Some(Self {\n+            scheme: url.scheme().to_string(),\n+            path_segments,\n+            query,\n+            host,\n+        })\n+    }\n+\n+    /// Host normalized for graph entry matching (lowercase, aliases).\n+    pub fn match_host(&self) -> String {\n+        normalize_match_host(&self.host)\n+    }\n+}\n+\n+pub fn normalize_match_host(host: &str) -> String {\n+    let h = host\n+        .strip_prefix(\"www.\")\n+        .unwrap_or(host)\n+        .to_ascii_lowercase();\n+    match h.as_str() {\n+        \"old.reddit.com\" | \"new.reddit.com\" => \"reddit.com\".to_string(),\n+        \"m.youtube.com\" => \"youtube.com\".to_string(),\n+        _ => h,\n+    }\n+}\n+\n+pub fn strip_tracking_query(query: &mut HashMap<String, String>) {\n+    query.retain(|k, _| {\n+        let lower = k.to_ascii_lowercase();\n+        !(lower.starts_with(\"utm_\")\n+            || matches!(\n+                lower.as_str(),\n+                \"fbclid\" | \"gclid\" | \"ref\" | \"ref_src\" | \"ref_source\" | \"mc_cid\" | \"mc_eid\"\n+            ))\n+    });\n+}\n+\n+#[cfg(test)]\n+pub(crate) fn test_parts(host: &str, segs: &[&str], query: &[(&str, &str)]) -> UrlParts {\n+    UrlParts {\n+        scheme: \"https\".to_string(),\n+        host: host.to_string(),\n+        path_segments: segs.iter().map(|s| (*s).to_string()).collect(),\n+        query: query\n+            .iter()\n+            .map(|(k, v)| (k.to_string(), v.to_string()))\n+            .collect(),\n+    }\n+}\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+\n+    #[test]\n+    fn parse_full_url_splits_host_path_query() {\n+        let p = UrlParts::parse(\"https://www.youtube.com/watch?v=abc&t=4\").unwrap();\n+        assert_eq!(p.host, \"www.youtube.com\");\n+        assert_eq!(p.path_segments, vec![\"watch\"]);\n+        assert_eq!(p.query.get(\"v\").map(String::as_str), Some(\"abc\"));\n+        assert_eq!(p.query.get(\"t\").map(String::as_str), Some(\"4\"));\n+    }\n+\n+    #[test]\n+    fn parse_r_shortcut_expands_to_reddit() {\n+        let p = UrlParts::parse(\"r/rust\").unwrap();\n+        assert_eq!(p.match_host(), \"reddit.com\");\n+        assert_eq!(p.path_segments, vec![\"r\", \"rust\"]);\n+    }\n+\n+    #[test]\n+    fn parse_slash_r_shortcut() {\n+        let p = UrlParts::parse(\"/r/aww\").unwrap();\n+        assert_eq!(p.path_segments, vec![\"r\", \"aww\"]);\n+    }\n+\n+    #[test]\n+    fn parse_schemeless_host_path() {\n+        let p = UrlParts::parse(\"reddit.com/r/rust/comments/aaa/slug\").unwrap();\n+        assert_eq!(p.match_host(), \"reddit.com\");\n+        assert_eq!(\n+            p.path_segments,\n+            vec![\"r\", \"rust\", \"comments\", \"aaa\", \"slug\"]\n+        );\n+    }\n+\n+    #[test]\n+    fn parse_empty_returns_none() {\n+        assert!(UrlParts::parse(\"\").is_none());\n+        assert!(UrlParts::parse(\"   \").is_none());\n+    }\n+\n+    #[test]\n+    fn normalize_match_host_reddit_aliases() {\n+        assert_eq!(normalize_match_host(\"old.reddit.com\"), \"reddit.com\");\n+        assert_eq!(normalize_match_host(\"NEW.reddit.com\"), \"reddit.com\");\n+        assert_eq!(normalize_match_host(\"www.reddit.com\"), \"reddit.com\");\n+    }\n+\n+    #[test]\n+    fn normalize_match_host_youtube_aliases() {\n+        assert_eq!(normalize_match_host(\"m.youtube.com\"), \"youtube.com\");\n+        assert_eq!(normalize_match_host(\"www.youtube.com\"), \"youtube.com\");\n+    }\n+\n+    #[test]\n+    fn strip_tracking_query_removes_known_params() {\n+        let mut q = HashMap::from([\n+            (\"v\".into(), \"1\".into()),\n+            (\"utm_source\".into(), \"x\".into()),\n+            (\"fbclid\".into(), \"y\".into()),\n+            (\"ref\".into(), \"z\".into()),\n+        ]);\n+        strip_tracking_query(&mut q);\n+        assert_eq!(q.len(), 1);\n+        assert_eq!(q.get(\"v\").map(String::as_str), Some(\"1\"));\n+    }\n+\n+    #[test]\n+    fn strip_tracking_query_utm_prefix() {\n+        let mut q = HashMap::from([(\"utm_campaign\".into(), \"email\".into())]);\n+        strip_tracking_query(&mut q);\n+        assert!(q.is_empty());\n+    }\n+}\ndiff --git a/server/src/url_rules/registry_tests.rs b/server/src/url_rules/registry_tests.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..7b76b550f808f590e011469fdae02adf603b43d2\n--- /dev/null\n+++ b/server/src/url_rules/registry_tests.rs\n@@ -0,0 +1,195 @@\n+//! End-to-end tests for the public registry API (`canonicalize_raw`, breadcrumbs, parent).\n+\n+use super::registry::{\n+    canonicalize_raw, looks_like_url, navigable_breadcrumbs, parent_url, resolve_id,\n+};\n+\n+fn canon(raw: &str) -> String {\n+    canonicalize_raw(raw).unwrap().canonical\n+}\n+\n+#[test]\n+fn looks_like_url_positive_cases() {\n+    for raw in [\n+        \"https://reddit.com/r/rust\",\n+        \"r/rust\",\n+        \"/r/aww\",\n+        \"reddit.com/r/x\",\n+        \"www.example.com/path\",\n+        \"youtu.be/abc\",\n+    ] {\n+        assert!(looks_like_url(raw), \"{raw}\");\n+    }\n+}\n+\n+#[test]\n+fn looks_like_url_negative_cases() {\n+    for raw in [\"alpha\", \"beta\", \"\", \"hello world\", \"no-dots\"] {\n+        assert!(!looks_like_url(raw), \"{raw}\");\n+    }\n+}\n+\n+#[test]\n+fn resolve_id_matches_canonicalize_raw() {\n+    let raw = \"https://youtu.be/xyz\";\n+    assert_eq!(\n+        resolve_id(raw).as_deref(),\n+        Some(canon(raw).as_str())\n+    );\n+}\n+\n+#[test]\n+fn canonicalize_empty_returns_none() {\n+    assert!(canonicalize_raw(\"\").is_none());\n+}\n+\n+#[test]\n+fn alias_when_slug_stripped() {\n+    let r = canonicalize_raw(\n+        \"https://reddit.com/r/rust/comments/aaa/very_long_title_slug\",\n+    )\n+    .unwrap();\n+    assert_eq!(r.canonical, \"https://reddit.com/r/rust/comments/aaa\");\n+    assert!(r.alias_of.is_some());\n+}\n+\n+#[test]\n+fn alias_none_when_already_canonical() {\n+    let raw = \"https://reddit.com/r/rust\";\n+    let r = canonicalize_raw(raw).unwrap();\n+    assert_eq!(r.canonical, raw);\n+    assert!(r.alias_of.is_none());\n+}\n+\n+#[test]\n+fn parent_url_subreddit_under_r_hub() {\n+    assert_eq!(\n+        parent_url(\"https://reddit.com/r/movies\").as_deref(),\n+        Some(\"https://reddit.com/r\")\n+    );\n+}\n+\n+#[test]\n+fn parent_url_domain_has_none() {\n+    assert_eq!(parent_url(\"https://reddit.com\").as_deref(), None);\n+}\n+\n+#[test]\n+fn parent_url_generic_site() {\n+    assert_eq!(\n+        parent_url(\"https://example.com/a/b\").as_deref(),\n+        Some(\"https://example.com/a\")\n+    );\n+}\n+\n+#[test]\n+fn breadcrumbs_from_canonical_string_roundtrip() {\n+    let id = \"https://reddit.com/r/golang/comments/abc123\";\n+    let crumbs = navigable_breadcrumbs(id);\n+    assert_eq!(crumbs.last().map(String::as_str), Some(id));\n+}\n+\n+// --- Table: Reddit raw URLs → canonical ---\n+\n+#[test]\n+fn reddit_canonical_matrix() {\n+    let cases: &[(&str, &str)] = &[\n+        (\"r/rust\", \"https://reddit.com/r/rust\"),\n+        (\"/r/aww\", \"https://reddit.com/r/aww\"),\n+        (\"https://reddit.com/r/rust\", \"https://reddit.com/r/rust\"),\n+        (\n+            \"https://www.reddit.com/r/programming/new\",\n+            \"https://reddit.com/r/programming\",\n+        ),\n+        (\n+            \"https://old.reddit.com/r/test/comments/xyz/slug/\",\n+            \"https://reddit.com/r/test/comments/xyz\",\n+        ),\n+        (\n+            \"reddit.com/r/Movies/comments/abc/Title_Case_Slug\",\n+            \"https://reddit.com/r/movies/comments/abc\",\n+        ),\n+    ];\n+    for (raw, want) in cases {\n+        assert_eq!(canon(raw), *want, \"raw={raw}\");\n+    }\n+}\n+\n+// --- Table: YouTube raw URLs → canonical ---\n+\n+#[test]\n+fn youtube_canonical_matrix() {\n+    let cases: &[(&str, &str)] = &[\n+        (\n+            \"https://youtube.com/watch?v=abc\",\n+            \"https://youtube.com/watch?v=abc\",\n+        ),\n+        (\n+            \"https://www.youtube.com/watch?v=abc&t=1&feature=share\",\n+            \"https://youtube.com/watch?v=abc\",\n+        ),\n+        (\"https://youtu.be/abc\", \"https://youtube.com/watch?v=abc\"),\n+        (\n+            \"https://youtube.com/shorts/abc\",\n+            \"https://youtube.com/watch?v=abc\",\n+        ),\n+    ];\n+    for (raw, want) in cases {\n+        assert_eq!(canon(raw), *want, \"raw={raw}\");\n+    }\n+}\n+\n+// --- Table: generic sites ---\n+\n+#[test]\n+fn generic_canonical_matrix() {\n+    let cases: &[(&str, &str)] = &[\n+        (\n+            \"https://news.ycombinator.com/item?id=38472\",\n+            \"https://news.ycombinator.com/item?id=38472\",\n+        ),\n+        (\n+            \"https://www.github.com/rust-lang/rust/issues/1?utm_source=x\",\n+            \"https://github.com/rust-lang/rust/issues/1\",\n+        ),\n+        (\"https://example.com\", \"https://example.com\"),\n+    ];\n+    for (raw, want) in cases {\n+        assert_eq!(canon(raw), *want, \"raw={raw}\");\n+    }\n+}\n+\n+// --- Phantom /comments/ regression (sorter2-specific) ---\n+\n+#[test]\n+fn phantom_comments_not_in_breadcrumbs_for_post() {\n+    let crumbs = navigable_breadcrumbs(\"https://reddit.com/r/rust/comments/aaa\");\n+    assert!(!crumbs.iter().any(|c| c.ends_with(\"/comments\")));\n+}\n+\n+#[test]\n+fn phantom_comments_not_sibling_of_subreddit_in_breadcrumb_chain() {\n+    let crumbs = navigable_breadcrumbs(\"https://reddit.com/r/rust/comments/aaa\");\n+    let subs: Vec<_> = crumbs\n+        .iter()\n+        .filter(|c| c.contains(\"/r/rust\") && !c.contains(\"/comments/\"))\n+        .collect();\n+    assert_eq!(subs, vec![\"https://reddit.com/r/rust\"]);\n+}\n+\n+// --- Distinct items must stay distinct ---\n+\n+#[test]\n+fn different_posts_different_canonical() {\n+    let a = canon(\"https://reddit.com/r/rust/comments/aaa\");\n+    let b = canon(\"https://reddit.com/r/rust/comments/bbb\");\n+    assert_ne!(a, b);\n+}\n+\n+#[test]\n+fn different_subreddits_different_canonical() {\n+    assert_ne!(\n+        canon(\"https://reddit.com/r/rust\"),\n+        canon(\"https://reddit.com/r/golang\")\n+    );\n+}\n","role":"user"}],"model":"openai/gpt-chat-latest"}