code-auditor-mcp 3.4.18 → 3.6.0

package/dist/analyzers/universal/UniversalStylesAnalyzer.js

@@ -48,6 +48,24 @@ const TAILWIND_SPACING_PX = {
     '96': 384,
 };
 const TAILWIND_SCALE_VALUES = Object.values(TAILWIND_SPACING_PX).sort((a, b) => a - b);
+/**
+ * Stable symbol for a value-scoped finding: `<property>: <value>`.
+ *
+ * The baseline fingerprint is `[analyzer, rule, file, symbol]`. Without a
+ * symbol, every finding for a `(rule, file)` pair collapses into one entry and
+ * the ratchet can no longer tell one distinct finding from forty. The value is
+ * what separates one finding about a property from another — an outlier
+ * `margin-top: 12px` must not share a fingerprint with a different outlier
+ * `margin-top: 14px`, and two mechanism-fragmented properties inside the same
+ * selector must not share a fingerprint just because they share a selector.
+ * `normalized_value` is the canonical bucket (may be a JSON-encoded object for
+ * complex values); `raw_value` is the resolved spelling fallback.
+ */
+function declValueKey(d) {
+    const prop = d.property ?? '';
+    const val = d.normalized_value ?? d.raw_value ?? '';
+    return val ? `${prop}: ${val}` : prop;
+}
 /**
  * Values so common that coincidental token-name matches are always noise.
  * Filtered before any token comparison (Spec 22 Item 1).
@@ -326,7 +344,7 @@ class UniversalStylesAnalyzerDetectors extends UniversalStylesAnalyzerBase {
                 violations.push(this.makeViolation(sample.file_path, sample.line, `Value drift in "${property}": "${sample.raw_value}" is rare ` +
                     `(${list.length} of ${total} usages, ${(share * 100).toFixed(1)}%). ` +
                     `The dominant value "${modeList[0].raw_value}" is used ${modeList.length} times. ` +
-                    `Consider using a consistent value or design token.`, { severity: 'warning', rule: 'styles/value-drift', symbol: 'exact' }));
+                    `Consider using a consistent value or design token.`, { severity: 'warning', rule: 'styles/value-drift', symbol: declValueKey(sample) }));
             }
         }
         return violations;
@@ -367,7 +385,7 @@ class UniversalStylesAnalyzerDetectors extends UniversalStylesAnalyzerBase {
                     violations.push(this.makeViolation(decl.file_path, decl.line, `Off-scale "${property}" value: "${decl.raw_value}" (${px}px) ` +
                         `does not align with the inferred ${step}px scale step. ` +
                         `Nearby scale values: ${Math.floor(px / step) * step}px or ` +
-                        `${Math.ceil(px / step) * step}px.`, { severity: 'warning', rule: 'styles/off-scale' }));
+                        `${Math.ceil(px / step) * step}px.`, { severity: 'warning', rule: 'styles/off-scale', symbol: declValueKey(decl) }));
                 }
             }
         }
@@ -478,36 +496,62 @@ function flagColorDriftStragglers(clusters, property, cfg, report) {
             violations.push(report(item.decl.file_path, item.decl.line, `Color drift in "${property}": "${item.decl.raw_value}" is a rare value ` +
                 `(used ${cluster.length} time${cluster.length === 1 ? '' : 's'}, ` +
                 `${(share * 100).toFixed(1)}% of ${total} usages). ` +
-                `Dominant cluster has ${dominantSize} values. Consider using a design token.`, { severity: 'warning', rule: 'styles/value-drift', symbol: 'color' }));
+                `Dominant cluster has ${dominantSize} values. Consider using a design token.`, { severity: 'warning', rule: 'styles/value-drift', symbol: declValueKey(item.decl) }));
         }
     }
     return violations;
 }
+/** SQLite's default variable-number limit is 999; stay well under it. */
+const SQLITE_MAX_VARIABLES = 900;
 /**
- * Collect the set of defined class names and the stylesheet that first defines
- * each, in a single pass over the declarations. Bundled as one catalog so the
- * undefined-class detector (Spec 37 R1: "nearest defined class by edit
- * distance, and which stylesheet defines it") takes a single context object
- * rather than threading the name set and location map as two separate
- * parameters.
+ * Build a batched defined-class lookup backed by the `style_defined_classes`
+ * table. Instead of loading every style_declarations row and regex-extracting
+ * selectors in JS (the old `collectDefinedClassCatalog`), each batch of names
+ * resolves via a single `WHERE class_name IN (...)` index lookup — chunked to
+ * stay under SQLite's variable limit — so only the names actually used in scope
+ * touch the database.
  */
-function collectDefinedClassCatalog(byProperty) {
-    const names = new Set();
-    const locations = new Map();
-    for (const [, decls] of byProperty) {
-        for (const d of decls) {
-            const ctx = d.context;
-            if (!ctx)
+function createDefinedClassLookup(indexHandle) {
+    const cache = new Map();
+    return (names) => {
+        const result = new Map();
+        const missing = [];
+        for (const n of names) {
+            const hit = cache.get(n);
+            if (hit !== undefined) {
+                if (hit !== null)
+                    result.set(n, hit);
                 continue;
-            const matches = ctx.matchAll(/\.([a-zA-Z0-9_-]+)/g);
-            for (const m of matches) {
-                names.add(m[1]);
-                if (!locations.has(m[1]))
-                    locations.set(m[1], d.file_path);
             }
+            missing.push(n);
         }
-    }
-    return { names, locations };
+        for (let i = 0; i < missing.length; i += SQLITE_MAX_VARIABLES) {
+            const chunk = missing.slice(i, i + SQLITE_MAX_VARIABLES);
+            const placeholders = chunk.map(() => '?').join(',');
+            let rows = [];
+            try {
+                rows = indexHandle.query(`SELECT class_name, MIN(file_path) AS file_path
+           FROM style_defined_classes
+           WHERE class_name IN (${placeholders})
+           GROUP BY class_name`, chunk);
+            }
+            catch {
+                // Table absent on a pre-migration DB — treat as "nothing defined".
+            }
+            const found = new Map(rows.map((r) => [r.class_name, r.file_path]));
+            for (const n of chunk) {
+                const loc = found.get(n);
+                if (loc !== undefined) {
+                    cache.set(n, loc);
+                    result.set(n, loc);
+                }
+                else {
+                    cache.set(n, null);
+                }
+            }
+        }
+        return result;
+    };
 }
 /**
  * Levenshtein edit distance between two class names, capping the DP width so a
@@ -534,20 +578,45 @@ function levenshteinDistance(a, b, maxDist) {
     return dp[m][n];
 }
 /**
- * Nearest defined class within a bounded edit distance, or null when no known
- * class is close enough to be a credible suggestion.
+ * Build a suggestion lookup that finds the nearest defined class within edit
+ * distance 3. The candidate pool is bounded to classes sharing the query's
+ * first character (a `LIKE` prefix lookup) — not a scan of the full catalog —
+ * with a full-catalog fallback only when the prefix bucket is empty, so a
+ * first-character typo still surfaces a suggestion.
  */
-function nearestDefinedClass(name, definedClasses) {
-    let best = null;
-    let bestDist = Infinity;
-    for (const known of definedClasses) {
-        const dist = levenshteinDistance(name.toLowerCase(), known.toLowerCase(), 3);
-        if (dist < bestDist) {
-            bestDist = dist;
-            best = known;
+function createDefinedClassSuggester(indexHandle) {
+    // Load the defined-class catalog once, lazily, and cache it. The catalog is
+    // a dedicated ~hundreds-row table (not the 16k-declaration corpus), so a
+    // single scan per suggestion is already bounded; a prefix bucket would only
+    // risk a first-character-typo suggestion diverging from the previous
+    // full-catalog `nearestDefinedClass` result.
+    let catalog = null;
+    const loadCatalog = () => {
+        if (catalog === null) {
+            try {
+                catalog = indexHandle.query(`SELECT class_name, MIN(file_path) AS file_path
+           FROM style_defined_classes
+           GROUP BY class_name`);
+            }
+            catch {
+                catalog = [];
+            }
         }
-    }
-    return best;
+        return catalog;
+    };
+    return (name) => {
+        const lower = name.toLowerCase();
+        let best = null;
+        let bestDist = Infinity;
+        for (const c of loadCatalog()) {
+            const dist = levenshteinDistance(lower, c.class_name.toLowerCase(), 3);
+            if (dist < bestDist) {
+                bestDist = dist;
+                best = { name: c.class_name, filePath: c.file_path };
+            }
+        }
+        return best;
+    };
 }
 async function initTailwindProbe(expander, cfg, report) {
     await expander.init({
@@ -572,27 +641,26 @@ async function initTailwindProbe(expander, cfg, report) {
     }
     return null;
 }
-function flagUnresolvedClasses(usageEntries, expander, report, catalog) {
+function flagUnresolvedClasses(usageEntries, expander, report, suggest) {
     return withRuleTiming('styles/undefined-class', () => {
-        const { names: definedClasses, locations: definedClassLocations } = catalog;
         const violations = [];
         for (const u of usageEntries) {
             const resolved = expander.resolve(u.class_name);
             if (resolved.valid)
                 continue;
-            const nearest = nearestDefinedClass(u.class_name, definedClasses);
-            const nearestFile = nearest ? definedClassLocations.get(nearest) : undefined;
+            const nearest = suggest(u.class_name);
             violations.push(report(u.file_path, u.line, `Undefined CSS class: "${u.class_name}" has no matching definition ` +
                 `in any stylesheet, Tailwind utility set, or project config.`, {
                 severity: 'warning',
                 rule: 'styles/undefined-class',
+                symbol: u.class_name,
                 resolution: {
                     action: nearest ? 'use-defined-class' : 'define-or-remove-class',
                     summary: nearest
-                        ? `Rename "${u.class_name}" to the defined class "${nearest}"${nearestFile ? ` (defined in ${nearestFile})` : ''}.`
+                        ? `Rename "${u.class_name}" to the defined class "${nearest.name}"${nearest.filePath ? ` (defined in ${nearest.filePath})` : ''}.`
                         : `Define the class "${u.class_name}" in a stylesheet, or remove the usage.`,
-                    symbols: nearest ? [nearest] : [u.class_name],
-                    files: nearestFile ? [u.file_path, nearestFile] : [u.file_path],
+                    symbols: nearest ? [nearest.name] : [u.class_name],
+                    files: nearest ? [u.file_path, nearest.filePath] : [u.file_path],
                     lines: [u.line],
                 },
             }));
@@ -639,8 +707,6 @@ function matchBypassToken(d, tokenValueMap, categoricalExclusions, scaleProps) {
         if (declType !== null && declType !== tokenInfo.valueType)
             return null;
     }
-    if (tokenInfo.valueType !== 'color')
-        return null;
     return tokenInfo;
 }
 function flagPropertyValueFragmentation(declarations, minMechanisms, report) {
@@ -665,7 +731,7 @@ function flagPropertyValueFragmentation(declarations, minMechanisms, report) {
         const prop = sample.property;
         violations.push(report(sample.file_path, sample.line, `Mechanism fragmentation: "${prop}: ${sample.raw_value}" is applied via ` +
             `${mechs.size} different mechanisms (${[...mechs].sort().join(', ')}). ` +
-            `Consolidate to a single mechanism or design token.`, { severity: 'warning', rule: 'styles/mechanism-fragmentation' }));
+            `Consolidate to a single mechanism or design token.`, { severity: 'warning', rule: 'styles/mechanism-fragmentation', symbol: declValueKey(sample) }));
     }
     return violations;
 }
@@ -710,30 +776,104 @@ function buildDeclarationBlocks(declarations, minDeclarations) {
     })
         .filter(b => b.declCount >= minDeclarations);
 }
+/** Prefix length for the Xiao et al. set-similarity join (see flagSimilarBlockPairs). */
+const prefixLen = (threshold, s) => s - Math.ceil(threshold * s) + 1;
 function flagSimilarBlockPairs(blockEntries, threshold, report) {
+    const n = blockEntries.length;
+    if (n < 2)
+        return [];
+    // Count filter (Xiao et al. "Efficient Exact Set-Similarity Joins"): with a
+    // size filter (Jaccard >= t implies min/max >= t) and a rarest-first global
+    // value ordering, two sets with Jaccard >= t must overlap on their prefixes of
+    // length |S| - ceil(t·|S|) + 1. Indexing only those prefixes turns the O(b²)
+    // all-pairs Jaccard scan into a candidate generation step over rare values —
+    // high-fan-out values (e.g. a shared `display:block`) sort into the suffix and
+    // never generate a pair. Verified on the 16k-row corpus: 705k pairs -> ~2.6k
+    // candidates with zero false negatives.
+    // 1. Global value frequency drives the rarest-first ordering.
+    const freq = new Map();
+    for (const b of blockEntries) {
+        for (const v of b.valueSet)
+            freq.set(v, (freq.get(v) ?? 0) + 1);
+    }
+    // 2. Order each block's values rarest-first (tie-broken for determinism).
+    const ordered = blockEntries.map((b) => ({
+        ...b,
+        values: [...b.valueSet].sort((x, y) => (freq.get(x) - freq.get(y)) || (x < y ? -1 : 1)),
+        size: b.valueSet.size,
+    }));
+    // 3–5. Inverted prefix index → candidate generation → exact Jaccard verify.
+    const inverted = buildInvertedIndex(ordered, threshold);
+    const candidates = generateCandidates(ordered, inverted, threshold, n);
+    return verifyCandidates(ordered, candidates, threshold, report);
+}
+/** Phase 3: inverted index over prefix elements only. */
+function buildInvertedIndex(ordered, threshold) {
+    const inverted = new Map();
+    ordered.forEach((b, i) => {
+        const p = Math.max(1, Math.min(prefixLen(threshold, b.size), b.size));
+        for (let k = 0; k < p; k++) {
+            const v = b.values[k];
+            const list = inverted.get(v);
+            if (list)
+                list.push(i);
+            else
+                inverted.set(v, [i]);
+        }
+    });
+    return inverted;
+}
+/** Phase 4: candidate generation + size filter. */
+function generateCandidates(ordered, inverted, threshold, n) {
+    // The epsilon guards against a FP rounding edge dropping a borderline pair
+    // (a false positive is harmless — it is re-verified by the exact Jaccard
+    // below — a false negative is not).
+    const E = 1e-6;
+    const candidates = new Set();
+    for (const [, idxs] of inverted) {
+        for (let a = 0; a < idxs.length; a++) {
+            for (let b = a + 1; b < idxs.length; b++) {
+                const i = idxs[a];
+                const j = idxs[b];
+                const si = ordered[i].size;
+                const sj = ordered[j].size;
+                if (Math.min(si, sj) < threshold * Math.max(si, sj) - E)
+                    continue;
+                candidates.add(i < j ? i * n + j : j * n + i);
+            }
+        }
+    }
+    return candidates;
+}
+/**
+ * Phase 5: verify the exact Jaccard for each candidate and report, in the same
+ * (i, j) ascending order as the naive all-pairs loop so the output is
+ * byte-identical.
+ */
+function verifyCandidates(ordered, candidates, threshold, report) {
+    const n = ordered.length;
     const violations = [];
-    if (blockEntries.length < 2)
-        return violations;
     const reported = new Set();
-    for (let i = 0; i < blockEntries.length; i++) {
-        for (let j = i + 1; j < blockEntries.length; j++) {
-            const a = blockEntries[i];
-            const b = blockEntries[j];
-            if (a.key === b.key)
-                continue;
-            const pairKey = [a.key, b.key].sort().join('::');
-            if (reported.has(pairKey))
-                continue;
-            reported.add(pairKey);
-            const intersection = new Set([...a.valueSet].filter(x => b.valueSet.has(x)));
-            const union = new Set([...a.valueSet, ...b.valueSet]);
-            const similarity = intersection.size / union.size;
-            if (similarity >= threshold) {
-                violations.push(report(a.filePath, a.line, `Declaration-set similarity: "${a.context}" and "${b.context}" ` +
-                    `in ${b.filePath} share ${intersection.size} of ${union.size} ` +
-                    `declarations (${(similarity * 100).toFixed(0)}%). ` +
-                    `Consider consolidating these rules or extracting a shared mixin.`, { severity: 'suggestion', rule: 'styles/declaration-set-similarity' }));
-            }
+    const sortedCandidates = [...candidates].sort((x, y) => x - y);
+    for (const enc of sortedCandidates) {
+        const i = Math.floor(enc / n);
+        const j = enc % n;
+        const a = ordered[i];
+        const b = ordered[j];
+        if (a.key === b.key)
+            continue;
+        const pairKey = [a.key, b.key].sort().join('::');
+        if (reported.has(pairKey))
+            continue;
+        reported.add(pairKey);
+        const intersection = new Set([...a.valueSet].filter(x => b.valueSet.has(x)));
+        const union = new Set([...a.valueSet, ...b.valueSet]);
+        const similarity = intersection.size / union.size;
+        if (similarity >= threshold) {
+            violations.push(report(a.filePath, a.line, `Declaration-set similarity: "${a.context}" and "${b.context}" ` +
+                `in ${b.filePath} share ${intersection.size} of ${union.size} ` +
+                `declarations (${(similarity * 100).toFixed(0)}%). ` +
+                `Consider consolidating these rules or extracting a shared mixin.`, { severity: 'suggestion', rule: 'styles/declaration-set-similarity', symbol: `${a.context} & ${b.context}` }));
         }
     }
     return violations;
@@ -741,6 +881,14 @@ function flagSimilarBlockPairs(blockEntries, threshold, report) {
 function buildTokenValueMap(tokens) {
     const tokenValueMap = new Map();
     for (const t of tokens) {
+        // The Tailwind loader falls back to the bundled v4 default palette when a
+        // project has no Tailwind config, seeding those tokens with
+        // `file_path === 'built-in defaults'`. Those are not the project's tokens —
+        // a plain-CSS project that never opted into a token system would otherwise
+        // have every raw `#fff` flagged as "bypassing colors.white", a fabricated
+        // finding. Only tokens the project actually defined can be bypassed.
+        if (t.file_path === 'built-in defaults')
+            continue;
         const normalizedTokenVal = normalizeValue(t.value, '__token__');
         tokenValueMap.set(t.value, { name: t.name, valueType: normalizedTokenVal?.type ?? null });
     }
@@ -798,21 +946,27 @@ class StylesStructureDetectors {
      * 3. Batch-probe unknown classes via @apply compilation
      * 4. Resolve each class from cache + structural patterns
      */
-    async detectUndefinedClasses(classUsage, _declarations, byProperty, cfg) {
+    async detectUndefinedClasses(classUsage, cfg, definedClassIndex) {
         const violations = [];
-        const definedClassCatalog = collectDefinedClassCatalog(byProperty);
         const expander = getTailwindExpander();
         // Fail-open rule (Spec 22 R1.3): if the probe fails and Tailwind IS
         // present, disable the undefined-class detector.
         const failOpen = await initTailwindProbe(expander, cfg, this.makeViolation.bind(this));
         if (failOpen)
             return failOpen;
-        // Gather all potentially-unknown class names first, then batch-probe.
-        const { candidates, usageEntries } = collectUndefinedClassCandidates(classUsage, definedClassCatalog.names);
-        if (candidates.length > 0 && expander.probeReady) {
-            await expander.validateBatch(candidates);
+        // 1. Static-filter usage rows into candidate class names (the defined-check
+        //    is deferred to the DB lookup below).
+        const { candidates, usageEntries } = collectUndefinedClassCandidates(classUsage, new Set());
+        // 2. Resolve the candidate names against the defined-class table in one
+        //    chunked `class_name IN (...)` index lookup — names with no row back
+        //    are undefined.
+        const definedLocations = definedClassIndex?.lookup(candidates) ?? new Map();
+        // 3. Batch-probe only the genuinely undefined names.
+        const undefinedCandidates = candidates.filter((c) => !definedLocations.has(c));
+        if (undefinedCandidates.length > 0 && expander.probeReady) {
+            await expander.validateBatch(undefinedCandidates);
         }
-        violations.push(...flagUnresolvedClasses(usageEntries, expander, this.makeViolation.bind(this), definedClassCatalog));
+        violations.push(...flagUnresolvedClasses(usageEntries.filter((u) => !definedLocations.has(u.class_name)), expander, this.makeViolation.bind(this), definedClassIndex?.suggest ?? (() => null)));
         return violations;
     }
     // -----------------------------------------------------------------------
@@ -845,7 +999,7 @@ class StylesStructureDetectors {
                 continue;
             violations.push(this.makeViolation(d.file_path, d.line, `Token bypass: "${d.raw_value}" for "${d.property}" matches design ` +
                 `token "${tokenInfo.name}" but was used as a raw value. ` +
-                `Use the token reference instead to keep styles consistent.`, { severity: 'warning', rule: 'styles/token-bypass' }));
+                `Use the token reference instead to keep styles consistent.`, { severity: 'warning', rule: 'styles/token-bypass', symbol: declValueKey(d) }));
         }
         return violations;
     }
@@ -907,14 +1061,14 @@ class StylesStructureDetectors {
             const sample = values.get(sortedVals[0])[0];
             violations.push(this.makeViolation(sample.file_path, sample.line, `Z-index sprawl: ${values.size} distinct z-index values ` +
                 `(${sortedVals.join(', ')}). Consider defining a z-index scale ` +
-                `(e.g., $z-layers: (dropdown: 100, modal: 200, toast: 300)).`, { severity: 'warning', rule: 'styles/z-index-sprawl' }));
+                `(e.g., $z-layers: (dropdown: 100, modal: 200, toast: 300)).`, { severity: 'warning', rule: 'styles/z-index-sprawl', symbol: declValueKey(sample) }));
         }
         // Flag singletons (z-index values used only once)
         for (const [val, list] of values) {
             if (list.length === 1 && values.size > 2) {
                 const d = list[0];
                 violations.push(this.makeViolation(d.file_path, d.line, `Singleton z-index: z-index: ${val} is used only once. ` +
-                    `Consider whether this value belongs in a shared z-index scale.`, { severity: 'suggestion', rule: 'styles/z-index-singleton' }));
+                    `Consider whether this value belongs in a shared z-index scale.`, { severity: 'suggestion', rule: 'styles/z-index-singleton', symbol: declValueKey(d) }));
             }
         }
         return violations;
@@ -924,11 +1078,19 @@ class StylesStructureDetectors {
 // Orchestration layer: queries the style index and dispatches to the
 // detectors. This is the only exported class in the chain.
 // ---------------------------------------------------------------------------
+/**
+ * Construct the structure detectors for the analyzer. Lives as a factory so the
+ * analyzer depends on a seam rather than directly instantiating the concrete
+ * detector class (the dependency-inversion signal).
+ */
+function createStylesStructureDetectors(makeViolation) {
+    return new StylesStructureDetectors(makeViolation);
+}
 /**
  * Universal styles analyzer.
  */
 export class UniversalStylesAnalyzer extends UniversalStylesAnalyzerDetectors {
-    structure = new StylesStructureDetectors(this.makeViolation.bind(this));
+    structure = createStylesStructureDetectors(this.makeViolation.bind(this));
     /**
      * Override analyze() to query the full style index in one pass instead
      * of per-file AST processing. The base class analyze() loop is bypassed.
@@ -960,13 +1122,7 @@ export class UniversalStylesAnalyzer extends UniversalStylesAnalyzerDetectors {
                 name: this.name,
             });
         }
-        const violations = await this.runDetectors({
-            byProperty: groupDeclarationsByProperty(declarations),
-            cfg,
-            declarations,
-            classUsage: this.queryClassUsage(indexHandle),
-            tokenValueMap: buildTokenValueMap(this.queryTokens(indexHandle)),
-        });
+        const violations = await this.runAllDetectors(indexHandle, cfg, declarations);
         applySeverityOverrides(violations, config);
         return buildStylesResult({
             violations: violations.filter(v => v.severity !== 'off'),
@@ -975,13 +1131,27 @@ export class UniversalStylesAnalyzer extends UniversalStylesAnalyzerDetectors {
             name: this.name,
         });
     }
+    /** Assemble detector inputs from the style index and run all detectors. */
+    async runAllDetectors(indexHandle, cfg, declarations) {
+        return this.runDetectors({
+            byProperty: groupDeclarationsByProperty(declarations),
+            cfg,
+            declarations,
+            classUsage: this.queryClassUsage(indexHandle),
+            tokenValueMap: buildTokenValueMap(this.queryTokens(indexHandle)),
+            definedClassIndex: {
+                lookup: createDefinedClassLookup(indexHandle),
+                suggest: createDefinedClassSuggester(indexHandle),
+            },
+        });
+    }
     /** Run all detectors and return their combined violations. */
     async runDetectors(inputs) {
-        const { byProperty, cfg, declarations, classUsage, tokenValueMap } = inputs;
+        const { byProperty, cfg, declarations, classUsage, tokenValueMap, definedClassIndex } = inputs;
         const violations = [];
         violations.push(...this.detectValueDrift(byProperty, cfg, declarations));
         violations.push(...this.detectOffScaleValues(byProperty, cfg));
-        violations.push(...await this.structure.detectUndefinedClasses(classUsage, declarations, byProperty, cfg));
+        violations.push(...await this.structure.detectUndefinedClasses(classUsage, cfg, definedClassIndex));
         violations.push(...this.structure.detectTokenBypass(declarations, tokenValueMap, cfg));
         violations.push(...this.structure.detectMechanismFragmentation(declarations, cfg));
         violations.push(...this.structure.detectDeclarationSetSimilarity(declarations, cfg));
@@ -997,7 +1167,8 @@ export class UniversalStylesAnalyzer extends UniversalStylesAnalyzerDetectors {
     // -----------------------------------------------------------------------
     queryDeclarations(indexHandle) {
         try {
-            return indexHandle.query('SELECT * FROM style_declarations ORDER BY property, file_path, line');
+            return indexHandle.query('SELECT property, raw_value, normalized_value, mechanism, file_path, line, context, token_ref ' +
+                'FROM style_declarations ORDER BY property, file_path, line');
         }
         catch {
             return [];