@heyramzi/lint 0.0.0-stage → 1.32.4

package/slop.js

@@ -0,0 +1,534 @@
+/**
+ * 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 {
+  FAQ_TITLE,
+  copyStrings,
+  properNouns,
+  withStringStarts,
+  withoutCode,
+  withoutComments,
+  withoutFaqSections,
+} from "#lint/slop-views.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 -->` wrapped in rows of em dashes, which reported 8 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;
+
+/**
+ * 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,
+  };
+}

package/svelte-markup.js

@@ -0,0 +1,107 @@
+/**
+ * The Svelte markup gate: the template checks oxlint can't make.
+ */
+
+/*
+ * oxlint only visits a .svelte file that has a `<script>`, and a markup-only component (a `<slot />` wrapper) has none. Pure here, git and process in `bin/heyramzi-svelte-markup.js`.
+ */
+import {
+  isRegularElement,
+  MATHML_ELEMENTS,
+  scanTemplate,
+  SVG_ELEMENTS,
+  VOID_ELEMENTS,
+} from "#lint/svelte-template.js";
+
+/** Generated or vendored trees: nobody can fix code they don't write. */
+export const DEFAULT_IGNORED = [
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  "vendor",
+  ".upstream",
+  "generated",
+  "_generated",
+  ".svelte-kit",
+  ".wrangler",
+  ".agents",
+  ".claude",
+  ".opencode",
+  ".gemini",
+  "playground",
+];
+
+/** Every violation in one .svelte source: `{ line, rule, message }`. */
+export function findMarkupViolations(source) {
+  const { tags } = scanTemplate(source);
+  const customElement = tags.some(
+    (tag) => tag.name === "svelte:options" && tag.attrs.some((a) => a.name === "customElement"),
+  );
+  const found = [];
+  const add = (line, rule, message) => found.push({ line, rule, message });
+
+  for (const tag of tags) {
+    if (tag.closing) continue;
+
+    if (tag.name === "slot" && !customElement) {
+      add(
+        tag.line,
+        "svelte4-slot",
+        "`<slot>` is Svelte 4. Take `children` or a named snippet prop and render it with `{@render children?.()}`.",
+      );
+    }
+    if (tag.name === "svelte:component") {
+      add(
+        tag.line,
+        "svelte4-component",
+        "`<svelte:component>` is Svelte 4. Put the component in a variable and render `<Component />`.",
+      );
+    }
+    for (const attr of tag.attrs) {
+      if (attr.name.startsWith("on:")) {
+        const event = attr.name.slice(3).split("|")[0];
+        add(
+          attr.line,
+          "svelte4-event",
+          `\`${attr.name.split("|")[0]}\` is Svelte 4. Use the \`on${event}\` attribute, and a callback prop on a component.`,
+        );
+      }
+      if (attr.name.startsWith("class:") && /\[[^\]]+\]/.test(attr.name)) {
+        add(
+          attr.line,
+          "class-arbitrary-value",
+          `\`${attr.name}\` never applies: \`class:\` can't carry a Tailwind arbitrary value. Use \`style:property={...}\` (for example \`style:min-height={compact ? '300px' : '460px'}\`).`,
+        );
+      }
+    }
+    if (
+      tag.selfClosing &&
+      tag.name !== "slot" &&
+      isRegularElement(tag.name) &&
+      !VOID_ELEMENTS.has(tag.name) &&
+      !SVG_ELEMENTS.has(tag.name) &&
+      !MATHML_ELEMENTS.has(tag.name)
+    ) {
+      add(
+        tag.line,
+        "self-closing",
+        `\`<${tag.name} />\` is ambiguous HTML. Write \`<${tag.name}></${tag.name}>\`.`,
+      );
+    }
+  }
+  return found.toSorted((a, b) => a.line - b.line);
+}
+
+/** Filter tracked files down to the .svelte files the gate reads. */
+export function selectFiles(tracked, { ignored = DEFAULT_IGNORED, targets = [] } = {}) {
+  return tracked.filter((file) => {
+    if (!file.endsWith(".svelte")) return false;
+    if (file.split("/").some((segment) => ignored.includes(segment))) return false;
+    if (targets.length === 0) return true;
+    return targets.some(
+      (target) => file === target || file.startsWith(`${target.replace(/\/$/, "")}/`),
+    );
+  });
+}