Something went wrong. Try again.
this post sux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910/* * sux shared logic — pure functions, no extension APIs. * Loaded as a classic script in the background page, content script, and sidebar, * and require()-able from Node for the unit tests. */(function (global) { "use strict";
var TEXT_CAP = 2000; var EX_CAP = 10; // newest example/counter posts sent to Jev per rule var EX_TEXT_CAP = 500; var WORD_CAP = 80;
// Build-time switch for the local-model feature (SUX-11). Off in current // builds: the in-browser runtime is delivered separately, and until it // registers an embedder the Local UI is a dead end. With LOCAL_MODEL off, // settings.mode collapses to "both" — which, without a runtime, behaves // exactly like Jev-only — and the sidebar hides the chooser. Flip to true // in a build that ships the runtime. var LOCAL_MODEL = false;
function cleanWord(w) { if (typeof w !== "string") return ""; return w.trim().toLowerCase().slice(0, WORD_CAP); }
function normalizeClauseA(c) { c = c || {}; return { enabled: !!c.enabled, word1: cleanWord(c.word1), word2: cleanWord(c.word2), trained: normalizeTrained(c.trained), }; }
function normalizeClauseB(c) { c = c || {}; return { enabled: !!c.enabled, word: cleanWord(c.word), above: c.above !== false, trained: normalizeTrained(c.trained), }; }
// SUX-9: word rules accumulate a local separator from Jev's confident // answers — hide-side posts (the rule would hide them) and keep-side posts // (it would show them). Once both sides exist, the separator scores new // posts locally and Jev calls fall toward zero. function normalizeTrained(t) { t = t || {}; var clean = function (list) { return (Array.isArray(list) ? list : []) .map(normalizeExample) .filter(function (x) { return x.text.trim() || x.alt.trim(); }); }; return { hide: clean(t.hide), keep: clean(t.keep) }; }
function normalizeExample(x) { x = x || {}; var ex = { text: typeof x.text === "string" ? x.text.slice(0, TEXT_CAP) : "", alt: typeof x.alt === "string" ? x.alt.slice(0, TEXT_CAP) : "", }; if (Array.isArray(x.emb) && x.emb.every(function (v) { return typeof v === "number" && isFinite(v); })) { ex.emb = x.emb.slice(); } return ex; }
// SUX-4 rule type E: "hide posts like these". Built from a handful of // example posts the user doesn't want to see; scored locally against the // feed average (SUX-3). `cutoff` is what SUX-5 sets automatically; until // then 0 (score > 0 hides) matches the bench's flag-if-positive rule. // `counters` (SUX-6) are posts the user peeked and said "not this" — they // sharpen the "not this" side of scoring; they never replace the feed side. function normalizeClauseE(c) { c = c || {}; return { enabled: !!c.enabled, name: typeof c.name === "string" ? c.name.trim().slice(0, WORD_CAP) : "", examples: (Array.isArray(c.examples) ? c.examples : []) .map(normalizeExample) .filter(function (x) { return x.text.trim() || x.alt.trim(); }), counters: (Array.isArray(c.counters) ? c.counters : []) .map(normalizeExample) .filter(function (x) { return x.text.trim() || x.alt.trim(); }), cutoff: typeof c.cutoff === "number" && isFinite(c.cutoff) ? c.cutoff : 0, strictness: typeof c.strictness === "number" && c.strictness >= 0 && c.strictness <= 1 ? c.strictness : 0.5, }; }
// Canonical settings shape: arbitrary clauses per rule type. Settings stored // by older builds had single ruleA/ruleB objects; those migrate to one-element // arrays so saved filters keep working. function normalizeSettings(s) { s = s || {}; var aSrc = Array.isArray(s.rulesA) ? s.rulesA : (s.ruleA ? [s.ruleA] : []); var bSrc = Array.isArray(s.rulesB) ? s.rulesB : (s.ruleB ? [s.ruleB] : []); return { enabled: !!s.enabled, apiKey: typeof s.apiKey === "string" ? s.apiKey : "", combine: s.combine === "or" ? "or" : "and", peek: !!s.peek, // SUX-6: hidden posts collapse to placeholders instead of vanishing // SUX-11: which backends may run. "local" = never call Jev (no network); // "jev" = Jev judges everything; "both" = the SUX-7 hybrid (local first, // Jev for the unsure). Fail-open stays: a backend that can't run shows // posts. Gated by the LOCAL_MODEL build switch — with the switch off, // mode collapses to "both" and the sidebar hides the chooser. mode: LOCAL_MODEL && (s.mode === "local" || s.mode === "jev") ? s.mode : "both", rulesA: aSrc.map(normalizeClauseA), rulesB: bSrc.map(normalizeClauseB), rulesE: (Array.isArray(s.rulesE) ? s.rulesE : []).map(normalizeClauseE), }; }
function modeAllowsJev(mode) { return mode !== "local"; } function modeAllowsLocal(mode) { return mode !== "jev"; }
// SUX-11: the runtime reports download/init progress through here; the // background mirrors it into getStats and the sidebar shows the bar. var modelProgress = { pct: 0, status: "idle", at: 0 }; function reportModelProgress(pct, status) { modelProgress = { pct: typeof pct === "number" && pct >= 0 && pct <= 100 ? pct : 0, status: typeof status === "string" ? status.slice(0, 80) : "", at: Date.now(), }; } function getModelProgress() { return modelProgress; }
function defaults() { return normalizeSettings(null); }
// A clause needs two distinct usable words. "neither" is reserved as the // Choice's third option, so a word colliding with it would silently overwrite // that option. function clauseAValid(c) { return !!c.word1 && !!c.word2 && c.word1 !== c.word2 && c.word1 !== "neither" && c.word2 !== "neither"; }
function clauseBValid(c) { return !!c.word; }
// An example rule needs at least one example to compare against. function clauseEValid(c) { return c.examples.length > 0; }
// True when the filter should actually run: master on AND at least one usable // enabled clause. function isActive(st) { return st.enabled && (st.rulesA.some(function (c) { return c.enabled && clauseAValid(c); }) || st.rulesB.some(function (c) { return c.enabled && clauseBValid(c); }) || st.rulesE.some(function (c) { return c.enabled && clauseEValid(c); })); }
// FNV-1a — small, fast, dependency-free; collisions only cause a shared verdict, // which identical config+content would produce anyway with overwhelming likelihood. function hash(str) { var h = 0x811c9dc5; for (var i = 0; i < str.length; i++) { h ^= str.charCodeAt(i); h = Math.imul(h, 0x01000193); } return (h >>> 0).toString(16); }
// Cache key = clause config + post content. Changing any word or the combinator // invalidates old verdicts; reposts with identical text share one key (and one // API call) because the post id is deliberately not part of the key. Disabled // or invalid clauses keep their slot ("") so array indexes stay aligned with // the question/detail keys. Example rules hash their examples plus the model // id — swap the model or the examples and every verdict is recomputed. function cacheKey(st, text, alt, modelId) { // Trained data (SUX-9) changes local scores, so it joins the key: a rule // that has learned from Jev must not serve verdicts cached before it learned. var trainedHash = function (c) { var t = c.trained || { hide: [], keep: [] }; return hash(t.hide.length + ":" + t.keep.length); }; var cfg = st.rulesA.map(function (c, i) { return c.enabled && clauseAValid(c) ? "A" + i + ":" + c.word1 + "|" + c.word2 + "|" + trainedHash(c) : ""; }); st.rulesB.forEach(function (c, i) { cfg.push(c.enabled && clauseBValid(c) ? "B" + i + ":" + c.word + "|" + (c.above ? "above" : "below") + "|" + trainedHash(c) : ""); }); st.rulesE.forEach(function (c, i) { if (!c.enabled || !clauseEValid(c)) { cfg.push(""); return; } var ex = c.examples.map(function (x) { return x.text + "" + x.alt; }).join(""); var cx = (c.counters || []).map(function (x) { return x.text + "\x01" + x.alt; }).join("\x02"); cfg.push("E" + i + ":" + hash(ex) + "|" + hash(cx) + "|" + c.cutoff + "|" + c.strictness + "|" + (modelId || "")); }); cfg.push(st.combine); return hash(cfg.join(";")) + ":" + hash((text || "") + "\n" + (alt || "")); }
// Per-clause score cache keys: one entry per (clause config, post content), // so editing or toggling one clause leaves every other clause's cached // scores usable. The key holds only what changes that clause's score — // rule B's direction and the combinator are applied at decide time, so // flipping them costs no calls. Index-free, so reordering clauses is free // too. Returns [{id: "A0", score: "p0", key}] for enabled valid clauses. function clauseScoreKeys(st, text, alt, modelId) { var post = hash((text || "") + "\n" + (alt || "")); var trained = function (c) { var t = c.trained || { hide: [], keep: [] }; return t.hide.length + ":" + t.keep.length; }; var out = []; st.rulesA.forEach(function (c, i) { if (!c.enabled || !clauseAValid(c)) return; out.push({ id: "A" + i, score: "p" + i, key: "A" + hash(c.word1 + "|" + c.word2 + "|" + trained(c) + "|" + (modelId || "")) + ":" + post }); }); st.rulesB.forEach(function (c, i) { if (!c.enabled || !clauseBValid(c)) return; out.push({ id: "B" + i, score: "n" + i, key: "B" + hash(c.word + "|" + trained(c) + "|" + (modelId || "")) + ":" + post }); }); st.rulesE.forEach(function (c, i) { if (!c.enabled || !clauseEValid(c)) return; var ex = c.examples.map(function (x) { return x.text + "\x01" + x.alt; }).join("\x02"); var cx = (c.counters || []).map(function (x) { return x.text + "\x01" + x.alt; }).join("\x02"); out.push({ id: "E" + i, score: "e" + i, key: "E" + hash(ex + "|" + cx + "|" + c.cutoff + "|" + c.strictness + "|" + (modelId || "")) + ":" + post }); }); return out; }
function isJudgeable(post) { return !!((post.text && post.text.trim()) || (post.alt && post.alt.trim())); }
// Jev questions, one per enabled valid clause, keyed compare<i>/single<i>/ // example<i> so clauses of the same type stay distinguishable. Wording // follows the jev skill: one property per question, named state path in // backticks, contrastive criteria, no policy in the question (thresholds // live in decideFromScores). Example-rule criteria describe the rule's // intent; the example posts themselves are not sent. // // `only` (SUX-7) restricts to the listed clause ids ("A0", "B1", "E2") so // an escalation round-trips just the unsure clauses; omitted → all. // // `ref` names the post's state path ("post" by default); batched requests // put several posts in one state as post0, post1, …. function buildQuestions(st, only, ref) { var want = only || null; var at = "`" + (ref || "post") + "`"; var wants = function (id) { return !want || want.indexOf(id) !== -1; }; var q = {}; st.rulesA.forEach(function (c, i) { if (!c.enabled || !clauseAValid(c) || !wants("A" + i)) return; var w1 = c.word1; var w2 = c.word2; var cmp = { type: "choice", instructions: "Which option best describes the main topic or overall vibe of the post in " + at + "? Judge the post's own words only.", }; cmp.criteria = {}; cmp.criteria[w1] = "The post is mainly about " + w1 + ", or mainly expresses " + w1 + "."; cmp.criteria[w2] = "The post is mainly about " + w2 + ", or mainly expresses " + w2 + "."; cmp.criteria.neither = "The post is about neither " + w1 + " nor " + w2 + ", is about both equally, or it is too unclear to tell."; q["compare" + i] = cmp; }); st.rulesB.forEach(function (c, i) { if (!c.enabled || !clauseBValid(c) || !wants("B" + i)) return; var w = c.word; q["single" + i] = { type: "noul", instructions: "Does the post in " + at + " read as \"" + w + "\"? Judge the post's own words only.", criteria: { true: "The post is mainly about " + w + " or clearly expresses " + w + ".", false: "The post is not about " + w + ", or only mentions it in passing.", }, }; }); st.rulesE.forEach(function (c, i) { if (!c.enabled || !clauseEValid(c) || !wants("E" + i)) return; var name = c.name || "the hidden examples"; q["example" + i] = { type: "noul", instructions: "The user has a rule (\"" + name + "\") built from example posts they don't want to see: `rule" + i + ".examples`. Posts in `rule" + i + ".not_like` were wrongly matched before — they are NOT that kind of post. Does the post in " + at + " match the kind of post the examples represent? Judge the post's own words only.", criteria: { true: "The post is the same kind of post as the rule's examples — someone who hid those would want this hidden too.", false: "The post is a different kind of post, or it only superficially resembles the examples.", }, }; }); return q; }
function buildRequest(st, post, only) { var req = { state: { post: { text: (post.text || "").slice(0, TEXT_CAP), alt: (post.alt || "").slice(0, TEXT_CAP), }, }, model: "jev-latest", questions: buildQuestions(st, only), }; // Example rules: Jev needs the examples themselves, not just the name. // Capped so a long-lived rule can't balloon every request. Object.keys(req.questions).forEach(function (k) { var m = /^example(\d+)$/.exec(k); if (!m) return; var c = st.rulesE[+m[1]]; req.state["rule" + m[1]] = { examples: c.examples.slice(-EX_CAP).map(exampleForJev), not_like: (c.counters || []).slice(-EX_CAP).map(exampleForJev), }; }); return req; }
// Several posts in one call (one state, one question set per post). Jev // evaluates every question independently against the shared state, so a // batch costs one round-trip instead of one per post. items: [{post, only}]. // Questions are keyed j<k>_<question>; splitBatchAnswers undoes that. function buildBatchRequest(st, items) { var req = { state: {}, model: "jev-latest", questions: {} }; items.forEach(function (it, k) { req.state["post" + k] = { text: (it.post.text || "").slice(0, TEXT_CAP), alt: (it.post.alt || "").slice(0, TEXT_CAP), }; var q = buildQuestions(st, it.only, "post" + k); Object.keys(q).forEach(function (name) { var m = /^example(\d+)$/.exec(name); if (m && !req.state["rule" + m[1]]) { var c = st.rulesE[+m[1]]; req.state["rule" + m[1]] = { examples: c.examples.slice(-EX_CAP).map(exampleForJev), not_like: (c.counters || []).slice(-EX_CAP).map(exampleForJev), }; } req.questions["j" + k + "_" + name] = q[name]; }); }); return req; }
// Per-post answer maps (unprefixed, as jevToScores expects) from a batch. function splitBatchAnswers(answers, n) { var out = []; for (var k = 0; k < n; k++) out.push({}); Object.keys(answers || {}).forEach(function (name) { var m = /^j(\d+)_(.+)$/.exec(name); if (m && +m[1] < n) out[+m[1]][m[2]] = answers[name]; }); return out; }
function exampleForJev(x) { var t = (x.text || "").slice(0, EX_TEXT_CAP); return x.alt ? t + " [image: " + x.alt.slice(0, EX_TEXT_CAP) + "]" : t; }
// Reduce Jev's answers to a plain per-rule score map: p<i> = P(word1) for // clause A<i>, n<i> = Noul for clause B<i> (example-based rules will add // e<i>). This is answerDetails without the rounding — the seam every // backend (Jev, local embeddings, a mix) feeds into decideFromScores. // Clauses with no usable answer are omitted; decideFromScores treats a // missing score as "no verdict". function jevToScores(st, answers) { var scores = {}; for (var i = 0; i < st.rulesA.length; i++) { var a = st.rulesA[i]; if (!a.enabled || !clauseAValid(a)) continue; var probs = answers && answers["compare" + i] && answers["compare" + i].probabilities; var p = probs && typeof probs[a.word1] === "number" ? probs[a.word1] : null; if (p !== null) scores["p" + i] = p; } for (var j = 0; j < st.rulesB.length; j++) { var b = st.rulesB[j]; if (!b.enabled || !clauseBValid(b)) continue; var single = answers && answers["single" + j]; var n = single && typeof single.noul === "number" ? single.noul : null; if (n !== null) scores["n" + j] = n; } // SUX-7: an escalated example rule comes back as example<k>.noul, a 0..1 // probability on Jev's scale. decideFromScores compares e<k> against the // clause's local cutoff (a cosine-gap scale), so map Jev's confidence onto // that scale: p=1 → a full ESC_MARGIN past the cutoff on the hide side, // p=0 → a full margin on the show side. The verdict is Jev's either way. for (var k = 0; k < st.rulesE.length; k++) { var e = st.rulesE[k]; if (!e.enabled || !clauseEValid(e)) continue; var exAns = answers && answers["example" + k]; var jp = exAns && typeof exAns.noul === "number" ? exAns.noul : null; if (jp !== null) scores["e" + k] = escalatedToLocalScale(jp, effectiveCutoff(e)); } return scores; }
// Decide from a plain score map (any backend) — "show" | "hide" | null. // Null means an enabled clause had no score (transient/malformed backend // output) — callers fail open in that case. // // Score keys: p<i> = P(word1) for clause A<i>, n<i> = Noul for clause B<i>, // e<i> = similarity-minus-feed for clause E<i> (higher = more like the // examples = more hideable). An E clause hides at or above its effective // cutoff (SUX-5: auto leave-one-out value shifted by the strictness slider). function decideFromScores(st, scores) { var results = []; for (var i = 0; i < st.rulesA.length; i++) { var a = st.rulesA[i]; if (!a.enabled || !clauseAValid(a)) continue; var p = scores && typeof scores["p" + i] === "number" ? scores["p" + i] : null; if (p === null) return null; results.push(p >= 0.5); // "at least 50% word1" } for (var j = 0; j < st.rulesB.length; j++) { var b = st.rulesB[j]; if (!b.enabled || !clauseBValid(b)) continue; var n = scores && typeof scores["n" + j] === "number" ? scores["n" + j] : null; if (n === null) return null; results.push(b.above ? n > 0.5 : n < 0.5); // strict: exactly 0.5 fails both ways } for (var k = 0; k < st.rulesE.length; k++) { var e = st.rulesE[k]; if (!e.enabled || !clauseEValid(e)) continue; var s = scores && typeof scores["e" + k] === "number" ? scores["e" + k] : null; if (s === null) return null; results.push(s < effectiveCutoff(e)); // below the hide-line → this clause doesn't hide } if (results.length === 0) return null; var pass = st.combine === "or" ? results.some(function (x) { return x; }) : results.every(function (x) { return x; }); return pass ? "show" : "hide"; }
// Jev-shaped convenience wrapper — kept while callers of the raw answer // shape (the userscript) still exist. function decideFromAnswers(st, answers) { return decideFromScores(st, jevToScores(st, answers)); }
// Round a plain score map for storage/telemetry (cache details, sidebar). function roundScores(scores) { var d = {}; Object.keys(scores || {}).forEach(function (k) { if (typeof scores[k] === "number" && isFinite(scores[k])) { d[k] = Math.round(scores[k] * 1000) / 1000; } }); return d; }
// Score details behind a verdict — telemetry for tuning and for explaining // near-threshold behavior. Rounded view of jevToScores: p<i> = P(word1) for // clause A<i>, n<i> = Noul for clause B<i>. function answerDetails(st, answers) { return roundScores(jevToScores(st, answers)); }
/* ---------------- model runtime interface ---------------- * * SUX-2: the in-browser model runtime implements this interface and hands * it to SuxShared.registerEmbedder. sux only ever touches these members, so * any model that can turn post text into vectors plugs in the same way: * * { * id: "embeddinggemma-300m-q4@<rev>", // identity — goes into cache keys * dims: 768, // vector width * ready(): Promise<void>, // download + init, reports progress * embed(texts: string[], kind: "post" | "query"): Promise<Float32Array[]> * } * * `kind` hides the model's prompt prefixes from sux (EmbeddingGemma uses * "task: classification | query: "); the runtime owns those strings. One * call embeds many texts. Laya does not fit this interface — the bench says * it isn't worth keeping anyway. */
var registeredEmbedder = null;
// Returns null when e satisfies the interface, else a short reason. Pure // shape check only; ready()/embed() behavior is the runtime's business. function checkEmbedder(e) { if (!e || typeof e !== "object") return "embedder must be an object"; if (typeof e.id !== "string" || !e.id) return "id must be a non-empty string"; if (typeof e.dims !== "number" || e.dims <= 0 || Math.floor(e.dims) !== e.dims) { return "dims must be a positive integer"; } if (typeof e.ready !== "function") return "ready() missing"; if (typeof e.embed !== "function") return "embed() missing"; return null; }
function registerEmbedder(e) { var problem = checkEmbedder(e); if (problem) throw new Error("bad embedder: " + problem); registeredEmbedder = e; }
function getEmbedder() { return registeredEmbedder; }
/* ---------------- vector math (pure; used by local scoring) ---------------- */
// Cosine similarity; 0 when either side is a zero vector (a missing // embedding must not produce NaN downstream). function cosine(a, b) { var dot = 0, na = 0, nb = 0; var n = Math.min(a ? a.length : 0, b ? b.length : 0); for (var i = 0; i < n; i++) { dot += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i]; } if (!na || !nb) return 0; return dot / (Math.sqrt(na) * Math.sqrt(nb)); }
// Component-wise mean of a non-empty array of equal-length vectors. function meanVector(vecs) { if (!vecs.length) return null; var out = new Array(vecs[0].length); for (var d = 0; d < out.length; d++) { var s = 0; for (var i = 0; i < vecs.length; i++) s += vecs[i][d]; out[d] = s / vecs.length; } return out; }
/* ---------------- SUX-4: example-rule scoring (pure) ---------------- */
// "Hide posts like these": how much more the post looks like the examples // than like the user's feed overall. Positive → closer to the examples than // to the feed average. Bench: AUROC 0.97 politics / 0.96 angry with 3–5 // examples and the pool as the "not this" side. // // SUX-6: counter-examples (posts the user peeked and rejected) sharpen the // "not this" side — they join the feed average in the contrast, they never // replace it. Near misses on top of the feed gave the best fuzzy-rule // results in the bench (self-promotion 0.83, funny 0.75); without the feed // average they're worse than nothing. function scoreExampleRule(postEmb, exampleEmbs, feedAvgEmb, counterEmbs) { var likeExamples = cosine(postEmb, meanVector(exampleEmbs)); var notThis = []; if (feedAvgEmb) notThis.push(feedAvgEmb); if (counterEmbs) { for (var i = 0; i < counterEmbs.length; i++) notThis.push(counterEmbs[i]); } var likeNotThis = notThis.length ? cosine(postEmb, meanVector(notThis)) : 0; return likeExamples - likeNotThis; }
/* ---------------- SUX-5: automatic cutoff + strictness ---------------- * * Natural cutoffs are too cautious: with 5 politics examples, flagged * posts are right 89% of the time but only 65% of politics posts get * flagged. So the cutoff comes from the examples themselves: score each * against the mean of the others (leave-one-out) and take the lowest — * every example just barely hides — then back off by MARGIN so near-miss * posts still hide. The strictness slider shifts the cutoff ±MARGIN around * that default (0.5 = the auto value). */
var CUTOFF_MARGIN = 0.05; // How far the strictness slider walks from the auto cutoff. The bench sets // this: the PR frontier for 5-example rules spans ≈ looMin−0.05 … looMin+0.10 // (P 0.37→0.84, R 0.98→0.68 on politics), so ±0.15 covers the useful range; // ±margin would spend the whole slider on a sliver of it. var STRICTNESS_SPAN = 0.15;
// Lowest leave-one-out score minus margin; null with fewer than 2 examples // (leave-one-out of one example is cos(x, x) = 1, a degenerate cutoff). function looCutoff(exampleEmbs, feedAvgEmb, margin) { if (!exampleEmbs || exampleEmbs.length < 2) return null; var m = typeof margin === "number" ? margin : CUTOFF_MARGIN; var lowest = Infinity; for (var i = 0; i < exampleEmbs.length; i++) { var others = []; for (var j = 0; j < exampleEmbs.length; j++) { if (j !== i) others.push(exampleEmbs[j]); } var s = scoreExampleRule(exampleEmbs[i], others, feedAvgEmb); if (s < lowest) lowest = s; } return lowest - m; }
// The cutoff decideFromScores actually uses: the stored auto-cutoff shifted // by the slider. Higher strictness → higher cutoff → fewer posts hidden. // strictness 0.5 = the auto value; 0/1 walk ±STRICTNESS_SPAN. function effectiveCutoff(c) { var base = typeof c.cutoff === "number" && isFinite(c.cutoff) ? c.cutoff : 0; var strictness = typeof c.strictness === "number" ? c.strictness : 0.5; return base + (strictness - 0.5) * 2 * STRICTNESS_SPAN; }
// SUX-6: which clause hid this post? The first enabled valid clause whose // score crosses its hide-line, E before B before A — example rules first // because they're the ones corrections can act on. Returns {type, index, // key, score, name} or null when nothing hides (peek placeholders only // render on hide, so null is unusual but safe). function hiddenByClause(st, scores) { for (var k = 0; k < st.rulesE.length; k++) { var e = st.rulesE[k]; if (!e.enabled || !clauseEValid(e)) continue; var s = scores && scores["e" + k]; if (typeof s === "number" && s >= effectiveCutoff(e)) { return { type: "E", index: k, key: "e" + k, score: s, name: e.name || "hidden examples" }; } } for (var j = 0; j < st.rulesB.length; j++) { var b = st.rulesB[j]; if (!b.enabled || !clauseBValid(b)) continue; var n = scores && scores["n" + j]; if (typeof n === "number" && (b.above ? n <= 0.5 : n >= 0.5)) { return { type: "B", index: j, key: "n" + j, score: n, name: b.word }; } } for (var i = 0; i < st.rulesA.length; i++) { var a = st.rulesA[i]; if (!a.enabled || !clauseAValid(a)) continue; var p = scores && scores["p" + i]; if (typeof p === "number" && p < 0.5) { return { type: "A", index: i, key: "p" + i, score: p, name: a.word1 + " vs " + a.word2 }; } } return null; }
/* ---------------- SUX-8: is this rule too fuzzy for the local model? ---------------- * * Tone and intent rules (funny, self-promotion) land ~0.15 AUROC below * topic rules no matter how many examples they get; the local model can't * see them. The heuristic is the mean leave-one-out score — how well the * examples recognize each other over the feed. Bench validation: medians * separate crisply (politics -0.027, angry +0.062 vs self-promotion * -0.053, funny -0.059, threshold -0.04) and match the AUROC ranking. * Mean pairwise similarity was tested and rejected (self-promotion * examples cluster tightly — they just don't separate from the feed). * Draw-to-draw tails overlap, so the badge is a warning, not a verdict. */
var FUZZY_LMEAN_THRESHOLD = -0.04;
// Mean leave-one-out score, or null with fewer than 2 examples. function ruleFuzziness(exampleEmbs, feedAvgEmb) { if (!exampleEmbs || exampleEmbs.length < 2) return null; var sum = 0; for (var i = 0; i < exampleEmbs.length; i++) { var others = []; for (var j = 0; j < exampleEmbs.length; j++) { if (j !== i) others.push(exampleEmbs[j]); } sum += scoreExampleRule(exampleEmbs[i], others, feedAvgEmb); } return sum / exampleEmbs.length; }
// true = warn: this rule needs Jev for good results. function needsJevForQuality(exampleEmbs, feedAvgEmb) { var f = ruleFuzziness(exampleEmbs, feedAvgEmb); return f === null ? false : f < FUZZY_LMEAN_THRESHOLD; }
/* ---------------- SUX-9: word rules trained from Jev's answers ---------------- * * The bench check (results_train_from_jev.md): a separator trained on * Jev's confident answers matches one trained on Claude's labels for * topic rules (politics 0.981 vs 0.981, angry 0.965 vs 0.964) and is ~89% * local after 50 Jev calls; funny lags (0.68 vs 0.73) — the SUX-8 fuzzy * class, which goes to Jev anyway. TRAIN_T sets how fast the trained * pseudo-probability saturates; 0.05 puts ~90% of scores outside the * SUX-7 band once ~30 posts are trained. */
var TRAIN_T = 0.05;
function trainedSidesReady(t) { return !!t && t.hide.length >= 1 && t.keep.length >= 1 && (t.hide.length + t.keep.length) >= 3; }
// Probability the rule hides the post, from the trained separator. function trainedHideProb(postEmb, trained, feedAvgEmb) { return 1 / (1 + Math.exp(-scoreExampleRule(postEmb, trained.hide, feedAvgEmb, trained.keep) / TRAIN_T)); }
// Which side of the separator a confident Jev answer lands on: "keep" (the // rule would show the post), "hide" (it would hide), or null (not confident // enough to train on). Direction-aware for rule B. function trainedSide(kind, clause, score) { if (typeof score !== "number") return null; if (kind === "A") { if (score >= 0.8) return "keep"; // confidently word1 → shown if (score <= 0.2) return "hide"; // confidently word2 → hidden return null; } if (score >= 0.8) return clause.above ? "keep" : "hide"; // confidently the word if (score <= 0.2) return clause.above ? "hide" : "keep"; // confidently not return null; }
// trainedHideProb back onto the clause's native probability scale: p<i> = // P(word1), n<i> = P(word). Hide prob is P(hidden); the native score is its // complement for A and for B-with-above (shown when the word matches). function trainedToNative(hideProb, kind, clause) { if (kind === "A") return 1 - hideProb; return clause.above ? 1 - hideProb : hideProb; }
/* ---------------- SUX-3: embedding cache keys, feed average ---------------- */
// Keyed by model id + post content, deliberately separate from cacheKey: // rule changes must not redo model work. Same FNV-1a as cacheKey; a shared // embedding on collision is harmless for the same reason. function embCacheKey(modelId, text, alt) { return hash(modelId + "\n" + (text || "") + "\n" + (alt || "")); }
// One EMA step: prev null → copy of next; otherwise out = (1-a)·prev + a·next. // Vectors are unnormalized embeddings, so the average keeps drifting toward // whatever the feed currently looks like; cosine scoring is scale-insensitive. function emaStep(prev, next, alpha) { if (!prev) return next.slice(); var out = new Array(next.length); for (var d = 0; d < next.length; d++) out[d] = (1 - alpha) * prev[d] + alpha * next[d]; return out; }
/* ---------------- SUX-10: zero-shot wording for word rules ---------------- * * Jev's criteria read "The post is mainly about angry or clearly expresses * angry" — ungrammatical for adjectives, and it drags the embedder too * (topic accuracy 0.40). These short natural descriptions are embedding-side * only; Jev keeps its own wording. Bench (results_wording*.md, q4): the * about/else pair embedded with kind "query" beats the old criteria text on * all five rules — politics 0.971 vs 0.945, angry 0.922 vs 0.916, * self-promotion 0.713 vs 0.599, funny 0.688 vs 0.602, topic 0.46 vs 0.40. */
function zeroShotDescriptions(word) { var w = String(word || "").trim(); return { pos: "A post about " + w + ".", neg: "A post about something else.", }; }
// Bench temperature: noul = sigmoid((cos_pos − cos_neg)/T), T = 0.02. Rule A // reuses it as P(word1) = sigmoid((cos(w1) − cos(w2))/T). var ZS_T = 0.02;
function zeroShotProb(cosFor, cosAgainst) { return 1 / (1 + Math.exp(-(cosFor - cosAgainst) / ZS_T)); }
/* ---------------- SUX-7: escalate unsure scores to Jev ---------------- * * A rule decides locally when its score sits at least ESC_MARGIN clear of * its boundary (0.5 for word rules, the effective cutoff for example * rules); inside the band the local model is guessing, so the clause goes * to Jev instead. Missing local score → Jev (that's the pre-escalation * behavior for word rules without a runtime). * * ESC_MARGIN is bench-set (bench/results_escalation.md): 0.2 spends the * escalation budget best — politics agrees with Jev on ~95% of posts at * ~13% escalated; 0.1 halves the Jev spend for ~2-4pp less agreement. The * ticket's "within 0.02 of Jev-only" guess is optimistic: zero-shot scores * are over-confident (T=0.02 saturates fast), so the band catches few * posts, and tone/intent rules (funny, self-promotion) stay ~0.15 AUROC * below Jev at any sane escalation rate — that's the SUX-8 fuzzy class. */
var ESC_MARGIN = 0.2;
function needsEscalation(score, boundary, margin) { var m = (typeof margin === "number" ? margin : ESC_MARGIN) - 1e-9; return Math.abs(score - boundary) < m; }
// Partition enabled valid clauses by backend. scores maps p<i>/n<i>/e<k> to // local scores; a clause with a score clear of its boundary is local, one // inside the band (or unscored) needs Jev. Returns {local, jev} of clause // ids ("A0", "B1", "E2" — array indexes into rulesA/rulesB/rulesE). function escalationPlan(st, scores, margin) { var plan = { local: [], jev: [] }; st.rulesA.forEach(function (c, i) { if (!c.enabled || !clauseAValid(c)) return; var p = scores && typeof scores["p" + i] === "number" ? scores["p" + i] : null; (p !== null && !needsEscalation(p, 0.5, margin) ? plan.local : plan.jev).push("A" + i); }); st.rulesB.forEach(function (c, j) { if (!c.enabled || !clauseBValid(c)) return; var n = scores && typeof scores["n" + j] === "number" ? scores["n" + j] : null; (n !== null && !needsEscalation(n, 0.5, margin) ? plan.local : plan.jev).push("B" + j); }); st.rulesE.forEach(function (c, k) { if (!c.enabled || !clauseEValid(c)) return; var s = scores && typeof scores["e" + k] === "number" ? scores["e" + k] : null; (s !== null && !needsEscalation(s, effectiveCutoff(c), margin) ? plan.local : plan.jev).push("E" + k); }); return plan; }
// Map an escalated Jev probability onto the local score scale so it // compares correctly against an example rule's cutoff: p=1 lands a full // margin on the hide side, p=0 on the show side, p=0.5 at the cutoff. function escalatedToLocalScale(p, cutoff, margin) { var m = typeof margin === "number" ? margin : ESC_MARGIN; return cutoff + (2 * p - 1) * m; }
// int8 storage (768 floats ≈ 3 KB → ≈ 0.8 KB per post at the 2,000-entry // cap): per-vector max-abs scaling, values snapped to [-127, 127]. SUX-12 // flags the loss if it ever matters; cosine barely notices it. function quantEmb(emb) { var max = 0; for (var i = 0; i < emb.length; i++) { var a = Math.abs(emb[i]); if (a > max) max = a; } if (!max) return { s: 1, q: emb.map(function () { return 0; }) }; var s = max / 127; return { s: s, q: emb.map(function (x) { return Math.round(x / s); }) }; }
function dequantEmb(qe) { var s = qe.s || 1; return qe.q.map(function (x) { return x * s; }); }
var SuxShared = { TEXT_CAP: TEXT_CAP, WORD_CAP: WORD_CAP, defaults: defaults, normalizeSettings: normalizeSettings, LOCAL_MODEL: LOCAL_MODEL, modeAllowsJev: modeAllowsJev, modeAllowsLocal: modeAllowsLocal, reportModelProgress: reportModelProgress, getModelProgress: getModelProgress, clauseAValid: clauseAValid, clauseBValid: clauseBValid, clauseEValid: clauseEValid, isActive: isActive, hash: hash, cacheKey: cacheKey, isJudgeable: isJudgeable, buildQuestions: buildQuestions, buildRequest: buildRequest, buildBatchRequest: buildBatchRequest, splitBatchAnswers: splitBatchAnswers, clauseScoreKeys: clauseScoreKeys, decideFromAnswers: decideFromAnswers, jevToScores: jevToScores, decideFromScores: decideFromScores, answerDetails: answerDetails, roundScores: roundScores, checkEmbedder: checkEmbedder, registerEmbedder: registerEmbedder, getEmbedder: getEmbedder, cosine: cosine, meanVector: meanVector, scoreExampleRule: scoreExampleRule, zeroShotDescriptions: zeroShotDescriptions, zeroShotProb: zeroShotProb, ZS_T: ZS_T, ESC_MARGIN: ESC_MARGIN, needsEscalation: needsEscalation, escalationPlan: escalationPlan, escalatedToLocalScale: escalatedToLocalScale, hiddenByClause: hiddenByClause, ruleFuzziness: ruleFuzziness, needsJevForQuality: needsJevForQuality, FUZZY_LMEAN_THRESHOLD: FUZZY_LMEAN_THRESHOLD, TRAIN_T: TRAIN_T, trainedSidesReady: trainedSidesReady, trainedHideProb: trainedHideProb, trainedSide: trainedSide, trainedToNative: trainedToNative, looCutoff: looCutoff, effectiveCutoff: effectiveCutoff, CUTOFF_MARGIN: CUTOFF_MARGIN, STRICTNESS_SPAN: STRICTNESS_SPAN, embCacheKey: embCacheKey, emaStep: emaStep, quantEmb: quantEmb, dequantEmb: dequantEmb, };
global.SuxShared = SuxShared; if (typeof module !== "undefined" && module.exports) { module.exports = SuxShared; }})(typeof globalThis !== "undefined" ? globalThis : this);