@akanjs/devkit 3.1.1-rc.9 → 3.1.2-rc.0

package/lint/no-oversized-list-limit.grit

@@ -0,0 +1,73 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// A client list request takes at most MAX_PAGE_SIZE (500) rows: SignalResolver.#clientPageLimit
+// (pkgs/akanjs/server/resolver/signal.resolver.ts) clamps a larger limit and answers with 500 rows and no
+// error, so a screen that asked for 10000 silently stops at row 500. A store list reads hasMoreOf<Model><Suffix>
+// as true after a full 500, so only a screen that calls loadMoreOf<Model><Suffix> ever sees the rest. The server
+// logs one warning per list; this rule moves it to the line that asked.
+//
+// Matched: a literal limit above 500 in the generated list fetch, `fetch.<model>List<Suffix>(...sliceArgs,
+// skip, limit, sort?, fetchPolicy?)`; as `limit:` in the option object of `fetch.init<Model><Suffix>`,
+// `fetch.get<Model>Init<Suffix>`, `st.do.init<Model><Suffix>` and `st.do.refresh<Model><Suffix>`; and as the
+// argument of `st.do.setLimitOf<Model><Suffix>`.
+//
+// A rule cannot know a slice's arity, so the positional limit is found by shape: an argument that reads as a
+// skip (`0`, `null`, `undefined`, a name with skip/offset, a page multiplied out) directly before the literal,
+// and after it nothing but a non-numeric sort and a fetch policy. That keeps a numeric slice argument out
+// (`fetch.statListInYear(2026)`, `fetch.statListInMonth(11, 2026)`), as it does a variable limit, `limit: 0`
+// (the store's one-page mode, which the server warns about itself) and a `limit:` key anywhere else (rate
+// limits). Left over: a slice whose own last two arguments read as `(0, 1000)`, such as a price range; suppress
+// that one with `// biome-ignore lint/plugin: <reason>`.
+pattern over_max_page_size() {
+  JsNumberLiteralExpression() as $size where {
+    $size <: r"(?:50[1-9]|5[1-9][0-9]|[6-9][0-9]{2}|[1-9][0-9]{0,2}(?:_?[0-9]{3})+|[1-9]e\+?(?:[3-9]|[1-9][0-9]+))"
+  }
+}
+
+pattern page_skip() {
+  or { r"(?:0|null|undefined)", r"(?i)[\s\S]*(?:skip|offset)[\s\S]*", r"(?i)[\s\S]*page[\s\S]*\*[\s\S]*" }
+}
+
+pattern page_sort() {
+  not JsNumberLiteralExpression()
+}
+
+JsCallExpression(callee = $callee, arguments = JsCallArguments(args = $args)) where {
+  or {
+    and {
+      $callee <: `fetch.$endpoint`,
+      $endpoint <: r"[a-z][A-Za-z0-9_$]*List(?:[A-Z][A-Za-z0-9_$]*)?",
+      $args <: or {
+        [..., page_skip(), over_max_page_size() as $limit],
+        [..., page_skip(), over_max_page_size() as $limit, page_sort()],
+        [..., page_skip(), over_max_page_size() as $limit, page_sort(), $_]
+      }
+    },
+    and {
+      or {
+        and {
+          $callee <: `fetch.$endpoint`,
+          $endpoint <: or { r"init[A-Z][A-Za-z0-9_$]*", r"get[A-Z][A-Za-z0-9_$]*Init(?:[A-Z][A-Za-z0-9_$]*)?" }
+        },
+        and { $callee <: `st.do.$action`, $action <: r"(?:init|refresh)[A-Z][A-Za-z0-9_$]*" }
+      },
+      $args <: some JsObjectExpression(
+        members = some JsPropertyObjectMember(
+          name = r"(?:limit|\x22limit\x22|'limit')",
+          value = over_max_page_size() as $limit
+        )
+      )
+    },
+    and {
+      $callee <: `st.do.$action`,
+      $action <: r"setLimitOf[A-Z][A-Za-z0-9_$]*",
+      $args <: [over_max_page_size() as $limit, ...]
+    }
+  },
+  register_diagnostic(
+    span = $limit,
+    message = "The server serves at most 500 rows per list request and drops the rest without an error, so this list silently stops at row 500. Page through it at 500 or fewer per request (skip/limit, or st.do.loadMoreOf<Model><Suffix>() while hasMoreOf<Model><Suffix>), or compute what the screen needs on the server in an insight or a dedicated endpoint.",
+    severity = "error"
+  )
+}

package/lint/no-unguarded-endpoint.grit

@@ -1,8 +1,8 @@
 engine biome(1.0)
 language js(typescript, jsx)
 
-// `SignalContext` checks `signalOption.guards ?? []`, so an endpoint, a named slice, or a slice's root query declaring
-// none is open to every HTTP and websocket caller. An option the rule cannot read, a variable or a spread, is left alone.
+// `SignalContext` refuses an endpoint, a named slice, or a slice's root query declaring no guards, and outside local
+// operation the server does not boot with one. An option the rule cannot read, a variable or a spread, is left alone.
 or {
   JsCallExpression(callee = $callee, arguments = JsCallArguments(args = $args)) as $call where {
     or {
@@ -32,7 +32,7 @@ or {
     },
     register_diagnostic(
       span = $callee,
-      message = "No `guards`, so every HTTP and websocket caller reaches this endpoint: a missing or empty `guards` fails open, which is also why MCP refuses it. Name the guards it needs, or write `guards: [Public]` when anonymous access is the intent.",
+      message = "No `guards`, so every call to this endpoint is refused with 403, and outside local operation the server does not boot. Name the guards it needs, or write `guards: [Public]` when anonymous access is the intent.",
       severity = "warn"
     )
   },
@@ -47,7 +47,7 @@ or {
         },
         register_diagnostic(
           span = $sliceOption,
-          message = "No `guards` on this slice, so every HTTP and websocket caller reaches its root query and generated reads and writes: a missing guard fails open. Pass { guards: { root: Admin, get: …, cru: … } }, naming `Public` where anonymous access is the intent.",
+          message = "No `guards` on this slice, so it mounts no root list or insight and none of its generated reads and writes. Pass { guards: { root: Admin, get: …, cru: … } }, naming `Public` where anonymous access is the intent.",
           severity = "warn"
         )
       },
@@ -64,7 +64,7 @@ or {
         },
         register_diagnostic(
           span = $guardMap,
-          message = "No `root` guard on this slice, so its root query lists any filter to every HTTP and websocket caller: a missing or empty `root` fails open. Write `root: Admin`.",
+          message = "No `root` guard on this slice. Left out, it mounts no root list or insight; `root: []` refuses every caller with 403, and outside local operation the server does not boot. Write `root: Admin`, or `root: Public` for anonymous access.",
           severity = "warn"
         )
       }

package/linter.test.ts

@@ -93,4 +93,16 @@ describe("Linter", () => {
       process.env.PATH = pathBefore;
     }
   });
+
+  test("splits path arguments into batches that stay under the command-line budget", () => {
+    const args = Array.from({ length: 10 }, (_, idx) => `apps/demo/lib/file${idx}.ts`);
+    const batches = Linter.batchArgs(args, 100);
+    expect(batches.flat()).toEqual(args);
+    expect(batches.length).toBeGreaterThan(1);
+    for (const batch of batches) expect(batch.reduce((sum, arg) => sum + arg.length + 3, 0)).toBeLessThanOrEqual(100);
+  });
+
+  test("keeps an argument longer than the budget in a batch of its own", () => {
+    expect(Linter.batchArgs(["a".repeat(50), "b", "c"], 10)).toEqual([["a".repeat(50)], ["b", "c"]]);
+  });
 });

package/linter.ts

@@ -386,27 +386,50 @@ export class Linter {
     return { ...lintResult, fixed: stdout !== source, output: stdout };
   }
 
-  // One spawn for all files: Biome's startup dominates a small file. Missing paths are dropped (a template may
-  // decline a file).
+  // As few spawns as the command line allows: Biome's startup dominates a small file. Missing paths are dropped (a
+  // template may decline a file).
   async fixFiles(filePaths: string[]): Promise<{ fixed: string[] }> {
     const resolved = filePaths.map((filePath) => this.#resolveFilePath(filePath)).filter(existsSync);
     if (resolved.length === 0) return { fixed: [] };
     const before = new Map(resolved.map((filePath) => [filePath, readFileSync(filePath, "utf8")]));
-    await this.#runBiome([
-      "check",
-      "--write",
-      "--reporter=json",
-      "--max-diagnostics=none",
-      "--no-errors-on-unmatched",
-      "--config-path",
-      this.configPath,
-      ...resolved.map((filePath) => this.#toBiomePath(filePath)),
-    ]);
+    const biomePaths = resolved.map((filePath) => this.#toBiomePath(filePath));
+    for (const batch of Linter.batchArgs(biomePaths, Linter.#pathArgsBudget))
+      await this.#runBiome([
+        "check",
+        "--write",
+        "--reporter=json",
+        "--max-diagnostics=none",
+        "--no-errors-on-unmatched",
+        "--config-path",
+        this.configPath,
+        ...batch,
+      ]);
     return {
       fixed: resolved.filter((filePath) => readFileSync(filePath, "utf8") !== before.get(filePath)),
     };
   }
 
+  //? Windows refuses a command line past 32,767 characters (ENAMETOOLONG), and a whole workspace scaffold passes it.
+  static readonly #pathArgsBudget = 24_000;
+
+  static batchArgs(args: string[], budget: number): string[][] {
+    const batches: string[][] = [];
+    let batch: string[] = [];
+    let length = 0;
+    for (const arg of args) {
+      const cost = arg.length + 3;
+      if (batch.length > 0 && length + cost > budget) {
+        batches.push(batch);
+        batch = [];
+        length = 0;
+      }
+      batch.push(arg);
+      length += cost;
+    }
+    if (batch.length > 0) batches.push(batch);
+    return batches;
+  }
+
   async getConfigForFile(filePath: string): Promise<unknown> {
     const resolvedFilePath = this.#resolveFilePath(filePath);
     if (!existsSync(resolvedFilePath)) throw new Error(`File not found: ${filePath}`);

package/maintainabilityBaseline.test.ts

@@ -0,0 +1,280 @@
+import { describe, expect, test } from "bun:test";
+import { MaintainabilityBaseline } from "./maintainabilityBaseline";
+import { type DebtRuleId, MaintainabilityContract, type MaintainabilityViolation } from "./maintainabilityContract";
+
+const sizeOf = (key: string, lineCount: number): MaintainabilityViolation => ({
+  kind: "size",
+  rule: key.includes("#") ? "akan.size.component" : "akan.size.file",
+  key,
+  file: key.split("#")[0] ?? key,
+  line: 1,
+  lineCount,
+  maxLines: 400,
+});
+const writeOf = (key: string, writeCount = 2): MaintainabilityViolation => ({
+  kind: "multiWrite",
+  rule: "akan.store.multi-write",
+  key,
+  file: key.split("#")[0] ?? key,
+  line: 1,
+  owner: key.split("#")[1] ?? "",
+  writes: [],
+  writeCount,
+});
+const accessOf = (key: string, accessCount: number): MaintainabilityViolation => ({
+  kind: "storeAccess",
+  rule: "akan.component.store-access",
+  key,
+  file: key.split("#")[0] ?? key,
+  line: 1,
+  component: key.split("#")[1] ?? "",
+  accessCount,
+  maxAccesses: 16,
+});
+const placementOf = (file: string, writes: string[]): MaintainabilityViolation => ({
+  kind: "writePlacement",
+  rule: "akan.write.placement",
+  key: file,
+  file,
+  line: 1,
+  writes,
+});
+const baselineOf = (
+  sections: { [rule in DebtRuleId]?: Record<string, number> },
+  reasons: Record<string, string> = {},
+) =>
+  new MaintainabilityBaseline(
+    new Map(Object.entries(sections).map(([rule, counts]) => [rule as DebtRuleId, new Map(Object.entries(counts))])),
+    new Map(Object.entries(reasons)),
+  );
+
+describe("MaintainabilityBaseline", () => {
+  test("keeps one section per rule the gate can fail, the growth check aside", () => {
+    expect(new Set(MaintainabilityBaseline.debtRules)).toEqual(
+      new Set(MaintainabilityContract.ruleIds.filter((rule) => rule !== "akan.baseline.growth")),
+    );
+  });
+
+  test("allows a recorded entry up to its count, writes included, and nothing it does not record", () => {
+    const baseline = MaintainabilityBaseline.parse(
+      JSON.stringify({
+        "akan.size.file": { "lib/a/A.Zone.tsx": 900 },
+        "akan.store.multi-write": { "lib/a/a.store.ts#run": 2 },
+        "akan.write.placement": { "ui/Board.tsx": 1 },
+      }),
+    );
+    expect(baseline.allows(sizeOf("lib/a/A.Zone.tsx", 900))).toBe(true);
+    expect(baseline.allows(sizeOf("lib/a/A.Zone.tsx", 901))).toBe(false);
+    expect(baseline.allows(sizeOf("lib/b/B.Zone.tsx", 401))).toBe(false);
+    expect(baseline.allows(writeOf("lib/a/a.store.ts#run"))).toBe(true);
+    expect(baseline.allows(writeOf("lib/a/a.store.ts#run", 3))).toBe(false);
+    expect(baseline.allows(writeOf("lib/a/a.store.ts#other"))).toBe(false);
+    expect(baseline.allows(placementOf("ui/Board.tsx", ["st.do.removeBoard"]))).toBe(true);
+    expect(baseline.allows(placementOf("ui/Board.tsx", ["st.do.removeBoard", "fetch.placeBoard"]))).toBe(false);
+  });
+
+  test("records the busiest of several breaches under one key", () => {
+    const chainOf = (writeCount: number): MaintainabilityViolation => ({
+      kind: "multiWrite",
+      rule: "akan.component.write-chain",
+      key: "lib/a/A.Zone.tsx#Canvas",
+      file: "lib/a/A.Zone.tsx",
+      line: 1,
+      owner: "Canvas",
+      writes: [],
+      writeCount,
+    });
+    const baseline = MaintainabilityBaseline.of([chainOf(2), chainOf(4)]);
+    expect([...(baseline.sections.get("akan.component.write-chain") ?? [])]).toEqual([["lib/a/A.Zone.tsx#Canvas", 4]]);
+  });
+
+  test("tightens to what still breaks: lowers a shrunk entry, keeps a grown one, drops the rest", () => {
+    const baseline = baselineOf({
+      "akan.size.file": { "lib/a/A.Zone.tsx": 900, "lib/b/B.Zone.tsx": 700, "lib/gone/Gone.Zone.tsx": 600 },
+      "akan.store.multi-write": { "lib/a/a.store.ts#run": 3, "lib/a/a.store.ts#fixed": 2 },
+    });
+    const tightened = baseline.tightenedBy([
+      sizeOf("lib/a/A.Zone.tsx", 850),
+      sizeOf("lib/b/B.Zone.tsx", 720),
+      sizeOf("lib/c/C.Zone.tsx", 500),
+      writeOf("lib/a/a.store.ts#run", 2),
+    ]);
+    expect([...(tightened.sections.get("akan.size.file") ?? [])]).toEqual([
+      ["lib/a/A.Zone.tsx", 850],
+      ["lib/b/B.Zone.tsx", 700],
+    ]);
+    expect([...(tightened.sections.get("akan.store.multi-write") ?? [])]).toEqual([["lib/a/a.store.ts#run", 2]]);
+    expect(baseline.tightenedBy([]).isEmpty).toBe(true);
+  });
+
+  test("names every entry a working baseline added or raised over the reference one, per rule", () => {
+    const committed = baselineOf({
+      "akan.size.file": { "lib/a/A.Zone.tsx": 900 },
+      "akan.store.multi-write": { "a.store.ts#run": 2 },
+    });
+    const working = baselineOf({
+      "akan.size.file": { "lib/a/A.Zone.tsx": 950, "lib/b/B.Zone.tsx": 500 },
+      "akan.store.multi-write": { "a.store.ts#run": 3, "a.store.ts#sneak": 2 },
+    });
+    expect(working.grownFrom(committed)).toEqual([
+      { rule: "akan.size.file", key: "lib/a/A.Zone.tsx", count: 950, committed: 900 },
+      { rule: "akan.size.file", key: "lib/b/B.Zone.tsx", count: 500, committed: undefined },
+      { rule: "akan.store.multi-write", key: "a.store.ts#run", count: 3, committed: 2 },
+      { rule: "akan.store.multi-write", key: "a.store.ts#sneak", count: 2, committed: undefined },
+    ]);
+    expect(committed.tightenedBy([sizeOf("lib/a/A.Zone.tsx", 800)]).grownFrom(committed)).toEqual([]);
+  });
+
+  test("ratchets a component's store accesses like a size: allows up to its entry, lowers it, refuses a raise", () => {
+    const baseline = MaintainabilityBaseline.parse(
+      JSON.stringify({
+        "akan.component.store-access": { "lib/a/A.Zone.tsx#Canvas": 40, "lib/gone/G.Zone.tsx#Old": 30 },
+      }),
+    );
+    expect(baseline.allows(accessOf("lib/a/A.Zone.tsx#Canvas", 40))).toBe(true);
+    expect(baseline.allows(accessOf("lib/a/A.Zone.tsx#Canvas", 41))).toBe(false);
+    expect(baseline.allows(accessOf("lib/b/B.Zone.tsx#Board", 17))).toBe(false);
+    expect(baseline.recordedOf(accessOf("lib/a/A.Zone.tsx#Canvas", 41))).toBe(40);
+
+    const tightened = baseline.tightenedBy([accessOf("lib/a/A.Zone.tsx#Canvas", 33)]);
+    expect([...(tightened.sections.get("akan.component.store-access") ?? [])]).toEqual([
+      ["lib/a/A.Zone.tsx#Canvas", 33],
+    ]);
+    expect(baseline.grownFrom(tightened)).toEqual([
+      { rule: "akan.component.store-access", key: "lib/a/A.Zone.tsx#Canvas", count: 40, committed: 33 },
+      { rule: "akan.component.store-access", key: "lib/gone/G.Zone.tsx#Old", count: 30, committed: undefined },
+    ]);
+    expect(tightened.grownFrom(baseline)).toEqual([]);
+  });
+
+  test("lets a shape entry grow only with a reason of ten non-space characters, a write entry never", () => {
+    const committed = baselineOf({
+      "akan.size.file": { "lib/a/A.Zone.tsx": 900 },
+      "akan.store.multi-write": { "a.store.ts#run": 2 },
+    });
+    const reason = "The canvas is one pointer state machine.";
+    const working = baselineOf(
+      {
+        "akan.size.file": { "lib/a/A.Zone.tsx": 950, "ui/Board.tsx": 450, "lib/b/B.Zone.tsx": 500 },
+        "akan.size.component": { "lib/c/C.Zone.tsx#Grid": 300 },
+        "akan.component.store-access": { "lib/d/D.Zone.tsx#Canvas": 30 },
+        "akan.store.multi-write": { "a.store.ts#run": 2, "a.store.ts#sneak": 2 },
+        "akan.component.write-chain": { "lib/c/C.Zone.tsx#Grid": 2 },
+        "akan.write.placement": { "ui/Board.tsx": 1 },
+        "akan.service.call-in-loop": { "lib/e/e.service.ts#sync": 1 },
+      },
+      {
+        "lib/a/A.Zone.tsx": reason,
+        "ui/Board.tsx": reason,
+        "lib/b/B.Zone.tsx": "a b c d e f g h i",
+        "lib/c/C.Zone.tsx#Grid": reason,
+        "lib/d/D.Zone.tsx#Canvas": reason,
+        "a.store.ts#sneak": reason,
+        "lib/e/e.service.ts#sync": reason,
+      },
+    );
+
+    expect(working.grownFrom(committed)).toEqual([
+      { rule: "akan.size.file", key: "lib/b/B.Zone.tsx", count: 500, committed: undefined },
+      { rule: "akan.store.multi-write", key: "a.store.ts#sneak", count: 2, committed: undefined },
+      { rule: "akan.component.write-chain", key: "lib/c/C.Zone.tsx#Grid", count: 2, committed: undefined },
+      { rule: "akan.write.placement", key: "ui/Board.tsx", count: 1, committed: undefined },
+    ]);
+    expect(working.reasonOf("lib/b/B.Zone.tsx")).toBeUndefined();
+    expect(working.reasonOf("a.store.ts#sneak")).toBeUndefined();
+    expect(working.reasonOf("lib/d/D.Zone.tsx#Canvas")).toBe(reason);
+    expect(working.reasonOf("lib/e/e.service.ts#sync")).toBe(reason);
+  });
+
+  test("keeps a reason only beside a shape entry it still describes", () => {
+    const reason = "The canvas is one pointer state machine.";
+    const baseline = baselineOf(
+      {
+        "akan.size.file": { "lib/a/A.Zone.tsx": 900, "lib/gone/Gone.Zone.tsx": 600 },
+        "akan.component.store-access": { "lib/a/A.Zone.tsx#Canvas": 30 },
+        "akan.store.multi-write": { "lib/a/a.store.ts#run": 2 },
+      },
+      {
+        "lib/a/A.Zone.tsx": reason,
+        "lib/gone/Gone.Zone.tsx": reason,
+        "lib/a/A.Zone.tsx#Canvas": reason,
+        "lib/a/a.store.ts#run": reason,
+        "lib/never/Recorded.tsx": reason,
+      },
+    );
+
+    const tightened = baseline.tightenedBy([
+      sizeOf("lib/a/A.Zone.tsx", 850),
+      accessOf("lib/a/A.Zone.tsx#Canvas", 20),
+      writeOf("lib/a/a.store.ts#run"),
+    ]);
+
+    expect([...(tightened.sections.get("akan.size.file") ?? [])]).toEqual([["lib/a/A.Zone.tsx", 850]]);
+    expect([...tightened.reasons]).toEqual([
+      ["lib/a/A.Zone.tsx", reason],
+      ["lib/a/A.Zone.tsx#Canvas", reason],
+    ]);
+    expect(baseline.tightenedBy([]).reasons.size).toBe(0);
+  });
+
+  test("prints the rule sections in rule order with sorted keys, as Biome would, and reprints them unchanged", () => {
+    const baseline = MaintainabilityBaseline.of([
+      writeOf("lib/z/z.store.ts#run"),
+      sizeOf("lib/court/Court.Zone.tsx#Canvas", 640),
+      sizeOf("lib/court/Court.Zone.tsx", 947),
+      writeOf("lib/court/court.store.ts#assignCourtPcOnCourt", 3),
+      placementOf("ui/Board.tsx", ["st.do.removeBoard"]),
+    ]);
+    const text = baseline.stringify();
+    expect(text).toBe(`{
+  "akan.size.file": {
+    "lib/court/Court.Zone.tsx": 947
+  },
+  "akan.size.component": {
+    "lib/court/Court.Zone.tsx#Canvas": 640
+  },
+  "akan.store.multi-write": {
+    "lib/court/court.store.ts#assignCourtPcOnCourt": 3,
+    "lib/z/z.store.ts#run": 2
+  },
+  "akan.write.placement": {
+    "ui/Board.tsx": 1
+  }
+}
+`);
+    expect(MaintainabilityBaseline.parse(text).stringify()).toBe(text);
+  });
+
+  test("prints the reasons last and only once there are some, reprinting them unchanged", () => {
+    const text = `{
+  "akan.size.file": {
+    "lib/a/A.Zone.tsx": 950,
+    "ui/Board.tsx": 450
+  },
+  "reasons": {
+    "lib/a/A.Zone.tsx": "The canvas is one pointer state machine.",
+    "ui/Board.tsx": "Generated SVG path table for the court layout."
+  }
+}
+`;
+    const reasonless = '{\n  "akan.size.file": {\n    "lib/a/A.Zone.tsx": 950\n  }\n}\n';
+
+    expect(MaintainabilityBaseline.parse(text).stringify()).toBe(text);
+    expect(MaintainabilityBaseline.parse(reasonless).stringify()).toBe(reasonless);
+    expect(MaintainabilityBaseline.parse('{ "reasons": {} }').stringify()).not.toContain("reasons");
+  });
+
+  test("refuses a file that is not the baseline shape, naming it", () => {
+    expect(() => MaintainabilityBaseline.parse("{", "apps/demo/akan.baseline.json")).toThrow(
+      "apps/demo/akan.baseline.json is not valid JSON.",
+    );
+    expect(() => MaintainabilityBaseline.parse("[]")).toThrow("holds an object");
+    expect(() => MaintainabilityBaseline.parse('{ "akan.size.file": { "a": "900" } }')).toThrow('"akan.size.file"');
+    expect(() => MaintainabilityBaseline.parse('{ "akan.store.multi-write": ["a#b"] }')).toThrow(
+      '"akan.store.multi-write"',
+    );
+    expect(() => MaintainabilityBaseline.parse('{ "maxLines": {} }')).toThrow("akan quality baseline --force");
+    expect(() => MaintainabilityBaseline.parse('{ "reasons": { "ui/Board.tsx": 1 } }')).toThrow('"reasons"');
+    expect(MaintainabilityBaseline.parse("{}").isEmpty).toBe(true);
+  });
+});