@gobing-ai/ts-rule-engine 0.2.8 → 0.3.0

package/dist/types.js

@@ -22,7 +22,10 @@ export const ConstraintRuleSchema = z.object({
     id: z.string().min(1),
     description: z.string().default(''),
     enabled: z.boolean().default(true),
-    severity: z.enum(['error', 'warning', 'info']).default('error'),
+    // Severity is intentionally NOT defaulted here: an omitted rule severity must
+    // stay absent at parse time so the loader can apply the file-level default
+    // (`rule.severity ?? file.severity ?? 'error'`). Normalization always fills it.
+    severity: z.enum(['error', 'warning', 'info']).optional(),
     evaluator: z.object({
         type: z.string().min(1),
         config: z.record(z.string(), z.unknown()).optional(),
@@ -31,6 +34,35 @@ export const ConstraintRuleSchema = z.object({
     exclude: z.array(z.string()).optional(),
     fix: RuleFixConfigSchema.optional(),
 });
+/**
+ * A relative module path a preset or rule file may load as an extension.
+ *
+ * Rejects absolute paths and `..` traversal: extension declarations are data, and a
+ * path that escapes the declaring file's directory is a trust-boundary violation even
+ * when extension loading is explicitly allowed.
+ */
+const relativeExtensionPath = z
+    .string()
+    .min(1)
+    .refine((value) => !/^([/\\]|[A-Za-z]:[/\\])/.test(value), {
+    message: 'extension path must be relative (no absolute paths)',
+})
+    .refine((value) => !value.split(/[/\\]/).includes('..'), {
+    message: 'extension path must not contain ".." traversal',
+});
+/**
+ * Shared zod schema for an `extensions` block, used by both preset and rule-file
+ * schemas so they validate identically. `.strict()` makes a typo'd or misplaced key
+ * a hard error rather than a silently-ignored field.
+ */
+export const ExtensionsSchema = z
+    .object({
+    resolvers: z.array(relativeExtensionPath).optional(),
+    evaluators: z.array(relativeExtensionPath).optional(),
+    fixers: z.array(relativeExtensionPath).optional(),
+    formatters: z.array(relativeExtensionPath).optional(),
+})
+    .strict();
 /** Zod schema for a constraint rule file. */
 export const ConstraintRuleFileSchema = z.object({
     $schema: z.string().optional(),
@@ -38,6 +70,7 @@ export const ConstraintRuleFileSchema = z.object({
     exclude: z.array(z.string()).optional(),
     severity: z.enum(['error', 'warning', 'info']).optional(),
     rules: z.array(ConstraintRuleSchema),
+    extensions: ExtensionsSchema.optional(),
 });
 /** Zod schema for a preset definition. */
 export const PresetDefinitionSchema = z.object({
@@ -48,12 +81,5 @@ export const PresetDefinitionSchema = z.object({
     overrides: z
         .record(z.string(), z.object({ fix: z.object({ mode: z.enum(['none', 'suggest', 'auto']) }).optional() }))
         .optional(),
-    extensions: z
-        .object({
-        resolvers: z.array(z.string()).optional(),
-        evaluators: z.array(z.string()).optional(),
-        fixers: z.array(z.string()).optional(),
-        formatters: z.array(z.string()).optional(),
-    })
-        .optional(),
+    extensions: ExtensionsSchema.optional(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/ts-rule-engine",
-    "version": "0.2.8",
+    "version": "0.3.0",
     "description": "@gobing-ai/ts-rule-engine — Constraint rule schemas, loading, evaluation, and result formatting.",
     "keywords": [
         "typescript",
@@ -32,6 +32,7 @@
     },
     "files": [
         "dist",
+        "rules",
         "schemas",
         "src",
         "README.md"
@@ -48,8 +49,10 @@
         "release": "echo 'Manual publish is disabled. Releases go through GitHub Actions via Trusted Publishing — push a tag: git tag @gobing-ai/ts-rule-engine-v<version> && git push --tags' && exit 1"
     },
     "dependencies": {
-        "@gobing-ai/ts-ai-runner": "^0.2.8",
-        "@gobing-ai/ts-runtime": "^0.2.8",
+        "@gobing-ai/ts-ai-runner": "^0.3.0",
+        "@gobing-ai/ts-db": "^0.3.0",
+        "@gobing-ai/ts-runtime": "^0.3.0",
+        "@gobing-ai/ts-utils": "^0.3.0",
         "yaml": "^2.7.0",
         "zod": "^4.1.0"
     },

package/rules/quality/coverage-gate.yaml

@@ -0,0 +1,21 @@
+# Coverage gate — per-file line coverage must meet threshold.
+rules:
+  - id: coverage-gate
+    description: "Per-file line coverage meets threshold (read from lcov)"
+    severity: error
+    evaluator:
+      type: coverage-gate
+      config:
+        lcovPath: coverage/lcov.info
+        threshold: 90
+        include:
+          - "apps/**"
+          - "packages/**"
+        exclude:
+          - "**/*.test.ts"
+          - "**/*.test.tsx"
+          - "**/*.spec.ts"
+          - "**/*.spec.tsx"
+          - "**/node_modules/**"
+          - "**/drizzle/**"
+          - "scripts/**"

package/rules/recommended.yaml

@@ -0,0 +1,10 @@
+# Recommended preset — portable rule categories for TypeScript projects.
+# Use with: spur rule run --preset recommended
+#
+# Bundled with @gobing-ai/ts-rule-engine. A project may override individual rule
+# files by placing same-named files under its local .spur/rules/ root.
+name: recommended
+extends:
+  - typescript
+  - structure
+  - quality

package/rules/spur-dev.yaml

@@ -0,0 +1,6 @@
+# Development preset — stricter rules for development workflow.
+# Use with: spur rule run --preset spur-dev --rule coverage-gate --fail-on warning
+name: spur-dev
+extends:
+  - typescript
+  - quality/coverage-gate

package/rules/structure/test-location.yaml

@@ -0,0 +1,38 @@
+# Test location rules — tests must live in tests/ directories mirroring src/.
+# No __tests__ directories, no .test.ts files under src/.
+rules:
+  - id: no-tests-dir
+    description: "Tests must live in tests/ directories at the same level as src/, not in __tests__."
+    severity: error
+    evaluator:
+      type: test-location
+      config:
+        expected: "**/*.test.*"
+        forbid:
+          - "**/__tests__/**"
+          - "**/src/**/*.test.ts"
+          - "**/src/**/*.test.tsx"
+        requireCorrespondingTest: false
+    include:
+      - "packages/**/tests/**/*.test.ts"
+      - "apps/**/tests/**/*.test.ts"
+      - "packages/**/tests/**/*.test.tsx"
+      - "apps/**/tests/**/*.test.tsx"
+
+  - id: require-corresponding-test
+    description: "Every source file must have a corresponding test file in tests/."
+    severity: warning
+    evaluator:
+      type: test-location
+      config:
+        expected: "**/*.test.*"
+        requireCorrespondingTest: true
+    include:
+      - "packages/**/src/**/*.ts"
+      - "apps/**/src/**/*.ts"
+    exclude:
+      - "**/index.ts"
+      - "**/*.d.ts"
+      - "**/types.ts"
+      - "**/node_modules/**"
+      - "**/tests/**"

package/rules/typescript/no-biome-suppressions.yaml

@@ -0,0 +1,23 @@
+# No Biome suppression comments — disallow biome-ignore comments.
+# Lint issues must be fixed at the source, not silenced.
+include:
+  - "packages/**/src/**/*.ts"
+  - "packages/**/src/**/*.tsx"
+  - "apps/**/src/**/*.ts"
+  - "apps/**/src/**/*.tsx"
+  - "packages/**/tests/**/*.ts"
+  - "packages/**/tests/**/*.tsx"
+  - "apps/**/tests/**/*.ts"
+  - "apps/**/tests/**/*.tsx"
+exclude:
+  - "**/node_modules/**"
+rules:
+  - id: no-biome-suppressions
+    description: >
+      Do not use biome-ignore or biome-ignore-all comments to suppress lint
+      rules.  Fix the underlying issue instead.
+    severity: error
+    evaluator:
+      type: regex
+      config:
+        pattern: "biome-ignore"

package/rules/typescript/tsdoc-exports.yaml

@@ -0,0 +1,24 @@
+# TSDoc export rules — every public export must carry a JSDoc comment.
+rules:
+  - id: every-export-has-tsdoc
+    description: "Every export (function, class, interface, type, const, enum) must have a /** ... */ JSDoc comment describing what it is and why."
+    severity: error
+    evaluator:
+      type: tsdoc-export
+      config:
+        kinds:
+          - function
+          - class
+          - interface
+          - type
+          - const
+          - enum
+    include:
+      - "packages/**/src/**/*.ts"
+      - "apps/**/src/**/*.ts"
+    exclude:
+      - "**/index.ts"
+      - "**/node_modules/**"
+      - "**/tests/**"
+      - "**/*.test.ts"
+      - "**/*.test.tsx"

package/schemas/preset.schema.json

@@ -7,7 +7,7 @@
     "required": ["name"],
     "properties": {
         "$schema": { "type": "string" },
-        "name": { "type": "string" },
+        "name": { "type": "string", "minLength": 1 },
         "extends": { "type": "array", "items": { "type": "string" } },
         "disable": { "type": "array", "items": { "type": "string" } },
         "overrides": {
@@ -30,10 +30,24 @@
             "type": "object",
             "additionalProperties": false,
             "properties": {
-                "resolvers": { "type": "array", "items": { "type": "string" } },
-                "evaluators": { "type": "array", "items": { "type": "string" } },
-                "fixers": { "type": "array", "items": { "type": "string" } },
-                "formatters": { "type": "array", "items": { "type": "string" } }
+                "resolvers": { "type": "array", "items": { "$ref": "#/$defs/relativeExtensionPath" } },
+                "evaluators": { "type": "array", "items": { "$ref": "#/$defs/relativeExtensionPath" } },
+                "fixers": { "type": "array", "items": { "$ref": "#/$defs/relativeExtensionPath" } },
+                "formatters": { "type": "array", "items": { "$ref": "#/$defs/relativeExtensionPath" } }
+            }
+        }
+    },
+    "$defs": {
+        "relativeExtensionPath": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Relative module path; absolute paths and '..' traversal are forbidden.",
+            "not": {
+                "anyOf": [
+                    { "pattern": "^[/\\\\]" },
+                    { "pattern": "^[A-Za-z]:[/\\\\]" },
+                    { "pattern": "(^|[/\\\\])\\.\\.([/\\\\]|$)" }
+                ]
             }
         }
     }

package/src/config/extensions.ts

@@ -36,21 +36,22 @@ const HOST_REGISTRY_BY_KIND: Partial<Record<ExtensionKind, 'resolvers' | 'evalua
 };
 
 /**
- * Collect extension refs declared by a preset's `extensions` block.
+ * Collect extension refs declared by a preset's or rule file's `extensions` block.
  *
- * Paths are resolved relative to the preset file's directory. Use the returned
- * refs with {@link loadExtensionsIntoHost}.
+ * Paths are resolved relative to the declaring file's directory. Use the returned
+ * refs with {@link loadExtensionsIntoHost}. Rule files and presets are treated
+ * identically — both flow through the same trust gate at load time.
  */
-export function collectPresetExtensions(
-    presetName: string,
-    presetDir: string,
+export function collectExtensions(
+    sourceName: string,
+    sourceDir: string,
     extensions: Partial<Record<ExtensionKind, string[] | undefined>> | undefined,
 ): ExtensionRef[] {
     if (extensions === undefined) return [];
     const refs: ExtensionRef[] = [];
     for (const kind of ['resolvers', 'evaluators', 'fixers', 'formatters'] as ExtensionKind[]) {
         for (const path of extensions[kind] ?? []) {
-            refs.push({ kind, presetName, absPath: resolve(presetDir, path) });
+            refs.push({ kind, presetName: sourceName, absPath: resolve(sourceDir, path) });
         }
     }
     return refs;

package/src/config/loader.ts

@@ -5,10 +5,11 @@ import {
     type ConstraintRuleFile,
     ConstraintRuleFileSchema,
     ConstraintRuleSchema,
+    type FixMode,
     type PresetDefinition,
     PresetDefinitionSchema,
 } from '../types';
-import { collectPresetExtensions, type ExtensionRef } from './extensions';
+import { collectExtensions, type ExtensionRef } from './extensions';
 
 /** Options for loading rule presets. */
 export interface RuleLoaderOptions {
@@ -62,31 +63,76 @@ export async function loadPreset(name: string, options: RuleLoaderOptions): Prom
     if (presetPath === null) return { rules: [], extensions: [] };
     const preset = PresetDefinitionSchema.parse(await readStructuredFile(presetPath, options)) as PresetDefinition;
     const rules: ConstraintRule[] = [];
-    const extensions = collectPresetExtensions(preset.name, dirname(presetPath), preset.extensions);
+    const extensions = collectExtensions(preset.name, dirname(presetPath), preset.extensions);
     for (const entry of preset.extends) {
         const loaded = await loadPresetEntry(merged, entry, new Set([name]), options);
         rules.push(...loaded.rules);
         extensions.push(...loaded.extensions);
     }
-    const disabled = new Set(preset.disable ?? []);
-    const normalized = rules.filter((rule) => !disabled.has(rule.id));
-    for (const rule of normalized) {
-        const override = preset.overrides?.[rule.id];
+    return { rules: applyPresetControls(preset.name, rules, preset.disable, preset.overrides), extensions };
+}
+
+/** Collapse rules sharing an id to a single entry; later definitions win (last-wins merge). */
+function dedupeById(rules: readonly ConstraintRule[]): ConstraintRule[] {
+    const byId = new Map<string, ConstraintRule>();
+    for (const rule of rules) byId.set(rule.id, rule);
+    return [...byId.values()];
+}
+
+/** Apply a preset's local disable and override controls after composing its children. */
+function applyPresetControls(
+    presetName: string,
+    rules: readonly ConstraintRule[],
+    disabledIds: readonly string[] | undefined,
+    overrides: PresetDefinition['overrides'],
+): ConstraintRule[] {
+    const disabled = new Set(disabledIds ?? []);
+    const controlled = dedupeById(rules).filter((rule) => !disabled.has(rule.id));
+    for (const rule of controlled) {
+        const override = overrides?.[rule.id];
         if (override?.fix !== undefined) {
+            assertFixModeNotPromoted(presetName, rule, override.fix.mode);
             rule.fix = { ...(rule.fix ?? { mode: 'none' }), ...override.fix };
         }
     }
-    return { rules: normalized, extensions };
+    return controlled;
+}
+
+/** Fix-mode authority ordering; an override may lower but never raise a rule's mode. */
+const FIX_MODE_AUTHORITY: Record<FixMode, number> = { none: 0, suggest: 1, auto: 2 };
+
+/** Throw when a preset override would escalate a rule's fix authority above its authored level. */
+function assertFixModeNotPromoted(presetName: string, rule: ConstraintRule, overrideMode: FixMode): void {
+    const ruleMode = rule.fix?.mode ?? 'none';
+    if (FIX_MODE_AUTHORITY[overrideMode] > FIX_MODE_AUTHORITY[ruleMode]) {
+        throw new Error(
+            `Preset "${presetName}" override for rule "${rule.id}" raises fix mode from "${ruleMode}" to "${overrideMode}"; overrides may only lower fix authority`,
+        );
+    }
 }
 
 export async function loadPresetRules(name: string, options: RuleLoaderOptions): Promise<ConstraintRule[]> {
     return (await loadPreset(name, options)).rules;
 }
 
-/** Load a direct rule file from disk. */
-export async function loadRuleFile(filePath: string, options: RuleFileLoadOptions = {}): Promise<ConstraintRule[]> {
+/**
+ * Load a direct rule file from disk.
+ *
+ * Returns the normalized rules plus any extension modules the file declares in an
+ * `extensions` block, resolved to absolute paths. Rule-file extensions are treated
+ * exactly like preset extensions — pass the refs to {@link loadExtensionsIntoHost},
+ * which enforces the same `allowExtensions` trust gate. A single-rule file (one rule
+ * object, not a `rules:` array) cannot declare extensions and yields `extensions: []`.
+ */
+export async function loadRuleFile(filePath: string, options: RuleFileLoadOptions = {}): Promise<LoadedPreset> {
     const resolved = resolve(filePath);
-    return normalizeRuleFile(await readStructuredFile(resolved, options), dirname(resolved));
+    const raw = await readStructuredFile(resolved, options);
+    const rules = normalizeRuleFile(raw, resolved);
+    const parsed = ConstraintRuleFileSchema.safeParse(raw);
+    const extensions = parsed.success
+        ? collectExtensions(basename(resolved), dirname(resolved), parsed.data.extensions)
+        : [];
+    return { rules, extensions };
 }
 
 async function loadPresetEntry(
@@ -105,13 +151,16 @@ async function loadPresetEntry(
         const preset = PresetDefinitionSchema.safeParse(await readStructuredFile(presetPath, options));
         if (preset.success) {
             const rules: ConstraintRule[] = [];
-            const extensions = collectPresetExtensions(preset.data.name, dirname(presetPath), preset.data.extensions);
+            const extensions = collectExtensions(preset.data.name, dirname(presetPath), preset.data.extensions);
             for (const child of preset.data.extends) {
                 const loaded = await loadPresetEntry(merged, child, nextSeen, options);
                 rules.push(...loaded.rules);
                 extensions.push(...loaded.extensions);
             }
-            return { rules: rules.filter((rule) => !(preset.data.disable ?? []).includes(rule.id)), extensions };
+            return {
+                rules: applyPresetControls(preset.data.name, rules, preset.data.disable, preset.data.overrides),
+                extensions,
+            };
         }
     }
 
@@ -119,7 +168,7 @@ async function loadPresetEntry(
     if (merged.categories.has(entry)) {
         const rules: ConstraintRule[] = [];
         for (const absPath of mergedFilesInCategory(merged, entry)) {
-            rules.push(...normalizeRuleFile(await readStructuredFile(absPath, options), dirname(absPath)));
+            rules.push(...normalizeRuleFile(await readStructuredFile(absPath, options), absPath));
         }
         return { rules, extensions: [] };
     }
@@ -128,7 +177,7 @@ async function loadPresetEntry(
     const subPath = findMergedFile(merged, entry);
     if (subPath !== null)
         return {
-            rules: normalizeRuleFile(await readStructuredFile(subPath, options), dirname(subPath)),
+            rules: normalizeRuleFile(await readStructuredFile(subPath, options), subPath),
             extensions: [],
         };
 
@@ -234,25 +283,47 @@ async function readStructuredFile(
     });
 }
 
-function normalizeRuleFile(raw: unknown, sourceDir: string): ConstraintRule[] {
+/** A rule as parsed by Zod: severity may be absent until normalization fills it. */
+type ParsedRule = Omit<ConstraintRule, 'severity'> & { severity?: ConstraintRule['severity'] };
+
+function normalizeRuleFile(raw: unknown, filePath: string): ConstraintRule[] {
+    const sourceDir = dirname(filePath);
     const maybeFile = ConstraintRuleFileSchema.safeParse(raw);
     if (maybeFile.success) return normalizeFileRules(maybeFile.data, sourceDir);
     const maybeRule = ConstraintRuleSchema.safeParse(raw);
-    if (maybeRule.success) return [normalizeRule(maybeRule.data, {}, sourceDir)];
-    throw new Error(`Invalid rule file: ${basename(sourceDir)}`);
+    if (maybeRule.success) return [normalizeRule(maybeRule.data, sourceDir)];
+    // Surface the schema diagnostics that best fit the input: a `rules:` array means
+    // the author intended a rule file, so report against that schema; otherwise the
+    // single-rule schema. Include field paths so the offending key is obvious.
+    const isRuleFileShape = typeof raw === 'object' && raw !== null && 'rules' in raw;
+    const issues = (isRuleFileShape ? maybeFile.error : maybeRule.error).issues;
+    throw new Error(`Invalid rule file "${basename(filePath)}": ${formatIssues(issues)}`);
 }
 
-function normalizeFileRules(file: ConstraintRuleFile, sourceDir: string): ConstraintRule[] {
+/** Render Zod issues as `path: message` fragments for actionable diagnostics. */
+function formatIssues(issues: readonly { path: PropertyKey[]; message: string }[]): string {
+    return issues
+        .map((issue) => {
+            const path = issue.path.map(String).join('.');
+            return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+        })
+        .join('; ');
+}
+
+/** A rule file as parsed by Zod: rule severities may be absent until normalization. */
+type ParsedRuleFile = Omit<ConstraintRuleFile, 'rules'> & { rules: ParsedRule[] };
+
+function normalizeFileRules(file: ParsedRuleFile, sourceDir: string): ConstraintRule[] {
     return file.rules.map((rule) =>
         normalizeRule(
             {
                 ...rule,
-                severity: rule.severity ?? file.severity ?? 'error',
+                // Rule-level severity wins, then the file-level default, then 'error'.
+                severity: rule.severity ?? file.severity,
                 include: rule.include ?? file.include,
                 // File-level excludes always apply; a rule's own excludes add to (not replace) them.
                 exclude: mergeExcludes(file.exclude, rule.exclude),
             },
-            {},
             sourceDir,
         ),
     );
@@ -264,7 +335,7 @@ function mergeExcludes(fileExclude?: string[], ruleExclude?: string[]): string[]
     return [...new Set([...(fileExclude ?? []), ...(ruleExclude ?? [])])];
 }
 
-function normalizeRule(rule: ConstraintRule, _defaults: Partial<ConstraintRule>, _sourceDir: string): ConstraintRule {
+function normalizeRule(rule: ParsedRule, _sourceDir: string): ConstraintRule {
     return {
         ...rule,
         enabled: rule.enabled ?? true,

package/src/engine.ts

@@ -39,26 +39,16 @@ export class RuleEngine {
         this.host.evaluators.register(type, evaluator, 'extension');
     }
 
-    /** Evaluate all enabled rules against a working directory. */
+    /**
+     * Evaluate all enabled rules against a working directory.
+     *
+     * Thin delegate to {@link evaluateWithFixes} with `maxFixMode = 'none'`; the fix
+     * branch in that path is short-circuited by `effectiveFixMode` so callers see only
+     * findings, never auto-generated fixes. Keeps the rule loop and error-finding
+     * semantics in one place.
+     */
     async evaluate(rules: ConstraintRule[], workdir: string): Promise<RuleEngineResult> {
-        const findings: ConstraintFinding[] = [];
-        const fixes: Fix[] = [];
-        for (const rule of rules) {
-            if (rule.enabled === false) continue;
-            try {
-                const result = await this.host.evaluators.get(rule.evaluator.type).evaluate(rule, { rule, workdir });
-                findings.push(...result.findings);
-                fixes.push(...result.fixes);
-            } catch (error) {
-                findings.push(
-                    createFinding(rule, error instanceof Error ? error.message : String(error), null, {
-                        code: `evaluator:${rule.evaluator.type}`,
-                        kind: 'error',
-                    }),
-                );
-            }
-        }
-        return { findings, fixes };
+        return this.evaluateWithFixes(rules, workdir, 'none');
     }
 
     /**

package/src/evaluators/coverage-gate-evaluator.ts

@@ -100,8 +100,8 @@ export class CoverageGateEvaluator implements RuleEvaluator {
 function parseLcov(raw: string): Map<string, FileCoverage> {
     const result = new Map<string, FileCoverage>();
     let file: string | null = null;
-    let linesFound = 0;
-    let linesHit = 0;
+    let linesFound: number | null = 0;
+    let linesHit: number | null = 0;
     for (const line of raw.split('\n')) {
         const trimmed = line.trim();
         if (trimmed.startsWith('SF:')) {
@@ -109,17 +109,27 @@ function parseLcov(raw: string): Map<string, FileCoverage> {
             linesFound = 0;
             linesHit = 0;
         } else if (trimmed.startsWith('LF:')) {
-            linesFound = Number(trimmed.slice(3));
+            linesFound = parseCount(trimmed.slice(3));
         } else if (trimmed.startsWith('LH:')) {
-            linesHit = Number(trimmed.slice(3));
+            linesHit = parseCount(trimmed.slice(3));
         } else if (trimmed === 'end_of_record' && file !== null) {
-            result.set(file, { linesFound, linesHit });
+            // Skip records with malformed counts: a non-numeric LF:/LH: would
+            // otherwise yield NaN coverage and a spurious below-threshold finding.
+            if (linesFound !== null && linesHit !== null) {
+                result.set(file, { linesFound, linesHit });
+            }
             file = null;
         }
     }
     return result;
 }
 
+/** Parse an lcov count field; return null for non-finite or negative values. */
+function parseCount(raw: string): number | null {
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
 /** Standard exclusions applied regardless of config (tests, generated, deps). */
 function isAlwaysExcluded(filePath: string): boolean {
     return (