@@ -67,7 +67,7 @@ const MULTI_PUBLISHER_DOMAINS = new Set([
   "fonts.google.com",
 ]);
 
-function empty(v) {
+export function empty(v) {
   if (v === undefined || v === null) return true;
   if (typeof v === "string" && v.trim() === "") return true;
   if (Array.isArray(v) && v.length === 0) return true;
@@ -1282,3 +1282,44 @@ export function checkLicenceGuide(vocab, guideText) {
   });
   return missing.map((k) => `docs/licenses.md does not mention the licence value "${k}" (add a row or a sentence for it)`);
 }
+
+/* ------------------------------------------------------- entry registry */
+/**
+ * Every per-entry check, in the order validate runs them (#255). Each takes
+ * `(rel, meta, body, ctx)`, where ctx = { vocab, spdxAllowed, aliases,
+ * formatVocab, today, stem, dirName, categories, readmeText }. validate
+ * loops over this list, and lib/checks tests fail when an exported
+ * `check*(rel, meta, ...)` function is in neither this list nor
+ * NOT_ENTRY_CHECKS, so a written check cannot go unwired.
+ */
+export const ENTRY_CHECKS = [
+  { name: "checkEntryBasics", run: (rel, meta, body, c) => checkEntryBasics(rel, meta, body, { stem: c.stem, dirName: c.dirName, categories: c.categories, readmeText: c.readmeText, today: c.today }) },
+  { name: "checkKnownKeys", run: (rel, meta) => checkKnownKeys(rel, meta) },
+  { name: "checkCreditPlaceholders", run: (rel, meta) => checkCreditPlaceholders(rel, meta) },
+  { name: "checkLimits", run: (rel, meta) => checkLimits(rel, meta) },
+  { name: "checkAiTag", run: (rel, meta, body) => checkAiTag(rel, meta, body) },
+  { name: "checkAttributionWaiver", run: (rel, meta, body, c) => checkAttributionWaiver(rel, meta, body, c.vocab) },
+  // V24 types commercial and attribution_required (a quoted "true" is text).
+  { name: "checkFieldTypes", run: (rel, meta) => checkFieldTypes(rel, meta) },
+  { name: "checkEntryUrl", run: (rel, meta) => checkEntryUrl(rel, meta) },
+  { name: "checkLicenseVocabulary", run: (rel, meta, body, c) => checkLicenseVocabulary(rel, meta, c.vocab) },
+  { name: "checkSpdxConsistency", run: (rel, meta, body, c) => checkSpdxConsistency(rel, meta, c.vocab, c.spdxAllowed) },
+  { name: "checkAttributionConsistency", run: (rel, meta, body, c) => checkAttributionConsistency(rel, meta, body, c.vocab) },
+  { name: "checkEvidenceDates", run: (rel, meta, body, c) => checkEvidenceDates(rel, meta, body, c.today) },
+  { name: "checkDeprecationReason", run: (rel, meta, body, c) => checkDeprecationReason(rel, meta, body, c.vocab) },
+  { name: "checkTaxonomyValues", run: (rel, meta) => checkTaxonomyValues(rel, meta) },
+  { name: "checkValueAliases", run: (rel, meta, body, c) => checkValueAliases(rel, meta, c.aliases) },
+  { name: "checkFormatVocabulary", run: (rel, meta, body, c) => checkFormatVocabulary(rel, meta, c.formatVocab) },
+  { name: "checkTagsRestatePublisher", run: (rel, meta) => checkTagsRestatePublisher(rel, meta) },
+  { name: "checkMaintenance", run: (rel, meta) => checkMaintenance(rel, meta) },
+  { name: "checkEngineFields", run: (rel, meta) => checkEngineFields(rel, meta) },
+  { name: "checkActiveIsSettled", run: (rel, meta) => checkActiveIsSettled(rel, meta) },
+  { name: "checkNonCommercialEvidence", run: (rel, meta, body) => checkNonCommercialEvidence(rel, meta, body) },
+  { name: "checkPreviewField", run: (rel, meta) => checkPreviewField(rel, meta) },
+  { name: "checkTitleMatchesName", run: (rel, meta, body) => checkTitleMatchesName(rel, meta, body) },
+  { name: "checkAddedDate", run: (rel, meta, body, c) => checkAddedDate(rel, meta, c.today) },
+];
+
+/** Exported check*(rel, meta, ...) functions that are not per-entry checks, with where they run. */
+export const NOT_ENTRY_CHECKS = {
+};
@@ -2331,6 +2331,39 @@ eq("search: q from the URL is capped", readState(`?q=${"a".repeat(5000)}`, { q:
   eq("normalize: optional fields only when set", "publisher" in e, false);
 }
 
+/* entry check registry and validateRepo (#255) ----------------------------- */
+{
+  const checks = await import("../checks.mjs");
+  const registered = new Set(checks.ENTRY_CHECKS.map((c) => c.name));
+  const entryShaped = Object.entries(checks)
+    .filter(([name, f]) => typeof f === "function" && name.startsWith("check"))
+    .filter(([, f]) => /^\(?\s*rel\s*,\s*meta\b/.test(f.toString().replace(/^function\s*\w*\s*/, "")))
+    .map(([name]) => name);
+  eq("registry: entry-shaped checks were found", entryShaped.length >= 20, true);
+  for (const name of entryShaped) {
+    eq(`registry: ${name} runs from ENTRY_CHECKS or is listed as not an entry check`, registered.has(name) || name in checks.NOT_ENTRY_CHECKS, true);
+  }
+  for (const name of registered) eq(`registry: ${name} is a real check`, typeof checks[name], "function");
+  eq("registry: no check is listed twice", registered.size, checks.ENTRY_CHECKS.length);
+
+  // The loop validate runs reaches a check: an unknown key is reported.
+  const ctx = { vocab: { licenses: {}, families: {} }, spdxAllowed: new Set(), aliases: {}, formatVocab: { formats: [], groups: {} }, today: "2026-11-07", stem: "a", dirName: "2d", categories: new Set(["2d"]), readmeText: "" };
+  const errs = [];
+  for (const c of checks.ENTRY_CHECKS) {
+    try {
+      errs.push(...c.run("catalog/2d/a.md", { id: "a", engine_lock_typo: "x" }, "", ctx));
+    } catch {
+      // A check that needs fuller context may throw on this stub; the one under test does not.
+    }
+  }
+  has("registry: the loop reaches checkKnownKeys", errs.join("\n"), "engine_lock_typo");
+
+  const { validateRepo } = await import("../validate.mjs");
+  const run = validateRepo();
+  eq("validateRepo: this checkout passes", run.errors.join("\n"), "");
+  eq("validateRepo: it counts the entries", run.entryCount > 400, true);
+}
+
 /* report (keep last) ------------------------------------------------------ */
 if (failures.length) {
   console.error(`lib.test failed (${failures.length}):`);
 
@@ -7,31 +7,16 @@ import { execFileSync } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
-  checkEntryBasics,
+  empty,
+  ENTRY_CHECKS,
   checkPreviewVocabulary,
   checkFeatured,
   checkAiGuide,
-  checkAttributionWaiver,
-  checkAiTag,
-  checkCreditPlaceholders,
-  checkLimits,
-  checkKnownKeys,
-  checkActiveIsSettled,
-  checkPreviewField,
   checkThumbManifest,
-  checkAddedDate,
-  checkAttributionConsistency,
   checkCategoryReadmeRows,
   checkComparisonLicences,
   checkCategorySets,
   checkCountTables,
-  checkDeprecationReason,
-  checkEngineFields,
-  checkEntryUrl,
-  checkEvidenceDates,
-  checkFieldTypes,
-  checkFormatVocabulary,
-  checkLicenseVocabulary,
   checkLicenceGuide,
   checkLineEndings,
   checkEntryCount,
@@ -40,15 +25,8 @@ import {
   categoryFormOptions,
   hasEmoji,
   checkRepoFiles,
-  checkMaintenance,
-  checkNonCommercialEvidence,
   checkPublisherConsistency,
-  checkSpdxConsistency,
   checkStacks,
-  checkTagsRestatePublisher,
-  checkTaxonomyValues,
-  checkTitleMatchesName,
-  checkValueAliases,
   checkValueSpellings,
   markdownAnchors,
 } from "./checks.mjs";
@@ -115,13 +93,6 @@ function repoFiles() {
   }
 }
 
-function isEmptyField(v) {
-  if (v === undefined || v === null) return true;
-  if (typeof v === "string" && v.trim() === "") return true;
-  if (Array.isArray(v) && v.length === 0) return true;
-  return false;
-}
-
 function relFromRoot(file) {
   return path.relative(ROOT, file).split(path.sep).join("/");
 }
@@ -192,8 +163,8 @@ function coverageReport(entries) {
   for (const meta of entries) {
     const cat = String(meta.category || "?");
     byCat.set(cat, (byCat.get(cat) || 0) + 1);
-    if (!isEmptyField(meta.license_spdx)) spdx += 1;
-    if (!isEmptyField(meta.publisher)) publisher += 1;
+    if (!empty(meta.license_spdx)) spdx += 1;
+    if (!empty(meta.publisher)) publisher += 1;
   }
   const n = entries.length;
   const pct = (c) => (n ? ((100 * c) / n).toFixed(1) : "0.0");
@@ -206,7 +177,12 @@ function coverageReport(entries) {
   return lines.join("\n");
 }
 
-function main() {
+/**
+ * Every repository check, over this checkout. Returns the errors and what
+ * the CLI summary prints; the CLI below exits on errors. Importable, so the
+ * tests run it (#255).
+ */
+export function validateRepo() {
   const errors = [];
   // "In the future" means after tomorrow in UTC, so no time zone's today fails.
   const today = latestAllowedDate();
@@ -237,33 +213,9 @@ function main() {
     const stem = path.basename(file, ".md");
     const catReadme = path.join(path.dirname(file), "README.md");
     const readmeText = linkTarget(catReadme).exists ? readText(catReadme) : null;
-    errors.push(
-      ...checkEntryBasics(rel, meta, body, { stem, dirName: path.basename(path.dirname(file)), categories, readmeText, today })
-    );
-    errors.push(...checkKnownKeys(rel, meta));
-    errors.push(...checkCreditPlaceholders(rel, meta));
-    errors.push(...checkLimits(rel, meta));
-    errors.push(...checkAiTag(rel, meta, body));
-    errors.push(...checkAttributionWaiver(rel, meta, body, vocab));
-    // V24 types commercial and attribution_required (a quoted "true" is text).
-    errors.push(...checkFieldTypes(rel, meta));
-    errors.push(...checkEntryUrl(rel, meta));
-    errors.push(...checkLicenseVocabulary(rel, meta, vocab));
-    errors.push(...checkSpdxConsistency(rel, meta, vocab, spdxAllowed));
-    errors.push(...checkAttributionConsistency(rel, meta, body, vocab));
-    errors.push(...checkEvidenceDates(rel, meta, body, today));
-    errors.push(...checkDeprecationReason(rel, meta, body, vocab));
-    errors.push(...checkTaxonomyValues(rel, meta));
-    errors.push(...checkValueAliases(rel, meta, aliases));
-    errors.push(...checkFormatVocabulary(rel, meta, formatVocab));
-    errors.push(...checkTagsRestatePublisher(rel, meta));
-    errors.push(...checkMaintenance(rel, meta));
-    errors.push(...checkEngineFields(rel, meta));
-    errors.push(...checkActiveIsSettled(rel, meta));
-    errors.push(...checkNonCommercialEvidence(rel, meta, body));
-    errors.push(...checkPreviewField(rel, meta));
-    errors.push(...checkTitleMatchesName(rel, meta, body));
-    errors.push(...checkAddedDate(rel, meta, today));
+    // Every per-entry check, from one list (checks.mjs ENTRY_CHECKS, #255).
+    const ctx = { vocab, spdxAllowed, aliases, formatVocab, today, stem, dirName: path.basename(path.dirname(file)), categories, readmeText };
+    for (const check of ENTRY_CHECKS) errors.push(...check.run(rel, meta, body, ctx));
     if (meta.id) {
       const id = String(meta.id);
       if (ids.has(id)) errors.push(`duplicate id "${id}": ${ids.get(id)} and ${rel}`);
@@ -373,16 +325,18 @@ function main() {
 
   errors.push(...checkRepoFiles(repoFiles()));
 
+  return { errors, entries, entryCount: entryFiles.length, idCount: ids.size, stackCount: stackFiles.length };
+}
+
+function main() {
+  const { errors, entries, entryCount, idCount, stackCount } = validateRepo();
   if (errors.length) {
     console.error(`validate failed (${errors.length}):`);
     for (const e of errors) console.error(`  - ${e}`);
     process.exit(1);
   }
-
-  console.log(
-    `validate ok: ${entryFiles.length} entries, ${ids.size} ids, ${stackFiles.length} stacks, no broken links`
-  );
+  console.log(`validate ok: ${entryCount} entries, ${idCount} ids, ${stackCount} stacks, no broken links`);
   console.log(coverageReport(entries));
 }
 
-main();
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main();