Side A introduces substantial new functionality (rank-centrality ranking engine, event reducer, form templating, UI action dispatch, parser graph, vote comparison logic) that provides lasting architectural value, even though the diff is messy (shell-pasted files with prompt artifacts). Side B is purely a rustfmt-style reformatting commit with zero behavioral change, offering only cosmetic value and no new functionality or bugfixes.
constitution · epochs · watch · epoch 3
comparison
c_f6d0fed9bf9a (tommy-mor) vs c_995cbd9de96d (tommy-mor)
download prompt · raw event · cmp_4cbe5452f77da1
council reasoning
Side A seeds substantial project foundations (graph-based reddit URL parser with extensive tests, rank-centrality ranking with connected components and issue #146 fix, event reducer/state, HTML UI actions + form templates, vote compare page, and client SSE plumbing), while Side B is pure non-functional formatting/reflow of imports and signatures in one existing file with zero behavior or design change.
Side A introduces substantial new functionality across the project: new ranking and reducer logic with tests, a parser graph and extensive parser test suite, browser UI plumbing, vote handling, form-template processing, and supporting scripts. Side B is a pure formatting pass that only reflows imports, line breaks, and expressions in an existing file without changing behavior.
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_995cbd9de96d (tommy-mor)
message
[2e4be477] format
diff preview
diff --git a/server/src/html/garden.rs b/server/src/html/garden.rs
index 76ba96e45c9e16291a6ccd8096fdd01b274c1560..2d5fcd903fe8f56800ad2c5564b704bd25f9b18d 100644
--- a/server/src/html/garden.rs
+++ b/server/src/html/garden.rs
@@ -9,30 +9,28 @@ use serde::Deserialize;
use serde_json::json;
use std::collections::HashSet;
-use base64::{engine::general_purpose::URL_SAFE_NO_PAD as B64_ENGINE, Engine as _};
+use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD as B64_ENGINE};
use crate::{
api::optional_principal,
canonical_path::{canonicalize_item, canonicalize_tag},
- form_template::template_json_compact,
- html::{
- ui_action::UI_RPC_FIELD,
- user_can_post_room,
- JsBuilder,
- },
events::ThreadCapability,
+ form_template::template_json_compact,
+ html::{JsBuilder, ui_action::UI_RPC_FIELD, user_can_post_room},
path_types::ItemId,
- reducer::{scope_from_room_wire, ContentState, ReducerState, ScopeId},
- scope_rank::{build_children_rankings, ChildrenRankings},
+ reducer::{ContentState, ReducerState, ScopeId, scope_from_room_wire},
+ scope_rank::{ChildrenRankings, build_children_rankings},
state::AppState,
timeago,
};
use super::{
- bc_path, bc_path_external, bc_segment, cli_panel, layout, layout_full_bleed_chromeless, now_ms,
- ratio_pct, render_linkified_with_embeds_in_scope, theme_from_jar, theme_next_from_uri,
+ bc_path, bc_path_external, bc_segment,
breadcrumb_path::{ExternalOntologyPath, OntologyPath},
- forum::{ingest_entry_markup, ThreadNav},
+ cli_panel,
+ forum::{ThreadNav, ingest_entry_markup},
+ layout, layout_full_bleed_chromeless, now_ms, ratio_pct, render_linkified_with_embeds_in_scope,
+ theme_from_jar, theme_next_from_uri,
};
/// `GET /vote/compare` — pairs `left` / `right` query params with optional `thread`.
@@ -90,7 +88,11 @@ fn canonical_edge_items(a: &ItemId, b: &ItemId) -> (ItemId, ItemId) {
}
/// All votes whose endpoints are exactly this unordered pair (unsorted).
-fn edge_vote_entries_for_pair(content: &ContentState, a: &ItemId, b: &ItemId) -> Vec<crate::reducer::VoteData> {
+fn edge_vote_entries_for_pair(
+ content: &ContentState,
+ a: &ItemId,
+ b: &ItemId,
+) -> Vec<crate::reducer::VoteData> {
let (lo, hi) = canonical_edge_items(a, b);
let lo_s = lo.as_str();
let hi_s = hi.as_str();
@@ -107,7 +109,11 @@ fn edge_vote_entries_for_pair(content: &ContentState, a: &ItemId, b: &ItemId) ->
.collect()
}
-fn ratios_for_compare_page(v: &crate::reducer::VoteData, page_left: &ItemId, page_right: &ItemId) -> (i32, i32) {
+fn ratios_for_compare_page(
+ v: &crate::reducer::VoteData,
+ page_left: &ItemId,
+ page_right: &ItemId,
+) -> (i32, i32) {
let pl = page_left.as_str();
let pr = page_right.as_str();
match (v.a.as_str(), v.b.as_str()) {
@@ -121,11 +127,7 @@ fn left_share_normalized(ratio_left: i32, ratio_right: i32) -> f64 {
let l = ratio_left.max(0) as f64;
let r = ratio_right.max(0) as f64;
let sum = l + r;
- if sum <= 0.0 {
- 0.5
- } else {
- l / sum
- }
+ if sum <= 0.0 { 0.5 } else { l / sum }
}
/// Stronger preference for **`page_left` first**; ties **newer first**.
@@ -177,11 +179,7 @@ fn vote_thread_tags_for_pair(content: &ContentState, a: &ItemId, b: &ItemId) ->
v.into_iter().map(|t| canonicalize_tag(&t)).collect()
}
-fn vote_edge_history_markup(
- content: &ContentState,
- left: &ItemId,
- right: &ItemId,
-) -> maud::Markup {
+fn vote_edge_history_markup(content: &ContentState, left: &ItemId, right: &ItemId) -> maud::Markup {
let votes = edge_vote_entries_for_pair(content, left, right);
let votes = sort_votes_for_compare_display(votes, left, right);
let legend_left = item_display_path(left.as_str());
@@ -276,7 +274,12 @@ fn item_code_label(item: &str) -> String {
item_display_path(item)
}
-fn vote_compare_href(nav: &ThreadNav, left: &ItemId, right: &ItemId, thread_override: Option<&str>) -> String {
+fn vote_compare_href(
+ nav: &ThreadNav,
+ left: &ItemId,
+ right: &ItemId,
+ thread_override: Option<&str>,
+) -> String {
let left_q = urlencoding::encode(left.as_str());
let right_q = urlencoding::encode(right.as_str());
let base = format!(
@@ -299,7 +302,8 @@ fn ont_pin_vote_controls(
next_path: &str,
) -> maud::Markup {
let room_wire = nav.room_wire.clone();
- let current = ItemId::parse(current_storage).unwrap_or_else(|| ItemId::opaque(current_storage.to_string()));
+ let current = ItemId::parse(current_storage)
+ .unwrap_or_else(|| ItemId::opaque(current_storage.to_string()));
let pin_matches_scope = pinned_room_and_item
.map(|(r, _)| r == nav.room_wire.as_str())
.unwrap_or(false);
@@ -307,26 +311,22 @@ fn ont_pin_vote_controls(
.filter(|_| pin_matches_scope)
.map(|(_, i)| i);
- let pin_rpc = template_json_compact(
- &json!({
- "action": "set_garden_pin",
- "clear": false,
- "room_wire": room_wire,
- "item_storage": current.as_str(),
- "next": next_path,
- "form_action": "/ui",
- }),
- )
+ let pin_rpc = template_json_compact(&json!({
+ "action": "set_garden_pin",
+ "clear": false,
+ "room_wire": room_wire,
+ "item_storage": current.as_str(),
+ "next": next_path,
+ "form_action": "/ui",
+ }))
.expect("pin rpc json");
- let unpin_rpc = template_json_compact(
- &json!({
- "action": "set_garden_pin",
- "clear": true,
- "room_wire": "",
- "next": next_path,
- "form_action": "/ui",
- }),
- )
+ let unpin_rpc = template_json_compact(&json!({
+ "action": "set_garden_pin",
+ "clear": true,
+ "room_wire": "",
+ "next": next_path,
+ "form_action": "/ui",
+ }))
.expect("unpin rpc json");
html! {
@@ -497,9 +497,9 @@ fn room_scope_has_garden_content(reduced: &ReducerState, nav: &ThreadNav) -> boo
fn content_for_garden_view<'a>(reduced: &'a ReducerState, scope: &ScopeId) -> &'a ContentState {
match scope {
ScopeId::Public => reduced.public(),
- ScopeId::Room(_) => reduced.content_for_scope(scope).expect(
- "room garden only renders after room_scope_has_garden_content returned true",
- ),
+ ScopeId::Room(_) => reduced
+ .content_for_scope(scope)
+ .expect("room garden only renders after room_scope_has_garden_content returned true"),
}
}
@@ -723,10 +723,8 @@ pub async fn room_external_garden_index(
}
let ext_path = ExternalOntologyPath::from_input("");
let parent = ItemId::parse("https://.").unwrap();
- let child_rankings = build_children_rankings(
- content_for_garden_view(&reduced, &nav.scope()),
- &parent,
- );
+ let child_rankings =
+ build_children_rankings(content_for_garden_view(&reduced, &nav.scope()), &parent);
drop(reduced);
let page = layout(
@@ -953,48 +951,74 @@ fn build_rank_history(
None => return vec![],
Some(e) => e,
};
- entries.iter().map(|e| {
- // Resolve caused_by: votes from this ingest that directly touched this item.
- let caused_by: Vec<crate::reducer::VoteData> = reduced.ingests_by_id
- .get(&e.post_id)
- .and_then(|ing| crate::dsl::parse_full(&ing.raw).ok())
- .map(|doc| {
- doc.statements.into_iter().filter_map(|s| {
- if let crate::dsl::Stmt::Vote { item1, item2, ratio_left, ratio_right, explanation } = s {
- let a_str = crate::canonical_path::canonicalize_item(&item1);
- let b_str = crate::canonical_path::canonicalize_item(&item2);
- if a_str == item || b_str == item {
- Some(crate::reducer::VoteData {
- ts: e.ts,
- a: ItemId::parse(&a_str).unwrap_or_else(|| ItemId::opaque(a_str)),
- b: ItemId::parse(&b_str).unwrap_or_else(|| ItemId::opaque(b_str)),
- ratio_left, ratio_right,
- body: explanation,
- principal: reduced.ingests_by_id.get(&e.post_id)
- .map(|ing| ing.principal.clone())
- .unwrap_or_default(),
- delegate: reduced.ingests_by_id.get(&e.post_id).and_then(|ing| ing.delegate.clone()),
- thread_tag: e.thread.clone(),
- })
- } else { None }
- } else { None }
- }).collect()
- })
- .unwrap_or_default();
-
- let thread_post_index =
- reduced.thread_post_index_chronological(scope, &e.thread, &e.post_id);
-
- RankHistoryEntryView {
- ts: e.ts,
- scope_rank: e.scope_rank,
- scope_total: e.scope_total,
- scope_rank_delta: e.scope_rank_delta,
- thread: e.thread.clone(),
- thread_post_index,
- caused_by,
- }
- }).collect()
+ entries
+ .iter()
+ .map(|e| {
+ // Resolve caused_by: votes from this ingest that directly touched this item.
+ let caused_by: Vec<crate::reducer::VoteData> = reduced
+ .ingests_by_id
+ .get(&e.post_id)
+ .and_then(|ing| crate::dsl::parse_full(&ing.raw).ok())
+ .map(|doc| {
+ doc.statements
+ .into_iter()
+ .filter_map(|s| {
+ if let crate::dsl::Stmt::Vote {
+ item1,
+ item2,
+ ratio_left,
+ ratio_right,
+ explanation,
+ } = s
+ {
+ let a_str = crate::canonical_path::canonicalize_item(&item1);
+ let b_str = crate::canonical_path::canonicalize_item(&item2);
+ if a_str == item || b_str == item {
+ Some(crate::reducer::VoteData {
+ ts: e.ts,
+ a: ItemId::parse(&a_str)
+ .unwrap_or_else(|| ItemId::opaque(a_str)),
+ b: ItemId::parse(&b_str)
+ .unwrap_or_else(|| ItemId::opaque(b_str)),
+ ratio_left,
+ ratio_right,
+ body: explanation,
+ principal: reduced
+ .ingests_by_id
+ .get(&e.post_id)
+ .map(|ing| ing.principal.clone())
+ .unwrap_or_default(),
+ delegate: reduced
+ .ingests_by_id
+ .get(&e.post_id)
+ .and_then(|ing| ing.delegate.clone()),
+ thread_tag: e.thread.clone(),
+ })
+ } else {
+ None
+ }
+ } else {
+
… preview truncated; 4,089 characters omittedHardlinks — judgments / attempts / prompt
judgments
- ~anthropic/claude-sonnet-latest: A (8:2)
- ~x-ai/grok-latest: A (25:1)
- openai/gpt-chat-latest: A (100:1)
attempts
Prompt text is loaded only by the download route.