Side A adds a self-contained, tested feature (garden ranking markdown copy) with unit tests, integration test, browser test, and docs, following an existing pattern cleanly. Side B is a genuine architectural consolidation (merging /post, /post/check, /post/redact into /ui) which has real value but is riskier/broader churn with less test coverage added relative to the surface area touched, and includes a stray TODO comment signaling incompleteness.
constitution · epochs · watch · epoch 3
comparison
c_57453fc5c6c0 (tommy-mor) vs c_effff18688f9 (tommy-mor)
download prompt · raw event · cmp_b94a70c073dee0
council reasoning
B permanently unifies browser ingest/check/redact onto POST /ui (deletes web_post.rs and the /post* routes, introduces WebSession, rewires forms/tests), which is lasting architectural simplification. A adds a useful copy-rankings control with solid tests, but it is an incremental feature on an existing JsBuilder pattern rather than a structural improvement.
Side B performs a substantial architectural refactor by consolidating browser posting, checking, and redaction into the unified POST /ui RPC flow, introducing shared WebSession resolution, removing the separate web_post module, updating forms and routes, and adapting tests. Side A adds a useful end-user feature—a clipboard copy button for garden rankings with markdown formatting, UI wiring, permission checks, and tests—but its impact is narrower than the broader simplification and unification of the web interaction layer in Side B.
sides
A — c_57453fc5c6c0 (tommy-mor)
message
[8f6be6d0] Add copy button for garden rankings (markdown clipboard) (#168) * Add garden ranking markdown copy button via POST /ui Introduce HtmlUiAction::CopyGardenRank that rebuilds the visible child ranking and returns JsBuilder clipboard JS (fetch → eval), matching CopyThread. Place a copy control on garden ranking headings; clipboard text is a concise markdown numbered list with unranked bullets. Co-authored-by: tommy <thmorriss@gmail.com> * Fix paren balance in garden ranking copy browser test Co-authored-by: tommy <thmorriss@gmail.com> --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com>
diff preview
diff --git a/agents.md b/agents.md
index 7d6fea5791f7c95677e17e8975a14df83f998fd6..1dc989e4b23071f2eef69f2479c9a1ca2bd04b32 100644
--- a/agents.md
+++ b/agents.md
@@ -40,6 +40,8 @@ Strict **CSP** that blocks `eval` would break the current app. Other projects ma
- **Non-morph `POST /ui` responses:** **`SetGardenPin`** returns **`303 See Other`** and **`Set-Cookie`** (same as **`POST /theme`**). Garden pin/unpin is a normal **`<form method="POST" action="/ui" data-navigate="full">`** — browser navigation applies cookies reliably (see **`test/browser_garden_pin.clj`**). Each **`__rpc__`** payload includes **`form_action: "/ui"`**; **`post_ui_html`** rejects mismatches to bind tokens to the UI endpoint.
+- **`CopyGardenRank`:** Browser copy control on garden ranking headings. Returns **`text/javascript`** via **`JsBuilder::clipboard_write_text_and_label_btn`** (same **`fetch` → `eval`** loop as **`CopyThread`**). Payload includes **`room`**, **`parent_path`**, **`depth`**, **`copy_btn_id`**, and optional **`external_hosts`** (for **`/-/`** host-root indexes). Clipboard text is a concise markdown numbered list of display paths (plus unranked bullets).
+
- **`VoteComparePost`:** On success returns **`text/javascript`** that **morphs** **`#vote-edge-history-region`** (recomputed **`<ul>`** — ratios match **`left`/`right`** query order, bullets, sorted by strength toward **`left`** then newer) and **`.vote-compare-nav`** (fresh next-pair link). The compare **`GET`** page uses **`layout_full_bleed_chromeless`** (no breadcrumbs, no **`#controls`**, no **`slug-pin-hud`**; **`view-vote-compare-fullscreen`** full-width **`body`**). **`__rpc__`** carries **`form_action: "/ui"`**; **`thread_tag`** and ratio fields come from the same form as **`$form`** holes. **Guests** on a shared pair see the compose UI with **`post vote`** as a link to **`/login?next=<pair path>`** (class **`vote-compare-login-cta`**); after OAuth / username selection they return to that matchup. An unauthenticated **`VoteComparePost`** (forged/stale form) still JS-redirects to the same **`/login?next=`** target.
- **`ThreadGraduate` / `GraduateThread`:** Private-room forum threads with **Manage** can be published to the public site under the same tag. The writer replays non-redacted ingests into **`room: public`** (chronological order), then appends a durable **`ThreadGraduated`** marker. Graduated private threads show a banner linking to public **`/t/:tag`**, block further private posts, and cannot be graduated twice. CLI: **`npx slugsocial private <room> forum graduate <tag>`**; RPC: **`ThreadGraduate`**.
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index b4a0c9e87e462050bd52728e49e0d6781bf1cfc8..611956d0a46062b49ce350be176e4be139312ff0 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -24,9 +24,9 @@ use crate::{
external_resolver_status_markup, fragment_new_thread_slot, login_to_post_hint_markup,
parse_html_ui_from_form, room_members_section_markup, thread_feed_html,
thread_feed_html_for_room, thread_feed_region_markup, thread_ui_collapse_redacted_post,
- thread_ui_copy_thread,
- thread_ui_expand_post_full, thread_ui_expand_redacted_post, ui_js_warn, user_can_post_room,
- user_can_view_room, HtmlUiAction, JsBuilder, ThreadNav,
+ garden_ui_copy_rank, thread_ui_copy_thread, thread_ui_expand_post_full,
+ thread_ui_expand_redacted_post, ui_js_warn, user_can_post_room, user_can_view_room,
+ HtmlUiAction, JsBuilder, ThreadNav,
},
reducer::{scope_from_room_wire, ScopeId},
state::AppState,
@@ -575,6 +575,25 @@ async fn dispatch_ui_action(
let viewer = session.map(|s| s.username.as_str());
thread_ui_copy_thread(state, &room, &thread_tag, ©_btn_id, viewer).await
}
+ HtmlUiAction::CopyGardenRank {
+ room,
+ parent_path,
+ depth,
+ copy_btn_id,
+ external_hosts,
+ } => {
+ let viewer = session.map(|s| s.username.as_str());
+ garden_ui_copy_rank(
+ state,
+ &room,
+ &parent_path,
+ depth,
+ ©_btn_id,
+ external_hosts,
+ viewer,
+ )
+ .await
+ }
HtmlUiAction::GraduateThread { room, thread_tag } => {
let Some(session) = session else {
return js_redirect("/login").into_response();
diff --git a/server/src/html/garden/copy.rs b/server/src/html/garden/copy.rs
new file mode 100644
index 0000000000000000000000000000000000000000..271ea87c34c99e23ab1b0d8572632fdc41380b78
--- /dev/null
+++ b/server/src/html/garden/copy.rs
@@ -0,0 +1,199 @@
+//! Copy garden rankings to the clipboard as concise markdown (POST /ui + JsBuilder eval).
+
+use crate::form_template::template_json_compact;
+use crate::html::forum::ThreadNav;
+use crate::html::js_string_literal;
+use crate::html::ui_action::HtmlUiAction;
+use crate::html::{JsBuilder, ui_js_warn};
+use crate::path_types::ItemId;
+use crate::reducer::scope_from_room_wire;
+use crate::scope_rank::{
+ build_children_rankings, build_rankings_for_item_set, external_root_host_items,
+ resolve_scope_recursive, ChildrenRankings,
+};
+use crate::state::AppState;
+use maud::{html, Markup};
+
+use super::access::user_can_view_room;
+use super::item::item_display_path;
+use crate::reducer::{ContentState, ScopeId};
+
+const COPY_BTN_ID: &str = "garden-rank-copy";
+
+/// `POST /ui` + `__rpc__` from an inline button; response body is `eval`'d (same as forum copy).
+fn garden_ui_fetch_onclick(rpc_compact_json: &str) -> String {
+ format!(
+ "fetch('/ui',{{method:'POST',headers:{{'Content-Type':'application/x-www-form-urlencoded'}},body:new URLSearchParams({{__rpc__:{}}}).toString(),credentials:'same-origin'}}).then(r=>r.text()).then(eval);return false",
+ js_string_literal(rpc_compact_json)
+ )
+}
+
+/// Concise markdown for ranked child groups (numbered lists + unranked bullets).
+pub(crate) fn format_garden_rank_markdown(rankings: &ChildrenRankings) -> String {
+ let mut out = String::new();
+ let multi = rankings.component_rankings.len() > 1;
+ for (ci, comp) in rankings.component_rankings.iter().enumerate() {
+ if ci > 0 {
+ out.push('\n');
+ }
+ if multi {
+ out.push_str(&format!("### ordering {}\n\n", ci + 1));
+ }
+ for (i, r) in comp.ranked.iter().enumerate() {
+ out.push_str(&format!(
+ "{}. {}\n",
+ i + 1,
+ item_display_path(r.item.as_str())
+ ));
+ }
+ }
+ if !rankings.unranked_items.is_empty() {
+ if !out.is_empty() {
+ out.push('\n');
+ }
+ for name in &rankings.unranked_items {
+ out.push_str(&format!("- {}\n", item_display_path(name.as_str())));
+ }
+ }
+ out
+}
+
+fn rankings_for_copy(
+ state_content: &crate::reducer::ContentState,
+ parent_path: &str,
+ depth: usize,
+ external_hosts: bool,
+) -> ChildrenRankings {
+ if external_hosts {
+ let hosts = external_root_host_items(state_content);
+ return build_rankings_for_item_set(state_content, &hosts);
+ }
+ let parent = ItemId::parse(parent_path.trim())
+ .unwrap_or_else(|| ItemId::ontology_root())
+ .normalized_storage();
+ let depth = depth.clamp(1, 5);
+ if depth > 1 {
+ let items = resolve_scope_recursive(state_content, &[parent.as_str().to_string()], depth);
+ build_rankings_for_item_set(state_content, &items)
+ } else {
+ build_children_rankings(state_content, &parent)
+ }
+}
+
+pub(crate) async fn garden_ui_copy_rank(
+ state: &AppState,
+ room: &str,
+ parent_path: &str,
+ depth: usize,
+ copy_btn_id: &str,
+ external_hosts: bool,
+ viewer: Option<&str>,
+) -> axum::response::Response {
+ let room = room.trim();
+ let scope = scope_from_room_wire(room);
+ if let ScopeId::Room(ref rid) = scope {
+ let reduced = state.reduced.read().await;
+ if !user_can_view_room(&reduced, rid, viewer) {
+ return ui_js_warn("forbidden");
+ }
+ }
+
+ let reduced = state.reduced.read().await;
+ let empty = ContentState::default();
+ let content = match &scope {
+ ScopeId::Public => reduced.public(),
+ ScopeId::Room(_) => reduced.content_for_scope(&scope).unwrap_or(&empty),
+ };
+ let rankings = rankings_for_copy(content, parent_path, depth, external_hosts);
+ let text = format_garden_rank_markdown(&rankings);
+ drop(reduced);
+
+ if text.is_empty() {
+ return ui_js_warn("nothing to copy");
+ }
+
+ JsBuilder::new()
+ .clipboard_write_text_and_label_btn(&text, copy_btn_id, "copied")
+ .into_response()
+}
+
+pub(super) fn garden_rank_copy_button_markup(
+ nav: &ThreadNav,
+ parent_path: &str,
+ depth: usize,
+ external_hosts: bool,
+) -> Markup {
+ let rpc = template_json_compact(&HtmlUiAction::CopyGardenRank {
+ room: nav.room_wire.clone(),
+ parent_path: parent_path.to_string(),
+ depth,
+ copy_btn_id: COPY_BTN_ID.to_string(),
+ external_hosts,
+ })
+ .expect("CopyGardenRank serializes");
+ html! {
+ button type="button" id=(COPY_BTN_ID) class="post-nav-btn ont-rank-copy-btn" title="Copy ranking as markdown"
+ onclick=(garden_ui_fetch_onclick(&rpc)) {
+ "copy"
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::path_types::ItemId;
+ use crate::ranking::RankedItem;
+ use crate::scope_rank::ScopedComponent;
+
+ #[test]
+ fn markdown_single_component_and_unranked() {
+ let rankings = ChildrenRankings {
+ component_rankings: vec![ScopedComponent {
+ pairs: 1,
+ ranked: vec![
+ RankedItem {
+ item: ItemId::parse("~/a").unwrap(),
+ score: 0.9,
+ },
+ RankedItem {
+ item: ItemId::parse("~/b").unwrap(),
+ score: 0.1,
+ },
+ ],
+ }],
+ unranked_items: vec![ItemId::parse("~/c").unwrap()],
+ };
+ assert_eq!(
+ format_garden_rank_markdown(&rankings),
+ "1. ~/a\n2. ~/b\n\n- ~/c\n"
+ );
+ }
+
+ #[test]
+ fn markdown_multi_component_headers() {
+ let rankings = ChildrenRankings {
+ component_rankings: vec![
+ ScopedComponent {
+ pairs: 1,
+ ranked: vec![RankedItem {
+ item: ItemId::parse("~/a").unwrap(),
+ score: 1.0,
+ }],
+ },
+ ScopedComponent {
+ pairs: 1,
+ ranked: vec![RankedItem {
+ item: ItemId::parse("~/b").unwrap(),
+ score: 1.0,
+ }],
+ },
+ ],
+ unranked_items: vec![],
+ };
+ assert_eq!(
+ format_garden_rank_markdown(&rankings),
+ "### ordering 1\n\n1. ~/a\n\n### ordering 2\n\n1. ~/b\n"
+ );
+ }
+}
diff --git a/server/src/html/garden/mod.rs b/server/src/html/garden/mod.rs
index ee8696727e5473fe1fa913b8a7b9f3cb9c32d12f..69012a2c1d069e47fa611d63d3bd2a329fd6255d 100644
--- a/server/src/html/garden/mod.rs
+++ b/server/src/html/garden/mod.rs
@@ -2,6 +2,7 @@
mod access;
mod browse;
+mod copy;
mod external;
mod item;
mod item_page;
@@ -13,6 +14,7 @@ mod vote;
#[cfg(test)]
mod tests;
+pub(crate) use copy::garden_ui_copy_rank;
pub(crate) use external::external_resolver_status_markup;
pub(crate) use pin::{encode_
… preview truncated; 12,313 characters omittedB — c_effff18688f9 (tommy-mor)
message
[c3cbcaa7] refactor
diff preview
diff --git a/server/src/api/auth.rs b/server/src/api/auth.rs
index b3631b06153d52f88348fef927e7a024b7b85ad6..cd556eb89e9dd8203eba6c8969ffd144db5d329d 100644
--- a/server/src/api/auth.rs
+++ b/server/src/api/auth.rs
@@ -71,6 +71,24 @@ pub fn optional_principal(headers: &HeaderMap, jar: &CookieJar, reduced: &Reduce
verify_token(reduced, c.value()).ok()
}
+/// Browser session: principal + bearer token string (same shape as CLI session cookie).
+#[derive(Debug, Clone)]
+pub struct WebSession {
+ pub username: String,
+ pub bearer: String,
+}
+
+/// Resolve username and bearer together for `POST /ui` dispatch (one read of headers + jar).
+pub fn resolve_web_session(headers: &HeaderMap, jar: &CookieJar, reduced: &ReducerState) -> Option<WebSession> {
+ let username = optional_principal(headers, jar, reduced)?;
+ let bearer = headers
+ .get(header::AUTHORIZATION)
+ .and_then(|v| v.to_str().ok())
+ .and_then(|s| s.strip_prefix("Bearer ").map(|t| t.trim().to_string()))
+ .or_else(|| jar.get(SLUG_SESSION_COOKIE).map(|c| c.value().to_string()))?;
+ Some(WebSession { username, bearer })
+}
+
fn redirect_with_session_cookie(public_url: &str, path_and_query: &str, bearer: &str, jar: &CookieJar) -> Response {
let mut res = Response::builder()
.status(StatusCode::TEMPORARY_REDIRECT)
diff --git a/server/src/api/mod.rs b/server/src/api/mod.rs
index a986f706ea4b261cbaf004c02b4cf84184b41371..4e223a7460997c464706dca850281447bd754ed5 100644
--- a/server/src/api/mod.rs
+++ b/server/src/api/mod.rs
@@ -4,7 +4,6 @@ mod rpc;
mod stream;
mod validate;
mod ui_html;
-mod web_post;
pub use auth::{
get_join_invite,
@@ -19,7 +18,9 @@ pub use auth::{
get_web_login,
get_logout,
optional_principal,
+ resolve_web_session,
session_cookie_header_value,
+ WebSession,
SLUG_SESSION_COOKIE,
};
@@ -35,7 +36,6 @@ pub use stream::{get_html_stream, get_stream};
pub use validate::{normalize_room_and_thread, validate_ingest_document, ValidatedIngest};
pub use ui_html::post_ui_html;
-pub use web_post::{check_web_ingest, post_web_ingest, post_web_redact};
#[cfg(test)]
mod tests {
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index 2b40a72059981d558768f73d189b991f3448c257..497f8fdd222a8ec7c3d76b0695e0352e973ca3ba 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -1,25 +1,29 @@
-//! Single `POST /ui` entry for browser [`crate::html::ui_action::HtmlUiAction`] (JSON in `__rpc__` + holes).
+//! Single `POST /ui` entry: parse `__rpc__` → [`HtmlUiAction`], resolve [`WebSession`] once, dispatch.
use axum::{
- body::Body,
+ body,
extract::State,
- http::{header, HeaderMap, StatusCode},
+ http::{header, HeaderMap, HeaderValue, StatusCode},
response::{IntoResponse, Response},
Form,
};
use axum_extra::extract::cookie::CookieJar;
+use slug_types::{RpcBatch, RpcBatchResponse, RpcCommand, RpcResult};
use std::collections::HashMap;
use crate::{
api::{
- auth::optional_principal,
- web_post::{run_check_web_ingest, run_post_web_ingest, run_post_web_redact, WebPostForm, WebRedactForm},
+ auth::{resolve_web_session, WebSession},
+ handle_rpc_batch,
+ rpc::{rpc_post_redact, rpc_post_with_bearer},
},
+ canonical_path::canonicalize_tag,
html::{
fragment_public_new_thread_form, fragment_room_new_thread_form, login_to_post_hint_markup,
- parse_html_ui_from_form, user_can_post_room, user_can_view_room, HtmlUiAction, JsBuilder,
- ThreadNav,
+ parse_html_ui_from_form, thread_feed_html, thread_feed_html_for_room, thread_feed_region_markup,
+ user_can_post_room, user_can_view_room, HtmlUiAction, JsBuilder, ThreadNav,
},
+ reducer::{scope_from_room_wire, ScopeId},
state::AppState,
};
@@ -34,6 +38,19 @@ pub async fn post_ui_html(
Err(e) => return ui_js_warn(&e.to_string()).into_response(),
};
+ let reduced = state.reduced.read().await;
+ let session = resolve_web_session(&headers, &jar, &reduced);
+ drop(reduced);
+
+ dispatch_ui_action(&state, session.as_ref(), action).await
+}
+
+/// All UI command logic: HTTP extractors stop above; this only sees [`AppState`], session, and [`HtmlUiAction`].
+async fn dispatch_ui_action(
+ state: &AppState,
+ session: Option<&WebSession>,
+ action: HtmlUiAction,
+) -> Response {
match action {
HtmlUiAction::PostIngest {
room,
@@ -42,47 +59,87 @@ pub async fn post_ui_html(
error_target,
form_id,
} => {
- run_post_web_ingest(
- &state,
- &headers,
- &jar,
- WebPostForm {
- room,
- thread_tag,
- text,
- error_target,
- form_id,
- },
- )
- .await
+ let Some(session) = session else {
+ return js_redirect("/login").into_response();
+ };
+ let room = room.trim().to_string();
+ let thread_tag = thread_tag.trim().to_string();
+ if text.trim().is_empty() {
+ return form_js_error(
+ error_target.as_ref(),
+ "empty post",
+ "Write something in the text area (DSL / prose).",
+ )
+ .into_response();
+ }
+ match rpc_post_with_bearer(state, &session.bearer, room.clone(), thread_tag.clone(), text).await {
+ Ok(RpcResult::PostOk { .. }) => {
+ post_success_response(
+ state,
+ &room,
+ &thread_tag,
+ error_target.as_ref(),
+ form_id.as_ref(),
+ Some(session.username.as_str()),
+ )
+ .await
+ .into_response()
+ }
+ Ok(_) => form_js_error(
+ error_target.as_ref(),
+ "unexpected response",
+ "Post did not return PostOk.",
+ )
+ .into_response(),
+ Err((msg, hint)) => form_js_error(error_target.as_ref(), &msg, hint.as_deref().unwrap_or("")).into_response(),
+ }
}
HtmlUiAction::CheckIngest {
room,
thread_tag,
text,
error_target,
- form_id,
+ form_id: _,
} => {
- run_check_web_ingest(
- &state,
- &headers,
- &jar,
- WebPostForm {
- room,
- thread_tag,
- text,
- error_target,
- form_id,
- },
- )
- .await
+ let Some(session) = session else {
+ return js_redirect("/login").into_response();
+ };
+ let room = room.trim().to_string();
+ let thread_tag = canonicalize_tag(&thread_tag);
+ if thread_tag.is_empty() {
+ return form_js_error(
+ error_target.as_ref(),
+ "missing thread tag",
+ "Set a thread tag before posting.",
+ )
+ .into_response();
+ }
+ if text.trim().is_empty() {
+ return js_clear_errors(&form_error_target(error_target.as_ref())).into_response();
+ }
+ match rpc_check_with_bearer(state, &session.bearer, room, text.clone()).await {
+ Ok(RpcResult::CheckOk { .. }) => js_clear_errors(&form_error_target(error_target.as_ref())).into_response(),
+ Ok(_) => form_js_error(error_target.as_ref(), "unexpected response", "Check did not return CheckOk.").into_response(),
+ Err((msg, hint)) => form_js_error(error_target.as_ref(), &msg, hint.as_deref().unwrap_or("")).into_response(),
+ }
}
HtmlUiAction::RedactPost { post_id } => {
- run_post_web_redact(&state, &headers, &jar, WebRedactForm { post_id }).await
+ let Some(session) = session else {
+ return js_redirect("/login").into_response();
+ };
+ let h = headers_from_bearer(&session.bearer);
+ match rpc_post_redact(state, &h, post_id).await {
+ Ok(RpcResult::RedactPostOk {}) => redact_success_response(state).await.into_response(),
+ Ok(_) => (StatusCode::BAD_REQUEST, "unexpected response").into_response(),
+ Err((msg, hint)) => {
+ let detail = hint.as_deref().unwrap_or("");
+ js_error("#errors", &msg, detail).into_response()
+ }
+ }
}
HtmlUiAction::ExpandPublicNewThreadForm => {
let reduced = state.reduced.read().await;
- let user = optional_principal(&headers, &jar, &reduced);
+ let user = session.map(|s| s.username.as_str());
drop(reduced);
let markup = if user.is_some() {
fragment_public_new_thread_form(true)
@@ -99,18 +156,18 @@ pub async fn post_ui_html(
return ui_js_warn("missing room").into_response();
}
let reduced = state.reduced.read().await;
- let user = optional_principal(&headers, &jar, &reduced);
+ let user = session.map(|s| s.username.as_str());
if !reduced.rooms.contains(&room_wire) {
drop(reduced);
return ui_js_warn("room not found").into_response();
}
- if !user_can_view_room(&reduced, &room_wire, user.as_deref()) {
+ if !user_can_view_room(&reduced, &room_wire, user) {
drop(reduced);
return ui_js_warn("forbidden").into_response();
}
- let can_post = user
+ let can_post = session
.as_ref()
- .map(|u| user_can_post_room(&reduced, &room_wire, u))
+ .map(|s| user_can_post_room(&reduced, &room_wire, &s.username))
.unwrap_or(false);
drop(reduced);
let Some(nav) = ThreadNav::from_room_id(&room_wire) else {
@@ -128,12 +185,195 @@ pub async fn post_ui_html(
}
}
+fn headers_from_bearer(bearer: &str) -> HeaderMap {
+ let mut headers = HeaderMap::new();
+ if let Ok(hv) = HeaderValue::from_str(&format!("Bearer {bearer}")) {
+ headers.insert(header::AUTHORIZATION, hv);
+ }
+ headers
+}
+
+fn post_redirect_location(room: &str, thread_tag: &str) -> String {
+ let tag = canonicalize_tag(thread_tag);
+ if room.trim() == "public" {
+ format!("/t/{tag}")
+ } else {
+ let room = room.trim();
+ let Some((a, b)) = room.split_once('/') else {
+ return "/".to_string();
+ };
+ format!("/r/{a}/{b}/t/{tag}")
+ }
+}
+
+fn js_quote(s: &str) -> String {
+ serde_json::to_string(s).expect("js string escaping must succeed")
+}
+
+fn js_redirect(to: &str) -> Response {
+ let js = format!("window.location = {};", js_quote(to));
+ Response::builder()
+ .status(StatusCode::OK)
+ .header(header::CONTENT_TYPE, "text/javascript; charset=utf-8")
+ .body(axum::body::Body::from(js))
+ .unwrap()
+}
+
+fn js_error(error_target: &str, title: &str, detail: &str) -> Response {
+ let markup = maud::html! {
+ div id=(error_target.trim_start_matches('#')) {
+ p class="auth-error" { (title) }
+ @if !detail.is_empty() {
+ pre class="muted" { (detail) }
+ }
+ }
+ };
+ JsBuilder::new()
+ .morph_selector(error_targe
… preview truncated; 33,445 characters omittedHardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.