lib.rsThe archive: every request lmjtfy has had answered, and the questions people asked. These are the messages the Worker and the archive's Durable Object exchange. No I/O and no clock.
The rule (the user, 2026-10-02): the same request is never sent to the same model twice. A request is the exact body, and it is kept with its response under the model it went to. Asking again returns that response. The archive is also what makes the call, so two visitors asking the same new thing at once share one request.
10#![forbid(unsafe_code)]
What the Worker asks the archive.
Jev's answer to wanted about input. request is the body the
Worker prepared and shows on the page; the archive prepares it again
from wanted, and refuses if the two differ.
24 Jev { input: String, wanted: Wanted, request: String, #[serde(default)] pick: Pick },
The LLM's reply to request, from model.
26 Llm { model: String, request: String, #[serde(default)] pick: Pick },
input was asked and got answers, one per question Jev answered.
llm is whether an LLM had to be asked; listed is whether the
question may be shown on the public feed. who is the asking
browser for this question only (Asker): a browser that asked it
before is not counted again. None when the browser sent no id.
browser is that browser's id itself, kept beside who so the
owner can see whose row it is.
Someone cloned or pulled repo (lmjtfy.git) through the site.
Counted, and told to every open page.
46 Fetched { repo: String, fetch: Fetch },
who thinks Jev's answer to input right (Up) or wrong (Down).
The vote is for the answer as it is kept now; the same vote again
takes it back. Answered with the Rating after it.
The votes on Jev's answer to input as it is kept now, and who's.
58 Rating { input: String, who: Option<Asker> },
What the home page shows from the archive.
60 Home,
The next FEED listed questions asked before after, newest first:
the feed scrolled to its end.
63 Older { after: Cursor },
What Jev said to input, if it was ever asked and answered. Nothing
is sent to find out.
66 Answer { input: String },
The archive object's name: there is one, for the whole site. A Worker that binds the archive (the site's, the admin's) reaches it by this.
73pub const OBJECT: &str = "everything";
The path of the archive's door for the owner's admin backend. The site's own Worker never sends a request there; the admin's Worker, which binds the same object from the owner's account, does.
78pub const ADMIN: &str = "/admin";
What the admin backend asks the archive.
Rows of the archive's tables: one statement that only reads
(reads_only), with a value for each ?.
The owner's say on whether input may be shown on the feed: yes, no,
or None to leave it to the rules again. Jev's own verdict
(asked.listed) is kept beside it, untouched.
What the archive answers the admin backend.
Whether sql is one statement that can only read. The admin's door
changes the archive through Admin's own messages, never through SQL:
the schema changes only by a migration, and a response that was kept is
never edited. Text in quotes is not looked at, so a question that says
"delete" can still be searched for; pass such text as a value.
109pub fn reads_only(sql: &str) -> bool { 110 let mut bare = String::new(); 111 let mut quoted = None; 112 for c in sql.chars() { 113 match quoted { 114 Some(quote) if c == quote => quoted = None, 115 Some(_) => {} 116 None if c == '\'' || c == '"' => quoted = Some(c), 117 None => bare.push(c.to_ascii_lowercase()), 118 } 119 } 120 let bare = bare.trim().trim_end_matches(';').trim_end(); 121 let words: Vec<&str> = bare.split(|c: char| !c.is_ascii_alphanumeric() && c != '_').filter(|word| !word.is_empty()).collect(); 122 const WRITES: [&str; 13] = ["insert", "update", "delete", "replace", "drop", "alter", "create", "attach", "detach", "pragma", "vacuum", "reindex", "analyze"]; 123 quoted.is_none() && !bare.contains(';') && matches!(words.first(), Some(&"select") | Some(&"with")) && !words.iter().any(|word| WRITES.contains(word)) 124}
Which of a request's kept responses an ask wants. A request is sent
again only when a visitor asks for that (Fresh, the page's ↻); every
response it ever got is kept, numbered from 1, newest last.
Sent now, whatever is kept, and kept as the newest.
135 Fresh,
That one, if kept; the newest kept otherwise.
137 Version(u32),
The newest kept, and never sent: Called::NotKept if there is none.
What a page that is stepping through old versions uses for the calls
after the one it stepped, so looking costs nothing.
Which version of each call a page wants, by call_id: the page's
$pins signal, id:3;id:fresh, later entries winning. A call it does
not name gets the newest kept.
150impl Pins { 151 pub fn parse(text: &str) -> Pins { 152 let mut pins: Vec<(String, Pick)> = Vec::new(); 153 for entry in text.split(';') { 154 let Some((id, what)) = entry.trim().split_once(':') else { continue }; 155 if id.len() != 12 || !id.bytes().all(|b| b.is_ascii_hexdigit()) { 156 continue; 157 } 158 let pick = match what { 159 "fresh" => Pick::Fresh, 160 number => match number.parse::<u32>() { 161 Ok(version) if version > 0 => Pick::Version(version), 162 _ => continue, 163 }, 164 }; 165 pins.retain(|(seen, _)| seen != id); 166 pins.push((id.to_owned(), pick)); 167 } 168 Pins(pins) 169 }
Stepping through old versions, and asking nothing new: a version is pinned and nothing is to be sent again. Then a call that is not pinned is only read, never sent, so looking costs nothing.
What to ask the archive for, for the call id.
A call, as the page names it for ↻ and ◀ ▶: the first 12 hex digits of the SHA-256 of where it went and what was sent.
A response the archive holds, and the call that got it.
The response body exactly as it arrived.
The round trip of the call that was sent, in milliseconds.
204 pub took_ms: f64,
When that call was answered, in Unix milliseconds.
206 pub answered_ms: f64,
Whether this ask is the one that sent it.
208 pub sent_now: bool,
Which of the request's kept responses this is, from 1, and how many there are.
The same record, as someone who did not send it sees it.
A browser, for one question: the hex SHA-256 of the browser's random id and the question. It says whether this browser asked this question before, and nothing else: two questions from one browser give unrelated values, and the id cannot be had back from one.
A browser's view of Jev's answer.
The votes on one answer, and the asking browser's own, if it voted.
Which shared budget refused a call.
What became of a call.
Sent, or not sendable, and there is no response. Nothing is kept, so the same request may be sent again.
268 Failed { error: String, request_id: Option<String>, took_ms: f64 },
Not sent: today's budget for it is used up.
270 Spent(Pot),
What Jev said to one question, as it is kept for the feed and for link previews: the answer in a few words, and the numbers behind it.
What the page prints large: "No?", "Pepperoni.", "28%.".
The numbers behind an answer, by the type of question it answered.
Kept before details were. Only the headline is known.
288 Unknown,
A yes-or-no: the probability of yes.
290 Noul { p_yes: f64 },
A how-likely, which Jev answers as a Noul about the thing itself: the probability that it is so.
293 Chance { p: f64 },
A pick: every option with its probability, most likely first.
295 Choice { confidence: f64, options: Vec<(String, f64)> },
A how-much: every level with its probability, lowest first.
300impl Answer {
The type and the numbers in one line, as the page prints them under
an answer. None when only the headline was kept.
303 pub fn note(&self) -> Option<String> { 304 Some(match &self.detail { 305 Detail::Unknown => return None, 306 Detail::Noul { p_yes } => format!("Noul · p(yes) = {p_yes:.2}"), 307 Detail::Chance { p } => format!("Noul · p = {p:.2} · Jev thinks that's {}", ask::likelihood(*p)), 308 Detail::Choice { confidence, .. } => format!("Choice · confidence {confidence:.2}"), 309 Detail::Score { score, confidence, levels } => { 310 format!("Score · {score:.1} of {} · confidence {confidence:.2}", levels.len().saturating_sub(1)) 311 } 312 }) 313 }
The most likeliest options or levels, likeliest first, for a line
of text. Empty for a Noul, whose one number is in the note.
317 pub fn spread(&self, most: usize) -> Vec<(&str, f64)> { 318 let mut spread: Vec<(&str, f64)> = match &self.detail { 319 Detail::Choice { options, .. } => options.iter().map(|(label, p)| (label.as_str(), *p)).collect(), 320 Detail::Score { levels, .. } => levels.iter().map(|(label, p)| (label.as_str(), *p)).collect(), 321 _ => Vec::new(), 322 }; 323 spread.sort_by(|a, b| b.1.total_cmp(&a.1)); 324 spread.truncate(most); 325 spread 326 }
Everything in one line: the headline, the note and the spread.
329 pub fn line(&self) -> String { 330 let mut parts = vec![self.headline.clone()]; 331 parts.extend(self.note()); 332 let spread: Vec<String> = self.spread(3).iter().map(|(label, p)| format!("{label} {:.0}%", p * 100.0)).collect(); 333 if !spread.is_empty() { 334 parts.push(spread.join(", ")); 335 } 336 parts.join(" · ") 337 } 338}
A kept answer as it is stored: with its numbers, or, from before they were kept, as the headline alone.
Reads the answers a question was stored with, old form or new.
350pub fn stored(text: &str) -> Vec<Answer> { 351 let stored: Vec<Stored> = serde_json::from_str(text).unwrap_or_default(); 352 stored 353 .into_iter() 354 .map(|stored| match stored { 355 Stored::Whole(answer) => answer, 356 Stored::Headline(headline) => Answer { headline, detail: Detail::Unknown }, 357 }) 358 .collect() 359}
A question somebody asked, and what Jev said. Nothing about who asked.
When it was last asked.
367 pub asked_ms: f64,
372impl Entry {
The answers in a few words each, as the feed prints them.
How many questions the feed shows as asked lately, and as most asked.
The archive in numbers.
Different questions answered.
388 pub questions: u32,
Times a question was asked and answered, repeats included.
390 pub asks: u32,
Of the different questions, those Jev answered with no LLM.
392 pub no_llm: u32,
Requests that went out and were answered.
394 pub sent: u32,
Requests that did not go out, because their response was kept.
396 pub kept: u32,
Clones and pulls of the code through the site.
404impl Stats {
The share of questions answered with no LLM, as a whole percentage.
What the home page shows from the archive. The lists hold only questions that may be shown publicly; the numbers count every question.
Newest first.
416 pub lately: Vec<Entry>,
Where the feed was scrolled to: the last question shown. Questions are listed newest first, ties broken by the question itself, so the next page starts strictly after this one and none is shown twice or skipped.
431impl Entry {
Where the feed is once this entry is the last shown.
What a fetch through the clone proxy was. Git's upload-pack request names the commits wanted; a pull also names the ones it has.
446impl Fetch {
Its name in the archive's counts, for one repository.
What the archive pushes to every open page over its socket, as JSON:
{"online": 3} or {"toast": "<html>"}.
Pages open now.
462 Online(u32),
Something happened, as markup to show for a moment.
464 Toast(String),
The build the site is now (LMJTFY_BUILD), told to each page as it
connects. A page built from another offers a reload: a deploy
restarts the object, every page reconnects, and each hears this.
468 Build(String),
Elements that changed, each with an id: a page that has an element
with that id replaces it. An element with data-prepend="<id>"
instead puts its children at the top of that element, each removing
any element with its id first: a question asked again moves to the
top of the feed, and what a page has scrolled in below stays. The
activity feeds stay current this way, with no refresh.
Where an open page connected from, as Cloudflare placed the request: a country code and a city, either unknown. It is kept on the page's socket while it is open, for the online list.
487impl Place {
From what the Worker passed on, kept only if it looks like a place: a country is two letters, a city a short line of text.
490 pub fn new(country: Option<&str>, city: Option<&str>) -> Place { 491 let country = country 492 .map(str::trim) 493 .filter(|code| code.len() == 2 && code.bytes().all(|b| b.is_ascii_alphabetic())) 494 .map(str::to_ascii_uppercase) 495 // Cloudflare's own codes for Tor and for unknown are not places. 496 .filter(|code| code != "T1" && code != "XX"); 497 let city = city 498 .map(str::trim) 499 .filter(|city| !city.is_empty() && city.chars().count() <= 64 && !city.chars().any(char::is_control)) 500 .map(str::to_owned); 501 Place { country, city } 502 }
The country's flag: its two letters as regional indicator symbols.
Austin, US, US, or somewhere.
A header value as the Worker percent-encoded it (+ for a space), back
to text. None if it is not UTF-8 or a % is not followed by two hex
digits.
524pub fn percent_decoded(text: &str) -> Option<String> { 525 let mut bytes = Vec::with_capacity(text.len()); 526 let mut rest = text.bytes(); 527 while let Some(byte) = rest.next() { 528 match byte { 529 b'+' => bytes.push(b' '), 530 b'%' => { 531 let hex = [rest.next()?, rest.next()?]; 532 bytes.push(u8::from_str_radix(std::str::from_utf8(&hex).ok()?, 16).ok()?); 533 } 534 byte => bytes.push(byte), 535 } 536 } 537 String::from_utf8(bytes).ok() 538}
What the archive keeps on an open page's socket: where it is, and whether
a Worker that passes places on sent it. A page that reconnects while a
deploy is still reaching Cloudflare's edge can come through the Worker
from before, which passes no place; passed is false for it, and the
archive asks it to reconnect once the deploy has settled.
When it connected, in Unix milliseconds.
550 pub at_ms: f64,
The row of events that says it connected, which the row that says
it left copies who it was from.
How long after connecting an unplaced page is asked to reconnect: long enough for a deploy to reach the whole edge.
559pub const REPLACE_AFTER_MS: f64 = 10_000.0;
561impl Seen {
Whether this page should reconnect to be placed: it came through a
Worker that passes no place, long enough ago. A socket with nothing
kept on it (None) was accepted by code from before places.
How many open pages are in each place, most first, then by name.
571pub fn places(open: impl IntoIterator<Item = Place>) -> Vec<(Place, u32)> { 572 let mut counted: std::collections::BTreeMap<Place, u32> = std::collections::BTreeMap::new(); 573 for place in open { 574 *counted.entry(place).or_default() += 1; 575 } 576 let mut counted: Vec<(Place, u32)> = counted.into_iter().collect(); 577 counted.sort_by(|(a, n), (b, m)| m.cmp(n).then_with(|| a.label().cmp(&b.label()))); 578 counted 579}
What the archive says back.
None if the question was never answered, so there is nothing to
vote on.
A moment as YYYY-MM-DD HH:MM UTC.