Side A introduces substantial, lasting core functionality (form template substitution, ranking/rank-centrality algorithm with regression tests, reducer state machine, vote comparison UI, UI action dispatch) that forms real application logic and infrastructure, even though the diff includes messy artifacts like shell-prompt-contaminated files. Side B adds only a single browser integration test for pool-scoped voting, which is useful for verification but far narrower in scope and does not add product capability or design.
constitution · epochs · watch · epoch 3
comparison
c_f6d0fed9bf9a (tommy-mor) vs c_7ca21f5e83a8 (tommy-mor)
download prompt · raw event · cmp_09145427fe6de9
council reasoning
Side A lands substantial product foundation (reducer/ranking/vote UI flow, form-template UI actions, client plumbing, parser) that the system depends on long-term, despite some seed noise and design notes. Side B adds a valuable but narrow E2E browser test for the pool-scoped vote loop; lasting value is real regression coverage, not new design or core behavior.
Side A introduces substantial project functionality: core reducer and ranking logic, vote UI, parser infrastructure, form-template handling, UI actions, test scripts, and extensive unit tests. Side B adds a valuable end-to-end browser test for the pool-scoped voting flow, but it exercises existing behavior rather than adding new capabilities, so its long-term contribution is much smaller.
sides
A — c_f6d0fed9bf9a (tommy-mor)
message
[1d9d8ade] init seed
diff preview
diff --git a/TEST.sh b/TEST.sh
new file mode 100755
index 0000000000000000000000000000000000000000..266b71f29259f5c2cad2617476ebe2ebc9596d39
--- /dev/null
+++ b/TEST.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cargo test --all
+./scripts/clj-test.sh
diff --git a/bundle.js b/bundle.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d316f9a57cc7c379fe4bd8e42e092c7eac5d265
--- /dev/null
+++ b/bundle.js
@@ -0,0 +1,52 @@
+/**
+ * Slug web UI: only plumbing — fetch/eval/SSE. No product UI logic here.
+ */
+(function () {
+ function evalJs(js) {
+ if (js && String(js).trim()) {
+ eval(js);
+ }
+ }
+
+ // Theme cookie sync (runs before paint; full reload if localStorage disagrees with cookie)
+
+ function initSlugUi() {
+ // POST forms → eval response (except theme + full-navigation forms)
+ document.addEventListener('submit', async function (e) {
+ var f = e.target;
+ if (!f || f.tagName !== 'FORM') return;
+ if ((f.method || 'get').toLowerCase() !== 'post') return;
+ if (f.id === 'slug-theme-form') return;
+ if (f.getAttribute('data-navigate') === 'full') return;
+ e.preventDefault();
+ var resp = await fetch(f.action, {
+ method: 'POST',
+ body: new URLSearchParams(new FormData(f)),
+ headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+ credentials: 'same-origin',
+ });
+ evalJs(await resp.text());
+ });
+
+ // SSE: server-pushed JS
+ function connectSSE() {
+ var ssePath = window.location.pathname + window.location.search;
+ var es = new EventSource('/sse?path=' + encodeURIComponent(ssePath));
+ es.onmessage = function (e) {
+ evalJs(e.data);
+ };
+ es.onerror = function () {
+ es.close();
+ setTimeout(connectSSE, 3000);
+ };
+ }
+ connectSSE();
+ }
+
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', initSlugUi);
+ } else {
+ initSlugUi();
+ }
+})();
+
diff --git a/clj-test.sh b/clj-test.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b62a49b98ed60a65a46807b7ad80fa3142f14952
--- /dev/null
+++ b/clj-test.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")/.."
+mkdir -p target
+exec clojure -M:kaocha
diff --git a/forms.rs b/forms.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d509fd889fde3fed2662ce0a39006b7a51ae762a
--- /dev/null
+++ b/forms.rs
@@ -0,0 +1,145 @@
+tommy@Tommys-Laptop:~/programming/slug-star/slug|main ⇒ cat server/src/form_template.rs
+//! Plan2-style JSON templates with `{"$form": "field_name"}` holes, filled from
+//! `application/x-www-form-urlencoded` (or any `String` → `String` map) **before**
+//! deserializing into a typed struct.
+//!
+//! # Wire format
+//!
+//! Templates are **compact JSON** (`serde_json::to_string`): one line, no pretty
+//! printing, strings escaped per JSON rules (`\"`, `\n`, etc.). Embed that string
+//! in HTML attributes or text nodes with normal HTML escaping (e.g. maud), not
+//! bespoke encodings.
+//!
+//! # Power vs flat hidden fields
+//!
+//! A form is always a string→string map. You can fake depth with dotted keys (`a.b.c`),
+//! but one structured blob (`__rpc__` = compact JSON) gives you nested objects,
+//! arrays, and optional fields without inventing a new naming scheme each time.
+//!
+//! # Security
+//!
+//! Substitution runs **before** `serde` into your command type. It does not fix
+//! authorization: if the client can replace the hidden `__rpc__` value, they can
+//! change the command shape unless you validate (signed blob, server-side session
+//! context, or treat the blob as hints only). Same threat model as any hidden field.
+
+use serde::Serialize;
+use serde_json::Value;
+use std::collections::HashMap;
+
+/// Serialize a value to compact JSON for a hidden `__rpc__` (or similar) field.
+pub fn template_json_compact<T: Serialize>(v: &T) -> serde_json::Result<String> {
+ serde_json::to_string(v)
+}
+
+/// Recursively walk the JSON AST and replace `{"$form": "key"}` with the submitted
+/// string for `key` (empty if missing). Other keys are unchanged.
+pub fn substitute_form_vars(val: &mut Value, form_data: &HashMap<String, String>) {
+ match val {
+ Value::Object(map) => {
+ if map.len() == 1 {
+ if let Some(Value::String(field_name)) = map.get("$form") {
+ let submitted = form_data
+ .get(field_name.as_str())
+ .map(|s| s.as_str())
+ .unwrap_or("");
+ *val = Value::String(submitted.to_string());
+ return;
+ }
+ }
+ for v in map.values_mut() {
+ substitute_form_vars(v, form_data);
+ }
+ }
+ Value::Array(arr) => {
+ for v in arr.iter_mut() {
+ substitute_form_vars(v, form_data);
+ }
+ }
+ _ => {}
+ }
+}
+
+/// Parse JSON, apply [`substitute_form_vars`], return the mutated value.
+pub fn fill_template_from_form(
+ template_json: &str,
+ form_data: &HashMap<String, String>,
+) -> Result<Value, serde_json::Error> {
+ let mut v: Value = serde_json::from_str(template_json)?;
+ substitute_form_vars(&mut v, form_data);
+ Ok(v)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde::Deserialize;
+
+ #[derive(Debug, Deserialize, PartialEq, Eq)]
+ struct Demo {
+ room: String,
+ thread_tag: String,
+ nested: Nested,
+ }
+
+ #[derive(Debug, Deserialize, PartialEq, Eq)]
+ struct Nested {
+ text: String,
+ }
+
+ #[test]
+ fn holes_become_strings() {
+ let json = r#"{
+ "room": "public",
+ "thread_tag": {"$form": "tag"},
+ "nested": {"text": {"$form": "body"}}
+ }"#;
+ let mut form = HashMap::new();
+ form.insert("tag".into(), "foo".into());
+ form.insert("body".into(), "hello\nworld".into());
+
+ let v = fill_template_from_form(json, &form).unwrap();
+ let d: Demo = serde_json::from_value(v).unwrap();
+ assert_eq!(
+ d,
+ Demo {
+ room: "public".into(),
+ thread_tag: "foo".into(),
+ nested: Nested {
+ text: "hello\nworld".into(),
+ },
+ }
+ );
+ }
+
+ #[test]
+ fn missing_form_key_is_empty_string() {
+ let json = r#"{"x": {"$form": "nope"}}"#;
+ let mut form = HashMap::new();
+ form.insert("other".into(), "y".into());
+ let v = fill_template_from_form(json, &form).unwrap();
+ assert_eq!(v["x"], "");
+ }
+
+ #[test]
+ fn array_of_holes() {
+ let json = r#"{"items": [{"$form": "a"}, {"$form": "b"}]}"#;
+ let mut form = HashMap::new();
+ form.insert("a".into(), "1".into());
+ form.insert("b".into(), "2".into());
+ let v = fill_template_from_form(json, &form).unwrap();
+ assert_eq!(v["items"], serde_json::json!(["1", "2"]));
+ }
+
+ #[test]
+ fn template_json_compact_escapes_and_single_line() {
+ let s = template_json_compact(&serde_json::json!({
+ "x": "quote\"and\nnewline"
+ }))
+ .unwrap();
+ assert!(!s.contains('\n'));
+ assert!(s.contains("\\\"") || s.contains("\\n"));
+ }
+}
+tommy@Tommys-Laptop:~/programming/slug-star/slug|main ⇒
+
diff --git a/gameifying.tdsl b/gameifying.tdsl
new file mode 100644
index 0000000000000000000000000000000000000000..93d2a61d94fcba4370c82d9612e6bb0f0318cc15
--- /dev/null
+++ b/gameifying.tdsl
@@ -0,0 +1,2 @@
+consider gating certain views (top all time?) by a 10 day usage streak.. or something like that.
+or like a path, on homepage(?), that shows day 1: r/amitheasshole, day2: r/aww, day3: gaming, or something like that. progressive revelation + usage incentive.
diff --git a/pagerank_streaming.tdsl b/pagerank_streaming.tdsl
new file mode 100644
index 0000000000000000000000000000000000000000..0f2231b94936c17610adf653ca26b0faa6f2ac3a
--- /dev/null
+++ b/pagerank_streaming.tdsl
@@ -0,0 +1,11 @@
+eventually i want to have ranking histories.
+like "visionary" and "fraud" waxing and waning in a uplot graph over time for #elon-musk.
+there are too many query combinations to precomupte the ranking histories
+(arbitrary user filters, and tag overlap combinations maybe),
+so we're just going to have to calculate them all on demand.
+computers are fast, its okay. for each vote, we need to calculate rank centrality again.
+i was thinking, for n votes we calculate the rank centrality,
+and get node weights. we then output that data to the client (over websocket, or testable barrier).
+then we calculate n+1 votes, _but we keep the node weights in memory_
+so the rank centrality process converges faster.
+this also has the side effect of making the ranking stream in satisfyingly as you load the page.
diff --git a/parser.rs b/parser.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2b87b974f8d1dd93bee35681d87668a94e4ef349
--- /dev/null
+++ b/parser.rs
@@ -0,0 +1,1808 @@
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::cell::RefCell;
+use crate::ui::action::UIAction;
+use crate::ui::types::{Suggestion, GuideOption, ScrollingSuggestion};
+
+// --- Core Abstractions ---
+
+/// Unique identifier for nodes in the graph
+type NodeId = &'static str;
+
+/// Pattern matching for edges
+#[derive(Debug, Clone)]
+pub enum EdgePattern {
+ /// Matches exact literal string
+ Literal(&'static str),
+
+ /// Matches any prefix of a string and suggests the full string
+ /// e.g., PrefixOf("reddit.com") matches "r", "re", "red", "reddit", "reddit.com"
+ PrefixOf(&'static str),
+
+ /// Captures a variable segment (e.g., subreddit name, username)
+ Variable(&'static str),
+
+ /// Matches any string (wildcard)
+ Any,
+}
+
+impl EdgePattern {
+ /// Try to match this pattern against input, return (consumed_chars, captured_value)
+ fn matches(&self, input: &str) -> Option<(usize, Option<String>)> {
+ match self {
+ EdgePattern::Literal(lit) => {
+ if input.starts_with(lit) {
+ Some((lit.len(), None))
+ } else {
+ None
+ }
+ }
+ EdgePattern::PrefixOf(target) => {
+ // Check if input is a prefix of target
+ if target.starts_with(input) && !input.is_empty() {
+ // It's a valid prefix
+ Some((input.len(), None))
+ } else if input.starts_with(target) {
+ // Full match
+ Some((target.len(), None))
+ } else {
+ None
+ }
+ }
+ EdgePattern::Variable(var_name) => {
+ // Consume until next '/' or end of string
+ let end = input.find('/').unwrap_or(input.len());
+ if end > 0 {
+ let captured = input[..end].to_string();
+ // Validate based on variable type
+ if is_valid_variable(var_name, &captured) {
+ Some((end, Some(captured)))
+ } else {
+ None
+ }
+ } else {
+ None
+ }
+ }
+ EdgePattern::Any => {
+ // Match everything until next '/' or end
+ let end = input.find('/').unwrap_or(input.len());
+ if end > 0 {
+ Some((end, Some(input[..end].to_string())))
+ } else {
+ None
+ }
+ }
+ }
+ }
+
+ /// G
… preview truncated; 148,978 characters omittedB — c_7ca21f5e83a8 (tommy-mor)
message
[7287df45] Add browser test for pool-scoped vote sequence. Seeds ~/pool/a-j (10 letters), enters /vote?pool=~/pool, then follows the vote → next-pair loop up to 15 iterations. Asserts each vote lands in edge history and each pair shown belongs to the pool. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
diff preview
diff --git a/test/browser_vote_pool.clj b/test/browser_vote_pool.clj
new file mode 100644
index 0000000000000000000000000000000000000000..d51f05db47dc3cb013e56e65f3a1edfbbcbd96ab
--- /dev/null
+++ b/test/browser_vote_pool.clj
@@ -0,0 +1,137 @@
+(ns test.browser-vote-pool
+ "Pool-scoped voting: seed ~/pool/a-j, enter via /vote?pool=~/pool, follow
+ the vote → next-pair → vote sequence until no next pair or 15 iterations."
+ (:require [babashka.fs :as fs]
+ [cheshire.core :as json]
+ [clojure.string :as str]
+ [clojure.test :refer [deftest is]]
+ [com.blockether.spel.core :as core]
+ [com.blockether.spel.locator :as locator]
+ [com.blockether.spel.page :as page]
+ [test.common :as common]
+ [test.oauth :as oauth]))
+
+(defn- wait-for-text [pg selector expected timeout-ms]
+ (let [deadline (+ (System/currentTimeMillis) timeout-ms)]
+ (loop []
+ (let [text (locator/text-content (page/locator pg selector))]
+ (if (and (string? text) (str/includes? text expected))
+ true
+ (if (< (System/currentTimeMillis) deadline)
+ (do (Thread/sleep 200) (recur))
+ false))))))
+
+(defn- element-text [pg selector]
+ (try (locator/text-content (page/locator pg selector)) (catch Exception _ nil)))
+
+(defn- enc [^String s]
+ (java.net.URLEncoder/encode s "UTF-8"))
+
+(def letters ["a" "b" "c" "d" "e" "f" "g" "h" "i" "j"])
+
+(defn vote-pool-flow! []
+ (println "\n━━━ browser vote pool (/vote?pool= seeds + follow next-pair sequence) ━━━\n")
+
+ (common/letlocals
+ (bind build (common/run-cargo-build-release! ["slugsocial-server"]))
+ (is (zero? (:exit build)) "cargo build succeeds")
+ (bind server-bin "target/release/slugsocial-server")
+
+ (bind tmp-dir (str (fs/create-temp-dir {:prefix "slug-browser-vote-pool-"})))
+ (bind slug-port (common/pick-port))
+ (bind google-port (common/pick-port))
+ (bind base-url (str "http://127.0.0.1:" slug-port))
+ (bind google-url (str "http://127.0.0.1:" google-port))
+
+ (bind !server (atom nil))
+ (bind !google (atom nil))
+ (bind server-env (common/slug-server-env tmp-dir base-url google-url slug-port))
+ (try
+ (reset! !google (oauth/start-mock-google google-port
+ :google-users ["google-user-alice"]))
+ (reset! !server (common/start-server server-bin server-env))
+ (is (common/wait-for-server base-url 10000) "server responds to /healthz")
+
+ (let [alice-token (oauth/fetch-bearer-token! base-url :username "alice")
+ thread-tag "browser-vote-pool"
+ ;; seed ~/pool/a through ~/pool/j as items with bodies
+ item-lines (str/join "\n"
+ (map (fn [l] (str "~/pool/" l " {" l "}")) letters))
+ raw (str "# " thread-tag "\n\n~/pool {root}\n" item-lines "\n")
+ post-resp (oauth/http-post-json
+ (str base-url "/api/v0/rpc")
+ [{"Post" {"room" "public"
+ "thread_tag" thread-tag
+ "text" raw
+ "return_rank_diff" false}}]
+ :headers {"Authorization" (str "Bearer " alice-token)})
+ post-json (json/parse-string (:body post-resp) false)
+ _ (is (true? (get-in post-json ["results" 0 "ok"]))
+ "seed ~/pool/a-j items via rpc")
+ pool-url (str base-url "/vote?pool=" (enc "~/pool"))]
+
+ (core/with-playwright [pw]
+ (core/with-browser [browser (core/launch-chromium pw {:headless true :channel "chrome"})]
+ (core/with-context [ctx (core/new-context browser)]
+ (core/with-page [pg (core/new-page-from-context ctx)]
+ (page/navigate pg (str base-url "/login"))
+ (is (wait-for-text pg "body" "@alice" 15000) "alice session after login")
+
+ ;; Enter via pool URL — page picks first pair automatically.
+ (page/navigate pg pool-url)
+ (is (wait-for-text pg "body.view-vote-compare" "compare" 15000)
+ "pool entry: vote compare page loads")
+
+ ;; Verify the initial pair is within the pool.
+ (let [pair-text (element-text pg ".vote-compare-pair")]
+ (is (and (string? pair-text) (str/includes? pair-text "~/pool/"))
+ (str "initial pair is within ~/pool: " pair-text)))
+
+ ;; Follow vote → next-pair sequence up to 15 iterations.
+ (let [votes-cast
+ (loop [i 0]
+ (if (>= i 15)
+ i
+ (let [explanation (str "pool vote " i " reason")]
+ (locator/fill (page/locator pg "#vote-explain") explanation)
+ (locator/click (page/locator pg "#vote-compare-form button[type=submit]"))
+ ;; Wait for edge history morph confirming the vote landed.
+ (if-not (wait-for-text pg "ul.vote-edge-history" explanation 20000)
+ (do (println " vote" i "history morph timed out — stopping")
+ i)
+ (let [has-next (wait-for-text pg "[data-testid=\"vote-next-pair\"]"
+ "next pair" 8000)]
+ (if-not has-next
+ ;; "no next pair" — pool exhausted.
+ (do (println " no next pair after vote" i " — pool exhausted")
+ (inc i))
+ (do
+ ;; Verify the pair on this page is within the pool before advancing.
+ (let [pt (element-text pg ".vote-compare-pair")]
+ (is (and (string? pt) (str/includes? pt "~/pool/"))
+ (str "pair at vote " i " is within ~/pool: " pt)))
+ (locator/click (page/locator pg "[data-testid=\"vote-next-pair\"]"))
+ ;; Wait for next pair to load.
+ (wait-for-text pg "body.view-vote-compare" "compare" 10000)
+ (recur (inc i)))))))))]
+
+ (is (>= votes-cast 1) (str "cast at least 1 vote, got: " votes-cast))
+ (println (str " pool voting sequence complete: " votes-cast " vote(s) cast")))
+
+ ;; After the sequence, the current page is still a pool-scoped vote page.
+ (let [url (page/url pg)]
+ (is (str/includes? (or url "") "/vote")
+ (str "still on /vote after sequence: " url))))))))
+
+ (finally
+ (when-some [s @!server] (common/kill-server s))
+ (when-some [g @!google] ((:stop-fn g)))
+ (fs/delete-tree tmp-dir)))
+
+ nil))
+
+(defn vote-pool-browser-test [& _args]
+ (vote-pool-flow!))
+
+(deftest browser-vote-pool-sequence
+ (vote-pool-flow!))
Hardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.