design-constraint-validator 2.1.0 → 2.2.0

package/cli/config-schema.d.ts

@@ -5,7 +5,7 @@ export declare const WcagRuleSchema: z.ZodObject<{
     ratio: z.ZodOptional<z.ZodNumber>;
     description: z.ZodOptional<z.ZodString>;
     backdrop: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+}, "strict", z.ZodTypeAny, {
     foreground: string;
     background: string;
     description?: string | undefined;
@@ -18,14 +18,35 @@ export declare const WcagRuleSchema: z.ZodObject<{
     ratio?: number | undefined;
     backdrop?: string | undefined;
 }>;
+export declare const ThresholdRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    op: z.ZodEnum<["<=", ">="]>;
+    valuePx: z.ZodNumber;
+    where: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<["error", "warn"]>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    op: "<=" | ">=";
+    valuePx: number;
+    where?: string | undefined;
+    level?: "error" | "warn" | undefined;
+}, {
+    id: string;
+    op: "<=" | ">=";
+    valuePx: number;
+    where?: string | undefined;
+    level?: "error" | "warn" | undefined;
+}>;
 export declare const ConstraintsSchema: z.ZodObject<{
+    enableBuiltInWcagDefaults: z.ZodOptional<z.ZodBoolean>;
+    enableBuiltInThreshold: z.ZodOptional<z.ZodBoolean>;
     wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
         foreground: z.ZodString;
         background: z.ZodString;
         ratio: z.ZodOptional<z.ZodNumber>;
         description: z.ZodOptional<z.ZodString>;
         backdrop: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strict", z.ZodTypeAny, {
         foreground: string;
         background: string;
         description?: string | undefined;
@@ -38,57 +59,73 @@ export declare const ConstraintsSchema: z.ZodObject<{
         ratio?: number | undefined;
         backdrop?: string | undefined;
     }>, "many">>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        foreground: z.ZodString;
-        background: z.ZodString;
-        ratio: z.ZodOptional<z.ZodNumber>;
-        description: z.ZodOptional<z.ZodString>;
-        backdrop: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        foreground: string;
-        background: string;
-        description?: string | undefined;
-        ratio?: number | undefined;
-        backdrop?: string | undefined;
+    thresholds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        op: z.ZodEnum<["<=", ">="]>;
+        valuePx: z.ZodNumber;
+        where: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodEnum<["error", "warn"]>>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        op: "<=" | ">=";
+        valuePx: number;
+        where?: string | undefined;
+        level?: "error" | "warn" | undefined;
     }, {
-        foreground: string;
-        background: string;
-        description?: string | undefined;
-        ratio?: number | undefined;
-        backdrop?: string | undefined;
+        id: string;
+        op: "<=" | ">=";
+        valuePx: number;
+        where?: string | undefined;
+        level?: "error" | "warn" | undefined;
     }>, "many">>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        foreground: z.ZodString;
-        background: z.ZodString;
-        ratio: z.ZodOptional<z.ZodNumber>;
-        description: z.ZodOptional<z.ZodString>;
-        backdrop: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
+}, "strict", z.ZodTypeAny, {
+    enableBuiltInWcagDefaults?: boolean | undefined;
+    enableBuiltInThreshold?: boolean | undefined;
+    wcag?: {
         foreground: string;
         background: string;
         description?: string | undefined;
         ratio?: number | undefined;
         backdrop?: string | undefined;
-    }, {
+    }[] | undefined;
+    thresholds?: {
+        id: string;
+        op: "<=" | ">=";
+        valuePx: number;
+        where?: string | undefined;
+        level?: "error" | "warn" | undefined;
+    }[] | undefined;
+}, {
+    enableBuiltInWcagDefaults?: boolean | undefined;
+    enableBuiltInThreshold?: boolean | undefined;
+    wcag?: {
         foreground: string;
         background: string;
         description?: string | undefined;
         ratio?: number | undefined;
         backdrop?: string | undefined;
-    }>, "many">>;
-}, z.ZodTypeAny, "passthrough">>;
+    }[] | undefined;
+    thresholds?: {
+        id: string;
+        op: "<=" | ">=";
+        valuePx: number;
+        where?: string | undefined;
+        level?: "error" | "warn" | undefined;
+    }[] | undefined;
+}>;
 export declare const DcvConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
     version: z.ZodOptional<z.ZodString>;
     constraints: z.ZodOptional<z.ZodObject<{
+        enableBuiltInWcagDefaults: z.ZodOptional<z.ZodBoolean>;
+        enableBuiltInThreshold: z.ZodOptional<z.ZodBoolean>;
         wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
             foreground: z.ZodString;
             background: z.ZodString;
             ratio: z.ZodOptional<z.ZodNumber>;
             description: z.ZodOptional<z.ZodString>;
             backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
+        }, "strict", z.ZodTypeAny, {
             foreground: string;
             background: string;
             description?: string | undefined;
@@ -101,174 +138,103 @@ export declare const DcvConfigSchema: z.ZodObject<{
             ratio?: number | undefined;
             backdrop?: string | undefined;
         }>, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            foreground: z.ZodString;
-            background: z.ZodString;
-            ratio: z.ZodOptional<z.ZodNumber>;
-            description: z.ZodOptional<z.ZodString>;
-            backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
+        thresholds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            op: z.ZodEnum<["<=", ">="]>;
+            valuePx: z.ZodNumber;
+            where: z.ZodOptional<z.ZodString>;
+            level: z.ZodOptional<z.ZodEnum<["error", "warn"]>>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            op: "<=" | ">=";
+            valuePx: number;
+            where?: string | undefined;
+            level?: "error" | "warn" | undefined;
         }, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
+            id: string;
+            op: "<=" | ">=";
+            valuePx: number;
+            where?: string | undefined;
+            level?: "error" | "warn" | undefined;
         }>, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            foreground: z.ZodString;
-            background: z.ZodString;
-            ratio: z.ZodOptional<z.ZodNumber>;
-            description: z.ZodOptional<z.ZodString>;
-            backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
+    }, "strict", z.ZodTypeAny, {
+        enableBuiltInWcagDefaults?: boolean | undefined;
+        enableBuiltInThreshold?: boolean | undefined;
+        wcag?: {
             foreground: string;
             background: string;
             description?: string | undefined;
             ratio?: number | undefined;
             backdrop?: string | undefined;
-        }, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }>, "many">>;
-    }, z.ZodTypeAny, "passthrough">>>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    version: z.ZodOptional<z.ZodString>;
-    constraints: z.ZodOptional<z.ZodObject<{
-        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            foreground: z.ZodString;
-            background: z.ZodString;
-            ratio: z.ZodOptional<z.ZodNumber>;
-            description: z.ZodOptional<z.ZodString>;
-            backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }>, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            foreground: z.ZodString;
-            background: z.ZodString;
-            ratio: z.ZodOptional<z.ZodNumber>;
-            description: z.ZodOptional<z.ZodString>;
-            backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }>, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            foreground: z.ZodString;
-            background: z.ZodString;
-            ratio: z.ZodOptional<z.ZodNumber>;
-            description: z.ZodOptional<z.ZodString>;
-            backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }>, "many">>;
-    }, z.ZodTypeAny, "passthrough">>>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    version: z.ZodOptional<z.ZodString>;
-    constraints: z.ZodOptional<z.ZodObject<{
-        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            foreground: z.ZodString;
-            background: z.ZodString;
-            ratio: z.ZodOptional<z.ZodNumber>;
-            description: z.ZodOptional<z.ZodString>;
-            backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }>, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            foreground: z.ZodString;
-            background: z.ZodString;
-            ratio: z.ZodOptional<z.ZodNumber>;
-            description: z.ZodOptional<z.ZodString>;
-            backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
+        }[] | undefined;
+        thresholds?: {
+            id: string;
+            op: "<=" | ">=";
+            valuePx: number;
+            where?: string | undefined;
+            level?: "error" | "warn" | undefined;
+        }[] | undefined;
+    }, {
+        enableBuiltInWcagDefaults?: boolean | undefined;
+        enableBuiltInThreshold?: boolean | undefined;
+        wcag?: {
             foreground: string;
             background: string;
             description?: string | undefined;
             ratio?: number | undefined;
             backdrop?: string | undefined;
-        }, {
+        }[] | undefined;
+        thresholds?: {
+            id: string;
+            op: "<=" | ">=";
+            valuePx: number;
+            where?: string | undefined;
+            level?: "error" | "warn" | undefined;
+        }[] | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    $schema?: string | undefined;
+    version?: string | undefined;
+    constraints?: {
+        enableBuiltInWcagDefaults?: boolean | undefined;
+        enableBuiltInThreshold?: boolean | undefined;
+        wcag?: {
             foreground: string;
             background: string;
             description?: string | undefined;
             ratio?: number | undefined;
             backdrop?: string | undefined;
-        }>, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            foreground: z.ZodString;
-            background: z.ZodString;
-            ratio: z.ZodOptional<z.ZodNumber>;
-            description: z.ZodOptional<z.ZodString>;
-            backdrop: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            foreground: string;
-            background: string;
-            description?: string | undefined;
-            ratio?: number | undefined;
-            backdrop?: string | undefined;
-        }, {
+        }[] | undefined;
+        thresholds?: {
+            id: string;
+            op: "<=" | ">=";
+            valuePx: number;
+            where?: string | undefined;
+            level?: "error" | "warn" | undefined;
+        }[] | undefined;
+    } | undefined;
+}, {
+    $schema?: string | undefined;
+    version?: string | undefined;
+    constraints?: {
+        enableBuiltInWcagDefaults?: boolean | undefined;
+        enableBuiltInThreshold?: boolean | undefined;
+        wcag?: {
             foreground: string;
             background: string;
             description?: string | undefined;
             ratio?: number | undefined;
             backdrop?: string | undefined;
-        }>, "many">>;
-    }, z.ZodTypeAny, "passthrough">>>;
-}, z.ZodTypeAny, "passthrough">>;
+        }[] | undefined;
+        thresholds?: {
+            id: string;
+            op: "<=" | ">=";
+            valuePx: number;
+            where?: string | undefined;
+            level?: "error" | "warn" | undefined;
+        }[] | undefined;
+    } | undefined;
+}>;
 export type DcvConfigParsed = z.infer<typeof DcvConfigSchema>;
 export declare function validateConfig(raw: unknown): {
     value?: DcvConfigParsed;

package/cli/config-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAMzB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEd,CAAC;AAEjB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGZ,CAAC;AAEjB,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,KAAK,CAAC,EAAE,eAAe,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAO3F"}
+{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAMhB,CAAC;AAEZ,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAMrB,CAAC;AAEZ,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAC;AAEZ,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjB,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,KAAK,CAAC,EAAE,eAAe,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAO3F"}

package/cli/config-schema.js

@@ -1,18 +1,38 @@
 import { z } from 'zod';
+// Schemas are `.strict()` on purpose (TASK-037): a validator must never silently
+// accept a typo'd key, because "the rule never ran" is indistinguishable from
+// "the rule passed" — a false green. A misspelled block (`wcagg`), a typo'd
+// field (`levle`), or an out-of-range bound is rejected loudly, not dropped.
+// WCAG contrast ratios are bounded by the spec to (1:1, 21:1]: 1 means "no
+// contrast required" (a no-op rule) and 21 is the maximum achievable (#000 on
+// #fff). Anything outside that is a config error, not a stricter policy.
 export const WcagRuleSchema = z.object({
     foreground: z.string(),
     background: z.string(),
-    ratio: z.number().positive().optional(),
+    ratio: z.number().finite().gt(1).max(21).optional(),
     description: z.string().optional(),
     backdrop: z.string().optional()
-});
+}).strict();
+export const ThresholdRuleSchema = z.object({
+    id: z.string(),
+    op: z.enum(['<=', '>=']),
+    valuePx: z.number().finite().nonnegative(),
+    where: z.string().optional(),
+    level: z.enum(['error', 'warn']).optional()
+}).strict();
 export const ConstraintsSchema = z.object({
-    wcag: z.array(WcagRuleSchema).optional()
-}).passthrough();
+    enableBuiltInWcagDefaults: z.boolean().optional(),
+    enableBuiltInThreshold: z.boolean().optional(),
+    wcag: z.array(WcagRuleSchema).optional(),
+    thresholds: z.array(ThresholdRuleSchema).optional()
+}).strict();
 export const DcvConfigSchema = z.object({
+    // `$schema` is the conventional editor-hint key; allow it so strictness does
+    // not punish a well-formed config, but still reject unknown top-level typos.
+    $schema: z.string().optional(),
     version: z.string().optional(),
     constraints: ConstraintsSchema.optional()
-}).passthrough();
+}).strict();
 export function validateConfig(raw) {
     const res = DcvConfigSchema.safeParse(raw);
     if (!res.success) {

package/cli/config-schema.ts

@@ -1,21 +1,43 @@
 import { z } from 'zod';
 
+// Schemas are `.strict()` on purpose (TASK-037): a validator must never silently
+// accept a typo'd key, because "the rule never ran" is indistinguishable from
+// "the rule passed" — a false green. A misspelled block (`wcagg`), a typo'd
+// field (`levle`), or an out-of-range bound is rejected loudly, not dropped.
+
+// WCAG contrast ratios are bounded by the spec to (1:1, 21:1]: 1 means "no
+// contrast required" (a no-op rule) and 21 is the maximum achievable (#000 on
+// #fff). Anything outside that is a config error, not a stricter policy.
 export const WcagRuleSchema = z.object({
   foreground: z.string(),
   background: z.string(),
-  ratio: z.number().positive().optional(),
+  ratio: z.number().finite().gt(1).max(21).optional(),
   description: z.string().optional(),
   backdrop: z.string().optional()
-});
+}).strict();
+
+export const ThresholdRuleSchema = z.object({
+  id: z.string(),
+  op: z.enum(['<=', '>=']),
+  valuePx: z.number().finite().nonnegative(),
+  where: z.string().optional(),
+  level: z.enum(['error', 'warn']).optional()
+}).strict();
 
 export const ConstraintsSchema = z.object({
-  wcag: z.array(WcagRuleSchema).optional()
-}).passthrough();
+  enableBuiltInWcagDefaults: z.boolean().optional(),
+  enableBuiltInThreshold: z.boolean().optional(),
+  wcag: z.array(WcagRuleSchema).optional(),
+  thresholds: z.array(ThresholdRuleSchema).optional()
+}).strict();
 
 export const DcvConfigSchema = z.object({
+  // `$schema` is the conventional editor-hint key; allow it so strictness does
+  // not punish a well-formed config, but still reject unknown top-level typos.
+  $schema: z.string().optional(),
   version: z.string().optional(),
   constraints: ConstraintsSchema.optional()
-}).passthrough();
+}).strict();
 
 export type DcvConfigParsed = z.infer<typeof DcvConfigSchema>;
 

package/cli/constraint-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constraint-registry.d.ts","sourceRoot":"","sources":["constraint-registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"constraint-registry.d.ts","sourceRoot":"","sources":["constraint-registry.ts"],"names":[],"mappings":"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"}

package/cli/constraint-registry.js

@@ -11,13 +11,22 @@
  * - All entry points (validate, set, graph) use this registry for consistency
  */
 import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { isAbsolute, join } from 'node:path';
 import { MonotonicPlugin, parseSize as parseSizePx } from '../core/constraints/monotonic.js';
 import { MonotonicLightness } from '../core/constraints/monotonic-lightness.js';
 import { WcagContrastPlugin } from '../core/constraints/wcag.js';
 import { ThresholdPlugin } from '../core/constraints/threshold.js';
 import { CrossAxisPlugin } from '../core/constraints/cross-axis.js';
-import { loadCrossAxisRules } from './cross-axis-loader.js';
+import { loadCrossAxisRulesDetailed, referencedIdsForFile } from './cross-axis-loader.js';
+/**
+ * A plugin that emits a fixed set of pre-computed issues unconditionally (it
+ * ignores the candidate set). Used to surface cross-axis loader notices —
+ * present-but-unusable files and skipped invalid rules (TASK-037) — through the
+ * normal issue channel so they appear as warnings instead of vanishing.
+ */
+function noticePlugin(notices) {
+    return { id: 'cross-axis-notices', evaluate: () => notices };
+}
 // Built-in default constraint rules. Shared by attachConstraints (to register
 // plugins) and collectReferencedIds (to compute coverage) so the two never drift.
 export const DEFAULT_WCAG_PAIRS = [
@@ -44,6 +53,7 @@ export function discoverConstraints(opts) {
     const { config, basePath = '.', bp, constraintsDir = 'themes' } = opts;
     const sources = [];
     const constraintsCfg = config.constraints ?? {};
+    const constraintsRoot = isAbsolute(constraintsDir) ? constraintsDir : join(basePath, constraintsDir);
     // 1. Built-in WCAG defaults
     const enableBuiltInWcag = constraintsCfg.enableBuiltInWcagDefaults === undefined ? true : !!constraintsCfg.enableBuiltInWcagDefaults;
     if (enableBuiltInWcag) {
@@ -72,15 +82,28 @@ export function discoverConstraints(opts) {
             op: r.op,
             valuePx: r.valuePx,
             where: r.where,
+            // Preserve configured severity (TASK-037): the core plugin honors `level`,
+            // but dropping it here silently promoted a `warn` threshold to an error.
+            level: r.level,
         }));
         sources.push({ type: 'custom-threshold', rules });
     }
+    // A breakpoint uses its own `<axis>.<bp>.order.json` when present, but MUST fall
+    // back to the global `<axis>.order.json` otherwise — without this, any axis
+    // lacking a per-bp file (e.g. spacing) contributed ZERO constraints under
+    // --breakpoint/--all-breakpoints, a silent false-pass (TASK-034).
+    const orderPathFor = (base) => {
+        const bpPath = bp ? join(constraintsRoot, `${base}.${bp}.order.json`) : undefined;
+        if (bpPath && existsSync(bpPath))
+            return bpPath;
+        const globalPath = join(constraintsRoot, `${base}.order.json`);
+        return existsSync(globalPath) ? globalPath : undefined;
+    };
     // 5. Order files (monotonic constraints)
     const axes = ['typography', 'spacing', 'layout'];
     for (const axis of axes) {
-        const suffix = bp ? `.${bp}` : '';
-        const orderPath = join(basePath, constraintsDir, `${axis}${suffix}.order.json`);
-        if (existsSync(orderPath)) {
+        const orderPath = orderPathFor(axis);
+        if (orderPath) {
             try {
                 const data = JSON.parse(readFileSync(orderPath, 'utf8'));
                 const orders = data.order || [];
@@ -93,10 +116,9 @@ export function discoverConstraints(opts) {
             }
         }
     }
-    // 6. Color lightness order files
-    const suffix = bp ? `.${bp}` : '';
-    const colorOrderPath = join(basePath, constraintsDir, `color${suffix}.order.json`);
-    if (existsSync(colorOrderPath)) {
+    // 6. Color lightness order files (same bp → global fallback)
+    const colorOrderPath = orderPathFor('color');
+    if (colorOrderPath) {
         try {
             const data = JSON.parse(readFileSync(colorOrderPath, 'utf8'));
             const orders = data.order || [];
@@ -109,13 +131,13 @@ export function discoverConstraints(opts) {
         }
     }
     // 7. Cross-axis rules (global)
-    const crossAxisPath = join(basePath, constraintsDir, 'cross-axis.rules.json');
+    const crossAxisPath = join(constraintsRoot, 'cross-axis.rules.json');
     if (existsSync(crossAxisPath)) {
         sources.push({ type: 'cross-axis-file', path: crossAxisPath });
     }
     // 8. Cross-axis rules (breakpoint-specific)
     if (bp) {
-        const crossAxisBpPath = join(basePath, constraintsDir, `cross-axis.${bp}.rules.json`);
+        const crossAxisBpPath = join(constraintsRoot, `cross-axis.${bp}.rules.json`);
         if (existsSync(crossAxisBpPath)) {
             sources.push({ type: 'cross-axis-file', path: crossAxisBpPath, bp });
         }
@@ -170,13 +192,17 @@ export function attachConstraints(engine, sources, opts) {
                     break;
                 }
                 case 'cross-axis-file': {
-                    // Phase 3B: Load rules from filesystem in CLI layer, pass to core plugin
-                    const rules = loadCrossAxisRules(source.path, {
+                    // Phase 3B: Load rules from filesystem in CLI layer, pass to core plugin.
+                    // Detailed load also surfaces notices (unusable file / skipped invalid
+                    // rules) as warnings so they are never silently dropped (TASK-037).
+                    const { rules, notices } = loadCrossAxisRulesDetailed(source.path, {
                         bp: source.bp,
                         knownIds,
                         debug: crossAxisDebug,
                     });
                     engine.use(CrossAxisPlugin(rules, source.bp));
+                    if (notices.length)
+                        engine.use(noticePlugin(notices));
                     break;
                 }
             }
@@ -249,9 +275,21 @@ export function collectReferencedIds(sources) {
             case 'lightness-file':
                 addOrders(source.orders);
                 break;
-            case 'cross-axis-file':
-                coverageKnown = false;
+            case 'cross-axis-file': {
+                // TASK-031/037: enumerate referenced ids so coverage stays KNOWN, but
+                // MIRROR attach exactly — same `source.bp` filter and same shape
+                // validation. A rule that did not run (wrong breakpoint, or invalid)
+                // must not make coverage look "matched" and suppress the no-match note.
+                // An unusable file stays conservative (coverageKnown=false).
+                const { ids: caIds, coverageKnown: known } = referencedIdsForFile(source.path, source.bp);
+                if (!known) {
+                    coverageKnown = false;
+                    break;
+                }
+                for (const id of caIds)
+                    ids.add(id);
                 break;
+            }
         }
     }
     return { ids, coverageKnown };