@chrissgon/light-site-auditor 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christopher Gonçalves
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,126 @@
+# light-site-auditor
+
+[Português](#português) · [English](#english)
+
+## Português
+
+Uma ferramenta de linha de comando, `auditor <url>`, que mede o peso da página inicial de um site, o tempo que ela leva para aparecer num celular com conexão 3G e as barreiras de acessibilidade, e escreve um relatório em português simples com o que corrigir.
+
+Cada número do relatório vem dos arquivos JSON salvos ao lado dele (`lighthouse.json` e `axe.json`), e cada explicação vem de um catálogo escrito e conferido de antemão (`src/explanations.pt.json`), nunca de texto gerado na hora. A leitura do catálogo por uma pessoa ainda está pendente.
+
+### Regra do consentimento
+
+O auditor só verifica um site real se o dono aceitou. Sem um registro de consentimento aceito para o endereço exato, ele recusa e sai com o código 2. Páginas deste computador (`localhost`, `127.0.0.1`, `[::1]`) não precisam de registro. Não existe opção para pular essa verificação.
+
+1. Peça o aceite ao dono com o texto de [`docs/field/consentimento.md`](docs/field/consentimento.md). Ele diz o que a verificação faz (abre a página inicial pública duas vezes, como um visitante, e mede com o Lighthouse e o axe no seu computador), o que não faz (não entra com login, não usa formulários, não abre outras páginas) e que o relatório fica só com o dono, a menos que ele concorde com outro uso.
+2. Registre o aceite num arquivo que comece assim:
+
+   ```markdown
+   ---
+   endereco: https://www.exemplo.com.br/
+   dono: Nome de quem aceitou
+   status: aceito
+   data: 2026-09-30
+   como: por e-mail, respondendo ao pedido de consentimento
+   reacao: pendente
+   ---
+   ```
+
+3. Rode com `--consent <arquivo>`. Um registro com `status: pendente`, outro endereço, um campo faltando ou uma data futura é recusado.
+
+### Instalar e usar
+
+Precisa do Node 22.19 ou mais novo (o Lighthouse 13.5.0 exige isso).
+
+Uma vez, baixe o navegador que o auditor usa (o Chromium do Playwright):
+
+```sh
+npx @chrissgon/light-site-auditor --instalar-navegador
+```
+
+Depois, audite:
+
+```sh
+npx @chrissgon/light-site-auditor https://www.exemplo.com.br/ --consent consentimento.md --out relatorio-exemplo
+```
+
+Ou instale o comando `auditor` de vez: `npm install -g @chrissgon/light-site-auditor`, e então `auditor --instalar-navegador` e `auditor <url> --consent <arquivo>`.
+
+O que é baixado (medido em 2026-09-30, num Mac com processador Apple, com cache vazio):
+
+| O quê | Tamanho | Quando |
+|-------|---------|--------|
+| O pacote `@chrissgon/light-site-auditor` | cerca de 23 kB | no primeiro `npx` |
+| As dependências (Lighthouse, Playwright, axe e o que elas usam) | cerca de 148 MB baixados, 185 MB instalados | no primeiro `npx` |
+| O Chromium do Playwright (Chrome for Testing 153.0.8010.12) | cerca de 191 MB baixados no Mac com processador Apple, 196 MB no Linux e 205 MB no Windows; 369 MB instalado no Mac | uma vez, com `--instalar-navegador` |
+| O FFmpeg do Playwright | cerca de 1 MB | junto com o Chromium |
+
+O navegador fica na pasta de navegadores do Playwright (no Mac, `~/Library/Caches/ms-playwright`) e serve para as próximas auditorias. No Linux, o Chromium pode pedir bibliotecas do sistema: `sudo npx playwright@1.63.0 install-deps chromium`. Se o navegador faltar, o auditor avisa e sai com o código 3.
+
+### O que o relatório traz
+
+A pasta do relatório recebe `relatorio.md`, `relatorio.html`, `lighthouse.json` e `axe.json`. Sem `--out`, ela é `relatorios/<endereço>-<data e hora>/`.
+
+| Parte | O que mostra | De onde vem no JSON |
+|-------|--------------|---------------------|
+| Peso da página | total baixado e peso por tipo de arquivo (HTML, CSS, JavaScript, imagens, fontes, outros) | `lighthouse.json`: `audits["network-requests"].details.items[].transferSize` |
+| Tempo no 3G | primeira coisa na tela e parte principal na tela, em segundos | `audits["first-contentful-paint"]` e `audits["largest-contentful-paint"]`, `numericValue` |
+| O que deixa a página lenta | diagnósticos e insights do Lighthouse abaixo de 0,9, cada um com o que é e o que fazer | `audits[<id>]` |
+| Barreiras de acessibilidade | regras WCAG 2.1 níveis A e AA do axe-core 4.13.0, com os trechos da página | `axe.json`: `violations` |
+| Palavras usadas | glossário dos termos técnicos do relatório | catálogo |
+
+O perfil de 3G é o `mobileRegular3G` do próprio Lighthouse (300 ms de ida e volta, 700 kbit/s, processador 4 vezes mais lento), com a simulação padrão do Lighthouse. Fontes e datas de acesso: [`docs/spikes/3g.md`](docs/spikes/3g.md).
+
+Trecho do relatório da página de exemplo:
+
+```markdown
+**Total baixado: 200,2 KB em 4 arquivos.**
+
+- **Parte principal na tela: 4,2 segundos.** Quanto tempo leva até aparecer o maior texto ou imagem da tela.
+
+### Imagem sem descrição
+
+**O que é:** A imagem não tem texto alternativo, o alt. Quem usa leitor de tela não sabe o que ela mostra.
+```
+
+### Desenvolver
+
+```sh
+npm ci
+npx playwright install --no-shell chromium
+npm test
+npm run build
+```
+
+Os testes sobem um servidor local com a página de exemplo de `tests/fixtures/site/` e não usam a internet. Para testar à mão: `npm run fixture` num terminal e `npm run auditor -- http://127.0.0.1:4173/ --out relatorios/exemplo` em outro. `npm run check-report -- <pasta>` confere se todo número de um relatório já escrito vem dos JSON da pasta.
+
+### Como os números são conferidos
+
+`tests/report.test.ts` roda o auditor na página de exemplo, recalcula a partir dos JSON salvos cada número que o relatório pode mostrar (sem usar o código do relatório) e falha se aparecer qualquer outro número. O catálogo não tem algarismos, então nenhum número pode vir dele.
+
+### O catálogo de explicações
+
+`src/explanations.pt.json` tem, para cada regra do axe e cada auditoria de peso do Lighthouse, um título, o que é e o que fazer. `tests/explanations.test.ts` confere que cada frase tem no máximo 25 palavras, que todo problema tem um "o que fazer", que nenhuma palavra técnica aparece sem estar no glossário do relatório e que os ids existem nas versões instaladas. Uma regra fora do catálogo aparece com o texto original da ferramenta e a marca "sem explicação ainda".
+
+### Licença
+
+MIT.
+
+## English
+
+A command-line tool, `auditor <url>`, that measures a site's home page weight, how long it takes to appear on a phone over 3G, and its accessibility barriers (WCAG 2.1 AA), and writes a plain-Portuguese report saying what to fix, with the raw Lighthouse and axe JSON beside it.
+
+**Consent rule.** A real site is audited only when its owner accepted: pass a consent record with `--consent <file>` (format and the Portuguese request text in [`docs/field/consentimento.md`](docs/field/consentimento.md)). Without an accepted record for the exact address the tool refuses (exit code 2); a `pendente` (pending) record is refused too. Pages on your own computer need no record. There is no flag to skip the check.
+
+**Install and use** (Node 22.19 or newer):
+
+```sh
+npx @chrissgon/light-site-auditor --instalar-navegador   # once: Playwright's Chromium, about 191-205 MB
+npx @chrissgon/light-site-auditor https://www.example.com/ --consent consent.md --out report
+```
+
+The first `npx` also downloads the package (about 23 kB) and its dependencies (about 148 MB, 185 MB installed). On Linux, Chromium may need system libraries: `sudo npx playwright@1.63.0 install-deps chromium`.
+
+**The report** (`relatorio.md` and `relatorio.html`, in Portuguese): total weight and weight by file type, first and largest content on 3G in seconds, Lighthouse diagnostics that did not pass with what to do, and axe's WCAG 2.1 A and AA violations with the affected snippets. Every number comes from `lighthouse.json` or `axe.json`; every explanation comes from a catalog written in advance.
+
+**Develop:** `npm ci`, `npx playwright install --no-shell chromium`, `npm test`, `npm run build`. MIT license.

package/dist/a11y.js

@@ -0,0 +1,44 @@
+import { writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { AxeBuilder } from "@axe-core/playwright";
+import { screenEmulationMetrics, userAgents } from "lighthouse/core/config/constants.js";
+import { chromium } from "playwright";
+/** The axe tags for WCAG 2.1 levels A and AA (axe-core's tag names). */
+export const WCAG21_AA_TAGS = ["wcag2a", "wcag2aa", "wcag21a", "wcag21aa"];
+/**
+ * Opens the page in Playwright's Chromium with the same phone screen Lighthouse emulates, runs
+ * axe-core with the WCAG 2.1 A and AA rules, and returns axe's raw result.
+ */
+export async function runAxe(url) {
+    // The full Chromium in its new headless mode, the same browser Lighthouse drives (src/lighthouse.ts),
+    // so users install one browser (`playwright install chromium --no-shell`), not two.
+    const browser = await chromium.launch({ channel: "chromium" });
+    try {
+        const screen = screenEmulationMetrics.mobile;
+        const context = await browser.newContext({
+            viewport: { width: screen.width, height: screen.height },
+            deviceScaleFactor: screen.deviceScaleFactor,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: userAgents.mobile,
+        });
+        const page = await context.newPage();
+        const response = await page.goto(url, { waitUntil: "load" });
+        if (!response || !response.ok())
+            throw new Error(`could not load ${url}: HTTP ${response?.status() ?? "no response"}`);
+        return await new AxeBuilder({ page }).withTags([...WCAG21_AA_TAGS]).analyze();
+    }
+    finally {
+        await browser.close();
+    }
+}
+// Entry point for trying it alone: `npx tsx src/a11y.ts <url> [out.json]` saves the raw JSON.
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+    const [url, out = "axe.json"] = process.argv.slice(2);
+    if (!url || url === "--help") {
+        process.stdout.write("Usage: npx tsx src/a11y.ts <url> [out.json]\n");
+        process.exit(url ? 0 : 2);
+    }
+    writeFileSync(out, `${JSON.stringify(await runAxe(url), null, 2)}\n`);
+    process.stderr.write(`saved ${out}\n`);
+}

package/dist/cli.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+import { chromium } from "playwright";
+import { runAxe } from "./a11y.js";
+import { checkConsent } from "./consent.js";
+import { runLighthouse } from "./lighthouse.js";
+import { buildReport } from "./report.js";
+const USAGE = `Uso: auditor <url> [--consent <arquivo>] [--out <pasta>]
+     auditor --instalar-navegador
+
+Mede o peso da página, o tempo para aparecer num celular com 3G e as barreiras de acessibilidade,
+e escreve relatorio.md e relatorio.html em português, com lighthouse.json e axe.json ao lado.
+
+  --consent <arquivo>   registro do consentimento do dono do site (obrigatório para sites reais;
+                        páginas deste computador, como localhost, não precisam). Modelo e texto
+                        do pedido: docs/field/consentimento.md
+  --out <pasta>         onde salvar (padrão: relatorios/<endereço>-<data e hora>)
+  --instalar-navegador  baixa, uma vez, o Chromium que o auditor usa (o do Playwright)
+  --help                mostra esta ajuda
+
+Códigos de saída: 0 relatório escrito; 1 a auditoria falhou; 2 uso errado ou endereço recusado;
+3 falta instalar o navegador.
+`;
+/** The command that downloads the Chromium build this package's Playwright expects (full browser only). */
+export function browserInstallCommand() {
+    const require = createRequire(import.meta.url);
+    const cli = join(dirname(require.resolve("playwright/package.json")), "cli.js");
+    return { command: process.execPath, args: [cli, "install", "chromium", "--no-shell"] };
+}
+const defaultOutput = { stdout: (t) => process.stdout.write(t), stderr: (t) => process.stderr.write(t) };
+/** Runs the CLI and returns its exit code. */
+export async function main(argv, io = defaultOutput) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                out: { type: "string" },
+                consent: { type: "string" },
+                "instalar-navegador": { type: "boolean" },
+                help: { type: "boolean" },
+            },
+        });
+    }
+    catch (error) {
+        io.stderr(`${error.message}\n\n${USAGE}`);
+        return 2;
+    }
+    if (parsed.values.help) {
+        io.stdout(USAGE);
+        return 0;
+    }
+    if (parsed.values["instalar-navegador"]) {
+        const { command, args } = browserInstallCommand();
+        io.stderr(`Baixando o Chromium do Playwright (${args.slice(1).join(" ")}).\n` +
+            "Se aparecer um aviso em inglês sobre 'npx playwright install', pode ignorar: o auditor já traz a versão certa do Playwright.\n");
+        return spawnSync(command, args, { stdio: "inherit" }).status ?? 1;
+    }
+    const [target] = parsed.positionals;
+    if (!target || parsed.positionals.length > 1) {
+        io.stderr(USAGE);
+        return 2;
+    }
+    let url;
+    try {
+        url = new URL(target);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            throw new Error("not http");
+    }
+    catch {
+        io.stderr(`Endereço inválido: ${target}. Use um endereço completo, como http://localhost:4173/\n`);
+        return 2;
+    }
+    let consentText;
+    if (parsed.values.consent !== undefined) {
+        try {
+            consentText = readFileSync(parsed.values.consent, "utf8");
+        }
+        catch {
+            io.stderr(`Recusado: não consegui ler o registro de consentimento ${parsed.values.consent}.\n`);
+            return 2;
+        }
+    }
+    const consent = checkConsent(url, consentText, new Date().toISOString().slice(0, 10));
+    if (!consent.ok) {
+        io.stderr(`Recusado: ${consent.reason}\n`);
+        return 2;
+    }
+    if (consent.record) {
+        const r = consent.record;
+        io.stderr(`Consentimento: ${r.dono}; ${r.status} em ${r.data}; ${r.como}\n`);
+    }
+    if (!existsSync(chromium.executablePath())) {
+        io.stderr("Falta o navegador que o auditor usa (o Chromium do Playwright).\n" +
+            "Instale uma vez com: auditor --instalar-navegador\n" +
+            "(com npx: npx @chrissgon/light-site-auditor --instalar-navegador)\n");
+        return 3;
+    }
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const out = resolve(parsed.values.out ?? join("relatorios", `${url.host.replace(/[^\w.-]/g, "_")}-${stamp}`));
+    try {
+        mkdirSync(out, { recursive: true });
+        // One after the other: the Lighthouse simulation starts from a real load, and a second browser
+        // running at the same time would slow that load and change the numbers.
+        io.stderr(`Lighthouse (3G, celular): ${url.href}\n`);
+        const lhr = await runLighthouse(url.href);
+        writeFileSync(join(out, "lighthouse.json"), `${JSON.stringify(lhr, null, 2)}\n`);
+        io.stderr(`axe (WCAG 2.1 A e AA): ${url.href}\n`);
+        const axe = await runAxe(url.href);
+        writeFileSync(join(out, "axe.json"), `${JSON.stringify(axe, null, 2)}\n`);
+        const report = buildReport(lhr, axe, { lighthouse: "lighthouse.json", axe: "axe.json" });
+        writeFileSync(join(out, "relatorio.md"), report.markdown);
+        writeFileSync(join(out, "relatorio.html"), report.html);
+    }
+    catch (error) {
+        io.stderr(`A auditoria falhou: ${error.message}\n`);
+        return 1;
+    }
+    io.stdout(`${join(out, "relatorio.md")}\n${join(out, "relatorio.html")}\n`);
+    return 0;
+}
+const invoked = process.argv[1] ? pathToFileURL(realpathSync(process.argv[1])).href : "";
+if (import.meta.url === invoked)
+    process.exitCode = await main(process.argv.slice(2));

package/dist/consent.js

@@ -0,0 +1,94 @@
+/**
+ * The consent gate (T-aud-7): a real site is audited only when a consent record says its owner
+ * accepted. The record is a Markdown file whose front matter holds the fields below; the text that
+ * asks for consent is docs/field/consentimento.md. There is no bypass: without an accepted record
+ * that names the exact address, the CLI refuses.
+ *
+ * ---
+ * endereco: https://example.com/
+ * dono: Nome do dono
+ * status: aceito
+ * data: 2026-09-30
+ * como: por e-mail, respondendo ao pedido de consentimento
+ * reacao: pendente
+ * ---
+ */
+/** Hosts on this computer. They need no consent: they are the user's own pages. */
+export const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+export const ACCEPTED = "aceito";
+const REQUIRED = ["endereco", "dono", "status", "data", "como"];
+/** Reads the front matter (`key: value` lines between two `---` lines at the top of the file). */
+export function parseConsent(text) {
+    const lines = text.replace(/^/, "").split(/\r?\n/);
+    if (lines[0]?.trim() !== "---")
+        return { error: "o arquivo não começa com um bloco entre linhas ---" };
+    const end = lines.indexOf("---", 1);
+    if (end < 0)
+        return { error: "o bloco do registro não fecha com uma linha ---" };
+    const fields = {};
+    for (const line of lines.slice(1, end)) {
+        if (!line.trim() || line.trimStart().startsWith("#"))
+            continue;
+        const colon = line.indexOf(":");
+        if (colon < 1)
+            return { error: `linha sem "campo: valor": ${line}` };
+        fields[line.slice(0, colon).trim()] = line.slice(colon + 1).trim();
+    }
+    const missing = REQUIRED.filter((key) => !fields[key]);
+    if (missing.length)
+        return { error: `faltam os campos ${missing.join(", ")}` };
+    return fields;
+}
+/** Normalises an address so `https://Site.com` and `https://site.com/` compare equal. */
+function normalise(address) {
+    try {
+        return new URL(address).href;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Decides whether `url` may be audited. `recordText` is the consent file's content (undefined when
+ * no file was given); `today` is YYYY-MM-DD.
+ */
+export function checkConsent(url, recordText, today) {
+    if (LOCAL_HOSTS.has(url.hostname))
+        return { ok: true };
+    if (recordText === undefined) {
+        return {
+            ok: false,
+            reason: `${url.hostname} é um site real. Auditar um site exige o consentimento do dono.\n` +
+                "Peça o aceite com o texto de docs/field/consentimento.md (no pacote e em " +
+                "https://github.com/chrissgon/light-site-auditor/blob/main/docs/field/consentimento.md), " +
+                "registre-o num arquivo e rode de novo com --consent <arquivo>.",
+        };
+    }
+    const record = parseConsent(recordText);
+    if ("error" in record)
+        return { ok: false, reason: `O registro de consentimento não pôde ser lido: ${record.error}.` };
+    const expected = normalise(record.endereco);
+    if (!expected)
+        return { ok: false, reason: `O endereço do registro não é válido: ${record.endereco}.` };
+    if (expected !== url.href) {
+        return {
+            ok: false,
+            reason: `O consentimento cobre ${expected}, não ${url.href}. Audite exatamente o endereço aceito pelo dono.`,
+        };
+    }
+    if (record.status !== ACCEPTED) {
+        const pending = record.status.startsWith("pendente");
+        return {
+            ok: false,
+            reason: pending
+                ? `O consentimento de ${expected} está pendente (${record.status}). Registre o aceite do dono (status: aceito, data e como) antes de auditar.`
+                : `O consentimento de ${expected} não está aceito (status: ${record.status}). Só "status: aceito" libera a auditoria.`,
+        };
+    }
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(record.data) || Number.isNaN(Date.parse(record.data))) {
+        return { ok: false, reason: `A data do consentimento não está no formato AAAA-MM-DD: ${record.data}.` };
+    }
+    if (record.data > today)
+        return { ok: false, reason: `A data do consentimento (${record.data}) é futura.` };
+    return { ok: true, record };
+}

package/dist/explanations.js

@@ -0,0 +1,42 @@
+import catalog from "./explanations.pt.json" with { type: "json" };
+/**
+ * The reviewed catalog of plain-Portuguese explanations (AC-4). Nothing here writes new text: every
+ * sentence of a report comes from src/explanations.pt.json, and tests/explanations.test.ts checks it.
+ */
+export const CATALOG = catalog;
+export const NO_EXPLANATION = CATALOG.report.noExplanation;
+function explain(entries, id, original) {
+    const entry = Object.hasOwn(entries, id) ? entries[id] : undefined;
+    if (entry)
+        return { explained: true, ...entry };
+    return { explained: false, title: original, original, mark: NO_EXPLANATION };
+}
+/** The explanation of an axe rule, or the rule's own `help` text marked "sem explicação ainda". */
+export const explainAxe = (ruleId, help) => explain(CATALOG.axe, ruleId, help);
+/** The explanation of a Lighthouse audit, or the audit's own title marked "sem explicação ainda". */
+export const explainLighthouse = (auditId, title) => explain(CATALOG.lighthouse, auditId, title);
+/** Replaces `{name}` placeholders; a placeholder without a value is an error, never left in a report. */
+export function fill(template, values) {
+    return template.replace(/\{(\w+)\}/g, (_, name) => {
+        if (!(name in values))
+            throw new Error(`no value for {${name}} in "${template}"`);
+        return String(values[name]);
+    });
+}
+export const sentences = (text) => text.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+export const words = (sentence) => sentence.split(/\s+/).filter((w) => /[\p{L}\p{N}{]/u.test(w));
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+/** A whole-word, case-insensitive pattern for a term, with the Portuguese plural (-s, -es). */
+export const termPattern = (term) => new RegExp(`(?<![\\p{L}\\p{N}])${escape(term)}(?:s|es)?(?![\\p{L}\\p{N}])`, "iu");
+/** The glossary terms that appear in the texts. */
+export const glossaryTermsIn = (texts) => Object.keys(CATALOG.glossary).filter((term) => texts.some((text) => termPattern(term).test(text)));
+/** The glossary terms the texts use, plus the terms their definitions use, until nothing new appears. */
+export function glossaryClosure(texts) {
+    const found = new Set(glossaryTermsIn(texts));
+    for (let size = -1; size !== found.size;) {
+        size = found.size;
+        for (const term of glossaryTermsIn([...found].map((t) => CATALOG.glossary[t])))
+            found.add(term);
+    }
+    return Object.keys(CATALOG.glossary).filter((term) => found.has(term));
+}