Side B fixes a real bug (inconsistent canonical URL forms for the tilde ontology root causing sibling-rank/child-lookup mismatches), adds targeted unit and integration tests plus a browser regression test, and documents the invariant clearly. Side A mostly removes an unrelated demo feature and adds a settlement-worker/caching refactor that is reasonable but riskier and less obviously validated (no new tests for correctness of the batching/caching logic), making B's fix more clearly a lasting correctness improvement.
constitution · epochs · watch · epoch 3
comparison
c_4772ee88dbe3 (tommy-mor) vs c_b0194743d156 (tommy-mor)
download prompt · raw event · cmp_d543d4b797ba67
council reasoning
A introduces lasting core infrastructure: a batched settlement worker for votes, ranking score caching with warm-on-boot, and read-only ranking panel paths, while stripping demo-counter scaffolding end-to-end. B is a real, well-tested canonicalization bugfix for tilde ontology root keys (normalized storage, garden root children/rankings), but it is narrower than A’s settlement/cache redesign of the vote and ranking hot path.
Side A replaces synchronous vote handling with a dedicated settlement worker that batches event logging and ranking recomputation, introduces cached ranking reads (`ranked_items_cached`) to avoid recomputing on every HTTP render, and removes obsolete demo-counter code and locking. Side B fixes canonical ontology root/path normalization and related garden rendering bugs with strong regression tests, but its impact is narrower than A's broader performance and architecture improvements.
sides
A — c_4772ee88dbe3 (tommy-mor)
message
[07715165] nice
diff preview
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index c3c62a76f424010d77a6090c84dd0b82098f573e..da2536112faea313352624cf2ce0ddd0ab3377c1 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -6,7 +6,7 @@ use axum::{
use std::collections::HashMap;
use crate::{
- html::{demo_counter_panel, js_string_literal, ranking_panel, JsBuilder},
+ html::{js_string_literal, ranking_panel, JsBuilder},
parser::parse_reddit_url,
parser_render::parser_panel_morph,
state::AppState,
@@ -35,13 +35,6 @@ pub async fn post_ui_html(
};
match action {
- HtmlUiAction::BumpDemoCounter => {
- let count = state.bump_demo_counter().await;
- let panel = demo_counter_panel(count, state.event_log.path().to_string_lossy().as_ref());
- JsBuilder::new()
- .morph_selector("#demo-counter-panel", panel)
- .into_response()
- }
HtmlUiAction::RecordVote {
a,
b,
@@ -54,8 +47,8 @@ pub async fn post_ui_html(
{
return ui_js_warn(&e).into_response();
}
- let mut group = state.group.write().await;
- let panel = ranking_panel(&mut group);
+ let group = state.group.read().await;
+ let panel = ranking_panel(&group);
JsBuilder::new()
.morph_selector("#ranking-panel", panel)
.into_response()
@@ -87,20 +80,6 @@ mod tests {
assert!(matches!(err, HtmlUiParseError::MissingRpc));
}
- #[test]
- fn bump_action_deserializes() {
- let template = serde_json::json!({ "action": "bump_demo_counter" });
- let mut form = HashMap::new();
- form.insert(
- UI_RPC_FIELD.to_string(),
- serde_json::to_string(&template).unwrap(),
- );
- assert_eq!(
- parse_html_ui_from_form(&form).unwrap(),
- HtmlUiAction::BumpDemoCounter
- );
- }
-
#[test]
fn record_vote_action_deserializes() {
let template = serde_json::json!({
diff --git a/server/src/events.rs b/server/src/events.rs
index b969242534e184d4f0a689543a479670b08a18df..eff80aef0257f706d2341f666e63d6a3d921bf6e 100644
--- a/server/src/events.rs
+++ b/server/src/events.rs
@@ -5,8 +5,6 @@ use serde::{Deserialize, Serialize};
pub enum Event {
/// Page view recorded (path → counter in views.json).
ViewRecorded { path: String, ts: i64 },
- /// Demo counter bump from `POST /ui` (persisted in the single JSONL log).
- DemoCounterBumped { ts: i64, value: u64 },
/// Pairwise comparison vote (replayed into [`crate::reducer::GroupState`] on boot).
VoteRecorded {
ts: i64,
diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs
index 5b1d0b5a887d89e7e80796aa7a6c8ed5baaf2782..d69ed962b5c8625bc83c933b1825f2cc1d0868e2 100644
--- a/server/src/html/mod.rs
+++ b/server/src/html/mod.rs
@@ -13,7 +13,7 @@ use crate::{
form_template::template_json_compact,
parser_action::ParserAction,
parser_render::parser_panel,
- ranking::ranked_items,
+ ranking::ranked_items_cached,
reducer::GroupState,
state::AppState,
ui_action::UI_RPC_FIELD,
@@ -199,10 +199,8 @@ fn layout(title: &str, body: Markup, views: u64, theme: &str, theme_next: &str)
}
}
-pub fn ranking_panel(group: &mut GroupState) -> Markup {
- const MAX_ITERS: usize = 10_000;
- const TOL: f64 = 1e-8;
- let items = ranked_items(group, MAX_ITERS, TOL);
+pub fn ranking_panel(group: &GroupState) -> Markup {
+ let items = ranked_items_cached(group);
html! {
section id="ranking-panel" class="demo-panel" {
h2 { "Ranking" }
@@ -260,35 +258,6 @@ pub fn vote_panel() -> Markup {
}
-pub fn demo_counter_panel(count: u64, event_log_path: &str) -> Markup {
- let rpc = template_json_compact(&serde_json::json!({ "action": "bump_demo_counter" }))
- .expect("rpc json");
- html! {
- section id="demo-counter-panel" class="demo-panel" {
- h1 { "sorter2" }
- p class="muted" {
- "Pairwise ranking scaffold — votes persist to JSONL and replay on boot."
- }
- p class="demo-count" {
- strong { "Counter: " }
- span id="demo-count-value" { (count) }
- }
- p class="muted small" {
- "Event log: " code { (event_log_path) }
- }
- form method="post" action="/ui" id="demo-bump-form" {
- input type="hidden" name=(UI_RPC_FIELD) value=(rpc);
- button type="submit" class="btn-primary" { "Bump (POST /ui → eval JS)" }
- }
- p class="muted small" {
- "Uses hidden "
- code { "__rpc__" }
- " JSON + Idiomorph morph — no full page reload."
- }
- }
- }
-}
-
pub async fn home(
State(state): State<AppState>,
jar: CookieJar,
@@ -297,16 +266,15 @@ pub async fn home(
let path = uri.path().to_string();
state.views.increment(path.clone());
let views = state.views.get_views(&path);
- let count = *state.demo_counter.read().await;
let theme = theme_from_jar(&jar);
let theme_next = theme_next_from_uri(&uri);
- let mut group = state.group.write().await;
+ let group = state.group.read().await;
let empty_action = ParserAction::suggest(String::new(), None);
let body = html! {
+ h1 { "sorter2" }
(parser_panel("", &empty_action))
(vote_panel())
- (ranking_panel(&mut group))
- (demo_counter_panel(count, state.event_log.path().to_string_lossy().as_ref()))
+ (ranking_panel(&group))
};
layout("sorter2", body, views, theme, &theme_next)
}
diff --git a/server/src/lib.rs b/server/src/lib.rs
index 6716c5b282e7980a7a0f03d63ad8b25eda61cc55..fa423640d598f4ba97a5885d228e78d7b97f7a22 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -9,6 +9,7 @@ pub mod parser_render;
pub mod path_types;
pub mod ranking;
pub mod reducer;
+pub mod settlement;
pub mod state;
pub mod ui_action;
pub mod views;
diff --git a/server/src/ranking.rs b/server/src/ranking.rs
index 89d3280126a8d8f841721ce8cb63ff735d68752a..2d706762792ba9239bb3f1c2e4974a2fde908013 100644
--- a/server/src/ranking.rs
+++ b/server/src/ranking.rs
@@ -91,6 +91,11 @@ pub fn compute_group_ranking(group: &mut GroupState, max_iters: usize, tol: f64)
pub fn ranked_items(group: &mut GroupState, max_iters: usize, tol: f64) -> Vec<RankedItem> {
compute_group_ranking(group, max_iters, tol);
+ ranked_items_cached(group)
+}
+
+/// Read cached scores without recomputing (HTTP fast path).
+pub fn ranked_items_cached(group: &GroupState) -> Vec<RankedItem> {
let mut items: Vec<RankedItem> = group
.idx_to_item
.iter()
@@ -105,7 +110,12 @@ pub fn ranked_items(group: &mut GroupState, max_iters: usize, tol: f64) -> Vec<R
items
}
-fn compute_scores_from_edges(n: usize, edges: impl Iterator<Item = ((usize, usize), f64)>, max_iters: usize, tol: f64) -> Vec<f64> {
+pub fn compute_scores_from_edges(
+ n: usize,
+ edges: impl Iterator<Item = ((usize, usize), f64)>,
+ max_iters: usize,
+ tol: f64,
+) -> Vec<f64> {
if n == 0 {
return vec![];
}
diff --git a/server/src/settlement.rs b/server/src/settlement.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1f722ceaea62cda22c28ab71551f259fbf049b81
--- /dev/null
+++ b/server/src/settlement.rs
@@ -0,0 +1,114 @@
+use std::sync::Arc;
+
+use tokio::sync::{mpsc, oneshot, RwLock};
+
+use crate::{
+ event_log::EventLog,
+ events::Event,
+ ranking::compute_scores_from_edges,
+ reducer::{GroupState, VoteData},
+};
+
+const MAX_ITERS: usize = 10_000;
+const TOL: f64 = 1e-8;
+
+pub struct SettlementCommand {
+ pub vote: VoteData,
+ pub event: Event,
+ pub reply: oneshot::Sender<Result<(), String>>,
+}
+
+#[derive(Clone)]
+pub struct SettlementClient {
+ tx: mpsc::Sender<SettlementCommand>,
+}
+
+impl SettlementClient {
+ pub fn spawn(group: Arc<RwLock<GroupState>>, event_log: Arc<EventLog>) -> Self {
+ let (tx, rx) = mpsc::channel(64);
+ tokio::spawn(settlement_worker(rx, group, event_log));
+ Self { tx }
+ }
+
+ pub async fn record_vote(&self, vote: VoteData, event: Event) -> Result<(), String> {
+ let (reply, rx) = oneshot::channel();
+ self.tx
+ .send(SettlementCommand {
+ vote,
+ event,
+ reply,
+ })
+ .await
+ .map_err(|_| "settlement worker stopped".to_string())?;
+ rx.await
+ .map_err(|_| "settlement worker stopped".to_string())?
+ }
+}
+
+async fn settlement_worker(
+ mut rx: mpsc::Receiver<SettlementCommand>,
+ group: Arc<RwLock<GroupState>>,
+ event_log: Arc<EventLog>,
+) {
+ while let Some(first) = rx.recv().await {
+ let mut batch = vec![first];
+ while let Ok(more) = rx.try_recv() {
+ batch.push(more);
+ }
+
+ let mut disk_err: Option<String> = None;
+ for cmd in &batch {
+ if let Err(e) = event_log.append(&cmd.event).await {
+ disk_err = Some(e.to_string());
+ break;
+ }
+ }
+
+ if let Some(err) = disk_err {
+ for cmd in batch {
+ let _ = cmd.reply.send(Err(err.clone()));
+ }
+ continue;
+ }
+
+ let (edges, n) = {
+ let mut w = group.write().await;
+ for cmd in &batch {
+ w.apply_vote(cmd.vote.clone());
+ }
+ (w.edges.clone(), w.idx_to_item.len())
+ };
+
+ let new_scores = compute_scores_from_edges(
+ n,
+ edges.iter().map(|(&k, &v)| (k, v)),
+ MAX_ITERS,
+ TOL,
+ );
+
+ {
+ let mut w = group.write().await;
+ w.cached_scores = new_scores;
+ w.dirty = false;
+ }
+
+ for cmd in batch {
+ let _ = cmd.reply.send(Ok(()));
+ }
+ }
+}
+
+/// Compute ranking cache from current in-memory edges (startup replay only).
+pub fn warm_ranking_cache(group: &mut GroupState) {
+ if !group.dirty {
+ return;
+ }
+ let n = group.idx_to_item.len();
+ group.cached_scores = compute_scores_from_edges(
+ n,
+ group.edges.iter().map(|(&k, &v)| (k, v)),
+ MAX_ITERS,
+ TOL,
+ );
+ group.dirty = false;
+}
diff --git a/server/src/state.rs b/server/src/state.rs
index 8ec9902e2ecc31cf8208f7ad6365891dc5537eed..1922541a4064c2de1df2d993a461cae783320e05 100644
--- a/server/src/state.rs
+++ b/server/src/state.rs
@@ -6,6 +6,7 @@ use crate::{
event_log::EventLog,
events::Event,
reducer::{GroupState, VoteData},
+ settlement::{warm_ranking_cache, SettlementClient},
views::ViewStore,
};
@@ -38,8 +39,8 @@ pub struct AppState {
pub cfg: Arc<AppConfig>,
pub event_log: Arc<EventLog>,
pub views: ViewStore,
- pub demo_counter: Arc<RwLock<u64>>,
pub group: Arc<RwLock<GroupState>>,
+ settlement: SettlementClient,
}
impl AppState {
@@ -48,14 +49,10 @@ impl AppState {
let views_path = format!("{}/views.json", cfg.data_dir);
let views = ViewStore::new(&views_path);
- let mut demo_counter: u64 = 0;
let mut group = GroupState::new();
if let Ok((events, _)) = event_log.load_all().await {
for ev in events {
match ev {
- Event::DemoCounterBumped { value, .. } => {
- demo_counter = demo_counter.max(value);
- }
Event::VoteRecorded {
ts,
a,
@@ -74,30 +71,20 @@ impl AppState {
}
}
+
… preview truncated; 6,096 characters omittedB — c_b0194743d156 (tommy-mor)
message
[c59951f5] fixed canonical item paths business
diff preview
diff --git a/server/src/html/breadcrumb_path.rs b/server/src/html/breadcrumb_path.rs
index 12ad2c84faf2fbb693015d4552e45b5c54d587b9..c8a3937923161a6ff248bd77e87eff0dc6fe9ab0 100644
--- a/server/src/html/breadcrumb_path.rs
+++ b/server/src/html/breadcrumb_path.rs
@@ -1,4 +1,4 @@
-use crate::path_types::CanonicalItemUrl;
+use crate::path_types::{tilde_http_path_to_canonical, CanonicalItemUrl};
/// Semantic view of an ontology path for rendering and routing decisions.
pub(super) struct OntologyPath {
@@ -11,16 +11,7 @@ impl OntologyPath {
/// Path is the `*path` segment from `/~/*path` (e.g. `topic/a`). Always treat it as under `~/`
/// so it canonicalizes to `https://slug.social/~/…`, not the non-tilde site path.
pub(super) fn from_input(path: &str) -> Self {
- let p = path.trim_start_matches('/');
- let raw = if p.starts_with("http://") || p.starts_with("https://") {
- p.to_string()
- } else if p.is_empty() {
- "~/".to_string()
- } else {
- format!("~/{}", p)
- };
- let canonical = CanonicalItemUrl::parse(&raw)
- .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap());
+ let canonical = tilde_http_path_to_canonical(path);
Self::from_canonical(canonical)
}
@@ -37,7 +28,7 @@ impl OntologyPath {
}
pub(super) fn root() -> Self {
- Self::from_canonical(CanonicalItemUrl::parse("~/").unwrap())
+ Self::from_canonical(CanonicalItemUrl::ontology_root())
}
pub(super) fn is_root(&self) -> bool {
diff --git a/server/src/html/garden.rs b/server/src/html/garden.rs
index d58d9b46f575eb6b7e4971086b07dda75ca2f645..319feb15a6b68d2b5df98b4289fedbc9bdd048d3 100644
--- a/server/src/html/garden.rs
+++ b/server/src/html/garden.rs
@@ -459,6 +459,8 @@ struct ItemPageViewModel {
item: String,
body: Option<String>,
sibling_rank: Option<SiblingRank>,
+ /// False at the tilde ontology root (`~/`): sibling-rank footnote does not apply.
+ item_has_parent: bool,
child_rankings: ChildrenRankings,
rank_history: Vec<RankHistoryEntryView>,
/// Forum threads that mention or vote on this item.
@@ -470,11 +472,12 @@ fn build_sibling_rank(
scope: &ScopeId,
item: &CanonicalItemUrl,
) -> Option<SiblingRank> {
+ let item = item.clone().normalized_storage();
let content = reduced
.content_for_scope(scope)
.unwrap_or_else(|| reduced.public());
let group = &content.ranking_group;
- let parent = item.parent()?;
+ let parent = item.parent()?.normalized_storage();
let siblings: Vec<CanonicalItemUrl> = content
.item_children
.get(&parent)
@@ -492,7 +495,7 @@ fn build_sibling_rank(
if scoped_idxs.is_empty() {
return None;
}
- let current_idx = *group.item_to_idx.get(item)?;
+ let current_idx = *group.item_to_idx.get(&item)?;
if !scoped_idxs.contains(¤t_idx) {
return None;
}
@@ -520,7 +523,7 @@ fn build_sibling_rank(
.filter_map(|li| local_to_global.get(*li).copied())
.collect();
let ranked = ranked_items_subset(group, &comp_global, 10000, 1e-8);
- let position = ranked.iter().position(|r| &r.item == item)? + 1;
+ let position = ranked.iter().position(|r| r.item == item)? + 1;
Some(SiblingRank {
position,
component_size: ranked.len(),
@@ -597,7 +600,9 @@ fn build_item_page_view_model(
.content_for_scope(scope)
.unwrap_or_else(|| reduced.public());
let item_key = CanonicalItemUrl::parse(item)
- .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap());
+ .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap())
+ .normalized_storage();
+ let item_has_parent = item_key.parent().is_some();
let child_rankings = build_children_rankings(content, &item_key);
let rank_history = build_rank_history(reduced, scope, item_key.as_str());
@@ -617,6 +622,7 @@ fn build_item_page_view_model(
.cloned()
.or_else(|| reduced.public().item_bodies.get(&item_key).cloned()),
sibling_rank: build_sibling_rank(reduced, scope, &item_key),
+ item_has_parent,
child_rankings,
rank_history,
threads,
@@ -652,7 +658,7 @@ async fn render_scope_view(
(format!("#{} of {}", rank.position, rank.component_size))
}
span class="muted" { (format!("({} siblings)", rank.sibling_total)) }
- } @else {
+ } @else if model.item_has_parent {
span class="muted" { "unranked among siblings" }
}
}
@@ -815,6 +821,18 @@ mod tests {
}));
}
+ fn apply_ingest_room(state: &mut ReducerState, ts: i64, room_id: &str, raw: &str) {
+ state.apply_event(Event::Ingest(Ingest {
+ ts,
+ id: format!("ing-{ts}"),
+ raw: raw.to_string(),
+ principal: "testuser".to_string(),
+ delegate: Some("00000000-0000-0000-0000-000000000000:test:local/test".to_string()),
+ room_id: room_id.to_string(),
+ thread_tag: String::new(),
+ }));
+ }
+
#[test]
fn item_page_model_includes_body_and_unranked_without_votes() {
let mut reduced = ReducerState::default();
@@ -885,4 +903,85 @@ mod tests {
|| model.child_rankings.unranked_items.contains(&CanonicalItemUrl("https://slug.social/~/topic/kid2".to_string()))
);
}
+
+ #[test]
+ fn item_page_room_scope_root_lists_top_level_children() {
+ let mut reduced = ReducerState::default();
+ apply_ingest_room(
+ &mut reduced,
+ 1,
+ "9ab12cd/my-room",
+ "@00000000-0000-0000-0000-000000000000:test:local/test\n~/t1 {a}\n~/t2 {b}\n",
+ );
+ use crate::path_types::CanonicalItemUrl;
+ let root = CanonicalItemUrl::ontology_root();
+ let model = build_item_page_view_model(
+ &reduced,
+ &ScopeId::Room("9ab12cd/my-room".to_string()),
+ root.as_str(),
+ );
+ assert!(!model.item_has_parent);
+ assert_eq!(model.child_rankings.unranked_items.len(), 2);
+ let set: std::collections::HashSet<&str> = model
+ .child_rankings
+ .unranked_items
+ .iter()
+ .map(|u| u.as_str())
+ .collect();
+ assert!(set.contains("https://slug.social/~/t1"));
+ assert!(set.contains("https://slug.social/~/t2"));
+ }
+
+ /// Top-level `~/a` vs `~/b` votes form one ranked component under the ontology root.
+ #[test]
+ fn item_page_room_scope_root_shows_ranked_child_group() {
+ let mut reduced = ReducerState::default();
+ apply_ingest_room(
+ &mut reduced,
+ 1,
+ "9ab12cd/my-room",
+ "@00000000-0000-0000-0000-000000000000:test:local/test\n\
+ ~/a {a}\n~/b {b}\n~/a 2:1 ~/b {because}\n",
+ );
+ use crate::path_types::CanonicalItemUrl;
+ let root = CanonicalItemUrl::ontology_root();
+ let model = build_item_page_view_model(
+ &reduced,
+ &ScopeId::Room("9ab12cd/my-room".to_string()),
+ root.as_str(),
+ );
+ assert_eq!(model.child_rankings.component_rankings.len(), 1);
+ assert_eq!(model.child_rankings.component_rankings[0].pairs, 1);
+ let names: Vec<&str> = model.child_rankings.component_rankings[0]
+ .ranked
+ .iter()
+ .map(|r| r.item.as_str())
+ .collect();
+ assert_eq!(
+ names,
+ vec!["https://slug.social/~/a", "https://slug.social/~/b"]
+ );
+ assert!(model.child_rankings.unranked_items.is_empty());
+ }
+
+ /// Legacy `https://slug.social/~/` spelling still resolves children under the real root key.
+ #[test]
+ fn item_page_model_normalizes_legacy_tilde_root_storage_url() {
+ let mut reduced = ReducerState::default();
+ apply_ingest(
+ &mut reduced,
+ 1,
+ "@00000000-0000-0000-0000-000000000000:test:local/test\n~/x {x}\n",
+ );
+ let model = build_item_page_view_model(
+ &reduced,
+ &ScopeId::Public,
+ "https://slug.social/~/",
+ );
+ assert_eq!(model.child_rankings.unranked_items.len(), 1);
+ assert_eq!(
+ model.child_rankings.unranked_items[0].as_str(),
+ "https://slug.social/~/x"
+ );
+ }
}
diff --git a/server/src/path_types.rs b/server/src/path_types.rs
index 4c8075bbd488f1b9a5eda9e03ced83f6238c6d5e..361a9d446c9043cbdea5f060db2e8633c2fd9bf9 100644
--- a/server/src/path_types.rs
+++ b/server/src/path_types.rs
@@ -1,3 +1,5 @@
//! Re-exports — implementations live in `slug-types` (`paths` module).
-pub use slug_types::paths::{CanonicalItemUrl, RelativePath, TildePath};
+pub use slug_types::paths::{
+ tilde_http_path_to_canonical, CanonicalItemUrl, RelativePath, TildeHttpPathTail, TildePath,
+};
diff --git a/server/src/scope_rank.rs b/server/src/scope_rank.rs
index dc640848232b7e79142bfeeea3003c9023f84854..d656b2f0a0a3623ca6b234b746beaaca8ae6017d 100644
--- a/server/src/scope_rank.rs
+++ b/server/src/scope_rank.rs
@@ -149,9 +149,10 @@ pub fn build_rankings_for_item_set(content: &ContentState, items_in_scope: &[Can
/// Build connected-component rankings for direct children of parent_scope.
/// Matches the HTML garden view: multiple components, isolates, no-vote items.
pub fn build_children_rankings(content: &ContentState, parent: &CanonicalItemUrl) -> ChildrenRankings {
+ let parent = parent.clone().normalized_storage();
let items: Vec<CanonicalItemUrl> = content
.item_children
- .get(parent)
+ .get(&parent)
.map(|s| s.iter().cloned().collect())
.unwrap_or_default();
build_rankings_for_item_set(content, &items)
diff --git a/server/tests/integration.rs b/server/tests/integration.rs
index f9c218378f6a173e56ae1cec797b3c492986eac0..d4c5bfe9c6f1c71dc61878bd8c5e729b1b7c69ef 100644
--- a/server/tests/integration.rs
+++ b/server/tests/integration.rs
@@ -704,6 +704,62 @@ async fn test_private_room_post_links_use_private_garden_routes() {
assert!(garden_body.contains(&format!("/r/{room_short}/{room_slug}/t/garden-thread")));
}
+#[tokio::test]
+async fn test_private_room_garden_root_lists_top_level_tilde_children() {
+ let (addr, _tmp, _log, _handle) = create_test_server().await;
+ let client = reqwest::Client::builder()
+ .redirect(reqwest::redirect::Policy::none())
+ .build()
+ .unwrap();
+ let bearer = test_bearer();
+
+ let create = rpc_batch(
+ &client,
+ addr,
+ Some(&bearer),
+ serde_json::json!([{
+ "RoomCreate": { "slug": "garden-root-list" }
+ }]),
+ )
+ .await;
+ let room_id = create["results"][0]["result"]["RoomCreated"]["room_id"]
+ .as_str()
+ .unwrap()
+ .to_string();
+ let (room_short, room_slug) = room_id.split_once('/').unwrap();
+
+ let rpc = ui_post_ingest_rpc(
+ &room_id,
+ "ing",
+ "~/test1 {wow}\n~/test2 {wow2}\n~/test1 2:1 ~/test2 {because}\n",
+ );
+ let post = client
+ .post(format!("http://{addr}/ui"))
+ .header("Authorization", format!("Bearer {bearer}"))
+ .form(&[("__rpc__", rpc.as_str())])
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(post.status(), reqwest::StatusCode::OK);
+
+ let root_page = client
+ .get(format!("http://{addr}/r/{room_short}/{room_slug}/~"))
+ .header("Authorization", format!("Bearer {bearer}"))
+ .send()
+ .await
+ .unwrap();
+ assert!(root_page.status().is_success());
+ let body = root_page.text().await.unwrap();
+
… preview truncated; 14,119 characters omittedHardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.