{"messages":[{"content":"You are ranking individual git commits to an open source project.\nCompare these two commits. Decide which commit contributed more.\nReturn ONLY a JSON object: {\"winner\": \"A\" or \"B\", \"ratio\": \"N:M\", \"explanation\": \"...\"}\n\nSide A — contributor: tommy-mor\nSide A — commit message:\n[154888ab] nit\n\nSide A — unified diff (full patch):\ndiff --git a/server/src/html/forum.rs b/server/src/html/forum.rs\nindex 670f5209c1e172b75156ef1b88ea382c70242062..691ee1dfe19c6b1800062701436d5ddcf7247d2a 100644\n--- a/server/src/html/forum.rs\n+++ b/server/src/html/forum.rs\n@@ -467,12 +467,7 @@ fn new_thread_form_public(show: bool) -> Markup {\n     html! {\n         section class=\"compose\" id=\"public-new-thread-compose\" {\n             div id=\"public-new-thread-errors\" {}\n-            form id=\"public-new-thread-form\" method=\"POST\" action=\"/ui\" data-check-action=\"/ui\" data-check-rpc=(template_json_compact(&json!({\n-                \"action\": \"check_ingest\",\n-                \"room\": \"public\",\n-                \"thread_tag\": {\"$form\": \"thread_tag\"},\n-                \"text\": {\"$form\": \"text\"},\n-            })).unwrap()) {\n+            form id=\"public-new-thread-form\" method=\"POST\" action=\"/ui\" {\n                 input type=\"hidden\" name=(UI_RPC_FIELD) value=(template_json_compact(&json!({\n                     \"action\": \"post_ingest\",\n                     \"room\": \"public\",\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"}