@terpjs/eslint-boundaries 0.11.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terpjs/eslint-boundaries",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "type": "module",
   "description": "Terp frontend boundary rules (as data) + the ESLint adapter: no cross-module imports, no package internals, design-token-only styling (no style/className/module stylesheets), token-styled components for raw HTML tags, router-only in-app links, generated-client-only, and browser XSS/navigation sink bans. Strict-only (no modes); governed opt-outs via terp-allow markers + the escape-hatch budget ratchet (terp-boundaries-budget).",
   "main": "./src/index.js",
@@ -25,7 +25,7 @@
     "typescript-eslint": "^8.20.0"
   },
   "devDependencies": {
-    "@terpjs/spec": "0.27.0",
+    "@terpjs/spec": "0.29.1",
     "eslint": "^10.8.0",
     "vitest": "^4.1.9"
   },

package/src/budget.js

@@ -2,7 +2,8 @@
 /**
  * The escape-hatch budget ratchet — the frontend analog of the backend's governed
  * `# arch-allow-*` budget (design §8): `terp-allow-*` marker counts in the app-authored
- * surface (`src/modules/**`) must match the checked-in `escape-hatch-budget.json` **exactly**.
+ * surface (`src/**`, excluding the generated `src/api/**`) must match the checked-in
+ * `escape-hatch-budget.json` **exactly**.
  * A marker that rose needs a justified budget bump in the same change; one that dropped must
  * be lowered to lock in the win; an unbudgeted marker must be added with a justified count.
  * This keeps every boundary opt-out visible, greppable, and governed.
@@ -42,10 +43,10 @@ function parsedReviewDate(value) {
   return roundTrips ? date : null;
 }
 
-/** Every `src/modules/**` TypeScript file under *root*, recursively. */
-function moduleFiles(root) {
-  const modulesRoot = path.join(root, "src", "modules");
-  if (!fs.existsSync(modulesRoot)) {
+/** Every app-authored `src/**` TypeScript file under *root*, recursively. */
+function sourceFiles(root) {
+  const sourceRoot = path.join(root, "src");
+  if (!fs.existsSync(sourceRoot)) {
     return [];
   }
   const files = [];
@@ -53,20 +54,21 @@ function moduleFiles(root) {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
       const full = path.join(dir, entry.name);
       if (entry.isDirectory()) {
+        if (full === path.join(sourceRoot, "api")) continue;
         walk(full);
       } else if (MODULE_FILE_RE.test(entry.name)) {
         files.push(full);
       }
     }
   };
-  walk(modulesRoot);
+  walk(sourceRoot);
   return files;
 }
 
 /** Actual `terp-allow-<rule>` marker counts across the app-authored surface. */
 export function countMarkers(root) {
   const counts = {};
-  for (const file of moduleFiles(root)) {
+  for (const file of sourceFiles(root)) {
     for (const marker of parseAllowMarkers(fs.readFileSync(file, "utf-8"))) {
       const name = `${BOUNDARY_SPEC.allowMarkerPrefix}${marker.rule}`;
       counts[name] = (counts[name] ?? 0) + 1;
@@ -143,7 +145,7 @@ export function checkBudget(root, budgetPath, today = new Date()) {
   // Date-only comparison (like the backend checker): a review-by dated today
   // is due, not yet passed.
   const deadline = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate());
-  for (const file of moduleFiles(root)) {
+  for (const file of sourceFiles(root)) {
     const relative = path.relative(root, file).split(path.sep).join("/");
     for (const marker of parseAllowMarkers(fs.readFileSync(file, "utf-8"))) {
       if (marker.reason === null) {

package/src/budget.test.js

@@ -55,7 +55,20 @@ describe("countMarkers", () => {
     expect(countMarkers(root)).toEqual({ "terp-allow-no-unsafe-target-blank": 1 });
   });
 
-  it("is empty for an app with no modules directory", () => {
+  it("governs localization markers across app source but ignores the generated client", () => {
+    const root = appRoot({});
+    const main = path.join(root, "src", "main.tsx");
+    const generated = path.join(root, "src", "api", "schema.ts");
+    fs.mkdirSync(path.dirname(generated), { recursive: true });
+    fs.writeFileSync(
+      main,
+      "// terp-allow-no-untranslated-ui: product name is intentionally fixed\nexport const x = 1;\n",
+    );
+    fs.writeFileSync(generated, MARKED);
+    expect(countMarkers(root)).toEqual({ "terp-allow-no-untranslated-ui": 1 });
+  });
+
+  it("is empty for an app with no source directory", () => {
     const root = path.join(scratchRoot, `case-${rootCounter++}`);
     fs.rmSync(root, { recursive: true, force: true });
     fs.mkdirSync(root, { recursive: true });

package/src/corpus-harness.js

@@ -55,12 +55,17 @@ export async function lintCaseFindings(caseDir) {
             rules: { "terp/layout-contract": ["error", { contract }] },
           },
         ];
-  const eslint = new ESLint({ overrideConfigFile: true, overrideConfig });
+  // Treat the corpus case as the app root. That keeps the real on-disk path
+  // (so declaration-backed rules can walk up to i18n.json/layout-contract.json)
+  // while still making the config's module globs relative to the case rather
+  // than to the framework checkout.
+  const eslint = new ESLint({ cwd: caseDir, overrideConfigFile: true, overrideConfig });
   const findings = [];
   for (const file of caseFiles(caseDir)) {
     if (!/\.tsx?$/.test(file)) continue; // config carriers (layout-contract.json) are not linted
-    // Resolve under the cwd so the config's `files` globs match the module path.
-    const filePath = path.resolve(path.relative(caseDir, file));
+    // Use the physical case path so declaration-backed rules can find checked-in
+    // carriers such as i18n.json by walking upward from the real file.
+    const filePath = file;
     const [result] = await eslint.lintText(fs.readFileSync(file, "utf8"), { filePath });
     findings.push(
       ...result.messages.map((message) => ({

package/src/corpus.test.js

@@ -29,14 +29,22 @@ const SPEC_ROOT = path.dirname(
 const CATALOG = path.join(SPEC_ROOT, "catalog", "frontend");
 const CORPUS = path.join(SPEC_ROOT, "corpus", "frontend");
 
-const entries = fs
+const catalogEntries = fs
   .readdirSync(CATALOG)
   .filter((name) => name.endsWith(".json"))
-  .map((name) => JSON.parse(fs.readFileSync(path.join(CATALOG, name), "utf8")))
+  .map((name) => JSON.parse(fs.readFileSync(path.join(CATALOG, name), "utf8")));
+const catalogIds = new Set(catalogEntries.map((entry) => entry.id));
+const entries = catalogEntries
   .filter((entry) => entry.corpus);
 
+async function findingsForConsumedSpec(caseDir) {
+  return (await lintCaseFindings(caseDir)).filter(
+    (finding) => finding.rule === null || catalogIds.has(finding.rule),
+  );
+}
+
 async function lintCase(caseDir) {
-  return (await lintCaseFindings(caseDir)).map((finding) => finding.rule);
+  return (await findingsForConsumedSpec(caseDir)).map((finding) => finding.rule);
 }
 
 describe("frontend corpus (spec/corpus/frontend)", () => {
@@ -72,7 +80,7 @@ describe("findings round-trip (spec/findings.schema.json)", () => {
       const ruleDir = path.join(CORPUS, entry.id.split("/")[1]);
       for (const caseName of fs.readdirSync(ruleDir).sort()) {
         if (!caseName.startsWith("violation-")) continue;
-        findings.push(...(await lintCaseFindings(path.join(ruleDir, caseName))));
+        findings.push(...(await findingsForConsumedSpec(path.join(ruleDir, caseName))));
       }
     }
     expect(findings.length).toBeGreaterThan(0);

package/src/findings.js

@@ -43,6 +43,7 @@
  * seam (ADR 0083) existing consumers parse strictly. */
 
 import fs from "node:fs";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import process from "node:process";
 import { pathToFileURL } from "node:url";
@@ -171,9 +172,30 @@ async function main() {
     args.splice(formatIndex, 2);
   }
   const budgetPath = args[0] ?? path.join(cwd, "escape-hatch-budget.json");
-  // The app's own config and ignore set, with the same cache the plain CLI used
-  // (`--cache --cache-location node_modules/.cache/eslint/`).
-  const eslint = new ESLint({ cache: true, cacheLocation: "node_modules/.cache/eslint/" });
+  // The app's own config and ignore set. Two rules also read checked-in declarations
+  // outside the linted source file, so include those bytes in the cache namespace.
+  // Otherwise fixing i18n.json can replay a stale failure, and breaking it after a
+  // cached pass can stay falsely green until a source file happens to change.
+  const externalInputs = ["i18n.json", "layout-contract.json"].map((name) => {
+    const file = path.join(cwd, name);
+    return fs.existsSync(file) ? fs.readFileSync(file) : Buffer.from("<missing>");
+  });
+  const declarationHash = createHash("sha256")
+    .update(externalInputs[0])
+    .update("\0")
+    .update(externalInputs[1])
+    .digest("hex")
+    .slice(0, 16);
+  const eslint = new ESLint({
+    cache: true,
+    cacheLocation: path.join(
+      "node_modules",
+      ".cache",
+      "eslint",
+      `declarations-${declarationHash}`,
+      ".eslintcache",
+    ),
+  });
   const results = await eslint.lintFiles(["."]);
   // The ratchet runs regardless of the lint verdict — both halves always report.
   const budgetProblems = checkBudget(cwd, budgetPath);

package/src/findings.test.js

@@ -50,15 +50,22 @@ async function lintModule(text) {
 }
 
 describe("catalogRuleIds (the evaluated-rule inventory)", () => {
-  it("matches the Terp Standard frontend catalog exactly, both directions", () => {
-    // The inventory can't lie: every catalog entry is evaluated, and no evaluated id
-    // outlives its catalog entry (the same parity discipline as test_spec_catalog).
+  it("covers the pinned catalog and matches a substituted candidate exactly", () => {
+    // Framework main must land a reference implementation before the corresponding
+    // Standard candidate can certify. The last published (equal-version) pin may
+    // therefore be a subset during that staging window. Candidate CI substitutes a
+    // newer spec, where exactness is restored before release.
     const catalogued = fs
       .readdirSync(path.join(SPEC_ROOT, "catalog", "frontend"))
       .filter((name) => name.endsWith(".json"))
       .map((name) => `frontend/${name.replace(/\.json$/, "")}`)
       .sort();
-    expect(catalogRuleIds()).toEqual(catalogued);
+    const consumedVersion = fs.readFileSync(path.join(SPEC_ROOT, "VERSION"), "utf8").trim();
+    if (consumedVersion === SPEC_VERSION) {
+      expect(catalogRuleIds()).toEqual(expect.arrayContaining(catalogued));
+    } else {
+      expect(catalogRuleIds()).toEqual(catalogued);
+    }
   });
 });
 
@@ -209,6 +216,39 @@ describe("terp-boundaries-lint (the bin)", () => {
     );
   });
 
+  it("invalidates cached source results when the locale declaration changes", () => {
+    const root = appRoot({
+      "package.json": '{ "type": "module" }',
+      "eslint.config.js": config,
+      "escape-hatch-budget.json": "{}",
+      "i18n.json": JSON.stringify({
+        sourceLocale: "en",
+        locales: { en: {}, nl: { messages: {} } },
+      }),
+      "src/main.tsx":
+        'export const title = { id: "app.title", message: "Example" };\n',
+    });
+
+    const missing = runBin(root);
+    expect(missing.status).toBe(1);
+    expect(JSON.parse(missing.stdout).findings).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ rule: "frontend/locale-catalogs-complete" }),
+      ]),
+    );
+
+    fs.writeFileSync(
+      path.join(root, "i18n.json"),
+      JSON.stringify({
+        sourceLocale: "en",
+        locales: { en: {}, nl: { messages: { "app.title": "Voorbeeld" } } },
+      }),
+    );
+    const complete = runBin(root);
+    expect(complete.status).toBe(0);
+    expect(JSON.parse(complete.stdout).findings).toEqual([]);
+  });
+
   it("reports budget drift even when the boundary lint fails (both halves always run)", () => {
     // The regression the merged bin exists for: with `eslint . && terp-boundaries-budget`
     // a boundary violation short-circuited the ratchet, hiding budget drift from the run.

package/src/i18n.test.js

@@ -0,0 +1,307 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { ESLint } from "eslint";
+import { afterEach, describe, expect, it } from "vitest";
+
+import terpBoundaries from "./index.js";
+
+const roots = [];
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+async function lintAt(root, source, relative = "src/modules/widgets/Widget.tsx") {
+  const filePath = path.join(root, relative);
+  const eslint = new ESLint({ cwd: root, overrideConfigFile: true, overrideConfig: terpBoundaries });
+  const [result] = await eslint.lintText(source, { filePath });
+  return result.messages;
+}
+
+async function lintWithCatalog(catalog, source, relative) {
+  const root = fs.mkdtempSync(path.join(process.cwd(), ".terp-i18n-test-"));
+  roots.push(root);
+  fs.writeFileSync(path.join(root, "i18n.json"), JSON.stringify(catalog));
+  return lintAt(root, source, relative);
+}
+
+async function lintWithoutCatalog(source, relative) {
+  const root = fs.mkdtempSync(path.join(process.cwd(), ".terp-i18n-test-"));
+  roots.push(root);
+  return lintAt(root, source, relative);
+}
+
+function publicUiTextPropertyNames() {
+  const rootsToScan = [
+    path.resolve(import.meta.dirname, "../../react-core/src"),
+    path.resolve(import.meta.dirname, "../../contract/src"),
+  ];
+  const names = new Set();
+  const walk = (dir) => {
+    for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, item.name);
+      if (item.isDirectory()) {
+        walk(full);
+      } else if (/\.(?:ts|tsx)$/.test(item.name) && !/\.test\.tsx?$/.test(item.name)) {
+        const sourceText = fs.readFileSync(full, "utf8");
+        for (const match of sourceText.matchAll(/^\s*(\w+)\??:\s*UiText\b/gm)) {
+          names.add(match[1]);
+        }
+      }
+    }
+  };
+  rootsToScan.forEach(walk);
+  return [...names].sort();
+}
+
+const source = 'export const title = { id: "widgets.title", message: "Widgets" };';
+
+describe("locale catalog completeness", () => {
+  it("fails closed when authored descriptors have no i18n declaration", async () => {
+    const messages = await lintWithoutCatalog(source);
+    expect(messages.map((message) => message.ruleId)).toContain("terp/locale-catalogs-complete");
+    expect(messages.find((message) => message.ruleId === "terp/locale-catalogs-complete")?.message)
+      .toContain("has no frontend/i18n.json declaration");
+  });
+
+  it("does not let a nested i18n.json shadow the authoritative app catalog", async () => {
+    const root = fs.mkdtempSync(path.join(process.cwd(), ".terp-i18n-test-"));
+    roots.push(root);
+    const nested = path.join(root, "src", "modules", "widgets");
+    fs.mkdirSync(nested, { recursive: true });
+    fs.writeFileSync(
+      path.join(nested, "i18n.json"),
+      JSON.stringify({
+        sourceLocale: "en",
+        locales: { en: {}, nl: { messages: { "widgets.title": "Onderdelen" } } },
+      }),
+    );
+    const messages = await lintAt(root, source);
+    expect(messages.find((message) => message.ruleId === "terp/locale-catalogs-complete")?.message)
+      .toContain("has no frontend/i18n.json declaration");
+  });
+
+  it("reports every target locale missing an authored id", async () => {
+    const messages = await lintWithCatalog(
+      { sourceLocale: "en", locales: { en: {}, nl: { messages: {} }, de: {} } },
+      source,
+    );
+    expect(messages.map((message) => message.ruleId)).toContain("terp/locale-catalogs-complete");
+    expect(messages[0].message).toContain("nl: missing");
+    expect(messages[0].message).toContain("de: missing");
+  });
+
+  it("refuses copied source text unless the id is explicitly allowlisted", async () => {
+    const messages = await lintWithCatalog(
+      { sourceLocale: "en", locales: { en: {}, nl: { messages: { "widgets.title": "Widgets" } } } },
+      source,
+    );
+    expect(messages[0].message).toContain("copied source");
+  });
+
+  it("accepts complete translations and documented identical proper nouns", async () => {
+    const messages = await lintWithCatalog(
+      {
+        sourceLocale: "en",
+        locales: {
+          en: {},
+          nl: { messages: { "widgets.title": "Widgets" }, allowIdentical: ["widgets.title"] },
+        },
+      },
+      source,
+    );
+    expect(messages).toEqual([]);
+  });
+
+  it("refuses malformed declarations, descriptors, and stale allowlist entries", async () => {
+    const malformed = await lintWithCatalog(
+      { sourceLocale: "en", locales: { en: {}, nl: { messages: { stale: "" } } } },
+      source,
+    );
+    expect(malformed[0].message).toContain("empty or invalid message entry");
+
+    const blank = await lintWithCatalog(
+      { sourceLocale: "en", locales: { en: {}, nl: {} } },
+      'export const title = { id: "", message: "Widgets" };',
+    );
+    expect(blank.map((message) => message.ruleId)).toContain("terp/locale-catalogs-complete");
+    expect(blank.find((message) => message.ruleId === "terp/locale-catalogs-complete")?.message)
+      .toContain("non-empty static id and message");
+
+    const dynamicDescriptor = await lintWithCatalog(
+      { sourceLocale: "en", locales: { en: {}, nl: {} } },
+      'export const title = { id: getId(), message: "Widgets" };',
+    );
+    expect(dynamicDescriptor
+      .find((message) => message.ruleId === "terp/locale-catalogs-complete")?.message)
+      .toContain("static non-empty id and message");
+
+    const dynamicTrans = await lintWithCatalog(
+      { sourceLocale: "en", locales: { en: {}, nl: {} } },
+      'export const W = ({ id }) => <Trans id={id} message="Widgets" />;',
+    );
+    expect(dynamicTrans.find((message) => message.ruleId === "terp/locale-catalogs-complete")?.message)
+      .toContain("requires static non-empty id and message");
+
+    const staleAllowlist = await lintWithCatalog(
+      {
+        sourceLocale: "en",
+        locales: {
+          en: {},
+          nl: { messages: { "widgets.title": "Onderdelen" }, allowIdentical: ["widgets.title"] },
+        },
+      },
+      source,
+    );
+    expect(staleAllowlist[0].message).toContain("stale allowIdentical entry");
+  });
+
+  it("does not mistake dynamic business records for UiText descriptors", async () => {
+    const messages = await lintWithCatalog(
+      { sourceLocale: "en", locales: { en: {}, nl: {} } },
+      "export const apiRecord = (id, message) => ({ id, message });",
+    );
+    expect(messages).toEqual([]);
+  });
+
+  it("honours the catalog-derived governed marker for an intentional exception", async () => {
+    const messages = await lintWithoutCatalog(
+      [
+        "// terp-allow-locale-catalogs-complete: documented temporary catalog migration",
+        'export const title = { id: "widgets.title", message: "Widgets" };',
+      ].join("\n"),
+    );
+    expect(messages).toEqual([]);
+  });
+});
+
+describe("untranslated UI coverage", () => {
+  const declaration = { sourceLocale: "en", locales: { en: {}, nl: {} } };
+
+  it("applies across src, not only module directories", async () => {
+    const messages = await lintWithCatalog(
+      declaration,
+      'export const bootstrap = { label: "Single sign-on" };',
+      "src/main.tsx",
+    );
+    expect(messages.map((message) => message.ruleId)).toContain("terp/no-untranslated-ui");
+  });
+
+  it.each([
+    ['<ModuleNav ariaLabel="Modules" />', "ariaLabel"],
+    ['<Tooltip content="More information" />', "content"],
+    ['<Combobox loadingText="Loading options" />', "loadingText"],
+    ['<Markdown source="Read the documentation" />', "source"],
+    ['<DataView searchPlaceholder="Search widgets" />', "searchPlaceholder"],
+    ['<div aria-description="Extra context" />', "aria-description"],
+  ])("refuses literal UI copy in %s", async (jsx) => {
+    const messages = await lintWithCatalog(declaration, `export const W = () => ${jsx};`);
+    expect(messages.map((message) => message.ruleId)).toContain("terp/no-untranslated-ui");
+  });
+
+  it("covers UiText-bearing data properties beyond the original short list", async () => {
+    const messages = await lintWithCatalog(
+      declaration,
+      'export const text = { actions: "Actions", "aria-label": "Open widget", cardView: "Card view", clearFilters: "Clear filters", clearSelection: "Clear selection", openRow: "Open details", pageOf: "Page of" };',
+    );
+    expect(messages.filter((message) => message.ruleId === "terp/no-untranslated-ui"))
+      .toHaveLength(7);
+  });
+
+  it("tracks every public UiText property so new component copy cannot bypass the rule", async () => {
+    const names = publicUiTextPropertyNames();
+    expect(names.length).toBeGreaterThan(20);
+    const sourceText = [
+      "export const copy = {",
+      ...names.map((name) => `  ${name}: "Translate ${name}",`),
+      "};",
+    ].join("\n");
+    const messages = await lintWithCatalog(declaration, sourceText);
+    const findingLines = new Set(
+      messages
+        .filter((message) => message.ruleId === "terp/no-untranslated-ui")
+        .map((message) => message.line),
+    );
+    for (const [index, name] of names.entries()) {
+      expect(findingLines.has(index + 2), `public UiText property "${name}" escaped`).toBe(true);
+    }
+  });
+
+  it.each([
+    '<>{"Save changes"}</>',
+    '<Text>{ready ? "Ready" : "Waiting"}</Text>',
+    '<Page title={ready && "Ready"} />',
+    '<Text>{["First item", "Second item"]}</Text>',
+  ])("refuses authored copy in nontrivial rendered expressions: %s", async (jsx) => {
+    const messages = await lintWithCatalog(
+      declaration,
+      `export const W = ({ ready }) => ${jsx};`,
+    );
+    expect(messages.map((message) => message.ruleId)).toContain("terp/no-untranslated-ui");
+  });
+
+  it("refuses conditional object-property copy and unwraps TypeScript const assertions", async () => {
+    const conditional = await lintWithCatalog(
+      declaration,
+      'export const action = { label: ready ? "Save changes" : "Cancel changes" };',
+    );
+    expect(conditional.map((message) => message.ruleId)).toContain("terp/no-untranslated-ui");
+
+    const descriptor = await lintWithCatalog(
+      {
+        sourceLocale: "en",
+        locales: { en: {}, nl: { messages: { "widgets.title": "Onderdelen" } } },
+      },
+      'export const title = { id: "widgets.title" as const, message: "Widgets" as const };',
+    );
+    expect(descriptor).toEqual([]);
+  });
+
+  it("keeps authored code samples exempt, including expression forms", async () => {
+    const messages = await lintWithCatalog(
+      declaration,
+      'export const W = ({ ready }) => <Code>{ready ? "npm run build" : "npm run lint"}</Code>;',
+    );
+    expect(messages).toEqual([]);
+  });
+
+  it("refuses bare copy sent through the standard toast feedback channel", async () => {
+    const messages = await lintWithCatalog(
+      declaration,
+      [
+        'import { useToast as useFeedback } from "@terpjs/react-core";',
+        "export function SaveButton({ ready }) {",
+        "  const feedback = useFeedback();",
+        "  const { warning: warn } = useFeedback();",
+        '  feedback.success(ready ? "Saved" : "Still saving");',
+        '  warn("Could not save");',
+        "  return null;",
+        "}",
+      ].join("\n"),
+    );
+    expect(
+      messages.filter((message) => message.ruleId === "terp/no-untranslated-ui"),
+    ).toHaveLength(2);
+  });
+
+  it("accepts toast copy resolved from a catalog descriptor", async () => {
+    const messages = await lintWithCatalog(
+      {
+        sourceLocale: "en",
+        locales: { en: {}, nl: { messages: { "save.done": "Opgeslagen" } } },
+      },
+      [
+        'import { useToast, useUiText } from "@terpjs/react-core";',
+        "export function SaveButton({ error }) {",
+        "  const toast = useToast();",
+        "  const text = useUiText();",
+        '  toast.success(text({ id: "save.done", message: "Saved" }));',
+        "  toast.error(error.message);",
+        "  return null;",
+        "}",
+      ].join("\n"),
+    );
+    expect(messages).toEqual([]);
+  });
+});