code-auditor-mcp 4.1.1 → 5.0.1

package/dist/phase/codeBlocks.js

@@ -0,0 +1,268 @@
+/**
+ * Spec 68 §3.2 — the per-file `code-block` producer.
+ *
+ * Projects the block/fragment extraction half of `UniversalDRYAnalyzer` onto one
+ * serializable fact. The fact is a union of two element shapes — a *block*
+ * (function/class/method/control-flow span, with its normalized hash and
+ * structural skeleton pre-computed) and a *fragment* (an object literal's field
+ * names or a call chain's method names) — so the three DRY rules
+ * (`dry/duplicate`, `dry/structural-similarity`, `dry/similar-expression`) read
+ * plain data and never the AST.
+ *
+ * The producer is a *pure projection*: it runs the legacy walk and computes the
+ * hash/skeleton with the default normalization (comments/whitespace ignored),
+ * but it applies **no threshold** and **no dedup**. `minLineThreshold`,
+ * `similarityThreshold`, `minShapeNames`, `excludePatterns`, the two
+ * check-gates, the fluent-chain exclusion and both dedup passes are the rules'
+ * — re-applied in `dry.ts` over the projected data, in the exact legacy order
+ * (filter → dedupe → compare). That keeps the tree's only job "project the raw
+ * blocks and fragments before it dies", and keeps every configurable decision a
+ * pure-data decision the rule can reproduce.
+ */
+import * as crypto from 'crypto';
+import { buildLocationIndex, locationKey } from '../languages/locationIndex.js';
+// ── Normalization (re-homed verbatim; the default ignore flags are fixed) ──
+// `ignoreComments` / `ignoreWhitespace` are internal normalization knobs, not
+// the DRY rules' declared threshold surface (`minLineThreshold` /
+// `similarityThreshold` / `minShapeNames`), so they are pinned at their
+// DEFAULT_DRY_CONFIG values (true) here — the same values the legacy
+// default-merged analyzer used before any user override.
+/** Reserved words left intact by `normalizeStructure` — hoisted so the replace
+ *  callback does not re-allocate a 70-entry Set for every identifier match. */
+const STRUCTURE_KEYWORDS = new Set([
+    'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue',
+    'return', 'throw', 'try', 'catch', 'finally', 'new', 'delete', 'typeof',
+    'instanceof', 'in', 'of', 'class', 'extends', 'super', 'this', 'function',
+    'const', 'let', 'var', 'async', 'await', 'yield', 'import', 'export',
+    'default', 'from', 'as', 'static', 'get', 'set', 'enum', 'type', 'interface',
+    'implements', 'abstract', 'public', 'private', 'protected', 'readonly',
+    'ID', 'LIT',
+]);
+/**
+ * Normalize code to its token-kind sequence.
+ * Identifiers → ID, string/number/regex literals → LIT.
+ */
+function normalizeStructure(code) {
+    let normalized = code;
+    // Template expressions: strip dynamic parts for structural matching
+    normalized = normalized.replace(/\$\{[^}]*\}/g, 'ID');
+    // String literals (single, double, backtick) → LIT
+    normalized = normalized.replace(/(['"`])\1/g, 'LIT'); // empty strings
+    normalized = normalized.replace(/`[^`]*`/g, 'LIT');
+    normalized = normalized.replace(/'[^']*'/g, 'LIT');
+    normalized = normalized.replace(/"[^"]*"/g, 'LIT');
+    // Numeric literals → LIT
+    normalized = normalized.replace(/\b\d+\.?\d*\b/g, 'LIT');
+    // Regex literals → LIT (approximate — /pattern/flags)
+    normalized = normalized.replace(/\/[^/*][^/]*\/[gimsuy]*/g, 'LIT');
+    // Boolean/null literals
+    normalized = normalized.replace(/\b(true|false|null|undefined)\b/g, 'LIT');
+    // Identifiers → ID (after literals so we don't replace inside strings)
+    // Match camelCase, PascalCase, snake_case, dollar-prefixed, underscore-prefixed
+    normalized = normalized.replace(/\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g, (match) => {
+        if (STRUCTURE_KEYWORDS.has(match))
+            return match;
+        return 'ID';
+    });
+    return normalized;
+}
+/** Normalize code for comparison — default ignore flags (whitespace + comments). */
+function normalizeCode(code) {
+    let normalized = code;
+    // ignoreWhitespace
+    normalized = normalized.split('\n').map((line) => line.trim()).filter((line) => line.length > 0).join('\n');
+    // ignoreComments
+    normalized = normalized.replace(/\/\/.*$/gm, '');
+    normalized = normalized.replace(/\/\*[\s\S]*?\*\//g, '');
+    return normalized;
+}
+/** Hash code for comparison. */
+function hashCode(text) {
+    return crypto.createHash('sha256').update(text).digest('hex');
+}
+/** Count lines in text (non-blank). */
+function countLines(text) {
+    return text.split('\n').filter((line) => line.trim().length > 0).length;
+}
+/** Walk the AST depth-first, invoking the callback on every node. */
+function walkAST(node, callback) {
+    callback(node);
+    if (node.children) {
+        for (const child of node.children) {
+            walkAST(child, callback);
+        }
+    }
+}
+/** True for a block-like node type (if/for/while/switch/try). */
+function isSignificantBlockType(type) {
+    const blockTypes = new Set([
+        'if_statement', 'for_statement', 'for_in_statement',
+        'while_statement', 'do_statement', 'switch_statement', 'try_statement',
+    ]);
+    return blockTypes.has(type);
+}
+/** Build a block fact from a node (raw text + pre-computed hash/skeleton). */
+function createCodeBlock(ctx, node) {
+    const text = ctx.adapter.getNodeText(node, ctx.sourceCode);
+    if (!text)
+        return null;
+    const normalizedText = normalizeCode(text);
+    const lineCount = countLines(text);
+    const structuralSkeleton = normalizeStructure(normalizedText);
+    return {
+        kind: 'block',
+        file: ctx.ast.filePath,
+        start: node.location.start,
+        end: node.location.end,
+        text,
+        hash: hashCode(normalizedText),
+        structuralSkeleton,
+        nodeType: node.type,
+        lineCount,
+    };
+}
+/** Look up the node at `location` in the pre-built index, build its block, and
+ *  append it. */
+function collectBlock(ctx, index, location, blocks) {
+    const node = index.get(locationKey(location));
+    if (!node)
+        return;
+    const block = createCodeBlock(ctx, node);
+    if (block)
+        blocks.push(block);
+}
+/** Extract all code blocks from an AST: functions, classes + methods, control-flow. */
+function extractBlocks(ctx) {
+    const blocks = [];
+    // `true` skips the whole-file wrapper: the block producer's legacy search
+    // started from `root.children`, never the root (see locationIndex.ts).
+    const index = buildLocationIndex(ctx.ast.root, true);
+    for (const func of ctx.adapter.extractFunctions(ctx.ast)) {
+        collectBlock(ctx, index, func.location.start, blocks);
+    }
+    const classes = ctx.adapter.extractClasses(ctx.ast);
+    for (const cls of classes) {
+        collectBlock(ctx, index, cls.location.start, blocks);
+        for (const method of cls.methods) {
+            collectBlock(ctx, index, method.location.start, blocks);
+        }
+    }
+    walkAST(ctx.ast.root, (node) => {
+        if (isSignificantBlockType(node.type)) {
+            collectBlock(ctx, index, node.location.start, blocks);
+        }
+    });
+    return blocks;
+}
+// ── Shape fragments ──────────────────────────────────────────────────────────
+/** Strip one layer of quotes from a string-literal object key. */
+function bareKeyName(key, getText) {
+    let t = getText(key).trim();
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+        t = t.slice(1, -1);
+    }
+    return t;
+}
+/** Field names of an object literal, in source order (`{ a: 1 }` and `{ a }`). */
+function objectFieldNames(node, getText) {
+    const names = [];
+    for (const child of node.children ?? []) {
+        if (child.type === 'pair') {
+            const key = child.children?.[0];
+            if (key) {
+                const name = bareKeyName(key, getText);
+                if (name)
+                    names.push(name);
+            }
+        }
+        else if (child.type === 'shorthand_property_identifier') {
+            const name = getText(child).trim();
+            if (name)
+                names.push(name);
+        }
+    }
+    return names;
+}
+/** Method names of a fluent call chain, in call order ([] for a bare call). */
+function callChainMethodNames(node, getText) {
+    const names = [];
+    let current = node;
+    while (current && current.type === 'call_expression') {
+        const callee = current.children?.[0];
+        if (!callee)
+            break;
+        if (callee.type === 'member_expression') {
+            const prop = callee.children?.find((c) => c.type === 'property_identifier');
+            if (!prop)
+                break;
+            names.push(getText(prop).trim());
+            current = callee.children?.[0];
+        }
+        else if (callee.type === 'call_expression') {
+            current = callee; // curried/IIFE — skip the anonymous level, keep walking
+        }
+        else {
+            break; // bare identifier callee — end of the chain
+        }
+    }
+    return names.reverse();
+}
+/**
+ * Extract shape fragments (object literals + call chains) from the AST, with no
+ * threshold filter and no dedup — both are the rule's. Object literals are only
+ * collected as the *direct value* of a declaration or assignment and carry that
+ * target; chains carry their method-name sequence.
+ */
+function extractFragments(ctx) {
+    const fragments = [];
+    const getText = (node) => ctx.adapter.getNodeText(node, ctx.sourceCode);
+    const collectObject = (node, target) => {
+        const names = objectFieldNames(node, getText);
+        fragments.push({
+            kind: 'fragment',
+            file: ctx.ast.filePath,
+            start: node.location.start,
+            end: node.location.end,
+            fragmentKind: 'object',
+            target,
+            names,
+            text: getText(node),
+        });
+    };
+    walkAST(ctx.ast.root, (node) => {
+        if (node.type === 'variable_declarator') {
+            // `const name: T = value` — target is the declarator name, value the last child.
+            const name = node.children?.[0];
+            const value = node.children?.[node.children.length - 1];
+            if (name && value?.type === 'object')
+                collectObject(value, getText(name));
+        }
+        else if (node.type === 'assignment_expression') {
+            // `target = value` — target is the left-hand side, value the last child.
+            const left = node.children?.[0];
+            const value = node.children?.[node.children.length - 1];
+            if (left && value?.type === 'object')
+                collectObject(value, getText(left));
+        }
+        else if (node.type === 'call_expression') {
+            const names = callChainMethodNames(node, getText);
+            fragments.push({
+                kind: 'fragment',
+                file: ctx.ast.filePath,
+                start: node.location.start,
+                end: node.location.end,
+                fragmentKind: 'chain',
+                names,
+                text: getText(node),
+            });
+        }
+    });
+    return fragments;
+}
+// ── Entry point ───────────────────────────────────────────────────────────────
+/** One file's code blocks + shape fragments, as a single `code-block` fact. */
+export function extractCodeBlocks(file) {
+    const ctx = { ast: file.ast, adapter: file.adapter, sourceCode: file.source };
+    return [...extractBlocks(ctx), ...extractFragments(ctx)];
+}
+//# sourceMappingURL=codeBlocks.js.map

package/dist/phase/codeBlocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeBlocks.js","sourceRoot":"","sources":["../../src/phase/codeBlocks.ts"],"names":[],"mappings":"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"}

package/dist/phase/colorMath.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Spec 69 R4 — the CIELAB color conversion, re-homed out of the
+ * `styles/value-drift` rule body into a shared module.
+ *
+ * The move is the one placement correction R4 named: `value-drift` was the only
+ * migrated rule whose body still *computed* a derived value — parsing a raw
+ * color string to sRGB and converting it to CIELAB Lab. That conversion is a
+ * pure, threshold-independent derivation from the raw declaration value, exactly
+ * the "one level up from raw source text" computation a processor should own.
+ *
+ * These three functions are the conversion (`parseColorToRGB`, `rgbToLab`) plus
+ * the ΔE76 distance over Lab (`labDistance`). The `color-values` corpus producer
+ * (`producers.ts`) imports the conversion and stores the Lab triple in the fact;
+ * the rule imports only `labDistance` — the comparison metric its clustering and
+ * flagging decisions use — so it reads pre-computed Lab and never re-parses a
+ * color. The rule decides; the processor computes.
+ */
+/** A CIELAB Lab triple (L, a, b), D65 reference white. */
+export type Lab = [number, number, number];
+/** A sRGB triple, each channel in [0, 255]. */
+export type RGB = [number, number, number];
+/** sRGB → CIELAB Lab (D65), the same transform `value-drift` ran in its body.
+ *
+ * @param rgb The sRGB triple, each channel in [0, 255].
+ * @returns The CIELAB Lab triple (L, a, b).
+ */
+export declare function rgbToLab([r, g, b]: RGB): Lab;
+/** Raw color string → sRGB, or null when it is not a parseable color.
+ *
+ * @param raw The raw color string (hex, `rgb()`, or a keyword).
+ * @returns The sRGB triple, or null when the string is not a parseable color.
+ */
+export declare function parseColorToRGB(raw: string): RGB | null;
+/** ΔE76 — the Euclidean distance between two Lab triples.
+ *
+ * @param a The first Lab triple.
+ * @param b The second Lab triple.
+ * @returns The ΔE76 color distance.
+ */
+export declare function labDistance(a: Lab, b: Lab): number;
+//# sourceMappingURL=colorMath.d.ts.map

package/dist/phase/colorMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorMath.d.ts","sourceRoot":"","sources":["../../src/phase/colorMath.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,0DAA0D;AAC1D,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE3C,+CAA+C;AAC/C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAM3C;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,GAAG,CAyB5C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CA6CvD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,CAKlD"}

package/dist/phase/colorMath.js

@@ -0,0 +1,109 @@
+/**
+ * Spec 69 R4 — the CIELAB color conversion, re-homed out of the
+ * `styles/value-drift` rule body into a shared module.
+ *
+ * The move is the one placement correction R4 named: `value-drift` was the only
+ * migrated rule whose body still *computed* a derived value — parsing a raw
+ * color string to sRGB and converting it to CIELAB Lab. That conversion is a
+ * pure, threshold-independent derivation from the raw declaration value, exactly
+ * the "one level up from raw source text" computation a processor should own.
+ *
+ * These three functions are the conversion (`parseColorToRGB`, `rgbToLab`) plus
+ * the ΔE76 distance over Lab (`labDistance`). The `color-values` corpus producer
+ * (`producers.ts`) imports the conversion and stores the Lab triple in the fact;
+ * the rule imports only `labDistance` — the comparison metric its clustering and
+ * flagging decisions use — so it reads pre-computed Lab and never re-parses a
+ * color. The rule decides; the processor computes.
+ */
+const COLOR_KEYWORDS = new Set([
+    'transparent', 'currentcolor', 'inherit', 'initial', 'unset', 'none',
+]);
+/** sRGB → CIELAB Lab (D65), the same transform `value-drift` ran in its body.
+ *
+ * @param rgb The sRGB triple, each channel in [0, 255].
+ * @returns The CIELAB Lab triple (L, a, b).
+ */
+export function rgbToLab([r, g, b]) {
+    const linear = (c) => {
+        const v = c / 255;
+        return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+    };
+    const lr = linear(r);
+    const lg = linear(g);
+    const lb = linear(b);
+    const x = lr * 0.4124564 + lg * 0.3575761 + lb * 0.1804375;
+    const y = lr * 0.2126729 + lg * 0.7151522 + lb * 0.0721750;
+    const z = lr * 0.0193339 + lg * 0.1191920 + lb * 0.9503041;
+    const XN = 0.95047;
+    const YN = 1.0;
+    const ZN = 1.08883;
+    const EPSILON = 0.008856;
+    const KAPPA = 903.3;
+    const f = (t) => t > EPSILON ? Math.cbrt(t) : (KAPPA * t + 16) / 116;
+    const fx = f(x / XN);
+    const fy = f(y / YN);
+    const fz = f(z / ZN);
+    return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+/** Raw color string → sRGB, or null when it is not a parseable color.
+ *
+ * @param raw The raw color string (hex, `rgb()`, or a keyword).
+ * @returns The sRGB triple, or null when the string is not a parseable color.
+ */
+export function parseColorToRGB(raw) {
+    try {
+        let v = raw.toLowerCase().trim();
+        if (COLOR_KEYWORDS.has(v))
+            return null;
+        if (v.startsWith('#')) {
+            if (v.length === 4) {
+                v = '#' + v[1] + v[1] + v[2] + v[2] + v[3] + v[3];
+            }
+            if (v.length === 7) {
+                return [
+                    parseInt(v.slice(1, 3), 16),
+                    parseInt(v.slice(3, 5), 16),
+                    parseInt(v.slice(5, 7), 16),
+                ];
+            }
+            if (v.length === 9) {
+                return [
+                    parseInt(v.slice(1, 3), 16),
+                    parseInt(v.slice(3, 5), 16),
+                    parseInt(v.slice(5, 7), 16),
+                ];
+            }
+        }
+        const rgbMatch = v.match(/rgb\(\s*(\d+)\s*,?\s*(\d+)\s*,?\s*(\d+)\s*\)/);
+        if (rgbMatch) {
+            return [
+                parseInt(rgbMatch[1]),
+                parseInt(rgbMatch[2]),
+                parseInt(rgbMatch[3]),
+            ];
+        }
+        const named = {
+            'white': [255, 255, 255], 'black': [0, 0, 0],
+            'red': [255, 0, 0], 'blue': [0, 0, 255], 'green': [0, 128, 0],
+        };
+        if (named[v])
+            return named[v];
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** ΔE76 — the Euclidean distance between two Lab triples.
+ *
+ * @param a The first Lab triple.
+ * @param b The second Lab triple.
+ * @returns The ΔE76 color distance.
+ */
+export function labDistance(a, b) {
+    const dl = a[0] - b[0];
+    const da = a[1] - b[1];
+    const db = a[2] - b[2];
+    return Math.sqrt(dl * dl + da * da + db * db);
+}
+//# sourceMappingURL=colorMath.js.map

package/dist/phase/colorMath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorMath.js","sourceRoot":"","sources":["../../src/phase/colorMath.ts"],"names":[],"mappings":"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"}

package/dist/phase/config.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Spec 68 §11.1 — threshold resolution for the both-paths phase model.
+ *
+ * The migrated rules read *flat* threshold keys with documented fallbacks
+ * (solid's `maxMethodComplexity`, data-access's `joinedTableCount`, …). The
+ * legacy analyzers read the same values through their own namespace config,
+ * default-merged inside `analyzeAST` / `analyzeWithFacts`. To serve a migrated
+ * rule with the *identical* effective value its legacy path would have used,
+ * resolve its thresholds from the same two inputs the analyzer merges — the
+ * runtime default (`RUNTIME_DEFAULT_CONFIGS`) under the user's
+ * `analyzerConfigs` — then flatten the one nested key the rules read flat
+ * (`performanceThresholds.joinedTableCount` → `joinedTableCount`).
+ *
+ * This is the minimal §10 bridge for the transitional state. §10 proper replaces
+ * the dot-path vocabulary and the per-analyzer namespace with the rule/threshold
+ * surface; until then the bridge keeps the two paths bit-identical so the parity
+ * pins and the production count hold.
+ */
+import type { ThresholdValues } from './types.js';
+/**
+ * Resolve the per-rule threshold map for every migrated rule from the
+ * pipeline's per-analyzer config (user overrides only — defaults come from
+ * {@link RUNTIME_DEFAULT_CONFIGS}, matching the legacy analyzers' internal merge).
+ *
+ * @param analyzerConfigs - The pipeline's per-analyzer user config overrides.
+ * @returns A `ruleId` → `ThresholdValues` map for every migrated rule.
+ */
+export declare function resolvePhaseThresholds(analyzerConfigs: Readonly<Record<string, Readonly<Record<string, unknown>>>>): ReadonlyMap<string, ThresholdValues>;
+//# sourceMappingURL=config.d.ts.map

package/dist/phase/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/phase/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAC3E,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAYtC"}

package/dist/phase/config.js

@@ -0,0 +1,54 @@
+/**
+ * Spec 68 §11.1 — threshold resolution for the both-paths phase model.
+ *
+ * The migrated rules read *flat* threshold keys with documented fallbacks
+ * (solid's `maxMethodComplexity`, data-access's `joinedTableCount`, …). The
+ * legacy analyzers read the same values through their own namespace config,
+ * default-merged inside `analyzeAST` / `analyzeWithFacts`. To serve a migrated
+ * rule with the *identical* effective value its legacy path would have used,
+ * resolve its thresholds from the same two inputs the analyzer merges — the
+ * runtime default (`RUNTIME_DEFAULT_CONFIGS`) under the user's
+ * `analyzerConfigs` — then flatten the one nested key the rules read flat
+ * (`performanceThresholds.joinedTableCount` → `joinedTableCount`).
+ *
+ * This is the minimal §10 bridge for the transitional state. §10 proper replaces
+ * the dot-path vocabulary and the per-analyzer namespace with the rule/threshold
+ * surface; until then the bridge keeps the two paths bit-identical so the parity
+ * pins and the production count hold.
+ */
+import { MIGRATED_RULES } from './rules/registry.js';
+import { RUNTIME_DEFAULT_CONFIGS } from '../config/effectiveConfig.js';
+/**
+ * Resolve the per-rule threshold map for every migrated rule from the
+ * pipeline's per-analyzer config (user overrides only — defaults come from
+ * {@link RUNTIME_DEFAULT_CONFIGS}, matching the legacy analyzers' internal merge).
+ *
+ * @param analyzerConfigs - The pipeline's per-analyzer user config overrides.
+ * @returns A `ruleId` → `ThresholdValues` map for every migrated rule.
+ */
+export function resolvePhaseThresholds(analyzerConfigs) {
+    const out = new Map();
+    for (const rule of MIGRATED_RULES) {
+        const namespace = rule.analyzer === 'data-access-org-filter' ? 'data-access' : rule.analyzer;
+        const defaults = (RUNTIME_DEFAULT_CONFIGS[namespace] ?? {});
+        const user = (analyzerConfigs[namespace] ?? {});
+        const merged = { ...defaults, ...user };
+        out.set(rule.id, flattenForNamespace(namespace, merged));
+    }
+    return out;
+}
+/**
+ * Project the analyzer's (default-merged) config onto the flat keys the migrated
+ * rules read. Only `data-access` carries a nested knob the rules read flat today.
+ */
+function flattenForNamespace(namespace, config) {
+    if (namespace === 'data-access') {
+        const perf = (config.performanceThresholds ?? {});
+        return {
+            ...config,
+            joinedTableCount: typeof perf.joinedTableCount === 'number' ? perf.joinedTableCount : 4,
+        };
+    }
+    return config;
+}
+//# sourceMappingURL=config.js.map

package/dist/phase/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/phase/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAGvE;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CACpC,eAA4E;IAE5E,MAAM,GAAG,GAAG,IAAI,GAAG,EAA2B,CAAC;IAE/C,KAAK,MAAM,IAAI,IAAI,cAAc,EAAE,CAAC;QAClC,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,KAAK,wBAAwB,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;QAC7F,MAAM,QAAQ,GAAG,CAAC,uBAAuB,CAAC,SAAS,CAAC,IAAI,EAAE,CAA4B,CAAC;QACvF,MAAM,IAAI,GAAG,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,EAAE,CAA4B,CAAC;QAC3E,MAAM,MAAM,GAAG,EAAE,GAAG,QAAQ,EAAE,GAAG,IAAI,EAAE,CAAC;QACxC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,mBAAmB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,SAAS,mBAAmB,CAAC,SAAiB,EAAE,MAA+B;IAC7E,IAAI,SAAS,KAAK,aAAa,EAAE,CAAC;QAChC,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,qBAAqB,IAAI,EAAE,CAA4B,CAAC;QAC7E,OAAO;YACL,GAAG,MAAM;YACT,gBAAgB,EAAE,OAAO,IAAI,CAAC,gBAAgB,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;SACxF,CAAC;IACJ,CAAC;IACD,OAAO,MAAyB,CAAC;AACnC,CAAC"}

package/dist/phase/consumed.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Spec 68 §2.3 residue check #2 — the fact kinds that are actually *read*.
+ *
+ * A fact kind is "consumed" when at least one migrated rule declares it in
+ * `needs.facts`, or at least one corpus processor declares it in `needs`
+ * (upstream facts). `ConsumedFactKind` is derived from those two real sources —
+ * never a hand-written list — so a produced kind that nothing reads fails the
+ * `_allConsumed` assertion in checks.ts rather than being found by hand a week
+ * later (the Spec 63 class: `crossLanguageViolations`, `importersOf`,
+ * `getContentHashesForFiles` were all computed and never read).
+ *
+ * The rule arm reads `MIGRATED_RULES` — whose element type is the *union* of
+ * each rule's `RuleDefinition<N>` (not `RuleDefinition<any>`), because the
+ * array is declared without an `any` annotation. `N` carries the literal tuple
+ * type of `needs.facts`, so the distributive conditional below recovers each
+ * declared fact kind. Widening `MIGRATED_RULES` back to `RuleDefinition<any>[]`
+ * would make `RuleConsumedFactKind` infer `any` and the check vacuous — the
+ * same trap the legacy `RULE_REGISTRY` `Record` view posed, which is why this
+ * check reads the literal view, never an indexable one.
+ */
+import type { MIGRATED_RULES } from './rules/registry.js';
+import { CORPUS_PRODUCERS } from './producers.js';
+/**
+ * Fact kinds declared by the migrated rules' `needs.facts`.
+ *
+ * `(typeof MIGRATED_RULES)[number]` is a union of `RuleDefinition<N>` over the
+ * concrete `Needs` aliases; `infer F` distributes over that union, and `F` is
+ * each rule's `needs.facts` element type. A rule whose `facts` was widened to
+ * `FactKind[]` would contribute the whole vocabulary and mask a real residue —
+ * the conformance test (spec68-consumed-coverage.spec.ts, deleted once this
+ * check became compile-time) pinned the runtime set for exactly that reason.
+ */
+type RuleConsumedFactKind = (typeof MIGRATED_RULES)[number] extends {
+    needs: {
+        facts: readonly (infer F)[];
+    };
+} ? F : never;
+/** Fact kinds a corpus processor consumes as upstream `needs`. */
+type ProcessorConsumedFactKind = {
+    [K in keyof typeof CORPUS_PRODUCERS]: (typeof CORPUS_PRODUCERS)[K] extends {
+        needs: readonly (infer N)[];
+    } ? N : never;
+}[keyof typeof CORPUS_PRODUCERS];
+/** Every fact kind read by at least one migrated rule or corpus processor. */
+export type ConsumedFactKind = RuleConsumedFactKind | ProcessorConsumedFactKind;
+export {};
+//# sourceMappingURL=consumed.d.ts.map

package/dist/phase/consumed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumed.d.ts","sourceRoot":"","sources":["../../src/phase/consumed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;;GASG;AACH,KAAK,oBAAoB,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,SAAS;IAClE,KAAK,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAA;KAAE,CAAC;CACxC,GACG,CAAC,GACD,KAAK,CAAC;AAEV,kEAAkE;AAClE,KAAK,yBAAyB,GAAG;KAC9B,CAAC,IAAI,MAAM,OAAO,gBAAgB,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,SAAS;QAAE,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAA;KAAE,GACtG,CAAC,GACD,KAAK;CACV,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAEjC,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,GAAG,yBAAyB,CAAC"}

package/dist/phase/consumed.js

@@ -0,0 +1,22 @@
+/**
+ * Spec 68 §2.3 residue check #2 — the fact kinds that are actually *read*.
+ *
+ * A fact kind is "consumed" when at least one migrated rule declares it in
+ * `needs.facts`, or at least one corpus processor declares it in `needs`
+ * (upstream facts). `ConsumedFactKind` is derived from those two real sources —
+ * never a hand-written list — so a produced kind that nothing reads fails the
+ * `_allConsumed` assertion in checks.ts rather than being found by hand a week
+ * later (the Spec 63 class: `crossLanguageViolations`, `importersOf`,
+ * `getContentHashesForFiles` were all computed and never read).
+ *
+ * The rule arm reads `MIGRATED_RULES` — whose element type is the *union* of
+ * each rule's `RuleDefinition<N>` (not `RuleDefinition<any>`), because the
+ * array is declared without an `any` annotation. `N` carries the literal tuple
+ * type of `needs.facts`, so the distributive conditional below recovers each
+ * declared fact kind. Widening `MIGRATED_RULES` back to `RuleDefinition<any>[]`
+ * would make `RuleConsumedFactKind` infer `any` and the check vacuous — the
+ * same trap the legacy `RULE_REGISTRY` `Record` view posed, which is why this
+ * check reads the literal view, never an indexable one.
+ */
+export {};
+//# sourceMappingURL=consumed.js.map

package/dist/phase/consumed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumed.js","sourceRoot":"","sources":["../../src/phase/consumed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}