design-constraint-validator 2.0.1 → 2.2.0

package/cli/cross-axis-loader.js

@@ -8,35 +8,117 @@
  * while CLI modules use this loader to read from filesystem.
  */
 import { existsSync, readFileSync } from 'node:fs';
-// ============================================================================
-// Filesystem Loading
-// ============================================================================
+import { z } from 'zod';
+export function readCrossAxisRulesFile(path) {
+    if (!existsSync(path))
+        return { status: 'missing' };
+    let data;
+    try {
+        data = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (e) {
+        return { status: 'invalid', reason: `invalid JSON (${e?.message ?? e})` };
+    }
+    const rules = data?.rules;
+    if (!Array.isArray(rules)) {
+        return { status: 'invalid', reason: 'expected a top-level "rules" array' };
+    }
+    return { status: 'ok', rules: rules };
+}
 /**
- * Load raw cross-axis rules from a JSON file.
- *
- * Returns undefined if file doesn't exist or can't be parsed.
- *
- * @param path Path to cross-axis rules JSON file
- * @returns Parsed rules or undefined if file missing/invalid
+ * Back-compat shim: returns the rule array, or `undefined` for both missing and
+ * present-but-unusable files. Prefer {@link readCrossAxisRulesFile} when the
+ * caller needs to surface the unusable case.
  */
 export function loadCrossAxisRulesFromFile(path) {
-    if (!existsSync(path)) {
-        return undefined;
+    const res = readCrossAxisRulesFile(path);
+    return res.status === 'ok' ? res.rules : undefined;
+}
+// ---------------------------------------------------------------------------
+// Rule shape validation (TASK-037)
+//
+// A cross-axis rule that fails to compile must be SKIPPED WITH A REASON, never
+// compiled into an always-true predicate or a NaN comparison. Examples the old
+// code admitted silently: a `when` missing `op`/`value` (always-true), a
+// `require` with no RHS (compared against 0), a non-numeric `fallback` (NaN).
+// ---------------------------------------------------------------------------
+const opEnum = z.enum(['<=', '>=', '<', '>', '==', '!=']);
+const sizeConst = z.union([z.number(), z.string()]);
+const RawCrossAxisRuleSchema = z
+    .object({
+    id: z.string(),
+    level: z.enum(['error', 'warn']).optional(),
+    where: z.string().optional(),
+    bp: z.string().optional(),
+    when: z.object({ id: z.string(), op: opEnum, value: z.number().finite() }).strict().optional(),
+    require: z
+        .object({ id: z.string(), op: opEnum, ref: z.string().optional(), fallback: sizeConst.optional() })
+        .strict()
+        .optional(),
+    compare: z.object({ a: z.string(), op: opEnum, b: z.string(), delta: sizeConst.optional() }).strict().optional(),
+})
+    .strict();
+export function validateRawRule(raw) {
+    const parsed = RawCrossAxisRuleSchema.safeParse(raw);
+    if (!parsed.success) {
+        const id = raw && typeof raw === 'object' && 'id' in raw && typeof raw.id === 'string'
+            ? raw.id
+            : undefined;
+        const reason = parsed.error.issues.map((e) => `${e.path.join('.') || '<root>'}: ${e.message}`).join('; ');
+        return { ok: false, id, reason };
     }
-    try {
-        const data = JSON.parse(readFileSync(path, 'utf8'));
-        return data.rules || [];
+    const rule = parsed.data;
+    const hasWhenReq = !!(rule.when && rule.require);
+    const hasCompare = !!rule.compare;
+    if (!hasWhenReq && !hasCompare) {
+        return { ok: false, id: rule.id, reason: 'must define when+require or compare' };
     }
-    catch {
-        // Return undefined on parse errors (consistent with silent failure behavior)
-        return undefined;
+    if (hasWhenReq && hasCompare) {
+        return { ok: false, id: rule.id, reason: 'must define exactly one of when+require or compare' };
     }
+    // Size constants must parse, or the compiled predicate degrades to NaN/0.
+    if (rule.require?.fallback !== undefined && px(rule.require.fallback) === null) {
+        return { ok: false, id: rule.id, reason: `require.fallback is not a parseable size: ${JSON.stringify(rule.require.fallback)}` };
+    }
+    if (rule.compare?.delta !== undefined && px(rule.compare.delta) === null) {
+        return { ok: false, id: rule.id, reason: `compare.delta is not a parseable size: ${JSON.stringify(rule.compare.delta)}` };
+    }
+    return { ok: true, rule };
+}
+/**
+ * Whether a rule is active for a given breakpoint scope. Shared by rule
+ * compilation and coverage enumeration so the two never drift (TASK-037): a
+ * rule that did not run must not be able to make coverage look "matched".
+ */
+export function ruleMatchesBp(r, bp) {
+    if (r?.bp && bp && r.bp !== bp)
+        return false; // targets a different bp
+    if (r?.bp && !bp)
+        return false; // bp-specific rule in a global run
+    return true;
 }
 // ============================================================================
 // Rule Parsing and Validation
 // ============================================================================
-// Helper functions (copied from core/cross-axis-config.ts)
-const px = (v) => typeof v === 'number' ? v : parseFloat(String(v)) * (String(v).trim().endsWith('rem') ? 16 : 1);
+// Parse a cross-axis size CONSTANT (rule `fallback`/`delta`), not a token value.
+// Mirrors the hardened finite-size policy (TASK-037): real numbers only, `rem`/
+// `em` 16px-relative, non-finite rejected — but allows a leading `-` because a
+// `compare.delta` is a signed offset (e.g. "-560px"). Returns null on garbage so
+// callers reject the rule instead of silently degrading to NaN/0.
+const px = (v) => {
+    if (typeof v === 'number')
+        return Number.isFinite(v) ? v : null;
+    if (typeof v !== 'string')
+        return null;
+    const m = v.trim().match(/^(-?\d*\.?\d+)\s*(px|rem|em)?$/i);
+    if (!m)
+        return null;
+    const n = parseFloat(m[1]);
+    if (!Number.isFinite(n))
+        return null;
+    const unit = (m[2] || 'px').toLowerCase();
+    return unit === 'rem' || unit === 'em' ? n * 16 : n;
+};
 const cmp = (a, b, op) => op === '>=' ? a >= b : op === '>' ? a > b : op === '<=' ? a <= b : op === '<' ? a < b : op === '==' ? a === b : a !== b;
 const prettyFail = (op) => ({ '>=': '<', '>': '≤', '<=': '>', '<': '≥', '==': '≠', '!=': '=' }[op] || '≠');
 const fmt = (v) => (Number.isFinite(Number(v)) ? `${Number(v)}px` : String(v));
@@ -46,7 +128,11 @@ function valueOrRef(ctx, ref, fallback) {
         if (v != null)
             return v;
     }
-    return typeof fallback === 'number' ? fallback : px(fallback ?? 0);
+    if (typeof fallback === 'number')
+        return fallback;
+    // `?? 0` is defensive only: validateRawRule rejects rules whose fallback does
+    // not parse, so a compiled rule never reaches here with garbage.
+    return px(fallback ?? 0) ?? 0;
 }
 function makeOp(op, rhs) {
     return (v) => cmp(v, rhs, op);
@@ -104,15 +190,18 @@ export function parseCrossAxisRules(rawRules, opts = {}) {
         }
         return true;
     };
-    for (const r of rawRules) {
-        // Filter by breakpoint
-        if (r.bp && bp && r.bp !== bp) {
+    for (const raw of rawRules) {
+        // Filter by breakpoint (shared with coverage enumeration so they never drift).
+        if (!ruleMatchesBp(raw, bp))
             continue;
-        }
-        if (r.bp && !bp) {
-            // Rule targets specific breakpoint; skip in global run
+        // Validate shape BEFORE compiling: an invalid rule is skipped with a reason,
+        // never compiled into an always-true or NaN predicate (TASK-037).
+        const valid = validateRawRule(raw);
+        if (!valid.ok) {
+            skipped.push({ id: valid.id, reason: valid.reason });
             continue;
         }
+        const r = valid.rule;
         try {
             if (r.when && r.require) {
                 // Validate IDs
@@ -151,7 +240,7 @@ export function parseCrossAxisRules(rawRules, opts = {}) {
                         test: (_, ctx) => {
                             const a = ctx.getPx(r.compare.a) ?? NaN;
                             const b = ctx.getPx(r.compare.b) ?? NaN;
-                            const delta = px(r.compare.delta ?? 0);
+                            const delta = px(r.compare.delta ?? 0) ?? 0;
                             if (Number.isNaN(a) || Number.isNaN(b))
                                 return true; // skip check if missing
                             return cmp(a, b + delta, r.compare.op);
@@ -159,15 +248,12 @@ export function parseCrossAxisRules(rawRules, opts = {}) {
                         msg: (_, ctx) => {
                             const a = ctx.getPx(r.compare.a);
                             const b = ctx.getPx(r.compare.b);
-                            const delta = px(r.compare.delta ?? 0);
+                            const delta = px(r.compare.delta ?? 0) ?? 0;
                             return `${r.compare.a} ${prettyFail(r.compare.op)} ${fmt((b ?? 0) + delta)} (was ${fmt(a ?? NaN)})`;
                         },
                     },
                 });
             }
-            else {
-                skipped.push({ id: r.id, reason: 'neither when+require nor compare present' });
-            }
         }
         catch (e) {
             skipped.push({ id: r.id, reason: `exception: ${e?.message ?? e}` });
@@ -220,3 +306,72 @@ export function loadCrossAxisRules(path, opts = {}) {
     const result = parseCrossAxisRules(rawRules, opts);
     return result.rules;
 }
+/**
+ * Load + parse cross-axis rules AND return notices to surface (TASK-037).
+ *
+ * Unlike {@link loadCrossAxisRules}, a present-but-unusable file or a skipped
+ * (invalid) rule produces a `warn`-level {@link ConstraintIssue} so it appears
+ * in the validation result instead of vanishing into a silent "no rules → green".
+ */
+export function loadCrossAxisRulesDetailed(path, opts = {}) {
+    const file = readCrossAxisRulesFile(path);
+    if (file.status === 'missing')
+        return { rules: [], notices: [] };
+    if (file.status === 'invalid') {
+        return {
+            rules: [],
+            notices: [
+                {
+                    id: 'cross-axis',
+                    rule: 'cross-axis',
+                    level: 'warn',
+                    where: path,
+                    message: `Cross-axis rules file present but unusable: ${file.reason}`,
+                },
+            ],
+        };
+    }
+    const result = parseCrossAxisRules(file.rules, opts);
+    const notices = result.skipped.map((s) => ({
+        id: `cross-axis:${s.id ?? '(no id)'}`,
+        rule: 'cross-axis',
+        level: 'warn',
+        message: `Cross-axis rule ${s.id ? `"${s.id}" ` : ''}skipped: ${s.reason}`,
+    }));
+    return { rules: result.rules, notices };
+}
+/**
+ * Token ids a cross-axis file contributes to constraint coverage for a given
+ * breakpoint scope (TASK-037). Mirrors compilation exactly: the SAME bp filter
+ * and the SAME shape validation, so a rule that did not run cannot make coverage
+ * look "matched" (which would suppress the "nothing was checked" note).
+ *
+ * `coverageKnown` is false only when the file is present-but-unusable.
+ */
+export function referencedIdsForFile(path, bp) {
+    const file = readCrossAxisRulesFile(path);
+    if (file.status === 'missing')
+        return { ids: [], coverageKnown: true };
+    if (file.status === 'invalid')
+        return { ids: [], coverageKnown: false };
+    const ids = [];
+    for (const raw of file.rules) {
+        if (!ruleMatchesBp(raw, bp))
+            continue;
+        const v = validateRawRule(raw);
+        if (!v.ok)
+            continue; // invalid rule did not compile → contributes no coverage
+        const r = v.rule;
+        if (r.when?.id)
+            ids.push(r.when.id);
+        if (r.require?.id)
+            ids.push(r.require.id);
+        if (r.require?.ref)
+            ids.push(r.require.ref);
+        if (r.compare?.a)
+            ids.push(r.compare.a);
+        if (r.compare?.b)
+            ids.push(r.compare.b);
+    }
+    return { ids, coverageKnown: true };
+}

package/cli/cross-axis-loader.ts

@@ -9,7 +9,9 @@
  */
 
 import { existsSync, readFileSync } from 'node:fs';
+import { z } from 'zod';
 import type { CrossAxisRule } from '../core/constraints/cross-axis.js';
+import type { ConstraintIssue } from '../core/engine.js';
 
 /**
  * Raw rule format as stored in JSON files.
@@ -71,27 +73,132 @@ export type LoadCrossAxisOptions = {
  * @param path Path to cross-axis rules JSON file
  * @returns Parsed rules or undefined if file missing/invalid
  */
-export function loadCrossAxisRulesFromFile(path: string): RawCrossAxisRule[] | undefined {
-  if (!existsSync(path)) {
-    return undefined;
-  }
+/**
+ * Outcome of reading a cross-axis rules file, distinguishing the three cases a
+ * validator must not collapse (TASK-037): a *missing* file (no rules, fine) vs.
+ * a *present-but-unusable* file (bad JSON / wrong shape — must be surfaced, never
+ * silently treated as "no rules → green") vs. a successfully read rule array.
+ */
+export type RawCrossAxisFileResult =
+  | { status: 'missing' }
+  | { status: 'invalid'; reason: string }
+  | { status: 'ok'; rules: RawCrossAxisRule[] };
 
+export function readCrossAxisRulesFile(path: string): RawCrossAxisFileResult {
+  if (!existsSync(path)) return { status: 'missing' };
+  let data: unknown;
   try {
-    const data = JSON.parse(readFileSync(path, 'utf8')) as { rules: RawCrossAxisRule[] };
-    return data.rules || [];
-  } catch {
-    // Return undefined on parse errors (consistent with silent failure behavior)
-    return undefined;
+    data = JSON.parse(readFileSync(path, 'utf8'));
+  } catch (e: any) {
+    return { status: 'invalid', reason: `invalid JSON (${e?.message ?? e})` };
+  }
+  const rules = (data as { rules?: unknown } | null)?.rules;
+  if (!Array.isArray(rules)) {
+    return { status: 'invalid', reason: 'expected a top-level "rules" array' };
+  }
+  return { status: 'ok', rules: rules as RawCrossAxisRule[] };
+}
+
+/**
+ * Back-compat shim: returns the rule array, or `undefined` for both missing and
+ * present-but-unusable files. Prefer {@link readCrossAxisRulesFile} when the
+ * caller needs to surface the unusable case.
+ */
+export function loadCrossAxisRulesFromFile(path: string): RawCrossAxisRule[] | undefined {
+  const res = readCrossAxisRulesFile(path);
+  return res.status === 'ok' ? res.rules : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Rule shape validation (TASK-037)
+//
+// A cross-axis rule that fails to compile must be SKIPPED WITH A REASON, never
+// compiled into an always-true predicate or a NaN comparison. Examples the old
+// code admitted silently: a `when` missing `op`/`value` (always-true), a
+// `require` with no RHS (compared against 0), a non-numeric `fallback` (NaN).
+// ---------------------------------------------------------------------------
+
+const opEnum = z.enum(['<=', '>=', '<', '>', '==', '!=']);
+const sizeConst = z.union([z.number(), z.string()]);
+
+const RawCrossAxisRuleSchema = z
+  .object({
+    id: z.string(),
+    level: z.enum(['error', 'warn']).optional(),
+    where: z.string().optional(),
+    bp: z.string().optional(),
+    when: z.object({ id: z.string(), op: opEnum, value: z.number().finite() }).strict().optional(),
+    require: z
+      .object({ id: z.string(), op: opEnum, ref: z.string().optional(), fallback: sizeConst.optional() })
+      .strict()
+      .optional(),
+    compare: z.object({ a: z.string(), op: opEnum, b: z.string(), delta: sizeConst.optional() }).strict().optional(),
+  })
+  .strict();
+
+export type RuleValidation =
+  | { ok: true; rule: RawCrossAxisRule }
+  | { ok: false; id?: string; reason: string };
+
+export function validateRawRule(raw: unknown): RuleValidation {
+  const parsed = RawCrossAxisRuleSchema.safeParse(raw);
+  if (!parsed.success) {
+    const id =
+      raw && typeof raw === 'object' && 'id' in raw && typeof (raw as any).id === 'string'
+        ? (raw as any).id
+        : undefined;
+    const reason = parsed.error.issues.map((e) => `${e.path.join('.') || '<root>'}: ${e.message}`).join('; ');
+    return { ok: false, id, reason };
+  }
+  const rule = parsed.data as RawCrossAxisRule;
+  const hasWhenReq = !!(rule.when && rule.require);
+  const hasCompare = !!rule.compare;
+  if (!hasWhenReq && !hasCompare) {
+    return { ok: false, id: rule.id, reason: 'must define when+require or compare' };
+  }
+  if (hasWhenReq && hasCompare) {
+    return { ok: false, id: rule.id, reason: 'must define exactly one of when+require or compare' };
+  }
+  // Size constants must parse, or the compiled predicate degrades to NaN/0.
+  if (rule.require?.fallback !== undefined && px(rule.require.fallback) === null) {
+    return { ok: false, id: rule.id, reason: `require.fallback is not a parseable size: ${JSON.stringify(rule.require.fallback)}` };
+  }
+  if (rule.compare?.delta !== undefined && px(rule.compare.delta) === null) {
+    return { ok: false, id: rule.id, reason: `compare.delta is not a parseable size: ${JSON.stringify(rule.compare.delta)}` };
   }
+  return { ok: true, rule };
+}
+
+/**
+ * Whether a rule is active for a given breakpoint scope. Shared by rule
+ * compilation and coverage enumeration so the two never drift (TASK-037): a
+ * rule that did not run must not be able to make coverage look "matched".
+ */
+export function ruleMatchesBp(r: { bp?: string }, bp?: string): boolean {
+  if (r?.bp && bp && r.bp !== bp) return false; // targets a different bp
+  if (r?.bp && !bp) return false; // bp-specific rule in a global run
+  return true;
 }
 
 // ============================================================================
 // Rule Parsing and Validation
 // ============================================================================
 
-// Helper functions (copied from core/cross-axis-config.ts)
-const px = (v: string | number) =>
-  typeof v === 'number' ? v : parseFloat(String(v)) * (String(v).trim().endsWith('rem') ? 16 : 1);
+// Parse a cross-axis size CONSTANT (rule `fallback`/`delta`), not a token value.
+// Mirrors the hardened finite-size policy (TASK-037): real numbers only, `rem`/
+// `em` 16px-relative, non-finite rejected — but allows a leading `-` because a
+// `compare.delta` is a signed offset (e.g. "-560px"). Returns null on garbage so
+// callers reject the rule instead of silently degrading to NaN/0.
+const px = (v: string | number): number | null => {
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null;
+  if (typeof v !== 'string') return null;
+  const m = v.trim().match(/^(-?\d*\.?\d+)\s*(px|rem|em)?$/i);
+  if (!m) return null;
+  const n = parseFloat(m[1]);
+  if (!Number.isFinite(n)) return null;
+  const unit = (m[2] || 'px').toLowerCase();
+  return unit === 'rem' || unit === 'em' ? n * 16 : n;
+};
 
 const cmp = (a: number, b: number, op: '<=' | '>=' | '<' | '>' | '==' | '!=') =>
   op === '>=' ? a >= b : op === '>' ? a > b : op === '<=' ? a <= b : op === '<' ? a < b : op === '==' ? a === b : a !== b;
@@ -105,7 +212,10 @@ function valueOrRef(ctx: any, ref?: string, fallback?: string | number) {
     const v = ctx.getPx(ref);
     if (v != null) return v;
   }
-  return typeof fallback === 'number' ? fallback : px(fallback ?? 0);
+  if (typeof fallback === 'number') return fallback;
+  // `?? 0` is defensive only: validateRawRule rejects rules whose fallback does
+  // not parse, so a compiled rule never reaches here with garbage.
+  return px(fallback ?? 0) ?? 0;
 }
 
 function makeOp(op: '<=' | '>=' | '<' | '>' | '==' | '!=', rhs: number) {
@@ -169,15 +279,18 @@ export function parseCrossAxisRules(rawRules: RawCrossAxisRule[], opts: LoadCros
     return true;
   };
 
-  for (const r of rawRules) {
-    // Filter by breakpoint
-    if (r.bp && bp && r.bp !== bp) {
-      continue;
-    }
-    if (r.bp && !bp) {
-      // Rule targets specific breakpoint; skip in global run
+  for (const raw of rawRules) {
+    // Filter by breakpoint (shared with coverage enumeration so they never drift).
+    if (!ruleMatchesBp(raw as RawCrossAxisRule, bp)) continue;
+
+    // Validate shape BEFORE compiling: an invalid rule is skipped with a reason,
+    // never compiled into an always-true or NaN predicate (TASK-037).
+    const valid = validateRawRule(raw);
+    if (!valid.ok) {
+      skipped.push({ id: valid.id, reason: valid.reason });
       continue;
     }
+    const r = valid.rule;
 
     try {
       if (r.when && r.require) {
@@ -217,20 +330,18 @@ export function parseCrossAxisRules(rawRules: RawCrossAxisRule[], opts: LoadCros
             test: (_: number, ctx: any) => {
               const a = ctx.getPx(r.compare!.a) ?? NaN;
               const b = ctx.getPx(r.compare!.b) ?? NaN;
-              const delta = px(r.compare!.delta ?? 0);
+              const delta = px(r.compare!.delta ?? 0) ?? 0;
               if (Number.isNaN(a) || Number.isNaN(b)) return true; // skip check if missing
               return cmp(a, b + delta, r.compare!.op);
             },
             msg: (_: number, ctx: any) => {
               const a = ctx.getPx(r.compare!.a);
               const b = ctx.getPx(r.compare!.b);
-              const delta = px(r.compare!.delta ?? 0);
+              const delta = px(r.compare!.delta ?? 0) ?? 0;
               return `${r.compare!.a} ${prettyFail(r.compare!.op)} ${fmt((b ?? 0) + delta)} (was ${fmt(a ?? NaN)})`;
             },
           },
         });
-      } else {
-        skipped.push({ id: r.id, reason: 'neither when+require nor compare present' });
       }
     } catch (e: any) {
       skipped.push({ id: r.id, reason: `exception: ${e?.message ?? e}` });
@@ -287,3 +398,67 @@ export function loadCrossAxisRules(path: string, opts: LoadCrossAxisOptions = {}
   const result = parseCrossAxisRules(rawRules, opts);
   return result.rules;
 }
+
+/**
+ * Load + parse cross-axis rules AND return notices to surface (TASK-037).
+ *
+ * Unlike {@link loadCrossAxisRules}, a present-but-unusable file or a skipped
+ * (invalid) rule produces a `warn`-level {@link ConstraintIssue} so it appears
+ * in the validation result instead of vanishing into a silent "no rules → green".
+ */
+export function loadCrossAxisRulesDetailed(
+  path: string,
+  opts: LoadCrossAxisOptions = {},
+): { rules: CrossAxisRule[]; notices: ConstraintIssue[] } {
+  const file = readCrossAxisRulesFile(path);
+  if (file.status === 'missing') return { rules: [], notices: [] };
+  if (file.status === 'invalid') {
+    return {
+      rules: [],
+      notices: [
+        {
+          id: 'cross-axis',
+          rule: 'cross-axis',
+          level: 'warn',
+          where: path,
+          message: `Cross-axis rules file present but unusable: ${file.reason}`,
+        },
+      ],
+    };
+  }
+  const result = parseCrossAxisRules(file.rules, opts);
+  const notices: ConstraintIssue[] = result.skipped.map((s) => ({
+    id: `cross-axis:${s.id ?? '(no id)'}`,
+    rule: 'cross-axis',
+    level: 'warn' as const,
+    message: `Cross-axis rule ${s.id ? `"${s.id}" ` : ''}skipped: ${s.reason}`,
+  }));
+  return { rules: result.rules, notices };
+}
+
+/**
+ * Token ids a cross-axis file contributes to constraint coverage for a given
+ * breakpoint scope (TASK-037). Mirrors compilation exactly: the SAME bp filter
+ * and the SAME shape validation, so a rule that did not run cannot make coverage
+ * look "matched" (which would suppress the "nothing was checked" note).
+ *
+ * `coverageKnown` is false only when the file is present-but-unusable.
+ */
+export function referencedIdsForFile(path: string, bp?: string): { ids: string[]; coverageKnown: boolean } {
+  const file = readCrossAxisRulesFile(path);
+  if (file.status === 'missing') return { ids: [], coverageKnown: true };
+  if (file.status === 'invalid') return { ids: [], coverageKnown: false };
+  const ids: string[] = [];
+  for (const raw of file.rules) {
+    if (!ruleMatchesBp(raw as RawCrossAxisRule, bp)) continue;
+    const v = validateRawRule(raw);
+    if (!v.ok) continue; // invalid rule did not compile → contributes no coverage
+    const r = v.rule;
+    if (r.when?.id) ids.push(r.when.id);
+    if (r.require?.id) ids.push(r.require.id);
+    if (r.require?.ref) ids.push(r.require.ref);
+    if (r.compare?.a) ids.push(r.compare.a);
+    if (r.compare?.b) ids.push(r.compare.b);
+  }
+  return { ids, coverageKnown: true };
+}