@heyramzi/lint 0.0.0-stage → 1.32.2

package/slop.js

@@ -0,0 +1,644 @@
+/**
+ * The publish gate. One function, run on anything before it goes out.
+ */
+
+/*
+ * WHY it exists: the two halves of this check were a 122-line node script and 835 lines of vendored Python, both parked under `ai-doc/skills/.../humanizer/ scripts/`,
+ */
+
+/*
+ * both invoked by hand, and neither reachable from code.
+ */
+
+/*
+ * So the social drafter, the slide renderer, the Buffer scheduler and the CMS each grew their own partial version, and the invisible-character half ran on nothing at all.
+ */
+
+/*
+ * Ramzi, 31 Aug 2026: "anything before it gets published goes through there."
+ */
+
+/*
+ * Two layers, in this order, because the second reads what the first leaves:
+ */
+
+/*
+ * 1. `stripInvisibles` removes the invisible characters. Deterministic, lossless for anything a reader can see, and it REWRITES the text.
+ */
+
+/*
+ * 2. `auditSlop` reports the slop. It never rewrites: a word list cannot write the replacement sentence, and a gate that guesses is a gate nobody trusts.
+ */
+
+/*
+ * `slopGate` runs both and is the only entry point a caller needs.
+ */
+
+/*
+ * Both lists are imported, never restated: `data/invisibles.js` and `data/slop-words.js` are the one home for each.
+ */
+
+import {
+  EMOJI_GLUE,
+  SEPARATORS,
+  SPACE_HOMOGLYPHS,
+  hex,
+  invisibleKind,
+  isInvisible,
+} from "#lint/data/invisibles.js";
+import { artifacts, patterns, phrases, words } from "#lint/data/slop-words.js";
+import { auditRegister } from "#lint/register.js";
+import { auditShorts } from "@heyramzi/social/shorts";
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * A word boundary that counts an accented letter as a letter.
+ */
+
+/*
+ * `\b` is defined against `[A-Za-z0-9_]`, so there is no boundary between a space and `é`: `\bécosystème\b` matched nothing, and every French ban starting with an accent was on the list
+ */
+
+/*
+ * and unenforced. The lookarounds do the same job over `\p{L}`, in both languages.
+ */
+const bounded = (word) =>
+  new RegExp(`(?<![\\p{L}\\p{N}_])${escapeRe(word)}(?![\\p{L}\\p{N}_])`, "iu");
+
+/**
+ * HTML in, prose out, so an email body and a markdown draft audit the same way.
+ */
+
+/*
+ * Entities go before tags. A preheader is deliberately padded with zero-width entities, and decoding those first would turn the padding into real characters and make every length count downstream wrong.
+ */
+export function stripMarkup(raw) {
+  return (
+    raw
+      .replace(/<(script|style)[\s\S]*?<\/\1>/gi, " ")
+      // A markup comment is a note to the next developer, not copy.
+
+      // It goes with the script block, for the same reason: the CBAM pages rule their sections with `<!-- ————— name ————— -->`, which reported 8 em dashes nobody reads.
+      .replace(/<!--[\s\S]*?-->/g, " ")
+      .replace(/&[a-z]+;|&#\d+;/gi, " ")
+      .replace(/<[^>]+>/g, " ")
+      // Svelte and Vue control blocks are code that survives tag stripping, and their loop variables read as prose: `{#each items as row,
+
+      // i (row)}` counted `i` as a first-person pronoun and failed 3 pages on the pronoun ledger.
+
+      // Only `{#`, `{:` and `{/` go; a plain `{value}` interpolation is left alone, because the copy it stands for is audited where it is written.
+
+      // `{@render ...}` is a call, so it goes.
+      .replace(/\{[#:/@][^}]*\}/g, " ")
+      .replace(/[ \t]+/g, " ")
+      .trim()
+  );
+}
+
+const isPictographic = (ch) => /\p{Extended_Pictographic}/u.test(ch);
+
+/**
+ * Remove every invisible character, normalise the fake spaces, and report what went.
+ */
+
+/*
+ * The one exception is emoji glue.
+ */
+
+/*
+ * A zero-width joiner or a variation selector sitting after an emoji is part of a visible sequence: strip it and a family becomes three people and a red heart loses
+ */
+
+/*
+ * its colour. Anywhere else the same character is a carrier and goes.
+ */
+
+/*
+ * `normalizeSpaces` is on by default. Turn it off only when editing a file whose spacing is deliberate; for anything headed into a web form, leave it on,
+ */
+
+/*
+ * because a no-break space between two words is invisible to the writer and breaks wrapping for the reader.
+ */
+export function stripInvisibles(text, { normalizeSpaces = true } = {}) {
+  const chars = [...text];
+  const removed = new Map();
+  const note = (cp) => {
+    const key = `${invisibleKind(cp)} ${hex(cp)}`;
+    removed.set(key, (removed.get(key) ?? 0) + 1);
+  };
+
+  let out = "";
+  for (let i = 0; i < chars.length; i += 1) {
+    const ch = chars[i];
+    const cp = ch.codePointAt(0);
+
+    if (EMOJI_GLUE.has(cp) && i > 0 && isPictographic(chars[i - 1])) {
+      out += ch;
+      continue;
+    }
+    if (isInvisible(cp)) {
+      note(cp);
+      continue;
+    }
+    if (SEPARATORS.has(cp)) {
+      note(cp);
+      out += SEPARATORS.get(cp);
+      continue;
+    }
+    if (normalizeSpaces && SPACE_HOMOGLYPHS.has(cp)) {
+      note(cp);
+      out += SPACE_HOMOGLYPHS.get(cp);
+      continue;
+    }
+    out += ch;
+  }
+
+  return {
+    text: out,
+    removed: [...removed].map(([what, count]) => ({ what, count })),
+  };
+}
+
+/** True when the text carries nothing invisible. The cheap gate. */
+export function isClean(text) {
+  return stripInvisibles(text).removed.length === 0;
+}
+
+/**
+ * A regex over these fires on ordinary English, so they are reported as `review` rather than as a hit and never fail the gate.
+ */
+
+/*
+ * A person decides whether the sentence defines a thing by denying another, or states a fact.
+ */
+const PIVOT_GREPS = [
+  /rather than/gi,
+  /instead of/gi,
+  /\bnot a\b/gi,
+  /\bnot the\b/gi,
+  /\bis not\b/gi,
+  /plutôt que/gi,
+  /au lieu de/gi,
+  /n'est pas un/gi,
+];
+
+/**
+ * "Banned formatting: no hashtags and no emojis, on any surface" was one line in `slopPromptBlock` and a check in nothing, so 13 skills wrote it out again as a checklist
+ */
+
+/*
+ * bullet and the gate reported a draft full of both as clean. The rule belongs here, where it is applied, not in the thirteenth file that remembers it.
+ */
+
+/*
+ * The emoji range is the one `rules/no-emoji.js` uses, so the ESLint rule and the gate cannot disagree about what an emoji is.
+ */
+// Combining marks are what this class is for.
+const EMOJI =
+  // oxlint-disable-next-line eslint/no-misleading-character-class
+  /[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1FA00}-\u{1FA9F}\u{20E3}]/gu;
+
+/**
+ * A hashtag is a `#` glued to a word mid-line.
+ */
+
+/*
+ * The three shapes that are not one, and each of which fired before they were excluded: a markdown heading, which is a `#` at line start;
+ */
+
+/*
+ * a hex colour, which is `#` and hex digits only; and an issue reference, which is `#` and digits.
+ */
+const HASHTAG = /(?<=[^\n#]\s|^\s*\S[^\n]*?\s)#(?![0-9a-fA-F]{3,8}\b)(?!\d+\b)[A-Za-z][\w-]*/g;
+
+/**
+ * Code is not copy.
+ */
+
+/*
+ * `#if`, `#endif`, `#Preview` and `#available` are Swift, `#newlink` is a DOM id and `#sales-alerts` is a Slack channel: all 16 hashtag hits in the first corpus run were one of
+ */
+
+/*
+ * those, every one of them inside a fence or a backtick span. Only the hashtag check reads this, because only it is confused by code.
+ */
+function withoutCode(text) {
+  return (
+    text
+      .replace(/```[\s\S]*?```/g, " ")
+      .replace(/`[^`\n]*`/g, " ")
+      // A tool directive is syntax the file has to carry: `/* eslint-enable ... */`
+      // failed the banned word `enable` in 2 files that contain no copy at all.
+      .replace(
+        /\/[*/][ \t]*(?:eslint|oxlint|prettier|biome|c8|v8|ts-(?:ignore|expect-error|nocheck))[^\n]*/g,
+        " ",
+      )
+  );
+}
+
+/** A source file with its comments blanked. Comments are notes to the next developer, not copy; `comment-length` gates them. */
+function withoutComments(text) {
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
+    .replace(/(^|[\s;{}(,])\/\/[^\n]*/g, "$1");
+}
+
+/**
+ * The copy inside a source file: string literals of 2+ words, comments gone. The ledger read `get
+ * ours()` and `winner: "ours"` as first person: 24 false hits.
+ */
+function copyStrings(text) {
+  const literals =
+    withoutComments(text).match(/"(?:[^"\\\n]|\\.)*"|`(?:[^`\\]|\\.)*`|'(?:[^'\\\n]|\\.)*'/g) ?? [];
+  return literals.filter((s) => /\p{L}{2,}\s+\p{L}{2,}/u.test(s)).join("\n");
+}
+
+/**
+ * A string literal's first sentence is sentence-initial, and every anchored pattern used to miss it.
+ */
+
+/*
+ * The anchors in `patterns` accept `^`, a newline, or `.!?` plus a space.
+ */
+
+/*
+ * In a copy module the sentence opens after `key: "`, which is none of the three, so `nobody-opener` and the 4 other anchored patterns never fired on the first sentence
+ */
+
+/*
+ * of any string. sitesmiths keeps every word of the page in `copy.ts`, ran the gate as its AGENTS.md tells it to, and shipped "Nobody
+ */
+
+/*
+ * pays us to start." past a pattern that had been lint-enforced since 5 Sep 2026. Opening the quote into a line break makes the anchors true again.
+ */
+
+/*
+ * Only for files the caller says are source, because in markdown `he said, "Nobody knows."` is a quotation rather than a key, and it stays one.
+ */
+function withStringStarts(text) {
+  return text.replace(/([:(,=[]\s*)["'`]/g, "$1\n");
+}
+
+/**
+ * An FAQ is the one section where a question heading is the right heading: it is written to match the query the reader typed,
+ */
+
+/*
+ * and it holds its own subheadings by design. `question-heading` and `empty-section` skip it rather than asking a page to hide the question it answers.
+ */
+const FAQ_TITLE =
+  /^(?:FAQ|F\.A\.Q\.?|Frequently asked questions|よくある質問|Questions? fréquentes?)$/i;
+
+function withoutFaqSections(text) {
+  let depth = 0;
+  return text
+    .split("\n")
+    .map((line) => {
+      const heading = /^(#{1,6})[ \t]+(.+?)[ \t]*#*$/.exec(line);
+      if (heading) {
+        const level = heading[1].length;
+        if (depth && level <= depth) depth = 0;
+        if (!depth && FAQ_TITLE.test(heading[2].trim())) depth = level;
+      }
+      return depth ? "" : line;
+    })
+    .join("\n");
+}
+
+/**
+ * The words the body capitalises mid-sentence, which are names rather than styling.
+ */
+
+/*
+ * Without it every review page naming 2 products failed `title-case-heading`: "What Wispr Flow does better than Wavenote" counts 2 capitals and none of them is a styling choice.
+ */
+
+/*
+ * Headings are excluded from the scan so a title-cased heading cannot vouch for itself.
+ */
+function properNouns(body) {
+  const found = new Set();
+  for (const line of body.replace(/^#{1,6}[ \t]+.*$/gm, " ").split("\n")) {
+    let start = true;
+    for (const raw of line.trim().split(/\s+/)) {
+      const word = raw.replace(/^[^\p{L}]+/u, "").replace(/[^\p{L}\p{N}'’-]+$/u, "");
+      if (word && !start && /^[A-ZÀ-Þ]/.test(word)) found.add(word);
+      start = /[.!?:][""''”’)\]]?$/.test(raw);
+    }
+  }
+  return found;
+}
+
+/**
+ * Which language the draft is in, so the checks that only work in one of them pick the right list.
+ */
+
+/*
+ * Stopword counting, not a library.
+ */
+
+/*
+ * The two sets share almost nothing, a draft of any length separates them by a wide margin, and the only caller that can be hurt by a wrong answer is
+ */
+
+/*
+ * the pronoun ledger, which reports rather than rewrites. English is the default on a tie, including on an empty string.
+ */
+const FR_STOPWORDS =
+  /(?<![\p{L}\p{N}_])(?:le|la|les|des|une|un|et|est|dans|pour|que|qui|pas|avec|sur|plus|cette|vous|nous|aux|mais|sont|être|ce|se|son|ses|leur|par|au|du|elle|il)(?![\p{L}\p{N}_])/giu;
+const EN_STOPWORDS =
+  /(?<![\p{L}\p{N}_])(?:the|and|is|of|to|in|that|it|for|with|you|this|are|on|but|not|have|from|as|was|they|be|at|by|or|an|its|their)(?![\p{L}\p{N}_])/giu;
+
+export function detectLanguage(text) {
+  // Japanese first, and by script rather than by stopword.
+
+  // A Japanese draft has no English or French stopwords of its own, so the count is decided by whatever it quotes, and every Japanese page on the Wavenote site came
+
+  // back "en" and was then graded on English pronouns it does not use.
+  const cjk = (text.match(/[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/g) ?? []).length;
+  const letters = (text.match(/[\p{L}]/gu) ?? []).length;
+  if (letters > 0 && cjk / letters > 0.2) return "ja";
+  const fr = (text.match(FR_STOPWORDS) ?? []).length;
+  const en = (text.match(EN_STOPWORDS) ?? []).length;
+  return fr > en ? "fr" : "en";
+}
+
+/**
+ * The first person against the second, per language.
+ */
+
+/*
+ * The English-only sets were the whole check until 5 Sep 2026, so every French draft counted 0 against 0 and failed `selfish-framing` by construction.
+ */
+
+/*
+ * The check now runs on the detected language and only fires when the writer actually used the first person: copy with no pronouns at all is a reference page,
+ */
+
+/*
+ * not a page about its author.
+ */
+const PRONOUNS = {
+  en: {
+    // Case-sensitive: a lone `i` is a loop index, `US` a country, and `Annex I` a numeral.
+    first:
+      /(?<![\p{L}\p{N}_])(?:(?<!(?:Annex|Article|Title|Chapter|Part|Section|Phase|Tier) )I|[Ww]e|WE|[Mm]y|[Oo]urs?|OUR|[Mm]ine|[Uu]s)(?![\p{L}\p{N}_])/gu,
+    second: /(?<![\p{L}\p{N}_])(?:you|your|yours)(?![\p{L}\p{N}_])/giu,
+  },
+  fr: {
+    first: /(?<![\p{L}\p{N}_])(?:je|j'|nous|mon|ma|mes|notre|nos|moi|me)(?![\p{L}\p{N}_])/giu,
+    second: /(?<![\p{L}\p{N}_])(?:vous|votre|vos|tu|ton|ta|tes|toi)(?![\p{L}\p{N}_])/giu,
+  },
+};
+
+/**
+ * The signs that are only visible across a whole document, so no regex over one sentence finds them: Wikipedia's title case, heading levels,
+ */
+
+/*
+ * boldface density, thematic breaks and mixed apostrophes (WP:AITITLECASE, WP:AIBOLD, WP:AICURLY), and the French page's "majuscules superflues dans les titres".
+ */
+
+/*
+ * Markdown only. HTML is stripped to prose before it reaches here, so a page audits on its words and an `.md` draft audits on its words and its outline.
+ */
+function auditStructure(text) {
+  const found = [];
+  const hit = (id, detail) => found.push({ kind: "structure", id, detail });
+
+  // Frontmatter is not a thematic break and its keys are not headings.
+  const body = text.replace(/^---\n[\s\S]*?\n---\n/, "\n");
+  const headings = [...body.matchAll(/^(#{1,6})[ \t]+(.+?)[ \t]*#*$/gm)].map((m) => ({
+    level: m[1].length,
+    title: m[2].trim(),
+    at: m.index,
+  }));
+
+  // Title case. The tell is the words a sentence would leave lowercase, so only words of 4 letters or more after the first one are counted,
+
+  // and 2 of them capitalised is the threshold: "Awards and Recognition" hits, "the ClickUp API" does not.
+  const names = properNouns(body);
+  for (const heading of headings) {
+    const rest = heading.title
+      .split(/\s+/)
+      .slice(1)
+      .filter((w) => w.replace(/\W/g, "").length >= 4);
+    const capitalised = rest.filter(
+      (w) => /^[A-ZÀ-Þ]/.test(w) && !names.has(w.replace(/[^\p{L}\p{N}'’-]+$/u, "")),
+    );
+    if (rest.length >= 2 && capitalised.length >= 2) hit("title-case-heading", heading.title);
+  }
+
+  const h1 = headings.filter((h) => h.level === 1);
+  if (h1.length > 1) hit("multiple-h1", `${h1.length} level-1 headings`);
+
+  for (let i = 1; i < headings.length; i += 1) {
+    if (headings[i].level - headings[i - 1].level > 1) {
+      hit(
+        "skipped-heading-level",
+        `${"#".repeat(headings[i - 1].level)} then ${"#".repeat(headings[i].level)} at "${headings[i].title}"`,
+      );
+    }
+    // A heading whose whole content is the next heading. Wikipedia's "headings
+    // only containing other headings": the section says nothing of its own.
+    const between = body
+      .slice(headings[i - 1].at, headings[i].at)
+      .split("\n")
+      .slice(1)
+      .join("")
+      .trim();
+    if (between === "" && !FAQ_TITLE.test(headings[i - 1].title)) {
+      hit("empty-section", headings[i - 1].title);
+    }
+  }
+
+  const bold = [...withoutCode(body).matchAll(/\*\*[^*\n]{2,}\*\*/g)];
+  // Japanese and Chinese put no spaces between words, so a whitespace split read a 3,500 character article as 256 words and failed all 15 Japanese pages on the site for
+
+  // boldface density. A CJK character counts as a word, which is how the languages are counted everywhere else.
+  const cjk = (body.match(/[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/g) ?? []).length;
+  const wordCount = body.split(/\s+/).filter(Boolean).length + cjk;
+  if (bold.length > 3 && bold.length > wordCount / 120) {
+    hit("boldface-overuse", `${bold.length} bold runs in ${wordCount} words`);
+  }
+
+  const breaks = [...body.matchAll(/^[ \t]*(?:-{3,}|\*{3,}|_{3,})[ \t]*$/gm)];
+  if (breaks.length > 1) hit("thematic-breaks", `${breaks.length} horizontal rules`);
+
+  for (const m of body.matchAll(/^[ \t]*[•▪●–—][ \t]+\S/gm)) {
+    hit("raw-bullet-glyph", m[0].trim());
+  }
+
+  return found;
+}
+
+/**
+ * The enumerable half of the humanizer, over one string.
+ */
+
+/*
+ * Six layers: the banned words, the banned phrases, the anchored sentence `patterns`, the chatbot `artifacts`, the document-level structure, and the pronoun ledger.
+ */
+
+/*
+ * Every sign on Wikipedia:Signs of AI writing that a machine can decide is in one of those; the French page adds no seventh.
+ */
+
+/*
+ * Enumerable is the operative word. `shapes` in `slop-words.js` is deliberately absent, because a regex for "negation pivot" fires on every ordinary "is not".
+ */
+
+/*
+ * Those still need a human read of the humanizer's `references/ patterns.md`, and this function's output says so.
+ */
+
+/*
+ * So does everything the page lists that lives outside the text: a dead citation URL, an invalid ISBN, a hallucinated template, an edit summary.
+ */
+
+/*
+ * Those are claims about the world, and a string is all this function gets.
+ */
+export function auditSlop(draft, { code = false } = {}) {
+  const text = code ? withoutComments(draft) : draft;
+  const findings = [];
+  const add = (kind, id, detail) => findings.push({ kind, id, detail });
+
+  // The ban lists read the draft with its code spans removed, because an identifier is not a word somebody chose: `enhance` is a Worker directory and `enable` is an API
+
+  // name, and both failed the gate in files that carry no copy at all.
+
+  // The `patterns` below still read the whole text, where the surrounding sentence is what they are judging.
+  const prose = withoutCode(text);
+  for (const word of words) {
+    const m = prose.match(bounded(word));
+    if (m) add("word", word, m[0]);
+  }
+  for (const phrase of phrases) {
+    // Bounded like a word, not `includes`. A substring test read "En sommeil" as the banned "en somme" and failed a dormant-status label on the UpSys site, 6 Sep 2026.
+
+    // Every phrase here is whole words.
+    if (bounded(phrase).test(prose)) add("phrase", phrase, phrase);
+  }
+  // A pattern names the view of the draft it judges, and defaults to the whole thing. Only `faqless` differs, for the reason `FAQ_TITLE` carries.
+
+  // It was a `pattern.id === "question-heading"` test here until 17 Sep 2026, which put half of one pattern in this file and meant the next pattern needing a view had
+
+  // to be added in two places.
+  const views = {
+    anchored: code ? withStringStarts(text) : text,
+    faqless: withoutFaqSections(text),
+    // In source, an import list or an object literal is a comma run too.
+    prose: code ? copyStrings(text) : prose,
+  };
+  for (const pattern of patterns) {
+    const m = views[pattern.view ?? "anchored"].match(pattern.test);
+    if (m) add("pattern", pattern.id, m[0].slice(0, 90));
+  }
+  for (const artifact of artifacts) {
+    const m = text.match(artifact.test);
+    if (m) add("artifact", artifact.id, m[0].slice(0, 90));
+  }
+  for (const finding of auditStructure(text)) findings.push(finding);
+  for (const m of text.matchAll(/[—–]/g)) {
+    add("dash", "em-or-en-dash", text.slice(Math.max(0, m.index - 30), m.index + 30));
+  }
+  for (const m of text.matchAll(EMOJI)) {
+    add("emoji", "emoji", text.slice(Math.max(0, m.index - 30), m.index + 30));
+  }
+  for (const m of withoutCode(text).matchAll(HASHTAG)) {
+    add("hashtag", "hashtag", m[0]);
+  }
+
+  const ledgerText = code ? copyStrings(text) : text;
+  const count = (re) => (ledgerText.match(re) ?? []).length;
+  const language = detectLanguage(text);
+  // Only the languages with pronoun sets are graded.
+
+  // Japanese marks the same distinction with particles and by leaving the subject out, so a regex over `we` and `you` says nothing about a Japanese draft.
+  const pronouns = PRONOUNS[language];
+  const first = pronouns ? count(pronouns.first) : 0;
+  const second = pronouns ? count(pronouns.second) : 0;
+  // Strictly outnumber, which is the rule `pronouns-and-openings.md` states. `<=` failed a draft at
+  // parity, and a gate stricter than its own spec teaches the reader to ignore it.
+  if (first > 0 && second < first)
+    add("ledger", "selfish-framing", `first ${first}, second ${second}`);
+
+  const review = [];
+  for (const grep of PIVOT_GREPS) {
+    for (const m of text.matchAll(grep)) {
+      const from = Math.max(0, m.index - 45);
+      review.push({
+        kind: "review-pivot",
+        id: m[0].toLowerCase(),
+        detail: `...${text.slice(from, m.index + 55)}...`,
+      });
+    }
+  }
+
+  // WP:AICURLY. Curly quotes alone prove nothing: macOS types them by default and French typography wants them.
+
+  // Mixing both forms in one draft is the sign, because that is what a paste from a chat window into typed text leaves behind.
+
+  // Reported, never failed, so a deliberate house style survives.
+  const curly = (text.match(/[‘’“”]/g) ?? []).length;
+  const straight = (text.match(/['"]/g) ?? []).length;
+  if (curly > 0 && straight > 0) {
+    review.push({
+      kind: "review-quotes",
+      id: "mixed-apostrophes",
+      detail: `${curly} curly, ${straight} straight`,
+    });
+  }
+
+  return {
+    findings,
+    review,
+    language,
+    ledger: { first, second },
+    words: text.split(/\s+/).filter(Boolean).length,
+  };
+}
+
+/**
+ * Clean, then audit. The one call a publishing path makes.
+ */
+
+/*
+ * Returns the cleaned text whether or not the audit passed, because the two results answer different questions: the text is always safe to send,
+ */
+
+/*
+ * and `ok` says whether it is good enough to send. A caller that refuses on `ok` still publishes `text` once the words are fixed, never the original.
+ */
+export function slopGate(
+  raw,
+  { markup = false, code = false, normalizeSpaces = true, register } = {},
+) {
+  const source = markup ? stripMarkup(raw) : raw;
+  const cleaned = stripInvisibles(source, { normalizeSpaces });
+  const audit = auditSlop(cleaned.text, { code });
+  // A ban list cannot see the fault that produced the 9 Sep 2026 Shorts batch: every script passed the words and still read as somebody else,
+
+  // because the register was written and the delivery was spoken. `register.js` carries why.
+  const registerAudit = register ? auditRegister(cleaned.text, register) : null;
+  // A Short also owes a hook from the library and a counted, reply-ending skeleton.
+  const shortsAudit = register === "shorts" ? auditShorts(cleaned.text) : null;
+  const findings = [
+    ...audit.findings,
+    ...(registerAudit?.findings ?? []),
+    ...(shortsAudit?.findings ?? []),
+  ];
+  return {
+    text: cleaned.text,
+    removed: cleaned.removed,
+    ok: findings.length === 0,
+    ...audit,
+    findings,
+    register: registerAudit,
+    shorts: shortsAudit,
+  };
+}