{"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[8d8230d1] reddit\n\nSide A — unified diff (full patch):\ndiff --git a/.gitignore b/.gitignore\nindex 4c7073f9fac0c30fd2050d79a60ef447af58ebeb..ada462e900d24a3a6d08165d158c80f79c35a5a5 100644\n--- a/.gitignore\n+++ b/.gitignore\n@@ -7,3 +7,4 @@\n data/\n repomix-output.xml\n dev-data/\n+.env\ndiff --git a/server/Cargo.toml b/server/Cargo.toml\nindex 7906a8547d56b8e6a48ef59c37aa82a8510fdee9..4677fedcb45292eebebe7e9cf6ce2f5738f18ddf 100644\n--- a/server/Cargo.toml\n+++ b/server/Cargo.toml\n@@ -16,6 +16,7 @@ tower = \"0.5\"\n tower-http = { version = \"0.5\", features = [\"trace\"] }\n tracing = \"0.1\"\n tracing-subscriber = { version = \"0.3\", features = [\"env-filter\"] }\n+reqwest = { version = \"0.12\", features = [\"json\"] }\n \n [dev-dependencies]\n reqwest = { version = \"0.12\", features = [\"json\"] }\ndiff --git a/server/src/html/mod.rs b/server/src/html/mod.rs\nindex 2864407ed6e8ec284a1dc663acf1805534566b62..df6505021d9f446c2b453e20e3eb3cf696a111f9 100644\n--- a/server/src/html/mod.rs\n+++ b/server/src/html/mod.rs\n@@ -272,5 +272,16 @@ pub async fn home(State(state): State<AppState>, uri: Uri) -> impl IntoResponse\n \n pub async fn browse(State(state): State<AppState>, uri: Uri) -> impl IntoResponse {\n     let item = ItemId::from_browse_uri(uri.path()).unwrap_or(ItemId::root());\n+    if item.as_str().starts_with(\"reddit.com\") {\n+        let needs_fetch = {\n+            let tree = state.tree.read().await;\n+            tree.get(&item)\n+                .map(|n| n.data.is_none())\n+                .unwrap_or(true)\n+        };\n+        if needs_fetch {\n+            state.reddit.request_fetch(item.clone());\n+        }\n+    }\n     item_page(state, uri, item).await\n }\ndiff --git a/server/src/reddit.rs b/server/src/reddit.rs\nindex d203dca09245daf869b3aa942898447700ae69fb..90053ad03b1d7c8e94f325dd4ee64c2b4f7da900 100644\n--- a/server/src/reddit.rs\n+++ b/server/src/reddit.rs\n@@ -1,4 +1,12 @@\n-//! Reddit API import (async, decoupled from UI request path).\n+//! Reddit API import via a single background worker (rate limits, dedup, backoff).\n+\n+use std::collections::{HashMap, HashSet};\n+use std::sync::Arc;\n+use std::time::{Duration, Instant};\n+\n+use reqwest::{header, Client, StatusCode};\n+use serde::Deserialize;\n+use tokio::sync::{mpsc, RwLock};\n \n use crate::{\n     path_types::ItemId,\n@@ -10,12 +18,401 @@ pub fn ensure_partial_tree(tree: &mut GlobalTree, id: &ItemId) {\n     tree.ensure_path(id);\n }\n \n-/// Placeholder for Reddit JSON import. Returns entity data when implemented.\n-pub async fn fetch_reddit_entity(_id: &ItemId) -> Option<EntityData> {\n-    None\n+pub struct RedditCommand {\n+    pub id: ItemId,\n+}\n+\n+#[derive(Clone)]\n+pub struct RedditBroker {\n+    tx: mpsc::Sender<RedditCommand>,\n+}\n+\n+#[derive(Clone)]\n+struct RedditCredentials {\n+    client_id: String,\n+    client_secret: String,\n+}\n+\n+struct OAuthToken {\n+    access_token: String,\n+    expires_at: Instant,\n+}\n+\n+impl RedditBroker {\n+    pub fn spawn(tree: Arc<RwLock<GlobalTree>>, user_agent: &str) -> Self {\n+        let (tx, rx) = mpsc::channel(100);\n+\n+        let mut headers = header::HeaderMap::new();\n+        headers.insert(\n+            header::USER_AGENT,\n+            header::HeaderValue::from_str(user_agent).expect(\"valid user agent\"),\n+        );\n+\n+        let client = Client::builder()\n+            .default_headers(headers)\n+            .timeout(Duration::from_secs(15))\n+            .build()\n+            .expect(\"reqwest client\");\n+\n+        let creds = RedditCredentials::from_env();\n+        tokio::spawn(reddit_worker(rx, tree, client, creds));\n+\n+        Self { tx }\n+    }\n+\n+    /// Fire-and-forget: queue a fetch; worker updates the tree when done.\n+    pub fn request_fetch(&self, id: ItemId) {\n+        let _ = self.tx.try_send(RedditCommand { id });\n+    }\n+}\n+\n+impl RedditCredentials {\n+    fn from_env() -> Option<Self> {\n+        let client_id = std::env::var(\"REDDIT_CLIENT_ID\").ok()?;\n+        let client_secret = std::env::var(\"REDDIT_CLIENT_SECRET\").ok()?;\n+        if client_id.is_empty() || client_secret.is_empty() {\n+            return None;\n+        }\n+        Some(Self {\n+            client_id,\n+            client_secret,\n+        })\n+    }\n+}\n+\n+pub fn default_user_agent() -> String {\n+    std::env::var(\"REDDIT_USER_AGENT\").unwrap_or_else(|_| {\n+        \"web:sorter2.social:v0.0.1 (by /u/sorter2)\".to_string()\n+    })\n }\n \n-/// Apply fetched entity data to a node (called from async worker).\n-pub fn apply_entity(tree: &mut GlobalTree, id: &ItemId, data: EntityData) {\n-    tree.set_entity_data(id, data);\n+async fn reddit_worker(\n+    mut rx: mpsc::Receiver<RedditCommand>,\n+    tree: Arc<RwLock<GlobalTree>>,\n+    client: Client,\n+    creds: Option<RedditCredentials>,\n+) {\n+    let mut in_flight = HashSet::new();\n+    let mut recently_fetched: HashMap<ItemId, Instant> = HashMap::new();\n+    let mut current_delay = Duration::from_secs(1);\n+    let mut oauth: Option<OAuthToken> = None;\n+    let cache_ttl = Duration::from_secs(300);\n+\n+    while let Some(cmd) = rx.recv().await {\n+        let now = Instant::now();\n+        recently_fetched.retain(|_, t| now.duration_since(*t) < cache_ttl);\n+\n+        if in_flight.contains(&cmd.id) || recently_fetched.contains_key(&cmd.id) {\n+            continue;\n+        }\n+\n+        in_flight.insert(cmd.id.clone());\n+        let fetch_id = cmd.id.clone();\n+\n+        tokio::time::sleep(current_delay).await;\n+\n+        if let Some(c) = &creds {\n+            oauth = ensure_oauth_token(&client, c, oauth.take()).await;\n+        }\n+\n+        let token = oauth.as_ref().map(|t| t.access_token.as_str());\n+        let use_oauth = token.is_some();\n+\n+        match do_fetch(&client, &fetch_id, use_oauth, token).await {\n+            Ok(FetchOutcome::Entity(data)) => {\n+                let mut w = tree.write().await;\n+                w.set_entity_data(&fetch_id, data);\n+                recently_fetched.insert(fetch_id.clone(), Instant::now());\n+                current_delay = Duration::from_millis(600);\n+            }\n+            Ok(FetchOutcome::NotFound) => {\n+                recently_fetched.insert(fetch_id.clone(), Instant::now());\n+            }\n+            Ok(FetchOutcome::RateLimited { reset_secs }) => {\n+                let wait = Duration::from_secs(reset_secs.max(1));\n+                tracing::warn!(\n+                    \"Reddit rate limit for {}; sleeping {}s\",\n+                    fetch_id,\n+                    wait.as_secs()\n+                );\n+                tokio::time::sleep(wait).await;\n+                current_delay = (current_delay * 2).min(Duration::from_secs(60));\n+            }\n+            Err(e) => {\n+                tracing::warn!(\"Reddit fetch failed for {}: {}\", fetch_id, e);\n+                current_delay = (current_delay * 2).min(Duration::from_secs(60));\n+            }\n+        }\n+\n+        in_flight.remove(&fetch_id);\n+    }\n+}\n+\n+enum FetchOutcome {\n+    Entity(EntityData),\n+    NotFound,\n+    RateLimited { reset_secs: u64 },\n+}\n+\n+async fn ensure_oauth_token(\n+    client: &Client,\n+    creds: &RedditCredentials,\n+    existing: Option<OAuthToken>,\n+) -> Option<OAuthToken> {\n+    if let Some(t) = existing {\n+        if Instant::now() < t.expires_at - Duration::from_secs(60) {\n+            return Some(t);\n+        }\n+    }\n+\n+    let resp = client\n+        .post(\"https://www.reddit.com/api/v1/access_token\")\n+        .basic_auth(&creds.client_id, Some(&creds.client_secret))\n+        .form(&[(\"grant_type\", \"client_credentials\")])\n+        .send()\n+        .await;\n+\n+    let resp = match resp {\n+        Ok(r) => r,\n+        Err(e) => {\n+            tracing::warn!(\"Reddit OAuth token request failed: {e}\");\n+            return None;\n+        }\n+    };\n+\n+    if !resp.status().is_success() {\n+        tracing::warn!(\"Reddit OAuth token HTTP {}\", resp.status());\n+        return None;\n+    }\n+\n+    #[derive(Deserialize)]\n+    struct TokenResponse {\n+        access_token: String,\n+        expires_in: u64,\n+    }\n+\n+    let body: TokenResponse = match resp.json().await {\n+        Ok(b) => b,\n+        Err(e) => {\n+            tracing::warn!(\"Reddit OAuth token parse failed: {e}\");\n+            return None;\n+        }\n+    };\n+\n+    Some(OAuthToken {\n+        access_token: body.access_token,\n+        expires_at: Instant::now() + Duration::from_secs(body.expires_in),\n+    })\n+}\n+\n+async fn do_fetch(\n+    client: &Client,\n+    id: &ItemId,\n+    use_oauth: bool,\n+    bearer: Option<&str>,\n+) -> Result<FetchOutcome, String> {\n+    let url = map_item_to_reddit_api(id, use_oauth);\n+    if url.is_empty() {\n+        return Ok(FetchOutcome::NotFound);\n+    }\n+\n+    let mut req = client.get(&url);\n+    if let Some(token) = bearer {\n+        req = req.bearer_auth(token);\n+    }\n+\n+    let resp = req.send().await.map_err(|e| e.to_string())?;\n+\n+    if resp.status() == StatusCode::TOO_MANY_REQUESTS {\n+        let reset = rate_limit_reset_secs(&resp);\n+        return Ok(FetchOutcome::RateLimited { reset_secs: reset });\n+    }\n+\n+    if resp.status() == StatusCode::SERVICE_UNAVAILABLE {\n+        return Err(\"Reddit unavailable (503)\".to_string());\n+    }\n+\n+    if !resp.status().is_success() {\n+        return Ok(FetchOutcome::NotFound);\n+    }\n+\n+    if rate_limit_remaining(&resp) == Some(0) {\n+        let reset = rate_limit_reset_secs(&resp);\n+        return Ok(FetchOutcome::RateLimited { reset_secs: reset });\n+    }\n+\n+    let bytes = resp.bytes().await.map_err(|e| e.to_string())?;\n+    Ok(parse_reddit_json(id, &bytes)\n+        .map(FetchOutcome::Entity)\n+        .unwrap_or(FetchOutcome::NotFound))\n+}\n+\n+fn rate_limit_remaining(resp: &reqwest::Response) -> Option<u64> {\n+    resp.headers()\n+        .get(\"x-ratelimit-remaining\")\n+        .and_then(|v| v.to_str().ok())\n+        .and_then(|s| s.parse::<f64>().ok())\n+        .map(|f| f.floor() as u64)\n+}\n+\n+fn rate_limit_reset_secs(resp: &reqwest::Response) -> u64 {\n+    resp.headers()\n+        .get(\"x-ratelimit-reset\")\n+        .and_then(|v| v.to_str().ok())\n+        .and_then(|s| s.parse::<f64>().ok())\n+        .map(|f| f.ceil() as u64)\n+        .unwrap_or(5)\n+}\n+\n+/// Map canonical item id to Reddit JSON API URL.\n+pub fn map_item_to_reddit_api(id: &ItemId, oauth: bool) -> String {\n+    let path = id.as_str();\n+    if !path.starts_with(\"reddit.com/\") && path != \"reddit.com\" {\n+        return String::new();\n+    }\n+\n+    let base = if oauth {\n+        \"https://oauth.reddit.com\"\n+    } else {\n+        \"https://www.reddit.com\"\n+    };\n+\n+    let segments: Vec<&str> = path.split('/').collect();\n+\n+    if let Some(i) = segments.iter().position(|&p| p == \"comments\") {\n+        if segments.len() > i + 1 {\n+            let api_path = segments[1..=i + 1].join(\"/\");\n+            return format!(\"{base}/{api_path}.json?raw_json=1\");\n+        }\n+    }\n+\n+    if segments.len() == 3 && segments[1] == \"r\" {\n+        return format!(\"{base}/r/{}/about.json?raw_json=1\", segments[2]);\n+    }\n+\n+    String::new()\n+}\n+\n+fn parse_reddit_json(id: &ItemId, bytes: &[u8]) -> Option<EntityData> {\n+    let v: serde_json::Value = serde_json::from_slice(bytes).ok()?;\n+    let segments: Vec<&str> = id.as_str().split('/').collect();\n+\n+    if segments.iter().any(|&p| p == \"comments\") {\n+        parse_post_listing(&v)\n+    } else {\n+        parse_subreddit_about(&v)\n+    }\n+}\n+\n+fn parse_subreddit_about(v: &serde_json::Value) -> Option<EntityData> {\n+    let data = v.get(\"data\")?;\n+    let title = data\n+        .get(\"title\")\n+        .or_else(|| data.get(\"display_name\"))\n+        .and_then(|t| t.as_str())?\n+        .to_string();\n+    let body_html = data\n+        .get(\"public_description_html\")\n+        .or_else(|| data.get(\"public_description\"))\n+        .and_then(|t| t.as_str())\n+        .map(|s| s.to_string());\n+    let thumb_url = data\n+        .get(\"icon_img\")\n+        .or_else(|| data.get(\"community_icon\"))\n+        .and_then(|t| t.as_str())\n+        .filter(|s| !s.is_empty())\n+        .map(|s| s.to_string());\n+\n+    Some(EntityData {\n+        title,\n+        author: None,\n+        body_html,\n+        thumb_url,\n+    })\n+}\n+\n+fn parse_post_listing(v: &serde_json::Value) -> Option<EntityData> {\n+    let listing = v.as_array()?.first()?;\n+    let child = listing\n+        .pointer(\"/data/children/0/data\")?;\n+    let title = child.get(\"title\")?.as_str()?.to_string();\n+    let author = child\n+        .get(\"author\")\n+        .and_then(|a| a.as_str())\n+        .filter(|a| *a != \"[deleted]\")\n+        .map(|s| s.to_string());\n+    let body_html = child\n+        .get(\"selftext_html\")\n+        .and_then(|t| t.as_str())\n+        .filter(|s| !s.is_empty())\n+        .map(|s| s.to_string());\n+    let thumb_url = child\n+        .get(\"thumbnail\")\n+        .and_then(|t| t.as_str())\n+        .filter(|s| s.starts_with(\"http\"))\n+        .map(|s| s.to_string());\n+\n+    Some(EntityData {\n+        title,\n+        author,\n+        body_html,\n+        thumb_url,\n+    })\n+}\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+\n+    #[test]\n+    fn map_subreddit_about_url() {\n+        let id = ItemId::parse(\"reddit.com/r/rust\").unwrap();\n+        assert_eq!(\n+            map_item_to_reddit_api(&id, false),\n+            \"https://www.reddit.com/r/rust/about.json?raw_json=1\"\n+        );\n+        assert_eq!(\n+            map_item_to_reddit_api(&id, true),\n+            \"https://oauth.reddit.com/r/rust/about.json?raw_json=1\"\n+        );\n+    }\n+\n+    #[test]\n+    fn map_post_url() {\n+        let id =\n+            ItemId::parse(\"reddit.com/r/amitheasshole/comments/1trnvdl\").unwrap();\n+        assert_eq!(\n+            map_item_to_reddit_api(&id, false),\n+            \"https://www.reddit.com/r/amitheasshole/comments/1trnvdl.json?raw_json=1\"\n+        );\n+    }\n+\n+    #[test]\n+    fn map_non_reddit_empty() {\n+        let id = ItemId::opaque(\"example.com/foo\");\n+        assert!(map_item_to_reddit_api(&id, false).is_empty());\n+    }\n+\n+    #[test]\n+    fn parse_subreddit_fixture() {\n+        let json = r#\"{\"kind\":\"t5\",\"data\":{\"title\":\"Rust\",\"display_name\":\"rust\",\"public_description\":\"systems\"}}\"#;\n+        let entity = parse_reddit_json(\n+            &ItemId::parse(\"reddit.com/r/rust\").unwrap(),\n+            json.as_bytes(),\n+        )\n+        .unwrap();\n+        assert_eq!(entity.title, \"Rust\");\n+    }\n+\n+    #[test]\n+    fn parse_post_fixture() {\n+        let json = r#\"[{\"kind\":\"Listing\",\"data\":{\"children\":[{\"kind\":\"t3\",\"data\":{\"title\":\"AITA\",\"author\":\"op\",\"selftext_html\":\"&lt;p&gt;hi&lt;/p&gt;\",\"thumbnail\":\"https://b.thumbs.redditmedia.com/x.jpg\"}}]}}]\"#;\n+        let entity = parse_reddit_json(\n+            &ItemId::parse(\"reddit.com/r/x/comments/abc\").unwrap(),\n+            json.as_bytes(),\n+        )\n+        .unwrap();\n+        assert_eq!(entity.title, \"AITA\");\n+        assert_eq!(entity.author.as_deref(), Some(\"op\"));\n+    }\n }\ndiff --git a/server/src/state.rs b/server/src/state.rs\nindex cc1722f5a5bf4d415f2327ea585c488a15a75592..8c03aa60c15aee803a534439400b69935b1a3d84 100644\n--- a/server/src/state.rs\n+++ b/server/src/state.rs\n@@ -5,9 +5,10 @@ use tokio::sync::RwLock;\n use crate::{\n     event_log::EventLog,\n     events::Event,\n+    journal::JournalClient,\n     path_types::ItemId,\n+    reddit::{default_user_agent, RedditBroker},\n     reducer::{GlobalTree, VoteData},\n-    journal::JournalClient,\n     views::ViewStore,\n };\n \n@@ -73,6 +74,7 @@ pub struct AppState {\n     pub views: ViewStore,\n     pub tree: Arc<RwLock<GlobalTree>>,\n     journal: JournalClient,\n+    pub reddit: RedditBroker,\n }\n \n impl AppState {\n@@ -112,6 +114,7 @@ impl AppState {\n \n         let tree = Arc::new(RwLock::new(tree));\n         let journal = JournalClient::spawn(tree.clone(), event_log.clone());\n+        let reddit = RedditBroker::spawn(tree.clone(), &default_user_agent());\n \n         Self {\n             cfg: Arc::new(cfg),\n@@ -119,6 +122,7 @@ impl AppState {\n             views,\n             tree,\n             journal,\n+            reddit,\n         }\n     }\n \n@@ -127,8 +131,11 @@ impl AppState {\n             id: id.as_str().to_string(),\n         };\n         self.event_log.append(&event).await.map_err(|e| e.to_string())?;\n-        let mut w = self.tree.write().await;\n-        w.ensure_path(id);\n+        {\n+            let mut w = self.tree.write().await;\n+            w.ensure_path(id);\n+        }\n+        self.reddit.request_fetch(id.clone());\n         Ok(())\n     }\n \ndiff --git a/todo b/todo\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..d196e8cb4cc80ccb95eeff01c73607d520e13212\n--- /dev/null\n+++ b/todo\n@@ -0,0 +1,7 @@\n+reddit import (only on explicit request)\n+reddit rendering\n+vote redering\n+pair chosing\n+nsfw gate\n+\n+logins (uuid user, two sides, oauths, and pseudonyms)\n\n\nSide B — contributor: tommy-mor\nSide B — commit message:\n[a888d56c] refactor: centralize path identity in slug-types\n\nMove canonicalization and CanonicalItemUrl into types::paths with\nGardenItemUrl, ForumThreadUrl, and TildeOntologyPath for JSON hrefs.\nServer canonical_path and path_types re-export slug-types; RPC and\nvalidation build hrefs via those types instead of string helpers.\n\nMade-with: Cursor\n\nSide B — unified diff (full patch):\ndiff --git a/server/src/api/helpers.rs b/server/src/api/helpers.rs\nindex 9b71491e9f9efc44a2a4beba09be8f64bd2ff2ee..03b3e77911ccd662bec8635345dafe2593cf242e 100644\n--- a/server/src/api/helpers.rs\n+++ b/server/src/api/helpers.rs\n@@ -4,12 +4,12 @@ use axum::{\n     Json,\n };\n use sha2::{Digest, Sha256};\n+use slug_types::paths::{CanonicalItemUrl, GardenItemUrl};\n use slug_types::*;\n use std::collections::HashMap;\n \n use crate::{\n     canonical_path::canonicalize_item,\n-    path_types::CanonicalItemUrl,\n     ranking::connected_components_from_voted_pairs,\n };\n \n@@ -30,64 +30,6 @@ pub fn now_ms() -> i64 {\n     t.as_millis() as i64\n }\n \n-/// Serialize a canonical item for JSON: absolute URLs stay as-is; bare paths get a `/` prefix.\n-pub fn item_path_for_api(item: &str) -> String {\n-    if item.starts_with(\"http://\") || item.starts_with(\"https://\") {\n-        item.to_string()\n-    } else {\n-        format!(\"/{}\", item)\n-    }\n-}\n-\n-/// Same as [`item_path_for_api`], but for private rooms ontology items are prefixed with\n-/// `/r/{short}/{slug}` so the URL matches the web app (`/r/…/~/…` routes).\n-pub fn item_path_for_api_in_room(item: &str, room_wire: &str) -> String {\n-    let room = room_wire.trim();\n-    if room.is_empty() || room == \"public\" {\n-        return item_path_for_api(item);\n-    }\n-    let Some((short, slug)) = room.split_once('/') else {\n-        return item_path_for_api(item);\n-    };\n-    if short.is_empty() || slug.is_empty() {\n-        return item_path_for_api(item);\n-    }\n-    let Some(c) = CanonicalItemUrl::parse(item) else {\n-        return item_path_for_api(item);\n-    };\n-    let root = CanonicalItemUrl::ontology_root();\n-    let item_norm = c.as_str().trim_end_matches('/');\n-    let root_norm = root.as_str().trim_end_matches('/');\n-    if let Some(tail) = c.tilde_tail() {\n-        return if tail.is_empty() {\n-            format!(\"https://slug.social/r/{short}/{slug}/~\")\n-        } else {\n-            format!(\"https://slug.social/r/{short}/{slug}/~/{}\", tail)\n-        };\n-    }\n-    if item_norm == root_norm {\n-        return format!(\"https://slug.social/r/{short}/{slug}/~\");\n-    }\n-    item_path_for_api(item)\n-}\n-\n-/// Absolute thread URL for forum JSON (`/t/…` vs `/r/…/t/…`).\n-pub fn forum_thread_web_url(room_wire: &str, thread_tag: &str) -> String {\n-    let room = room_wire.trim();\n-    let tag = thread_tag.trim().trim_start_matches('#');\n-    if room.is_empty() || room == \"public\" {\n-        format!(\"https://slug.social/t/{tag}\")\n-    } else if let Some((short, slug)) = room.split_once('/') {\n-        if short.is_empty() || slug.is_empty() {\n-            format!(\"https://slug.social/t/{tag}\")\n-        } else {\n-            format!(\"https://slug.social/r/{short}/{slug}/t/{tag}\")\n-        }\n-    } else {\n-        format!(\"https://slug.social/t/{tag}\")\n-    }\n-}\n-\n /// Resolve an item path as a first-class canonical path.\n pub fn resolve_item(item: &str) -> Result<String, String> {\n     let canonical = canonicalize_item(item);\n@@ -109,14 +51,12 @@ pub fn parse_parent_specs(parent: Option<&String>) -> Vec<String> {\n }\n \n /// Apply offset+limit pagination to the flattened component rankings.\n-/// Items are flattened in component order (largest component first), then unranked last.\n-/// Returns (components, unranked_items) after the window.\n pub fn paginate_rankings(\n     components: Vec<RankComponent>,\n-    unranked_items: Vec<String>,\n+    unranked_items: Vec<GardenItemUrl>,\n     offset: usize,\n     limit: Option<usize>,\n-) -> (Vec<RankComponent>, Vec<String>) {\n+) -> (Vec<RankComponent>, Vec<GardenItemUrl>) {\n     let mut remaining_skip = offset;\n     let mut remaining_take = limit.unwrap_or(usize::MAX);\n     let mut out_components: Vec<RankComponent> = Vec::new();\n@@ -141,7 +81,7 @@ pub fn paginate_rankings(\n         });\n     }\n \n-    let out_unranked: Vec<String> = if remaining_take > 0 {\n+    let out_unranked: Vec<GardenItemUrl> = if remaining_take > 0 {\n         unranked_items\n             .into_iter()\n             .skip(remaining_skip)\n@@ -183,11 +123,9 @@ pub fn is_pair_voted(group: &crate::reducer::GroupState, a: &str, b: &str) -> bo\n     group.voted_pairs.contains(&(i, j))\n }\n \n-/// Compute graph connectivity stats for a set of items within the ranking group.\n pub fn compute_connectivity_stats(group: &crate::reducer::GroupState, pool: &[String]) -> ConnectivityStats {\n     let n = pool.len();\n \n-    // Map pool items to global indices (items not yet in the group get no index)\n     let global_idxs: Vec<Option<usize>> = pool\n         .iter()\n         .map(|it| {\n@@ -197,7 +135,6 @@ pub fn compute_connectivity_stats(group: &crate::reducer::GroupState, pool: &[St\n         .collect();\n     let present: Vec<usize> = global_idxs.iter().filter_map(|x| *x).collect();\n \n-    // Build local index mapping for items that exist in the ranking group\n     let global_to_local: HashMap<usize, usize> = present\n         .iter()\n         .enumerate()\n@@ -213,7 +150,6 @@ pub fn compute_connectivity_stats(group: &crate::reducer::GroupState, pool: &[St\n         }),\n     );\n \n-    // Items not in the ranking group at all are also isolates\n     let items_not_in_group = global_idxs.iter().filter(|x| x.is_none()).count();\n \n     let num_components = comps.len() + isolates.len() + items_not_in_group;\n@@ -237,52 +173,3 @@ pub fn vote_touches_path(a: &str, b: &str, parent_canon: &str) -> bool {\n     let under = |item: &str| item == parent_canon || item.starts_with(&format!(\"{}/\", parent_canon));\n     under(a) || under(b)\n }\n-\n-#[cfg(test)]\n-mod wire_url_tests {\n-    use super::{forum_thread_web_url, item_path_for_api_in_room};\n-\n-    #[test]\n-    fn public_room_unchanged() {\n-        let u = \"https://slug.social/~/a/b\";\n-        assert_eq!(item_path_for_api_in_room(u, \"public\"), u);\n-    }\n-\n-    #[test]\n-    fn private_room_prefixes_ontology() {\n-        assert_eq!(\n-            item_path_for_api_in_room(\"https://slug.social/~/topic/x\", \"9ab12cd/my-room\"),\n-            \"https://slug.social/r/9ab12cd/my-room/~/topic/x\"\n-        );\n-    }\n-\n-    #[test]\n-    fn private_room_ontology_root() {\n-        assert_eq!(\n-            item_path_for_api_in_room(\"https://slug.social/~\", \"9ab12cd/my-room\"),\n-            \"https://slug.social/r/9ab12cd/my-room/~\"\n-        );\n-        assert_eq!(\n-            item_path_for_api_in_room(\"https://slug.social/~/\", \"9ab12cd/my-room\"),\n-            \"https://slug.social/r/9ab12cd/my-room/~\"\n-        );\n-    }\n-\n-    #[test]\n-    fn external_url_untouched_in_private_room() {\n-        let u = \"https://example.com/z\";\n-        assert_eq!(item_path_for_api_in_room(u, \"9ab12cd/my-room\"), u);\n-    }\n-\n-    #[test]\n-    fn forum_web_public_vs_room() {\n-        assert_eq!(\n-            forum_thread_web_url(\"public\", \"debate\"),\n-            \"https://slug.social/t/debate\"\n-        );\n-        assert_eq!(\n-            forum_thread_web_url(\"9ab12cd/my-room\", \"#debate\"),\n-            \"https://slug.social/r/9ab12cd/my-room/t/debate\"\n-        );\n-    }\n-}\ndiff --git a/server/src/api/mod.rs b/server/src/api/mod.rs\nindex 042aa248305f9362a3be78f9eea2a5abf6ba707a..cf22cb0129366c3aed031bc86f3197a4321cb806 100644\n--- a/server/src/api/mod.rs\n+++ b/server/src/api/mod.rs\n@@ -24,8 +24,7 @@ pub use auth::{\n \n pub use helpers::{\n     api_error, compute_connectivity_stats, is_pair_voted, now_ms, paginate_rankings,\n-    parse_parent_specs, pick_random_distinct, sha256_hex, resolve_item, vote_touches_path,\n-    item_path_for_api,\n+    parse_parent_specs, pick_random_distinct, resolve_item, sha256_hex, vote_touches_path,\n };\n \n pub use rpc::handle_rpc_batch;\ndiff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs\nindex 5b91f5836625eedbb1cd9423168046e3fb576c17..5f7d50188f1381267402f2e57e671234ef5db2fd 100644\n--- a/server/src/api/rpc.rs\n+++ b/server/src/api/rpc.rs\n@@ -8,6 +8,7 @@ use axum::{\n     Json,\n };\n use rand::seq::SliceRandom;\n+use slug_types::paths::{ForumThreadUrl, GardenItemUrl, TildeOntologyPath};\n use slug_types::*;\n \n use crate::{\n@@ -27,9 +28,8 @@ use crate::{\n \n use super::auth::verify_bearer_principal;\n use super::helpers::{\n-    compute_connectivity_stats, forum_thread_web_url, is_pair_voted, item_path_for_api,\n-    item_path_for_api_in_room, now_ms, paginate_rankings, parse_parent_specs, pick_random_distinct,\n-    resolve_item, vote_touches_path,\n+    compute_connectivity_stats, is_pair_voted, now_ms, paginate_rankings, parse_parent_specs,\n+    pick_random_distinct, resolve_item, vote_touches_path,\n };\n use super::validate::{normalize_room_and_thread, validate_ingest_document};\n \n@@ -184,7 +184,7 @@ fn compute_scope_rank_changes(\n         };\n         if changed {\n             changes.push(RankChange {\n-                item: item_path_for_api_in_room(&item, room_wire),\n+                item: GardenItemUrl::from_storage_str(&item, room_wire),\n                 before: b,\n                 after: a,\n             });\n@@ -206,7 +206,7 @@ fn compute_scope_rank_changes(\n         parent: if parent.is_empty() {\n             \"/\".to_string()\n         } else {\n-            item_path_for_api_in_room(parent, room_wire)\n+            GardenItemUrl::from_storage_str(parent, room_wire).into_inner()\n         },\n         changes,\n     })\n@@ -302,7 +302,7 @@ fn build_rank_response_for_content(\n                     .ranked\n                     .into_iter()\n                     .map(|r| RankRow {\n-                        item: item_path_for_api_in_room(r.item.as_str(), room_wire),\n+                        item: GardenItemUrl::from_stored(&r.item, room_wire),\n                         percent: if want_percent {\n                             Some((r.score / max_score) * 100.0)\n                         } else {\n@@ -315,10 +315,10 @@ fn build_rank_response_for_content(\n         })\n         .collect();\n \n-    let prefixed_unranked: Vec<String> = rankings\n+    let prefixed_unranked: Vec<GardenItemUrl> = rankings\n         .unranked_items\n         .into_iter()\n-        .map(|s| item_path_for_api_in_room(s.as_str(), room_wire))\n+        .map(|s| GardenItemUrl::from_stored(&s, room_wire))\n         .collect();\n \n     let (components, unranked_items) = if offset > 0 || limit.is_some() {\n@@ -537,13 +537,13 @@ async fn rpc_post(\n         (\n             \"npx slugsocial public garden pair\".to_string(),\n             \"npx slugsocial public garden rank\".to_string(),\n-            forum_thread_web_url(\"public\", &thread_id),\n+            ForumThreadUrl::from_room_tag(\"public\", &thread_id),\n         )\n     } else {\n         (\n             format!(\"npx slugsocial private {room_key} garden pair\"),\n             format!(\"npx slugsocial private {room_key} garden rank\"),\n-            forum_thread_web_url(&room_key, &thread_id),\n+            ForumThreadUrl::from_room_tag(&room_key, &thread_id),\n         )\n     };\n \n@@ -664,7 +664,7 @@ async fn rpc_check(\n                         .ranked\n                         .into_iter()\n                         .map(|r| RankRow {\n-                            item: item_path_for_api_in_room(r.item.as_str(), &room_key),\n+                            item: GardenItemUrl::from_stored(&r.item, &room_key),\n                             score: r.score,\n                             percent: None,\n                         })\n@@ -672,12 +672,12 @@ async fn rpc_check(\n                 })\n                 .collect();\n             CheckScopeRanking {\n-                parent: item_path_for_api_in_room(parent.as_str(), &room_key),\n+                parent: GardenItemUrl::from_stored(parent, &room_key).into_inner(),\n                 components,\n                 unranked_items: scoped\n                     .unranked_items\n                     .into_iter()\n-                    .map(|it| item_path_for_api_in_room(it.as_str(), &room_key))\n+                    .map(|it| GardenItemUrl::from_stored(&it, &room_key))\n                     .collect(),\n             }\n         })\n@@ -687,13 +687,13 @@ async fn rpc_check(\n         vec![\n             \"npx slugsocial public forum post <TAG> --delegate <uuid:rig:model>\".to_string(),\n             \"npx slugsocial public forum list\".to_string(),\n-            forum_thread_web_url(\"public\", &thread_id),\n+            ForumThreadUrl::from_room_tag(\"public\", &thread_id).into_inner(),\n         ]\n     } else {\n         vec![\n             format!(\"npx slugsocial private {room_key} forum post <TAG> --delegate <uuid:rig:model>\"),\n             format!(\"npx slugsocial private {room_key} forum list\"),\n-            forum_thread_web_url(&room_key, &thread_id),\n+            ForumThreadUrl::from_room_tag(&room_key, &thread_id).into_inner(),\n         ]\n     };\n \n@@ -717,7 +717,7 @@ fn rpc_list_forum_threads(reduced: &ReducerState, room: &str) -> ThreadsResponse\n         .map(|((_, tag), ts)| ThreadSummary {\n             thread: format!(\"#{tag}\"),\n             last_activity_ts: ts.last_activity_ts,\n-            web: forum_thread_web_url(room, tag),\n+            web: ForumThreadUrl::from_room_tag(room, tag),\n         })\n         .collect();\n     out.sort_by(|a, b| b.last_activity_ts.cmp(&a.last_activity_ts));\n@@ -885,7 +885,7 @@ fn rpc_search(reduced: &ReducerState, q: &str, limit: usize, principal: Option<&\n         }\n         if score > 0 {\n             scored_items.push((score, SearchItemHit {\n-                path: item_path_for_api(item.as_str()),\n+                path: GardenItemUrl::from_storage_str(item.as_str(), \"public\"),\n                 body: content.item_bodies.get(item).map(|b| snippet_around(b, &words, 120)),\n             }));\n         }\n@@ -1058,8 +1058,8 @@ async fn rpc_get_pair(state: &AppState, room: String, parent_path: String) -> Re\n         .collect();\n     let cs = compute_connectivity_stats(&content.ranking_group, &pool);\n     Ok(RpcResult::Pair(PairResponse {\n-        left: item_path_for_api_in_room(&left, &room),\n-        right: item_path_for_api_in_room(&right, &room),\n+        left: GardenItemUrl::from_storage_str(&left, &room),\n+        right: GardenItemUrl::from_storage_str(&right, &room),\n         left_body: lb,\n         right_body: rb,\n         threads: th,\n@@ -1137,7 +1137,7 @@ pub async fn handle_rpc_batch(\n                 if !content.items.contains(&item) {\n                     line_err(\n                         \"item not found\",\n-                        Some(format!(\"{} does not exist\", item_path_for_api_in_room(&item_str, &room))),\n+                        Some(format!(\"{} does not exist\", GardenItemUrl::from_storage_str(&item_str, &room))),\n                     )\n                 } else {\n                     const MAX_ITEM_BODY: usize = 10_000;\n@@ -1160,7 +1160,7 @@ pub async fn handle_rpc_batch(\n                         .map(|s| s.iter().cloned().collect())\n                         .unwrap_or_default();\n                     line_ok(RpcResult::GardenItem(ItemResponse {\n-                        item: item_path_for_api_in_room(&item_str, &room),\n+                        item: GardenItemUrl::from_storage_str(&item_str, &room),\n                         body,\n                         truncated,\n                         body_len,\n@@ -1554,7 +1554,7 @@ pub async fn handle_rpc_batch(\n                     for r in items {\n                         let pct = want_percent.then(|| ((r.score - bot) / range * 100.0).clamp(0.0, 100.0));\n                         ranked.push(RankRow {\n-                            item: item_path_for_api_in_room(r.item.as_str(), &room),\n+                            item: GardenItemUrl::from_storage_str(r.item.as_str(), &room),\n                             score: r.score,\n                             percent: pct,\n                         });\n@@ -1574,7 +1574,7 @@ pub async fn handle_rpc_batch(\n                 let page: Vec<RankRow> = ranked\n                     .into_iter()\n                     .chain(unranked.into_iter().map(|it| RankRow {\n-                        item: item_path_for_api_in_room(&it, &room),\n+                        item: GardenItemUrl::from_storage_str(&it, &room),\n                         score: 0.0,\n                         percent: want_percent.then_some(0.0),\n                     }))\n@@ -1618,7 +1618,7 @@ pub async fn handle_rpc_batch(\n                 if !content.items.contains(&item) {\n                     line_err(\n                         \"item not found\",\n-                        Some(format!(\"{} does not exist\", item_path_for_api_in_room(&item_str, &room))),\n+                        Some(format!(\"{} does not exist\", GardenItemUrl::from_storage_str(&item_str, &room))),\n                     )\n                 } else {\n                     let votes: Vec<VoteRow> = content\n@@ -1629,8 +1629,8 @@ pub async fn handle_rpc_batch(\n                                 .take(limit)\n                                 .map(|v| VoteRow {\n                                     ts: v.ts,\n-                                    a: item_path_for_api_in_room(v.a.as_str(), &room),\n-                                    b: item_path_for_api_in_room(v.b.as_str(), &room),\n+                                    a: GardenItemUrl::from_stored(&v.a, &room),\n+                                    b: GardenItemUrl::from_stored(&v.b, &room),\n                                     ratio: format!(\"{}:{}\", v.ratio_left, v.ratio_right),\n                                     actor: Some(v.principal.clone()),\n                                     body: v.body.clone(),\n@@ -1640,7 +1640,7 @@ pub async fn handle_rpc_batch(\n                         })\n                         .unwrap_or_default();\n                     line_ok(RpcResult::Matchup(MatchupResponse {\n-                        item: item_path_for_api_in_room(&item_str, &room),\n+                        item: GardenItemUrl::from_storage_str(&item_str, &room),\n                         votes,\n                     }))\n                 }\n@@ -1667,8 +1667,8 @@ pub async fn handle_rpc_batch(\n                                     if a == item_str || b == item_str {\n                                         Some(VoteRow {\n                                             ts: e.ts,\n-                                            a: item_path_for_api_in_room(&a, &room),\n-                                            b: item_path_for_api_in_room(&b, &room),\n+                                            a: GardenItemUrl::from_storage_str(&a, &room),\n+                                            b: GardenItemUrl::from_storage_str(&b, &room),\n                                             ratio: format!(\"{}:{}\", ratio_left, ratio_right),\n                                             actor: reduced.ingests_by_id.get(&e.post_id).map(|ing| ing.principal.clone()),\n                                             body: explanation,\n@@ -1704,7 +1704,7 @@ pub async fn handle_rpc_batch(\n                     }\n                 }).collect();\n                 line_ok(RpcResult::RankHistory(RankHistoryResponse {\n-                    item: item_path_for_api_in_room(&item_str, &room),\n+                    item: GardenItemUrl::from_storage_str(&item_str, &room),\n                     history,\n                 }))\n                 }\n@@ -1716,17 +1716,13 @@ pub async fn handle_rpc_batch(\n                 } else {\n                 let content = content_for_room(&reduced, &room);\n                 let parents: HashSet<&str> = content.item_children.keys().map(|s| s.as_str()).collect();\n-                let mut paths: Vec<String> = content\n+                let mut paths: Vec<GardenItemUrl> = content\n                     .items\n                     .iter()\n                     .filter(|p| !parents.contains(p.as_str()))\n-                    .map(|p| p.as_str().to_string())\n-                    .collect();\n-                paths.sort();\n-                let paths: Vec<String> = paths\n-                    .into_iter()\n-                    .map(|p| item_path_for_api_in_room(&p, &room))\n+                    .map(|p| GardenItemUrl::from_stored(p, &room))\n                     .collect();\n+                paths.sort_by(|a, b| a.as_str().cmp(b.as_str()));\n                 line_ok(RpcResult::Leaves(LeavesResponse { paths }))\n                 }\n             },\n@@ -1743,24 +1739,13 @@ pub async fn handle_rpc_batch(\n                         let mut v: Vec<PathSummary> = roots.iter()\n                             .map(|path| {\n                                 let children = content.item_children.get(path.as_str()).map(|s| s.len()).unwrap_or(0);\n-                                let path_label = CanonicalItemUrl::parse(path.as_str())\n-                                    .and_then(|c| {\n-                                        c.tilde_tail().map(|t| {\n-                                            if t.is_empty() {\n-                                                \"~/\".to_string()\n-                                            } else {\n-                                                format!(\"~/{}\", t)\n-                                            }\n-                                        })\n-                                    })\n-                                    .unwrap_or_else(|| path.to_string());\n                                 PathSummary {\n-                                    path: path_label,\n+                                    path: TildeOntologyPath::from_stored(path),\n                                     children,\n-                                    web: item_path_for_api_in_room(path.as_str(), &room),\n+                                    web: GardenItemUrl::from_stored(path, &room),\n                                 }\n                             }).collect();\n-                        v.sort_by(|a, b| a.path.cmp(&b.path));\n+                        v.sort_by(|a, b| a.path.as_str().cmp(b.path.as_str()));\n                         v\n                     })\n                     .unwrap_or_default();\n@@ -1790,8 +1775,8 @@ pub async fn handle_rpc_batch(\n                     .take(limit)\n                     .map(|v| VoteRow {\n                         ts: v.ts,\n-                        a: item_path_for_api_in_room(v.a.as_str(), &room),\n-                        b: item_path_for_api_in_room(v.b.as_str(), &room),\n+                        a: GardenItemUrl::from_stored(&v.a, &room),\n+                        b: GardenItemUrl::from_stored(&v.b, &room),\n                         ratio: format!(\"{}:{}\", v.ratio_left, v.ratio_right),\n                         actor: Some(v.principal.clone()),\n                         body: v.body.clone(),\ndiff --git a/server/src/api/validate.rs b/server/src/api/validate.rs\nindex 27150577982f52cbd6d11bb93654dc3d4cf75cc5..a51c783ee9785569b5a44c0b1572471fe00d174b 100644\n--- a/server/src/api/validate.rs\n+++ b/server/src/api/validate.rs\n@@ -7,8 +7,9 @@ use crate::{\n     path_types::CanonicalItemUrl,\n     reducer::{ReducerState, ScopeId},\n };\n+use slug_types::paths::GardenItemUrl;\n \n-use super::helpers::{item_path_for_api, resolve_item};\n+use super::helpers::resolve_item;\n \n #[derive(Debug)]\n pub struct ValidatedIngest {\n@@ -22,6 +23,10 @@ pub fn validate_ingest_document(\n     text: &str,\n     scope: &ScopeId,\n ) -> Result<ValidatedIngest, (StatusCode, String, Option<String>)> {\n+    let room_wire = match scope {\n+        ScopeId::Public => \"public\",\n+        ScopeId::Room(r) => r.as_str(),\n+    };\n     let public_content = reduced.public();\n     let scoped_content = match scope {\n         ScopeId::Public => None,\n@@ -61,14 +66,14 @@ pub fn validate_ingest_document(\n                 let Some(body_text) = body else {\n                     return Err((\n                         StatusCode::BAD_REQUEST,\n-                        format!(\"item missing body: {}\", item_path_for_api(&item)),\n+                        format!(\"item missing body: {}\", GardenItemUrl::from_storage_str(&item, room_wire)),\n                         Some(\"items must be declared with bodies, e.g. `~/path/item { ... }`\".to_string()),\n                     ));\n                 };\n                 if body_text.trim().is_empty() {\n                     return Err((\n                         StatusCode::BAD_REQUEST,\n-                        format!(\"item body is empty: {}\", item_path_for_api(&item)),\n+                        format!(\"item body is empty: {}\", GardenItemUrl::from_storage_str(&item, room_wire)),\n                         Some(\"write at least one sentence inside `{ ... }`\".to_string()),\n                     ));\n                 }\n@@ -101,7 +106,7 @@ pub fn validate_ingest_document(\n                         let key = CanonicalItemUrl((*it).clone());\n                         !defined_in_doc.contains(*it) && !item_exists(&key)\n                     })\n-                    .map(|it| item_path_for_api(it))\n+                    .map(|it| GardenItemUrl::from_storage_str(it, room_wire).into_inner())\n                     .collect();\n                 if !missing.is_empty() {\n                     return Err((\n@@ -119,7 +124,7 @@ pub fn validate_ingest_document(\n                         let key = CanonicalItemUrl((*it).clone());\n                         !defined_in_doc.contains(*it) && !body_exists(&key)\n                     })\n-                    .map(|it| item_path_for_api(it))\n+                    .map(|it| GardenItemUrl::from_storage_str(it, room_wire).into_inner())\n                     .collect();\n                 if !missing_body.is_empty() {\n                     return Err((\ndiff --git a/server/src/canonical_path.rs b/server/src/canonical_path.rs\nindex 5c0febe883d8b3978a25896ed0d71df8509a8717..8a1998025121838b0867f8c5ddbd28aea41a23d2 100644\n--- a/server/src/canonical_path.rs\n+++ b/server/src/canonical_path.rs\n@@ -1,92 +1,3 @@\n-//! Normalization for thread tags and ontology item URLs (DSL ↔ stored canonical form).\n-//! Not event types — see `events` and `path_types`.\n+//! Re-exports — implementations live in `slug-types` (`paths` module).\n \n-/// Thread / public tag: stored without leading `#`, lowercase.\n-pub fn canonicalize_tag(input: &str) -> String {\n-    input.trim().trim_start_matches('#').to_lowercase()\n-}\n-\n-/// Ontology item reference → canonical absolute URL on the slug host.\n-pub fn canonicalize_item(input: &str) -> String {\n-    let s = input.trim();\n-    if s.is_empty() {\n-        return String::new();\n-    }\n-\n-    if let Some(rest) = s.strip_prefix(\"https://\") {\n-        let (host, tail) = rest.split_once('/').map_or((rest, \"\"), |(h, t)| (h, t));\n-        let host = host.trim().to_lowercase();\n-        if tail.is_empty() {\n-            return format!(\"https://{}\", host);\n-        } else {\n-            return format!(\"https://{}/{}\", host, tail);\n-        }\n-    }\n-    if let Some(rest) = s.strip_prefix(\"http://\") {\n-        let (host, tail) = rest.split_once('/').map_or((rest, \"\"), |(h, t)| (h, t));\n-        let host = host.trim().to_lowercase();\n-        if tail.is_empty() {\n-            return format!(\"http://{}\", host);\n-        } else {\n-            return format!(\"http://{}/{}\", host, tail);\n-        }\n-    }\n-\n-    let is_tilde = s.starts_with(\"~/\");\n-    let rest = s.strip_prefix(\"~/\").or_else(|| s.strip_prefix(\"/\")).unwrap_or(s);\n-\n-    let tail = rest\n-        .split('/')\n-        .filter_map(|seg| {\n-            let t = seg.trim();\n-            if t.is_empty() {\n-                None\n-            } else {\n-                Some(t.to_lowercase())\n-            }\n-        })\n-        .collect::<Vec<_>>()\n-        .join(\"/\");\n-\n-    if is_tilde {\n-        format!(\"https://slug.social/~/{}\", tail)\n-    } else if tail.is_empty() {\n-        \"https://slug.social\".to_string()\n-    } else {\n-        format!(\"https://slug.social/{}\", tail)\n-    }\n-}\n-\n-pub fn item_path_segments(input: &str) -> Vec<String> {\n-    let canonical = canonicalize_item(input);\n-    if canonical.is_empty() {\n-        return vec![];\n-    }\n-\n-    if let Some(rest) = canonical.strip_prefix(\"https://\") {\n-        let (host, tail) = rest.split_once('/').map_or((rest, \"\"), |(h, t)| (h, t));\n-        let mut out = vec![format!(\"https://{}\", host)];\n-        out.extend(tail.split('/').filter(|s| !s.is_empty()).map(|s| s.to_string()));\n-        return out;\n-    }\n-    if let Some(rest) = canonical.strip_prefix(\"http://\") {\n-        let (host, tail) = rest.split_once('/').map_or((rest, \"\"), |(h, t)| (h, t));\n-        let mut out = vec![format!(\"http://{}\", host)];\n-        out.extend(tail.split('/').filter(|s| !s.is_empty()).map(|s| s.to_string()));\n-        return out;\n-    }\n-\n-    canonical\n-        .split('/')\n-        .filter(|s| !s.is_empty())\n-        .map(|s| s.to_string())\n-        .collect()\n-}\n-\n-pub fn item_parent_path(input: &str) -> Option<String> {\n-    let segs = item_path_segments(input);\n-    if segs.len() <= 1 {\n-        return None;\n-    }\n-    Some(segs[..segs.len() - 1].join(\"/\"))\n-}\n+pub use slug_types::paths::{canonicalize_item, canonicalize_tag, item_parent_path, item_path_segments};\ndiff --git a/server/src/html/forum.rs b/server/src/html/forum.rs\nindex ab7970feca47a4431ddc19dab2c8186180b78413..f789e347dc136f8ffd356f4492f0bd76cea04bf0 100644\n--- a/server/src/html/forum.rs\n+++ b/server/src/html/forum.rs\n@@ -697,7 +697,7 @@ async fn thread_view_inner(\n     let offset = q.offset.unwrap_or(0);\n     let page_ids: Vec<String> = all_ids.into_iter().skip(offset).take(PAGE_SIZE).collect();\n \n-    let (display_ingests, subtitle) = {\n+    let (display_ingests, _subtitle) = {\n         let reduced = state.reduced.read().await;\n         let ingests = page_ids\n             .iter()\ndiff --git a/server/src/path_types.rs b/server/src/path_types.rs\nindex cad58cac7da948f92d6ea2a5587d917ab21d57ea..4c8075bbd488f1b9a5eda9e03ced83f6238c6d5e 100644\n--- a/server/src/path_types.rs\n+++ b/server/src/path_types.rs\n@@ -1,260 +1,3 @@\n-//! Path representation types.\n-//!\n-//! The codebase currently treats item identifiers as strings in a few different\n-//! encodings:\n-//! - user/DSL input like `~/a/b`\n-//! - canonical item URLs like `https://slug.social/~/a/b`\n-//! - relative paths within a rooted tree view (e.g. `llms/openai` under a root)\n-//!\n-//! This module adds lightweight newtypes so code can be explicit about what it\n-//! expects without changing core storage formats.\n-//!\n-//! **Storage vs wire:** [`CanonicalItemUrl`] values are shared across scopes\n-//! (`https://slug.social/~/…`); which [`crate::reducer::ContentState`] they live in\n-//! is determined by scope, not by embedding the room id in the string. For JSON/RPC\n-//! and browser links in a private room, use [`crate::api::helpers::item_path_for_api_in_room`]\n-//! so ontology items become `https://slug.social/r/{short}/{slug}/~/…`.\n+//! Re-exports — implementations live in `slug-types` (`paths` module).\n \n-use std::borrow::Borrow;\n-use std::fmt;\n-\n-use serde::{Deserialize, Serialize};\n-\n-use crate::canonical_path::canonicalize_item;\n-\n-/// Canonical item identifier as produced by `canonical_path::canonicalize_item`.\n-///\n-/// In practice this is usually:\n-/// - `https://slug.social/~/...` for ontology items, or\n-/// - `https://...` / `http://...` for URL items.\n-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]\n-pub struct CanonicalItemUrl(pub String);\n-\n-impl CanonicalItemUrl {\n-    pub fn parse(input: &str) -> Option<Self> {\n-        let c = canonicalize_item(input);\n-        if c.is_empty() {\n-            None\n-        } else {\n-            Some(Self(c))\n-        }\n-    }\n-\n-    pub fn as_str(&self) -> &str {\n-        &self.0\n-    }\n-\n-    /// Returns the `~/...` tail for ontology items (`https://slug.social/~/...`).\n-    pub fn tilde_tail(&self) -> Option<&str> {\n-        self.0.strip_prefix(\"https://slug.social/~/\")\n-    }\n-\n-    /// Returns the final non-empty `/`-separated segment of the path.\n-    ///\n-    /// `https://slug.social/~/a/b/c` → `\"c\"`\n-    /// `https://slug.social/~/a`     → `\"a\"`\n-    pub fn last_segment(&self) -> &str {\n-        self.0\n-            .rsplit('/')\n-            .find(|s| !s.is_empty())\n-            .unwrap_or(self.0.as_str())\n-    }\n-\n-    /// The ontology root key as stored in `item_children`: `\"https://slug.social/~\"`.\n-    /// Use this (not `parse(\"~/\")`) when looking up top-level children.\n-    pub fn ontology_root() -> Self {\n-        Self(\"https://slug.social/~\".to_string())\n-    }\n-\n-    /// Returns the parent of this canonical item URL by stripping the last\n-    /// path segment, or `None` if there is no parent (already at root).\n-    ///\n-    /// `https://slug.social/~/a/b/c` → `Some(\"https://slug.social/~/a/b\")`\n-    /// `https://slug.social/~/a`     → `Some(\"https://slug.social/~\")`\n-    /// `https://slug.social/~/`      → `None`  (tilde root)\n-    pub fn parent(&self) -> Option<Self> {\n-        // tilde_tail() is None for non-ontology URLs and \"\" for the root ~/\n-        if self.tilde_tail().map(|t| t.is_empty()).unwrap_or(true) {\n-            return None;\n-        }\n-        // Strip everything from the last '/' onwards.\n-        let last_slash = self.0.rfind('/')?;\n-        let parent_str = &self.0[..last_slash];\n-        if parent_str.is_empty() {\n-            None\n-        } else {\n-            Some(Self(parent_str.to_string()))\n-        }\n-    }\n-\n-    /// Segments of an ontology path suitable for breadcrumb rendering.\n-    /// Strips the `https://slug.social` prefix and returns the `~/…` parts.\n-    ///\n-    /// `https://slug.social/~/a/b` → `[\"~\", \"a\", \"b\"]`\n-    /// `https://slug.social/~/`    → `[\"~\"]`\n-    pub fn tilde_segments(&self) -> Vec<&str> {\n-        match self.tilde_tail() {\n-            Some(tail) if !tail.is_empty() => {\n-                std::iter::once(\"~\")\n-                    .chain(tail.split('/').filter(|s| !s.is_empty()))\n-                    .collect()\n-            }\n-            Some(_) => vec![\"~\"],\n-            None => vec![],\n-        }\n-    }\n-}\n-\n-impl fmt::Display for CanonicalItemUrl {\n-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n-        self.0.fmt(f)\n-    }\n-}\n-\n-/// Allow `HashMap<CanonicalItemUrl, _>` to be searched by `&str`.\n-impl Borrow<str> for CanonicalItemUrl {\n-    fn borrow(&self) -> &str {\n-        &self.0\n-    }\n-}\n-\n-impl PartialEq<str> for CanonicalItemUrl {\n-    fn eq(&self, other: &str) -> bool {\n-        self.0 == other\n-    }\n-}\n-\n-impl PartialEq<&str> for CanonicalItemUrl {\n-    fn eq(&self, other: &&str) -> bool {\n-        self.0 == *other\n-    }\n-}\n-\n-impl PartialEq<String> for CanonicalItemUrl {\n-    fn eq(&self, other: &String) -> bool {\n-        &self.0 == other\n-    }\n-}\n-\n-/// A `~/...` input path (as used in the DSL and UX).\n-///\n-/// This is not canonicalized; it is a presentation/input form.\n-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]\n-pub struct TildePath(pub String);\n-\n-impl TildePath {\n-    pub fn new(input: &str) -> Option<Self> {\n-        let s = input.trim();\n-        if s.starts_with(\"~/\") && s.len() > 2 {\n-            Some(Self(s.to_string()))\n-        } else if s == \"~/\" {\n-            Some(Self(\"~/\".to_string()))\n-        } else {\n-            None\n-        }\n-    }\n-\n-    pub fn as_str(&self) -> &str {\n-        &self.0\n-    }\n-\n-    pub fn canonicalize(&self) -> Option<CanonicalItemUrl> {\n-        CanonicalItemUrl::parse(&self.0)\n-    }\n-}\n-\n-impl fmt::Display for TildePath {\n-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n-        self.0.fmt(f)\n-    }\n-}\n-\n-/// A path relative to a chosen root in a tree UI.\n-///\n-/// This is intended for compact state encodings (blobs). It must be joined to a\n-/// root `CanonicalItemUrl` (typically an ontology root) to become a full item.\n-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]\n-pub struct RelativePath(pub String);\n-\n-impl RelativePath {\n-    pub fn new(input: &str) -> Option<Self> {\n-        let s = input.trim().trim_matches('/');\n-        if s.is_empty() {\n-            Some(Self(String::new()))\n-        } else {\n-            // Keep this permissive: the DSL parser is the main gatekeeper.\n-            Some(Self(s.to_string()))\n-        }\n-    }\n-\n-    pub fn as_str(&self) -> &str {\n-        &self.0\n-    }\n-\n-    /// Join this relative path under a canonical ontology root\n-    /// (`https://slug.social/~/...`) to form a canonical item URL.\n-    pub fn join_under_ontology_root(&self, root: &CanonicalItemUrl) -> Option<CanonicalItemUrl> {\n-        let base = root.tilde_tail()?;\n-        // base is the tail after https://slug.social/~/, e.g. \"models\" or \"models/llms\"\n-        let joined = if base.is_empty() {\n-            if self.0.is_empty() {\n-                \"~/\".to_string()\n-            } else {\n-                format!(\"~/{}\", self.0)\n-            }\n-        } else if self.0.is_empty() {\n-            format!(\"~/{}\", base)\n-        } else {\n-            format!(\"~/{}/{}\", base.trim_end_matches('/'), self.0)\n-        };\n-        CanonicalItemUrl::parse(&joined)\n-    }\n-}\n-\n-impl fmt::Display for RelativePath {\n-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n-        self.0.fmt(f)\n-    }\n-}\n-\n-\n-#[cfg(test)]\n-mod tests {\n-    use super::*;\n-\n-    #[test]\n-    fn canonical_parent_deep() {\n-        let c = CanonicalItemUrl::parse(\"~/a/b/c\").unwrap();\n-        assert_eq!(c.parent().unwrap().as_str(), \"https://slug.social/~/a/b\");\n-    }\n-\n-    #[test]\n-    fn canonical_parent_one_level() {\n-        let c = CanonicalItemUrl::parse(\"~/a\").unwrap();\n-        assert_eq!(c.parent().unwrap().as_str(), \"https://slug.social/~\");\n-    }\n-\n-    #[test]\n-    fn canonical_parent_root_is_none() {\n-        let root = CanonicalItemUrl::parse(\"~/\").unwrap();\n-        assert!(root.parent().is_none());\n-    }\n-\n-    #[test]\n-    fn tilde_segments_deep() {\n-        let c = CanonicalItemUrl::parse(\"~/a/b\").unwrap();\n-        assert_eq!(c.tilde_segments(), vec![\"~\", \"a\", \"b\"]);\n-    }\n-\n-    #[test]\n-    fn tilde_segments_root() {\n-        let c = CanonicalItemUrl::parse(\"~/\").unwrap();\n-        assert_eq!(c.tilde_segments(), vec![\"~\"]);\n-    }\n-\n-    #[test]\n-    fn tilde_segments_non_ontology_is_empty() {\n-        let c = CanonicalItemUrl::parse(\"https://example.com/foo\").unwrap();\n-        assert_eq!(c.tilde_segments(), Vec::<&str>::new());\n-    }\n-}\n+pub use slug_types::paths::{CanonicalItemUrl, RelativePath, TildePath};\ndiff --git a/types/src/lib.rs b/types/src/lib.rs\nindex c1cde3b783d03b02783385b5f07659fb112aae3e..5fc867bf2af84c2ca63fa1cdd03413110ad784a3 100644\n--- a/types/src/lib.rs\n+++ b/types/src/lib.rs\n@@ -1,7 +1,13 @@\n use serde::{Deserialize, Serialize};\n \n+pub mod paths;\n pub mod timeago;\n \n+pub use paths::{\n+    canonicalize_item, canonicalize_tag, item_parent_path, item_path_segments, CanonicalItemUrl,\n+    ForumThreadUrl, GardenItemUrl, RelativePath, TildeOntologyPath, TildePath,\n+};\n+\n #[derive(Debug, Serialize, Deserialize)]\n pub struct ApiError {\n     pub ok: bool,\n@@ -12,7 +18,7 @@ pub struct ApiError {\n \n #[derive(Debug, Clone, Serialize, Deserialize)]\n pub struct RankRow {\n-    pub item: String,\n+    pub item: GardenItemUrl,\n     pub score: f64,\n     /// Normalized score as a percentage of the top item (0–100). Present when ?percent=true.\n     #[serde(skip_serializing_if = \"Option::is_none\")]\n@@ -43,7 +49,7 @@ pub struct RankComponent {\n #[derive(Debug, Serialize, Deserialize)]\n pub struct RankResponse {\n     pub components: Vec<RankComponent>,\n-    pub unranked_items: Vec<String>,\n+    pub unranked_items: Vec<GardenItemUrl>,\n }\n \n /// Graph connectivity stats for a scope, returned with pair suggestions.\n@@ -63,8 +69,8 @@ pub struct ConnectivityStats {\n \n #[derive(Debug, Serialize, Deserialize)]\n pub struct PairResponse {\n-    pub left: String,\n-    pub right: String,\n+    pub left: GardenItemUrl,\n+    pub right: GardenItemUrl,\n     pub left_body: Option<String>,\n     pub right_body: Option<String>,\n     /// Thread tags that discuss either item (connective tissue to forum).\n@@ -79,7 +85,7 @@ pub struct PairResponse {\n pub struct NextMoves {\n     pub pair: String,\n     pub rank: String,\n-    pub web: String,\n+    pub web: ForumThreadUrl,\n }\n \n #[derive(Debug, Serialize, Deserialize)]\n@@ -90,14 +96,14 @@ pub struct PathsResponse {\n /// Leaf items only (no children). For search / \"full path list\" — does not scale, works for now.\n #[derive(Debug, Serialize, Deserialize)]\n pub struct LeavesResponse {\n-    pub paths: Vec<String>,\n+    pub paths: Vec<GardenItemUrl>,\n }\n \n #[derive(Debug, Serialize, Deserialize)]\n pub struct PathSummary {\n-    pub path: String,\n+    pub path: TildeOntologyPath,\n     pub children: usize,\n-    pub web: String,\n+    pub web: GardenItemUrl,\n }\n \n #[derive(Debug, Clone, Serialize, Deserialize)]\n@@ -109,7 +115,7 @@ pub struct ThreadsResponse {\n pub struct ThreadSummary {\n     pub thread: String,\n     pub last_activity_ts: i64,\n-    pub web: String,\n+    pub web: ForumThreadUrl,\n }\n \n #[derive(Debug, Serialize, Deserialize)]\n@@ -178,7 +184,7 @@ pub struct IngestRow {\n \n #[derive(Debug, Serialize, Deserialize)]\n pub struct ItemResponse {\n-    pub item: String,\n+    pub item: GardenItemUrl,\n     pub body: Option<String>,\n     /// True when the body was truncated due to size. Fetch with `?full=true` for the complete body.\n     #[serde(default, skip_serializing_if = \"std::ops::Not::not\")]\n@@ -201,15 +207,15 @@ pub struct RecentVotesResponse {\n /// Vote history for one item (matchup: wins/losses + thread per vote).\n #[derive(Debug, Serialize, Deserialize)]\n pub struct MatchupResponse {\n-    pub item: String,\n+    pub item: GardenItemUrl,\n     pub votes: Vec<VoteRow>,\n }\n \n #[derive(Debug, Clone, Serialize, Deserialize)]\n pub struct VoteRow {\n     pub ts: i64,\n-    pub a: String,\n-    pub b: String,\n+    pub a: GardenItemUrl,\n+    pub b: GardenItemUrl,\n     pub ratio: String,\n     /// Principal username when present (stored form, no `@`).\n     pub actor: Option<String>,\n@@ -510,7 +516,7 @@ pub struct RankPosition {\n /// How one item's rank changed after a vote.\n #[derive(Debug, Clone, Serialize, Deserialize)]\n pub struct RankChange {\n-    pub item: String,\n+    pub item: GardenItemUrl,\n     /// Position before the vote. None = was unranked (no voted connections in this scope).\n     pub before: Option<RankPosition>,\n     /// Position after the vote. None = became unranked (e.g. component split, unlikely).\n@@ -544,7 +550,7 @@ pub struct CheckScopeRanking {\n     /// Parent scope path (e.g. \"/models\" or \"/\" for root).\n     pub parent: String,\n     pub components: Vec<RankComponent>,\n-    pub unranked_items: Vec<String>,\n+    pub unranked_items: Vec<GardenItemUrl>,\n }\n \n #[derive(Debug, Serialize, Deserialize)]\n@@ -567,7 +573,7 @@ pub struct SearchResponse {\n \n #[derive(Debug, Serialize, Deserialize)]\n pub struct SearchItemHit {\n-    pub path: String,\n+    pub path: GardenItemUrl,\n     #[serde(skip_serializing_if = \"Option::is_none\")]\n     pub body: Option<String>,\n }\n@@ -614,7 +620,7 @@ pub struct RankHistoryRow {\n \n #[derive(Debug, Serialize, Deserialize)]\n pub struct RankHistoryResponse {\n-    pub item: String,\n+    pub item: GardenItemUrl,\n     pub history: Vec<RankHistoryRow>,\n }\n \ndiff --git a/types/src/paths.rs b/types/src/paths.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..2950a7502255927583fbacdfd2adb700f0b0c221\n--- /dev/null\n+++ b/types/src/paths.rs\n@@ -0,0 +1,498 @@\n+//! Canonical paths, storage ids, and JSON href newtypes. All normalization and\n+//! room-aware URL rules for items live here.\n+\n+use std::borrow::Borrow;\n+use std::fmt;\n+\n+use serde::{Deserialize, Serialize};\n+\n+// ---------------------------------------------------------------------------\n+// Normalization (moved from server `canonical_path`)\n+// ---------------------------------------------------------------------------\n+\n+/// Thread / public tag: stored without leading `#`, lowercase.\n+pub fn canonicalize_tag(input: &str) -> String {\n+    input.trim().trim_start_matches('#').to_lowercase()\n+}\n+\n+/// Ontology item reference → canonical absolute URL on the slug host.\n+pub fn canonicalize_item(input: &str) -> String {\n+    let s = input.trim();\n+    if s.is_empty() {\n+        return String::new();\n+    }\n+\n+    if let Some(rest) = s.strip_prefix(\"https://\") {\n+        let (host, tail) = rest.split_once('/').map_or((rest, \"\"), |(h, t)| (h, t));\n+        let host = host.trim().to_lowercase();\n+        if tail.is_empty() {\n+            return format!(\"https://{}\", host);\n+        } else {\n+            return format!(\"https://{}/{}\", host, tail);\n+        }\n+    }\n+    if let Some(rest) = s.strip_prefix(\"http://\") {\n+        let (host, tail) = rest.split_once('/').map_or((rest, \"\"), |(h, t)| (h, t));\n+        let host = host.trim().to_lowercase();\n+        if tail.is_empty() {\n+            return format!(\"http://{}\", host);\n+        } else {\n+            return format!(\"http://{}/{}\", host, tail);\n+        }\n+    }\n+\n+    let is_tilde = s.starts_with(\"~/\");\n+    let rest = s.strip_prefix(\"~/\").or_else(|| s.strip_prefix(\"/\")).unwrap_or(s);\n+\n+    let tail = rest\n+        .split('/')\n+        .filter_map(|seg| {\n+            let t = seg.trim();\n+            if t.is_empty() {\n+                None\n+            } else {\n+                Some(t.to_lowercase())\n+            }\n+        })\n+        .collect::<Vec<_>>()\n+        .join(\"/\");\n+\n+    if is_tilde {\n+        format!(\"https://slug.social/~/{}\", tail)\n+    } else if tail.is_empty() {\n+        \"https://slug.social\".to_string()\n+    } else {\n+        format!(\"https://slug.social/{}\", tail)\n+    }\n+}\n+\n+pub fn item_path_segments(input: &str) -> Vec<String> {\n+    let canonical = canonicalize_item(input);\n+    if canonical.is_empty() {\n+        return vec![];\n+    }\n+\n+    if let Some(rest) = canonical.strip_prefix(\"https://\") {\n+        let (host, tail) = rest.split_once('/').map_or((rest, \"\"), |(h, t)| (h, t));\n+        let mut out = vec![format!(\"https://{}\", host)];\n+        out.extend(tail.split('/').filter(|s| !s.is_empty()).map(|s| s.to_string()));\n+        return out;\n+    }\n+    if let Some(rest) = canonical.strip_prefix(\"http://\") {\n+        let (host, tail) = rest.split_once('/').map_or((rest, \"\"), |(h, t)| (h, t));\n+        let mut out = vec![format!(\"http://{}\", host)];\n+        out.extend(tail.split('/').filter(|s| !s.is_empty()).map(|s| s.to_string()));\n+        return out;\n+    }\n+\n+    canonical\n+        .split('/')\n+        .filter(|s| !s.is_empty())\n+        .map(|s| s.to_string())\n+        .collect()\n+}\n+\n+pub fn item_parent_path(input: &str) -> Option<String> {\n+    let segs = item_path_segments(input);\n+    if segs.len() <= 1 {\n+        return None;\n+    }\n+    Some(segs[..segs.len() - 1].join(\"/\"))\n+}\n+\n+// ---------------------------------------------------------------------------\n+// Storage + input path newtypes\n+// ---------------------------------------------------------------------------\n+\n+/// Canonical item identifier as produced by [`canonicalize_item`].\n+///\n+/// Shared across all scopes; room is not embedded. Usually\n+/// `https://slug.social/~/…` or an external `http(s)://…` URL item.\n+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]\n+pub struct CanonicalItemUrl(pub String);\n+\n+impl CanonicalItemUrl {\n+    pub fn parse(input: &str) -> Option<Self> {\n+        let c = canonicalize_item(input);\n+        if c.is_empty() {\n+            None\n+        } else {\n+            Some(Self(c))\n+        }\n+    }\n+\n+    pub fn as_str(&self) -> &str {\n+        &self.0\n+    }\n+\n+    pub fn tilde_tail(&self) -> Option<&str> {\n+        self.0.strip_prefix(\"https://slug.social/~/\")\n+    }\n+\n+    pub fn last_segment(&self) -> &str {\n+        self.0\n+            .rsplit('/')\n+            .find(|s| !s.is_empty())\n+            .unwrap_or(self.0.as_str())\n+    }\n+\n+    pub fn ontology_root() -> Self {\n+        Self(\"https://slug.social/~\".to_string())\n+    }\n+\n+    pub fn parent(&self) -> Option<Self> {\n+        if self.tilde_tail().map(|t| t.is_empty()).unwrap_or(true) {\n+            return None;\n+        }\n+        let last_slash = self.0.rfind('/')?;\n+        let parent_str = &self.0[..last_slash];\n+        if parent_str.is_empty() {\n+            None\n+        } else {\n+            Some(Self(parent_str.to_string()))\n+        }\n+    }\n+\n+    pub fn tilde_segments(&self) -> Vec<&str> {\n+        match self.tilde_tail() {\n+            Some(tail) if !tail.is_empty() => {\n+                std::iter::once(\"~\")\n+                    .chain(tail.split('/').filter(|s| !s.is_empty()))\n+                    .collect()\n+            }\n+            Some(_) => vec![\"~\"],\n+            None => vec![],\n+        }\n+    }\n+\n+    /// `~/…` list label for ontology items (paths index, CLI).\n+    pub fn tilde_list_label(&self) -> TildeOntologyPath {\n+        TildeOntologyPath::from_stored(self)\n+    }\n+\n+    /// Absolute href for JSON/RPC and browsers for this stored id in `room`.\n+    pub fn json_href(&self, room_wire: &str) -> GardenItemUrl {\n+        GardenItemUrl::from_stored(self, room_wire)\n+    }\n+}\n+\n+impl fmt::Display for CanonicalItemUrl {\n+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n+        self.0.fmt(f)\n+    }\n+}\n+\n+impl Borrow<str> for CanonicalItemUrl {\n+    fn borrow(&self) -> &str {\n+        &self.0\n+    }\n+}\n+\n+impl PartialEq<str> for CanonicalItemUrl {\n+    fn eq(&self, other: &str) -> bool {\n+        self.0 == other\n+    }\n+}\n+\n+impl PartialEq<&str> for CanonicalItemUrl {\n+    fn eq(&self, other: &&str) -> bool {\n+        self.0 == *other\n+    }\n+}\n+\n+impl PartialEq<String> for CanonicalItemUrl {\n+    fn eq(&self, other: &String) -> bool {\n+        &self.0 == other\n+    }\n+}\n+\n+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]\n+pub struct TildePath(pub String);\n+\n+impl TildePath {\n+    pub fn new(input: &str) -> Option<Self> {\n+        let s = input.trim();\n+        if s.starts_with(\"~/\") && s.len() > 2 {\n+            Some(Self(s.to_string()))\n+        } else if s == \"~/\" {\n+            Some(Self(\"~/\".to_string()))\n+        } else {\n+            None\n+        }\n+    }\n+\n+    pub fn as_str(&self) -> &str {\n+        &self.0\n+    }\n+\n+    pub fn canonicalize(&self) -> Option<CanonicalItemUrl> {\n+        CanonicalItemUrl::parse(&self.0)\n+    }\n+}\n+\n+impl fmt::Display for TildePath {\n+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n+        self.0.fmt(f)\n+    }\n+}\n+\n+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]\n+pub struct RelativePath(pub String);\n+\n+impl RelativePath {\n+    pub fn new(input: &str) -> Option<Self> {\n+        let s = input.trim().trim_matches('/');\n+        if s.is_empty() {\n+            Some(Self(String::new()))\n+        } else {\n+            Some(Self(s.to_string()))\n+        }\n+    }\n+\n+    pub fn as_str(&self) -> &str {\n+        &self.0\n+    }\n+\n+    pub fn join_under_ontology_root(&self, root: &CanonicalItemUrl) -> Option<CanonicalItemUrl> {\n+        let base = root.tilde_tail()?;\n+        let joined = if base.is_empty() {\n+            if self.0.is_empty() {\n+                \"~/\".to_string()\n+            } else {\n+                format!(\"~/{}\", self.0)\n+            }\n+        } else if self.0.is_empty() {\n+            format!(\"~/{}\", base)\n+        } else {\n+            format!(\"~/{}/{}\", base.trim_end_matches('/'), self.0)\n+        };\n+        CanonicalItemUrl::parse(&joined)\n+    }\n+}\n+\n+impl fmt::Display for RelativePath {\n+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n+        self.0.fmt(f)\n+    }\n+}\n+\n+// ---------------------------------------------------------------------------\n+// Wire / JSON: correct-by-construction hrefs\n+// ---------------------------------------------------------------------------\n+\n+fn api_path_or_url(item: &str) -> String {\n+    if item.starts_with(\"http://\") || item.starts_with(\"https://\") {\n+        item.to_string()\n+    } else {\n+        format!(\"/{}\", item)\n+    }\n+}\n+\n+/// Ontology item as serialized in JSON (absolute URL or `/`-prefixed path).\n+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]\n+#[serde(transparent)]\n+pub struct GardenItemUrl(pub String);\n+\n+impl GardenItemUrl {\n+    pub fn as_str(&self) -> &str {\n+        &self.0\n+    }\n+\n+    pub fn into_inner(self) -> String {\n+        self.0\n+    }\n+\n+    /// Stored canonical id + RPC `room` field (`\"public\"` or `\"short/slug\"`).\n+    pub fn from_stored(stored: &CanonicalItemUrl, room_wire: &str) -> Self {\n+        Self(garden_href_string(stored.as_str(), room_wire))\n+    }\n+\n+    /// Like [`Self::from_stored`] but accepts a string that may already be canonical.\n+    pub fn from_storage_str(stored: &str, room_wire: &str) -> Self {\n+        Self(garden_href_string(stored, room_wire))\n+    }\n+}\n+\n+impl fmt::Display for GardenItemUrl {\n+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n+        self.0.fmt(f)\n+    }\n+}\n+\n+fn garden_href_string(item: &str, room_wire: &str) -> String {\n+    let room = room_wire.trim();\n+    if room.is_empty() || room == \"public\" {\n+        return api_path_or_url(item);\n+    }\n+    let Some((short, slug)) = room.split_once('/') else {\n+        return api_path_or_url(item);\n+    };\n+    if short.is_empty() || slug.is_empty() {\n+        return api_path_or_url(item);\n+    }\n+    let Some(c) = CanonicalItemUrl::parse(item) else {\n+        return api_path_or_url(item);\n+    };\n+    let root = CanonicalItemUrl::ontology_root();\n+    let item_norm = c.as_str().trim_end_matches('/');\n+    let root_norm = root.as_str().trim_end_matches('/');\n+    if let Some(tail) = c.tilde_tail() {\n+        return if tail.is_empty() {\n+            format!(\"https://slug.social/r/{short}/{slug}/~\")\n+        } else {\n+            format!(\"https://slug.social/r/{short}/{slug}/~/{}\", tail)\n+        };\n+    }\n+    if item_norm == root_norm {\n+        return format!(\"https://slug.social/r/{short}/{slug}/~\");\n+    }\n+    api_path_or_url(item)\n+}\n+\n+/// Forum thread URL for JSON (`/t/…` or `/r/…/t/…` on slug.social).\n+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]\n+#[serde(transparent)]\n+pub struct ForumThreadUrl(pub String);\n+\n+impl ForumThreadUrl {\n+    pub fn as_str(&self) -> &str {\n+        &self.0\n+    }\n+\n+    pub fn into_inner(self) -> String {\n+        self.0\n+    }\n+\n+    pub fn from_room_tag(room_wire: &str, thread_tag: &str) -> Self {\n+        let room = room_wire.trim();\n+        let tag = thread_tag.trim().trim_start_matches('#');\n+        Self(if room.is_empty() || room == \"public\" {\n+            format!(\"https://slug.social/t/{tag}\")\n+        } else if let Some((short, slug)) = room.split_once('/') {\n+            if short.is_empty() || slug.is_empty() {\n+                format!(\"https://slug.social/t/{tag}\")\n+            } else {\n+                format!(\"https://slug.social/r/{short}/{slug}/t/{tag}\")\n+            }\n+        } else {\n+            format!(\"https://slug.social/t/{tag}\")\n+        })\n+    }\n+}\n+\n+impl fmt::Display for ForumThreadUrl {\n+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n+        self.0.fmt(f)\n+    }\n+}\n+\n+/// `~/a/b` style path for list UIs (paths index `path` field).\n+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]\n+#[serde(transparent)]\n+pub struct TildeOntologyPath(pub String);\n+\n+impl TildeOntologyPath {\n+    pub fn from_stored(c: &CanonicalItemUrl) -> Self {\n+        let s = match c.tilde_tail() {\n+            Some(tail) if !tail.is_empty() => format!(\"~/{}\", tail),\n+            Some(_) => \"~/\".to_string(),\n+            None => c.to_string(),\n+        };\n+        Self(s)\n+    }\n+\n+    pub fn as_str(&self) -> &str {\n+        &self.0\n+    }\n+}\n+\n+impl fmt::Display for TildeOntologyPath {\n+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n+        self.0.fmt(f)\n+    }\n+}\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+\n+    #[test]\n+    fn canonical_parent_deep() {\n+        let c = CanonicalItemUrl::parse(\"~/a/b/c\").unwrap();\n+        assert_eq!(c.parent().unwrap().as_str(), \"https://slug.social/~/a/b\");\n+    }\n+\n+    #[test]\n+    fn canonical_parent_one_level() {\n+        let c = CanonicalItemUrl::parse(\"~/a\").unwrap();\n+        assert_eq!(c.parent().unwrap().as_str(), \"https://slug.social/~\");\n+    }\n+\n+    #[test]\n+    fn canonical_parent_root_is_none() {\n+        let root = CanonicalItemUrl::parse(\"~/\").unwrap();\n+        assert!(root.parent().is_none());\n+    }\n+\n+    #[test]\n+    fn tilde_segments_deep() {\n+        let c = CanonicalItemUrl::parse(\"~/a/b\").unwrap();\n+        assert_eq!(c.tilde_segments(), vec![\"~\", \"a\", \"b\"]);\n+    }\n+\n+    #[test]\n+    fn tilde_segments_root() {\n+        let c = CanonicalItemUrl::parse(\"~/\").unwrap();\n+        assert_eq!(c.tilde_segments(), vec![\"~\"]);\n+    }\n+\n+    #[test]\n+    fn tilde_segments_non_ontology_is_empty() {\n+        let c = CanonicalItemUrl::parse(\"https://example.com/foo\").unwrap();\n+        assert_eq!(c.tilde_segments(), Vec::<&str>::new());\n+    }\n+\n+    #[test]\n+    fn garden_public_passthrough_https() {\n+        let u = \"https://slug.social/~/a/b\";\n+        assert_eq!(GardenItemUrl::from_storage_str(u, \"public\").as_str(), u);\n+    }\n+\n+    #[test]\n+    fn garden_private_room_prefixes_ontology() {\n+        assert_eq!(\n+            GardenItemUrl::from_storage_str(\"https://slug.social/~/topic/x\", \"9ab12cd/my-room\").as_str(),\n+            \"https://slug.social/r/9ab12cd/my-room/~/topic/x\"\n+        );\n+    }\n+\n+    #[test]\n+    fn garden_private_room_ontology_root() {\n+        assert_eq!(\n+            GardenItemUrl::from_storage_str(\"https://slug.social/~\", \"9ab12cd/my-room\").as_str(),\n+            \"https://slug.social/r/9ab12cd/my-room/~\"\n+        );\n+        assert_eq!(\n+            GardenItemUrl::from_storage_str(\"https://slug.social/~/\", \"9ab12cd/my-room\").as_str(),\n+            \"https://slug.social/r/9ab12cd/my-room/~\"\n+        );\n+    }\n+\n+    #[test]\n+    fn garden_external_url_untouched_in_private_room() {\n+        let u = \"https://example.com/z\";\n+        assert_eq!(GardenItemUrl::from_storage_str(u, \"9ab12cd/my-room\").as_str(), u);\n+    }\n+\n+    #[test]\n+    fn forum_web_public_vs_room() {\n+        assert_eq!(\n+            ForumThreadUrl::from_room_tag(\"public\", \"debate\").as_str(),\n+            \"https://slug.social/t/debate\"\n+        );\n+        assert_eq!(\n+            ForumThreadUrl::from_room_tag(\"9ab12cd/my-room\", \"#debate\").as_str(),\n+            \"https://slug.social/r/9ab12cd/my-room/t/debate\"\n+        );\n+    }\n+}\n","role":"user"}],"model":"openai/gpt-chat-latest"}