@terpjs/eslint-boundaries 0.5.3 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terpjs/eslint-boundaries",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "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",

package/src/budget.js

@@ -190,6 +190,7 @@ function main() {
       JSON.stringify({
         terp_findings: 1,
         tool: "terp-boundaries-budget",
+        ok: problems.length === 0,
         rules: ["frontend/escape-hatch"],
         findings: problems.map((problem) => ({
           rule: "frontend/escape-hatch",

package/src/budget.test.js

@@ -178,6 +178,7 @@ describe("terp-boundaries-budget --format json (the findings envelope)", () => {
     expect(envelope.findings[0].rule).toBe("frontend/escape-hatch");
     expect(envelope.findings[0].path).toBe("escape-hatch-budget.json");
     expect(envelope.findings[0].message).toMatch(/unbudgeted marker/);
+    expect(envelope.ok).toBe(false);
     expect(run.stderr).toMatch(/unbudgeted marker/);
   });
 
@@ -188,6 +189,9 @@ describe("terp-boundaries-budget --format json (the findings envelope)", () => {
     const envelope = JSON.parse(run.stdout);
     expect(envelope.rules).toEqual(["frontend/escape-hatch"]);
     expect(envelope.findings).toEqual([]);
+    // The version marker stays 1 on a clean run — `ok` is what says it passed.
+    expect(envelope.terp_findings).toBe(1);
+    expect(envelope.ok).toBe(true);
   });
 
   it("still reads a positional budget path alongside the flag", () => {

package/src/findings.js

@@ -8,11 +8,19 @@
  * envelope** on stdout:
  *
  *   { "terp_findings": 1, "tool": "@terpjs/eslint-boundaries",
+ *     "ok": true,                                // did this run pass? (no findings)
  *     "rules": ["frontend/<rule>", …],          // every catalog rule this run evaluated
  *     "not_applicable": ["frontend/<rule>", …], // opt-in rules this app has not enabled
  *     "findings": [{ rule, path, line, message }, …],   // spec findings.schema.json shape
  *     "unattributed": [{ path, line, message, reported_as }, …] }
  *
+ * `terp_findings: 1` is the envelope's **format version**, not a count — it is the
+ * discriminator a consumer matches on (the same role `terp_check_report: 1` plays for
+ * the check report) and it stays 1 whether the run found zero problems or twenty. The
+ * count lives in `findings.length`, and the verdict in `ok`. Reading the marker as a
+ * finding count is a real reported misread, which is why `ok` is there: a consumer that
+ * wants "did this pass" should never have to interpret a version number.
+ *
  * `rules` is the evaluated-rule inventory ({@link catalogRuleIds}, minus the opt-in
  * rules listed under `not_applicable` — today `frontend/layout-contract` when the app
  * has no checked-in layout-contract.json, so a consumer never renders an unenforced
@@ -129,6 +137,9 @@ export function renderEnvelope(results, cwd = process.cwd(), options = {}) {
     envelope: {
       terp_findings: 1,
       tool: "@terpjs/eslint-boundaries",
+      // The verdict, stated: `terp_findings` is a format version and reads like a
+      // count, so leaving "did it pass" implicit invites the wrong answer.
+      ok: findings.length === 0,
       rules: catalogRuleIds().filter((id) => !notApplicable.includes(id)),
       not_applicable: notApplicable,
       findings,

package/src/findings.test.js

@@ -81,6 +81,29 @@ describe("renderEnvelope", () => {
     expect(human.length).toBe(envelope.findings.length);
   });
 
+  it("states the verdict, so the format version is never read as a count", async () => {
+    // `terp_findings: 1` is a discriminator; it stays 1 whatever the run found. A
+    // reported misread ("0 findings but terp_findings says 1") cost an app a cycle,
+    // so the envelope answers "did this pass" outright.
+    const clean = await lintModule("export function View() {\n  return null;\n}\n");
+    const cleanEnvelope = renderEnvelope(clean, path.resolve("."), {
+      layoutContract: true,
+    }).envelope;
+    expect(cleanEnvelope.findings).toEqual([]);
+    expect(cleanEnvelope.terp_findings).toBe(1);
+    expect(cleanEnvelope.ok).toBe(true);
+
+    const dirty = await lintModule(
+      'export function View() {\n  return <button style={{ color: "#fff" }}>x</button>;\n}\n',
+    );
+    const dirtyEnvelope = renderEnvelope(dirty, path.resolve("."), {
+      layoutContract: true,
+    }).envelope;
+    expect(dirtyEnvelope.findings.length).toBeGreaterThan(1);
+    expect(dirtyEnvelope.terp_findings).toBe(1);
+    expect(dirtyEnvelope.ok).toBe(false);
+  });
+
   it("publishes an un-opted-in layout contract as not_applicable, never as passing", async () => {
     // The opt-in rule is inert without a checked-in layout-contract.json; keeping it
     // in `rules` would let a consumer render "evaluated, zero findings" = green for a