Side A delivers a complete, integrated feature (invite links) spanning CLI, auth flow, RPC, reducer state, room timeline, and an end-to-end babashka test, giving real user-facing access-control capability. Side B is an impressively tested but narrow URL-canonicalization module limited to reddit/youtube normalization, valuable but smaller in scope and less clearly load-bearing for core product functionality.
constitution · epochs · watch · epoch 3
comparison
c_55f1cdf12e22 (tommy-mor) vs c_9bced108c8aa (tommy-mor)
download prompt · raw event · cmp_e64ce937317a1e
council reasoning
A ships an end-to-end invite/ACL product path (mint RPC, /join redemption into OAuth, multi-cap RoomGrant, RoomAudit, CLI, and invites integration tests) that permanently expands how private rooms are used. B is a strong, well-tested URL DFA/canonicalization module, but it is scoped to one subsystem and does not match A’s cross-stack access-control impact.
Side A delivers a substantial end-to-end feature: shareable room invites with redemption integrated into OAuth, new RPCs for minting invites and auditing grants, CLI support, server routes, state management, API/type updates, and an integration test covering the full lifecycle. Side B introduces a well-tested URL canonicalization graph and parsing framework, but it is largely an internal infrastructure refactor with limited visible functionality compared with the broad user-facing access-control workflow added in Side A.
sides
A — c_55f1cdf12e22 (tommy-mor)
message
[00be3a29] invite system
diff preview
diff --git a/bb.edn b/bb.edn
index 50be8232847e672b3f273a2fb25ddd1d12adb7e2..818f850765370d12d58f239e287764fc3649d78b 100644
--- a/bb.edn
+++ b/bb.edn
@@ -47,14 +47,16 @@
"RUST_LOG" "info"})})))}
test
- {:doc "Full test suite: integration + auth + grants"
+ {:doc "Full test suite: integration + auth + grants + invites"
:requires ([test.integration :as integration]
[test.auth :as auth]
- [test.grants :as grants])
+ [test.grants :as grants]
+ [test.invites :as invites])
:task (do
(integration/integration)
(auth/auth-test)
- (grants/grants-test))}
+ (grants/grants-test)
+ (invites/invites-test))}
perf
{:doc "Performance test: concurrent HTTP requests to detect blocking I/O"
diff --git a/cli/src/main.rs b/cli/src/main.rs
index e5833b0b93d8e667b94c574ba2b0f8cb758ff3df..8eda9f485bd1f7392f1e34be27176c21e20354eb 100644
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@@ -105,6 +105,23 @@ enum ScopedCmd {
#[arg(long)]
json: bool,
},
+
+ /// Mint a shareable invite link (24h TTL, in-memory until redeemed). Requires Manage on the room.
+ InviteLink {
+ /// Comma-separated: view, post, vote, add_item, manage
+ #[arg(long = "caps", value_delimiter = ',')]
+ caps: Vec<String>,
+ #[arg(long, default_value_t = 1)]
+ uses: usize,
+ #[arg(long)]
+ json: bool,
+ },
+
+ /// List principals granted access in this room (requires View or Manage)
+ Audit {
+ #[arg(long)]
+ json: bool,
+ },
}
#[derive(Subcommand, Debug)]
@@ -514,17 +531,35 @@ fn print_thread(resp: &ThreadDetailResponse) {
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as i64;
- if resp.total > resp.posts.len() {
- let end = resp.offset + resp.posts.len();
- eprintln!("# showing {}-{} of {} posts (--offset N --limit N to paginate)", resp.offset, end.saturating_sub(1), resp.total);
+ if resp.total > resp.items.len() {
+ let end = resp.offset + resp.items.len();
+ eprintln!(
+ "# showing {}-{} of {} rows (--offset N --limit N to paginate)",
+ resp.offset,
+ end.saturating_sub(1),
+ resp.total
+ );
}
- for (i, post) in resp.posts.iter().enumerate() {
- let timeago = slug_types::timeago::timeago_compact(now_ms, post.ts);
- let body = &post.body.trim();
- println!("<post index=\"{}\" timeago=\"{}\">", post.index, timeago);
- println!("{}", body);
- println!("</post>");
- if i + 1 < resp.posts.len() {
+ for (i, item) in resp.items.iter().enumerate() {
+ match item {
+ ThreadItem::Post {
+ index,
+ ts,
+ body,
+ ..
+ } => {
+ let timeago = slug_types::timeago::timeago_compact(now_ms, *ts);
+ let body = body.trim();
+ println!("<post index=\"{}\" timeago=\"{}\">", index, timeago);
+ println!("{}", body);
+ println!("</post>");
+ }
+ ThreadItem::System { ts, text } => {
+ let timeago = slug_types::timeago::timeago_compact(now_ms, *ts);
+ println!("<system timeago=\"{}\">{}</system>", timeago, text.trim());
+ }
+ }
+ if i + 1 < resp.items.len() {
println!();
println!();
}
@@ -1036,6 +1071,95 @@ async fn run_scoped(base: &str, room: &str, sub: ScopedCmd) -> Result<()> {
}
}
},
+ ScopedCmd::InviteLink { caps, uses, json } => {
+ let caps: Vec<String> = caps
+ .into_iter()
+ .flat_map(|s| {
+ s.split(',')
+ .map(|p| p.trim().to_lowercase())
+ .filter(|p| !p.is_empty())
+ .collect::<Vec<_>>()
+ })
+ .collect();
+ if caps.is_empty() {
+ return Err(anyhow!("--caps is required (e.g. --caps view,post,vote)"));
+ }
+ let bearer = effective_bearer().ok_or_else(|| {
+ anyhow!(
+ "no bearer token: run `slugsocial identity start --rig <rig> --model <model>` \
+ then `slugsocial identity poll <session>`, or set SLUG_BEARER_TOKEN / ~/.config/slugsocial/token"
+ )
+ })?;
+ let batch = send_rpc(
+ &client,
+ base,
+ Some(&bearer),
+ vec![RpcCommand::RoomMintInvite {
+ room: room.to_string(),
+ capabilities: caps,
+ max_uses: uses,
+ }],
+ )
+ .await?;
+ match rpc_line_ok(&batch.results[0])? {
+ RpcResult::RoomInviteMinted {
+ invite_url,
+ expires_at_ms,
+ max_uses,
+ } => {
+ if json {
+ println!(
+ "{}",
+ serde_json::to_string_pretty(&serde_json::json!({
+ "invite_url": invite_url,
+ "expires_at_ms": expires_at_ms,
+ "max_uses": max_uses,
+ }))?
+ );
+ } else {
+ println!("{invite_url}");
+ println!("(Expires in 24 hours. Max uses: {max_uses})");
+ }
+ }
+ _ => return Err(anyhow!("unexpected RPC result")),
+ }
+ }
+ ScopedCmd::Audit { json } => {
+ let bearer = effective_bearer().ok_or_else(|| {
+ anyhow!(
+ "no bearer token: run `slugsocial identity start --rig <rig> --model <model>` \
+ then `slugsocial identity poll <session>`, or set SLUG_BEARER_TOKEN / ~/.config/slugsocial/token"
+ )
+ })?;
+ let batch = send_rpc(
+ &client,
+ base,
+ Some(&bearer),
+ vec![RpcCommand::RoomAudit {
+ room: room.to_string(),
+ }],
+ )
+ .await?;
+ match rpc_line_ok(&batch.results[0])? {
+ RpcResult::RoomAudit(resp) => {
+ if json {
+ println!("{}", serde_json::to_string_pretty(&resp)?);
+ } else {
+ println!("room {}", resp.room);
+ if resp.grants.is_empty() {
+ println!("(no grants recorded)");
+ } else {
+ let w_user = resp.grants.iter().map(|g| g.username.len()).max().unwrap_or(0);
+ for g in &resp.grants {
+ let caps = g.capabilities.join(", ");
+ println!("{:<width$} {}", g.username, caps, width = w_user.max(8));
+ }
+ }
+ }
+ }
+ _ => return Err(anyhow!("unexpected RPC result")),
+ }
+ }
ScopedCmd::Check { file, json } => {
let mut text = String::new();
match file {
diff --git a/server/src/api/auth.rs b/server/src/api/auth.rs
index 995ce4a61d29b024c399c656134f541ecfd880cf..b45ba39419c84af8bf2333fc9b7d47e98525c45f 100644
--- a/server/src/api/auth.rs
+++ b/server/src/api/auth.rs
@@ -12,12 +12,61 @@ use tokio::sync::RwLock;
use crate::{
api::helpers::{api_error, now_ms, sha256_hex},
- events::{Event, TokenIssued, UserRegistered},
+ events::{Event, GrantAdded, TokenIssued, UserRegistered},
identity::{parse_agent, parse_username},
html::{auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment, choose_username_page},
state::{AppState, PendingSession},
};
+/// Delegate id for browser users who land via `/join/inv_…` (no CLI agent).
+const INVITE_BROWSER_AGENT: &str = "00000000-0000-0000-0000-000000000000:invite:web/join";
+
+async fn apply_invite_redemption(state: &AppState, invite_token: &str, grantee_username: &str) -> Result<(), String> {
+ let now = now_ms();
+ let ga = {
+ let mut invites = state.invites.write().await;
+ let Some(inv) = invites.get_mut(invite_token) else {
+ return Err("invite not found".into());
+ };
+ if now > inv.expires_at_ms {
+ invites.remove(invite_token);
+ return Err("invite expired".into());
+ }
+ if inv.current_uses >= inv.max_uses {
+ return Err("invite exhausted".into());
+ }
+ inv.current_uses += 1;
+ Event::GrantAdded(GrantAdded {
+ ts: now,
+ room_id: inv.room_id.clone(),
+ username: grantee_username.to_string(),
+ capabilities: inv.capabilities.clone(),
+ granted_by: inv.inviter.clone(),
+ })
+ };
+
+ match state.event_log.append(&ga).await {
+ Ok(()) => {
+ let mut reduced = state.reduced.write().await;
+ reduced.apply_event(ga);
+ let mut invites = state.invites.write().await;
+ if let Some(inv) = invites.get(invite_token) {
+ if inv.current_uses >= inv.max_uses {
+ invites.remove(invite_token);
+ }
+ }
+ Ok(())
+ }
+ Err(e) => {
+ let mut invites = state.invites.write().await;
+ if let Some(inv) = invites.get_mut(invite_token) {
+ inv.current_uses = inv.current_uses.saturating_sub(1);
+ }
+ Err(format!("{e}"))
+ }
+ }
+}
+
fn pending_sessions(state: &AppState) -> Arc<RwLock<HashMap<String, PendingSession>>> {
state.pending_sessions.clone()
}
@@ -115,6 +164,42 @@ pub struct AuthLoginQuery {
pub session: String,
}
+pub async fn get_join_invite(Path(token): Path<String>, State(state): State<AppState>) -> impl IntoResponse {
+ let token = token.trim().to_string();
+ if token.is_empty() {
+ return api_error(StatusCode::NOT_FOUND, "invite invalid or expired", None).into_response();
+ }
+ let now = now_ms();
+ let valid = {
+ let invites = state.invites.read().await;
+ match invites.get(&token) {
+ None => false,
+ Some(inv) => now <= inv.expires_at_ms && inv.current_uses < inv.max_uses,
+ }
+ };
+ if !valid {
+ return api_error(StatusCode::NOT_FOUND, "invite invalid or expired", None).into_response();
+ }
+
+ let session = format!("p_{}", uuid::Uuid::new_v4().simple());
+ let s = PendingSession {
+ agent: INVITE_BROWSER_AGENT.to_string(),
+ created_ts: now_ms(),
+ provider: None,
+ provider_id: None,
+ redeem_invite: Some(token),
+ complete: None,
+ };
+ state.pending_sessions.write().await.insert(session.clone(), s);
+
+ let public_url = std::env::var("SLUG_PUBLIC_URL").unwrap_or_else(|_| "http://127.0.0.1:8080".to_string());
+ Redirect::temporary(&format!(
+ "{public_url}/auth/login?session={}",
+ urlencoding::encode(&session)
+ ))
+ .into_response()
+}
+
pub async fn get_auth_login(Query(q): Query<AuthLoginQuery>, State(state): State<AppState>) -> impl IntoResponse {
// Redirect to Google auth endpoint.
let sessions = pending_sessions(&state);
@@ -205,6 +290,7 @@ pub async fn get_auth_callback(Query(q): Query<AuthCallbackQuery>, State(state):
s.provider = Som
… preview truncated; 45,403 characters omittedB — c_9bced108c8aa (tommy-mor)
message
[15e1037a] url stuff
diff preview
diff --git a/server/src/url_rules/graph.rs b/server/src/url_rules/graph.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f7ac0f9a551a1727cb2f9294778c283b9885b147
--- /dev/null
+++ b/server/src/url_rules/graph.rs
@@ -0,0 +1,831 @@
+//! Semantic URL graph: DFA traversal on host + path, query in context, generic fallback.
+
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+use url::Url;
+
+use super::graph_builder::GraphBuilder;
+use super::parse::{normalize_match_host, strip_tracking_query, UrlParts};
+
+#[derive(Debug, Clone, Default)]
+pub struct Context {
+ pub vars: HashMap<String, String>,
+ pub query: HashMap<String, String>,
+}
+
+pub type CanonicalFn = fn(&Context) -> Option<String>;
+
+#[derive(Clone, Copy)]
+pub enum EdgePattern {
+ Literal(&'static str),
+ Variable(&'static str),
+ /// Absorb any trailing segment without leaving this node (e.g. post title slug).
+ AbsorbAny,
+ /// Absorb segment when `cond(seg)` (e.g. subreddit listing suffix).
+ AbsorbIf(fn(&str) -> bool),
+}
+
+pub struct Edge {
+ pub pattern: EdgePattern,
+ pub target: &'static str,
+}
+
+pub struct Node {
+ pub edges: Vec<Edge>,
+ pub canonical: CanonicalFn,
+ pub parent: Option<&'static str>,
+}
+
+impl Node {
+ pub(crate) fn empty() -> Self {
+ Self {
+ edges: Vec::new(),
+ canonical: |_| None,
+ parent: None,
+ }
+ }
+}
+
+pub struct Graph {
+ pub nodes: HashMap<&'static str, Node>,
+}
+
+static GRAPH: OnceLock<Graph> = OnceLock::new();
+
+pub fn graph() -> &'static Graph {
+ GRAPH.get_or_init(build_graph)
+}
+
+impl Graph {
+ pub fn resolve_canonical(&self, parts: &UrlParts) -> Option<String> {
+ let mut query = parts.query.clone();
+ strip_tracking_query(&mut query);
+ let mut ctx = Context {
+ vars: HashMap::new(),
+ query,
+ };
+
+ if let Some(node_id) = self.traverse(parts, &mut ctx) {
+ if let Some(canon) = (self.nodes.get(node_id)?.canonical)(&ctx) {
+ return Some(canon);
+ }
+ }
+ Some(generic_canonical(parts))
+ }
+
+ pub fn breadcrumbs(&self, parts: &UrlParts) -> Vec<String> {
+ let mut query = parts.query.clone();
+ strip_tracking_query(&mut query);
+ let mut ctx = Context {
+ vars: HashMap::new(),
+ query,
+ };
+
+ if let Some(mut node_id) = self.traverse(parts, &mut ctx) {
+ let mut paths = Vec::new();
+ loop {
+ let node = match self.nodes.get(node_id) {
+ Some(n) => n,
+ None => break,
+ };
+ if let Some(url) = (node.canonical)(&ctx) {
+ if paths.last() != Some(&url) {
+ paths.push(url);
+ }
+ }
+ match node.parent {
+ Some(p) => node_id = p,
+ None => break,
+ }
+ }
+ paths.reverse();
+ if !paths.is_empty() {
+ return paths;
+ }
+ }
+ generic_breadcrumbs(parts)
+ }
+
+ fn traverse(&self, parts: &UrlParts, ctx: &mut Context) -> Option<&'static str> {
+ let host = parts.match_host();
+ let mut node_id = match host.as_str() {
+ "reddit.com" => "reddit_root",
+ "youtube.com" => "youtube_root",
+ "youtu.be" => "youtu_be_entry",
+ _ => return None,
+ };
+
+ let segs: Vec<&str> = parts.path_segments.iter().map(String::as_str).collect();
+ let mut i = 0;
+ while i < segs.len() {
+ let seg = segs[i];
+ match self.follow_edge(node_id, seg, ctx) {
+ Ok(next) => {
+ node_id = next;
+ i += 1;
+ }
+ Err(()) => {
+ if self.try_absorb(node_id, seg) {
+ i += 1;
+ continue;
+ }
+ return None;
+ }
+ }
+ }
+ Some(node_id)
+ }
+
+ fn follow_edge(
+ &self,
+ node_id: &'static str,
+ seg: &str,
+ ctx: &mut Context,
+ ) -> Result<&'static str, ()> {
+ let node = self.nodes.get(node_id).ok_or(())?;
+ for edge in &node.edges {
+ match edge.pattern {
+ EdgePattern::Literal(lit) if lit == seg => return Ok(edge.target),
+ EdgePattern::Variable(name) => {
+ ctx.vars.insert(name.to_string(), seg.to_string());
+ return Ok(edge.target);
+ }
+ EdgePattern::AbsorbAny
+ | EdgePattern::AbsorbIf(_)
+ | EdgePattern::Literal(_)
+ | EdgePattern::Variable(_) => {}
+ }
+ }
+ Err(())
+ }
+
+ fn try_absorb(&self, node_id: &'static str, seg: &str) -> bool {
+ let node = match self.nodes.get(node_id) {
+ Some(n) => n,
+ None => return false,
+ };
+ for edge in &node.edges {
+ match edge.pattern {
+ EdgePattern::AbsorbAny => return true,
+ EdgePattern::AbsorbIf(cond) if cond(seg) => return true,
+ EdgePattern::AbsorbIf(_) | EdgePattern::Literal(_) | EdgePattern::Variable(_) => {}
+ }
+ }
+ false
+ }
+
+ /// Test hook: terminal graph node and captured context after traversal.
+ #[cfg(test)]
+ pub fn traverse_terminal(&self, parts: &UrlParts) -> Option<(&'static str, Context)> {
+ let mut query = parts.query.clone();
+ strip_tracking_query(&mut query);
+ let mut ctx = Context {
+ vars: HashMap::new(),
+ query,
+ };
+ let node = self.traverse(parts, &mut ctx)?;
+ Some((node, ctx))
+ }
+}
+
+fn is_reddit_listing_suffix(seg: &str) -> bool {
+ matches!(seg, "hot" | "top" | "new" | "rising" | "controversial")
+}
+
+/// Percent-encode a path or query fragment so `&`, `?`, etc. cannot break URL structure.
+fn enc(s: &str) -> String {
+ urlencoding::encode(s).into_owned()
+}
+
+// --- Canonical formatters ---
+
+fn canon_reddit_root(_: &Context) -> Option<String> {
+ Some("https://reddit.com".to_string())
+}
+
+fn canon_reddit_r_hub(_: &Context) -> Option<String> {
+ Some("https://reddit.com/r".to_string())
+}
+
+fn canon_reddit_subreddit(ctx: &Context) -> Option<String> {
+ let sub = ctx.vars.get("subreddit")?;
+ Some(format!(
+ "https://reddit.com/r/{}",
+ enc(&sub.to_ascii_lowercase())
+ ))
+}
+
+fn canon_reddit_post(ctx: &Context) -> Option<String> {
+ let sub = ctx.vars.get("subreddit")?.to_ascii_lowercase();
+ let id = ctx.vars.get("post_id")?;
+ Some(format!(
+ "https://reddit.com/r/{}/comments/{}",
+ enc(&sub),
+ enc(id)
+ ))
+}
+
+fn canon_youtube_root(_: &Context) -> Option<String> {
+ Some("https://youtube.com".to_string())
+}
+
+fn canon_youtube_watch(ctx: &Context) -> Option<String> {
+ let v = ctx
+ .query
+ .get("v")
+ .or_else(|| ctx.vars.get("video_id"))?;
+ Some(format!("https://youtube.com/watch?v={}", enc(v)))
+}
+
+fn canon_youtu_be(ctx: &Context) -> Option<String> {
+ let v = ctx.vars.get("vid_id")?;
+ Some(format!("https://youtube.com/watch?v={}", enc(v)))
+}
+
+pub fn build_graph() -> Graph {
+ GraphBuilder::new()
+ .node("reddit_root")
+ .canonical(canon_reddit_root)
+ .edge(EdgePattern::Literal("r"), "reddit_r_hub")
+ .node("reddit_r_hub")
+ .parent("reddit_root")
+ .canonical(canon_reddit_r_hub)
+ .edge(EdgePattern::Variable("subreddit"), "reddit_subreddit")
+ .node("reddit_subreddit")
+ .parent("reddit_r_hub")
+ .canonical(canon_reddit_subreddit)
+ .edge(
+ EdgePattern::AbsorbIf(is_reddit_listing_suffix),
+ "reddit_subreddit",
+ )
+ .edge(EdgePattern::Literal("comments"), "reddit_comments_gate")
+ .node("reddit_comments_gate")
+ .parent("reddit_subreddit")
+ .canonical(canon_reddit_subreddit)
+ .edge(EdgePattern::Variable("post_id"), "reddit_post")
+ .node("reddit_post")
+ .parent("reddit_subreddit")
+ .canonical(canon_reddit_post)
+ .edge(EdgePattern::AbsorbAny, "reddit_post")
+ .node("youtube_root")
+ .canonical(canon_youtube_root)
+ .edge(EdgePattern::Literal("watch"), "youtube_watch")
+ .edge(EdgePattern::Literal("shorts"), "youtube_shorts_gate")
+ .node("youtube_watch")
+ .parent("youtube_root")
+ .canonical(canon_youtube_watch)
+ .node("youtube_shorts_gate")
+ .parent("youtube_root")
+ .canonical(canon_youtube_root)
+ .edge(EdgePattern::Variable("video_id"), "youtube_watch")
+ .node("youtu_be_entry")
+ .canonical(canon_youtube_root)
+ .edge(EdgePattern::Variable("vid_id"), "youtu_be_video")
+ .node("youtu_be_video")
+ .parent("youtube_root")
+ .canonical(canon_youtu_be)
+ .build()
+}
+
+// --- Generic internet fallback ---
+
+pub fn generic_canonical(parts: &UrlParts) -> String {
+ let host = normalize_match_host(&parts.host);
+ let path_segments: Vec<String> = parts.path_segments.clone();
+ let mut query = parts.query.clone();
+ strip_tracking_query(&mut query);
+
+ let mut url = if path_segments.is_empty() {
+ Url::parse(&format!("https://{host}"))
+ .unwrap_or_else(|_| Url::parse("https://invalid").unwrap())
+ } else {
+ let path = format!("/{}", path_segments.join("/"));
+ Url::parse(&format!("https://{host}{path}"))
+ .unwrap_or_else(|_| Url::parse("https://invalid").unwrap())
+ };
+
+ if !query.is_empty() {
+ let mut pairs: Vec<_> = query.iter().collect();
+ pairs.sort_by(|a, b| a.0.cmp(b.0));
+ url.query_pairs_mut().clear();
+ for (k, v) in pairs {
+ url.query_pairs_mut().append_pair(k, v);
+ }
+ }
+
+ let mut s = url.to_string();
+ if path_segments.is_empty() {
+ s = s.trim_end_matches('/').to_string();
+ }
+ s
+}
+
+pub fn generic_breadcrumbs(parts: &UrlParts) -> Vec<String> {
+ let host = normalize_match_host(&parts.host);
+ let n = parts.path_segments.len();
+ let mut out = Vec::new();
+
+ let base = generic_canonical(&UrlParts {
+ scheme: "https".to_string(),
+ host: host.clone(),
+ path_segments: vec![],
+ query: HashMap::new(),
+ });
+ out.push(base);
+
+ for i in 0..n {
+ let segs: Vec<String> = parts.path_segments[..=i].to_vec();
+ let url = generic_canonical(&UrlParts {
+ scheme: "https".to_string(),
+ host: host.clone(),
+ path_segments: segs,
+ query: HashMap::new(),
+ });
+ if out.last() != Some(&url) {
+ out.push(url);
+ }
+ }
+ out
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::url_rules::parse::test_parts;
+
+ fn g() -> &'static Graph {
+ graph()
+ }
+
+ fn canon(parts: &UrlParts) -> String {
+ g().resolve_canonical(parts).unwrap()
+ }
+
+ fn crumbs(parts: &UrlParts) -> Vec<String> {
+ g().breadcrumbs(parts)
+ }
+
+ fn terminal(parts: &UrlParts) -> Option<&'static str> {
+ g().traverse_terminal(parts).map(|(n, _)| n)
+ }
+
+ fn vars(parts: &UrlParts) -> HashMap<String, String> {
+ g().traverse_terminal(parts)
+ .map(|(_, c)| c.vars)
+ .unwrap_or_default()
+ }
+
+ #[test]
+ fn youtu_be_malicious_segment_encoded_not_injected() {
+ let p = test_parts("youtu.be", &["abc&t=1"], &[]);
+ assert_eq!(canon(&p
… preview truncated; 29,502 characters omittedHardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.