@pyreon/lint 0.11.5 → 0.11.7

package/src/tests/runner.test.ts

@@ -1,15 +1,15 @@
-import { AstCache } from "../cache"
-import { createIgnoreFilter } from "../config/ignore"
-import { loadConfig } from "../config/loader"
-import { getPreset } from "../config/presets"
-import { allRules } from "../rules/index"
-import { applyFixes, lintFile } from "../runner"
-import type { LintConfig, Rule } from "../types"
-import { LineIndex } from "../utils/source"
+import { AstCache } from '../cache'
+import { createIgnoreFilter } from '../config/ignore'
+import { loadConfig } from '../config/loader'
+import { getPreset } from '../config/presets'
+import { allRules } from '../rules/index'
+import { applyFixes, lintFile } from '../runner'
+import type { LintConfig, Rule } from '../types'
+import { LineIndex } from '../utils/source'
 
 // Helper to create a config that enables all rules at default severity
 function defaultConfig(): LintConfig {
-  return getPreset("recommended")
+  return getPreset('recommended')
 }
 
 // Helper to lint a string with specific rules
@@ -18,7 +18,7 @@ function lintSource(
   rules?: Rule[],
   filePath?: string,
 ): ReturnType<typeof lintFile> {
-  return lintFile(filePath ?? "test.tsx", source, rules ?? allRules, defaultConfig())
+  return lintFile(filePath ?? 'test.tsx', source, rules ?? allRules, defaultConfig())
 }
 
 // Helper to find diagnostics by rule ID
@@ -30,54 +30,54 @@ function findByRule(result: ReturnType<typeof lintFile>, ruleId: string) {
 function lintWith(ruleId: string, source: string, filePath?: string) {
   const rule = allRules.find((r) => r.meta.id === ruleId)
   if (!rule) throw new Error(`Rule not found: ${ruleId}`)
-  return lintFile(filePath ?? "test.tsx", source, [rule], defaultConfig())
+  return lintFile(filePath ?? 'test.tsx', source, [rule], defaultConfig())
 }
 
 // ── Rule Metadata ───────────────────────────────────────────────────────────
 
-describe("Rule metadata", () => {
-  it("should have 55 rules", () => {
-    expect(allRules.length).toBe(55)
+describe('Rule metadata', () => {
+  it('should have 56 rules', () => {
+    expect(allRules.length).toBe(56)
   })
 
-  it("should have unique rule IDs", () => {
+  it('should have unique rule IDs', () => {
     const ids = allRules.map((r) => r.meta.id)
     const unique = new Set(ids)
     expect(unique.size).toBe(ids.length)
   })
 
-  it("all rule IDs should start with pyreon/", () => {
+  it('all rule IDs should start with pyreon/', () => {
     for (const rule of allRules) {
       expect(rule.meta.id).toMatch(/^pyreon\//)
     }
   })
 
-  it("all rules should have valid categories", () => {
+  it('all rules should have valid categories', () => {
     const validCategories = new Set([
-      "reactivity",
-      "jsx",
-      "lifecycle",
-      "performance",
-      "ssr",
-      "architecture",
-      "store",
-      "form",
-      "styling",
-      "hooks",
-      "accessibility",
-      "router",
+      'reactivity',
+      'jsx',
+      'lifecycle',
+      'performance',
+      'ssr',
+      'architecture',
+      'store',
+      'form',
+      'styling',
+      'hooks',
+      'accessibility',
+      'router',
     ])
     for (const rule of allRules) {
       expect(validCategories.has(rule.meta.category)).toBe(true)
     }
   })
 
-  it("should have correct category counts", () => {
+  it('should have correct category counts', () => {
     const counts: Record<string, number> = {}
     for (const rule of allRules) {
       counts[rule.meta.category] = (counts[rule.meta.category] ?? 0) + 1
     }
-    expect(counts.reactivity).toBe(8)
+    expect(counts.reactivity).toBe(9)
     expect(counts.jsx).toBe(11)
     expect(counts.lifecycle).toBe(4)
     expect(counts.performance).toBe(4)
@@ -94,25 +94,25 @@ describe("Rule metadata", () => {
 
 // ── Runner Basics ───────────────────────────────────────────────────────────
 
-describe("Runner", () => {
-  it("should parse valid TypeScript/JSX", () => {
+describe('Runner', () => {
+  it('should parse valid TypeScript/JSX', () => {
     const result = lintSource(`const x = 1`)
     expect(result.diagnostics).toBeDefined()
   })
 
-  it("should skip non-JS files", () => {
-    const result = lintFile("test.css", "body { color: red }", allRules, defaultConfig())
+  it('should skip non-JS files', () => {
+    const result = lintFile('test.css', 'body { color: red }', allRules, defaultConfig())
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("should sort diagnostics by position", () => {
+  it('should sort diagnostics by position', () => {
     const source = `
 const a = signal(0)
 const b = signal(0)
 // These are just declared, not used
 `
-    const rule = allRules.find((r) => r.meta.id === "pyreon/no-signal-leak")
-    if (!rule) throw new Error("Rule not found")
+    const rule = allRules.find((r) => r.meta.id === 'pyreon/no-signal-leak')
+    if (!rule) throw new Error('Rule not found')
     const result = lintSource(source, [rule])
     if (result.diagnostics.length >= 2) {
       const first = result.diagnostics[0]
@@ -123,11 +123,11 @@ const b = signal(0)
     }
   })
 
-  it("should apply fixes in reverse order", () => {
+  it('should apply fixes in reverse order', () => {
     const source = `<div className="a" htmlFor="b" />`
     const result = lintSource(source)
-    const classnameDiags = findByRule(result, "pyreon/no-classname")
-    const htmlforDiags = findByRule(result, "pyreon/no-htmlfor")
+    const classnameDiags = findByRule(result, 'pyreon/no-classname')
+    const htmlforDiags = findByRule(result, 'pyreon/no-htmlfor')
 
     // Both should be fixable
     expect(classnameDiags.length).toBeGreaterThanOrEqual(1)
@@ -136,292 +136,292 @@ const b = signal(0)
     expect(htmlforDiags[0]?.fix).toBeDefined()
 
     const fixed = applyFixes(source, result.diagnostics)
-    expect(fixed).toContain("class=")
-    expect(fixed).toContain("for=")
-    expect(fixed).not.toContain("className")
-    expect(fixed).not.toContain("htmlFor")
+    expect(fixed).toContain('class=')
+    expect(fixed).toContain('for=')
+    expect(fixed).not.toContain('className')
+    expect(fixed).not.toContain('htmlFor')
   })
 
-  it("should use AST cache when provided", () => {
+  it('should use AST cache when provided', () => {
     const cache = new AstCache()
     const source = `const x = 1`
     const config = defaultConfig()
 
     // First lint populates cache
-    lintFile("test.ts", source, allRules, config, cache)
+    lintFile('test.ts', source, allRules, config, cache)
     expect(cache.size).toBe(1)
 
     // Second lint reuses cache
-    lintFile("test.ts", source, allRules, config, cache)
+    lintFile('test.ts', source, allRules, config, cache)
     expect(cache.size).toBe(1)
   })
 })
 
 // ── Source Utilities ─────────────────────────────────────────────────────────
 
-describe("LineIndex", () => {
-  it("should compute line/column for single-line source", () => {
-    const idx = new LineIndex("hello world")
+describe('LineIndex', () => {
+  it('should compute line/column for single-line source', () => {
+    const idx = new LineIndex('hello world')
     expect(idx.locate(0)).toEqual({ line: 1, column: 0 })
     expect(idx.locate(5)).toEqual({ line: 1, column: 5 })
   })
 
-  it("should compute line/column for multi-line source", () => {
-    const idx = new LineIndex("line1\nline2\nline3")
+  it('should compute line/column for multi-line source', () => {
+    const idx = new LineIndex('line1\nline2\nline3')
     expect(idx.locate(0)).toEqual({ line: 1, column: 0 })
     expect(idx.locate(6)).toEqual({ line: 2, column: 0 })
     expect(idx.locate(12)).toEqual({ line: 3, column: 0 })
     expect(idx.locate(8)).toEqual({ line: 2, column: 2 })
   })
 
-  it("should handle empty source", () => {
-    const idx = new LineIndex("")
+  it('should handle empty source', () => {
+    const idx = new LineIndex('')
     expect(idx.locate(0)).toEqual({ line: 1, column: 0 })
   })
 })
 
 // ── AST Cache ──────────────────────────────────────────────────────────────
 
-describe("AstCache", () => {
-  it("should store and retrieve entries", () => {
+describe('AstCache', () => {
+  it('should store and retrieve entries', () => {
     const cache = new AstCache()
-    const lineIndex = new LineIndex("test")
-    const program = { type: "Program" }
+    const lineIndex = new LineIndex('test')
+    const program = { type: 'Program' }
 
-    cache.set("test", { program, lineIndex })
+    cache.set('test', { program, lineIndex })
     expect(cache.size).toBe(1)
 
-    const result = cache.get("test")
+    const result = cache.get('test')
     expect(result).toBeDefined()
     expect(result!.program).toBe(program)
   })
 
-  it("should return undefined for missing entries", () => {
+  it('should return undefined for missing entries', () => {
     const cache = new AstCache()
-    expect(cache.get("missing")).toBeUndefined()
+    expect(cache.get('missing')).toBeUndefined()
   })
 
-  it("should clear all entries", () => {
+  it('should clear all entries', () => {
     const cache = new AstCache()
-    const lineIndex = new LineIndex("a")
-    cache.set("a", { program: {}, lineIndex })
-    cache.set("b", { program: {}, lineIndex })
+    const lineIndex = new LineIndex('a')
+    cache.set('a', { program: {}, lineIndex })
+    cache.set('b', { program: {}, lineIndex })
     expect(cache.size).toBe(2)
 
     cache.clear()
     expect(cache.size).toBe(0)
   })
 
-  it("should use content-based keys (different content = different entry)", () => {
+  it('should use content-based keys (different content = different entry)', () => {
     const cache = new AstCache()
-    const lineIndex = new LineIndex("a")
-    cache.set("content1", { program: { id: 1 }, lineIndex })
-    cache.set("content2", { program: { id: 2 }, lineIndex })
+    const lineIndex = new LineIndex('a')
+    cache.set('content1', { program: { id: 1 }, lineIndex })
+    cache.set('content2', { program: { id: 2 }, lineIndex })
     expect(cache.size).toBe(2)
   })
 })
 
 // ── Reactivity Rules ────────────────────────────────────────────────────────
 
-describe("Reactivity rules", () => {
-  it("pyreon/no-bare-signal-in-jsx: flags {count()} in JSX", () => {
+describe('Reactivity rules', () => {
+  it('pyreon/no-bare-signal-in-jsx: flags {count()} in JSX', () => {
     const source = `const App = () => <div>{count()}</div>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-bare-signal-in-jsx")
+    const diags = findByRule(result, 'pyreon/no-bare-signal-in-jsx')
     expect(diags.length).toBe(1)
     expect(diags[0]?.fix).toBeDefined()
   })
 
-  it("pyreon/no-bare-signal-in-jsx: skips PascalCase and use* calls", () => {
+  it('pyreon/no-bare-signal-in-jsx: skips PascalCase and use* calls', () => {
     const source = `const App = () => <div>{MyComponent()}{useTheme()}</div>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-bare-signal-in-jsx")
+    const diags = findByRule(result, 'pyreon/no-bare-signal-in-jsx')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-signal-in-loop: flags signal inside for loop", () => {
+  it('pyreon/no-signal-in-loop: flags signal inside for loop', () => {
     const source = `for (let i = 0; i < 10; i++) { const s = signal(0) }`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-signal-in-loop")
+    const diags = findByRule(result, 'pyreon/no-signal-in-loop')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-signal-in-loop: clean when outside loop", () => {
+  it('pyreon/no-signal-in-loop: clean when outside loop', () => {
     const source = `const s = signal(0)`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-signal-in-loop")
+    const diags = findByRule(result, 'pyreon/no-signal-in-loop')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-nested-effect: flags effect inside effect", () => {
+  it('pyreon/no-nested-effect: flags effect inside effect', () => {
     const source = `effect(() => { effect(() => {}) })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-nested-effect")
+    const diags = findByRule(result, 'pyreon/no-nested-effect')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-peek-in-tracked: flags .peek() inside effect", () => {
+  it('pyreon/no-peek-in-tracked: flags .peek() inside effect', () => {
     const source = `effect(() => { const v = x.peek() })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-peek-in-tracked")
+    const diags = findByRule(result, 'pyreon/no-peek-in-tracked')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-unbatched-updates: flags 3+ .set() without batch", () => {
+  it('pyreon/no-unbatched-updates: flags 3+ .set() without batch', () => {
     const source = `function update() { a.set(1); b.set(2); c.set(3) }`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-unbatched-updates")
+    const diags = findByRule(result, 'pyreon/no-unbatched-updates')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-unbatched-updates: clean with batch", () => {
+  it('pyreon/no-unbatched-updates: clean with batch', () => {
     const source = `function update() { batch(() => { a.set(1); b.set(2); c.set(3) }) }`
     const result = lintSource(source)
     // The outer function has batch, so no warning on it
     // The inner arrow gets checked too but has no .set() calls directly
-    const diags = findByRule(result, "pyreon/no-unbatched-updates")
+    const diags = findByRule(result, 'pyreon/no-unbatched-updates')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/prefer-computed: flags effect with single .set()", () => {
+  it('pyreon/prefer-computed: flags effect with single .set()', () => {
     const source = `effect(() => { x.set(a() + b()) })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/prefer-computed")
+    const diags = findByRule(result, 'pyreon/prefer-computed')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-effect-assignment: flags effect with single .update()", () => {
+  it('pyreon/no-effect-assignment: flags effect with single .update()', () => {
     const source = `effect(() => { x.update(v => v + 1) })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-effect-assignment")
+    const diags = findByRule(result, 'pyreon/no-effect-assignment')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-signal-leak: flags unused signal declarations", () => {
+  it('pyreon/no-signal-leak: flags unused signal declarations', () => {
     const source = `const unused = signal(0)`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-signal-leak")
+    const diags = findByRule(result, 'pyreon/no-signal-leak')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-signal-leak: clean when signal is used", () => {
+  it('pyreon/no-signal-leak: clean when signal is used', () => {
     const source = `const count = signal(0)\nconst double = computed(() => count() * 2)`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-signal-leak")
+    const diags = findByRule(result, 'pyreon/no-signal-leak')
     expect(diags.length).toBe(0)
   })
 })
 
 // ── JSX Rules ───────────────────────────────────────────────────────────────
 
-describe("JSX rules", () => {
-  it("pyreon/no-map-in-jsx: flags .map() in JSX", () => {
+describe('JSX rules', () => {
+  it('pyreon/no-map-in-jsx: flags .map() in JSX', () => {
     const source = `const App = () => <ul>{items.map(i => <li>{i}</li>)}</ul>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-map-in-jsx")
+    const diags = findByRule(result, 'pyreon/no-map-in-jsx')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/use-by-not-key: flags key on <For>", () => {
+  it('pyreon/use-by-not-key: flags key on <For>', () => {
     const source = `const App = () => <For each={items} key={r => r.id}>{r => <li />}</For>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/use-by-not-key")
+    const diags = findByRule(result, 'pyreon/use-by-not-key')
     expect(diags.length).toBe(1)
     expect(diags[0]?.fix).toBeDefined()
   })
 
-  it("pyreon/no-classname: flags className and fixes to class", () => {
+  it('pyreon/no-classname: flags className and fixes to class', () => {
     const source = `const App = () => <div className="foo" />`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-classname")
+    const diags = findByRule(result, 'pyreon/no-classname')
     expect(diags.length).toBe(1)
     expect(diags[0]?.fix).toBeDefined()
   })
 
-  it("pyreon/no-htmlfor: flags htmlFor and fixes to for", () => {
+  it('pyreon/no-htmlfor: flags htmlFor and fixes to for', () => {
     const source = `const App = () => <label htmlFor="name" />`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-htmlfor")
+    const diags = findByRule(result, 'pyreon/no-htmlfor')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-onchange: flags onChange on input", () => {
+  it('pyreon/no-onchange: flags onChange on input', () => {
     const source = `const App = () => <input onChange={handler} />`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-onchange")
+    const diags = findByRule(result, 'pyreon/no-onchange')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-onchange: clean on non-input elements", () => {
+  it('pyreon/no-onchange: clean on non-input elements', () => {
     const source = `const App = () => <div onChange={handler} />`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-onchange")
+    const diags = findByRule(result, 'pyreon/no-onchange')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-ternary-conditional: flags ternary with JSX", () => {
+  it('pyreon/no-ternary-conditional: flags ternary with JSX', () => {
     const source = `const App = () => <div>{flag ? <span>a</span> : <span>b</span>}</div>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-ternary-conditional")
+    const diags = findByRule(result, 'pyreon/no-ternary-conditional')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-and-conditional: flags && with JSX", () => {
+  it('pyreon/no-and-conditional: flags && with JSX', () => {
     const source = `const App = () => <div>{flag && <span>yes</span>}</div>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-and-conditional")
+    const diags = findByRule(result, 'pyreon/no-and-conditional')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-missing-for-by: flags <For> without by", () => {
+  it('pyreon/no-missing-for-by: flags <For> without by', () => {
     const source = `const App = () => <For each={items}>{r => <li />}</For>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-missing-for-by")
+    const diags = findByRule(result, 'pyreon/no-missing-for-by')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-missing-for-by: clean when by is present", () => {
+  it('pyreon/no-missing-for-by: clean when by is present', () => {
     const source = `const App = () => <For each={items} by={r => r.id}>{r => <li />}</For>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-missing-for-by")
+    const diags = findByRule(result, 'pyreon/no-missing-for-by')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-props-destructure: flags destructured props in component", () => {
+  it('pyreon/no-props-destructure: flags destructured props in component', () => {
     const source = `const App = ({ name }) => <div>{name}</div>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-props-destructure")
+    const diags = findByRule(result, 'pyreon/no-props-destructure')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-props-destructure: clean for non-component functions", () => {
+  it('pyreon/no-props-destructure: clean for non-component functions', () => {
     const source = `const fn = ({ a, b }) => a + b`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-props-destructure")
+    const diags = findByRule(result, 'pyreon/no-props-destructure')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-index-as-by: flags by={(_, i) => i}", () => {
+  it('pyreon/no-index-as-by: flags by={(_, i) => i}', () => {
     const source = `const App = () => <For each={items} by={(_, i) => i}>{r => <li />}</For>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-index-as-by")
+    const diags = findByRule(result, 'pyreon/no-index-as-by')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-children-access: flags props.children in renderer file", () => {
+  it('pyreon/no-children-access: flags props.children in renderer file', () => {
     const result = lintWith(
-      "pyreon/no-children-access",
+      'pyreon/no-children-access',
       `import { renderToString } from "@pyreon/runtime-server"\nconst c = props.children`,
-      "renderer.ts",
+      'renderer.ts',
     )
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/no-children-access: clean in non-renderer file", () => {
+  it('pyreon/no-children-access: clean in non-renderer file', () => {
     const result = lintWith(
-      "pyreon/no-children-access",
+      'pyreon/no-children-access',
       `const c = props.children`,
-      "component.tsx",
+      'component.tsx',
     )
     expect(result.diagnostics.length).toBe(0)
   })
@@ -429,110 +429,110 @@ describe("JSX rules", () => {
 
 // ── Lifecycle Rules ─────────────────────────────────────────────────────────
 
-describe("Lifecycle rules", () => {
-  it("pyreon/no-missing-cleanup: flags onMount with setInterval and no return", () => {
+describe('Lifecycle rules', () => {
+  it('pyreon/no-missing-cleanup: flags onMount with setInterval and no return', () => {
     const source = `onMount(() => { setInterval(() => {}, 1000) })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-missing-cleanup")
+    const diags = findByRule(result, 'pyreon/no-missing-cleanup')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-missing-cleanup: clean when onMount returns cleanup", () => {
+  it('pyreon/no-missing-cleanup: clean when onMount returns cleanup', () => {
     const source = `onMount(() => { const id = setInterval(() => {}, 1000); return () => clearInterval(id) })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-missing-cleanup")
+    const diags = findByRule(result, 'pyreon/no-missing-cleanup')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-mount-in-effect: flags onMount inside effect", () => {
+  it('pyreon/no-mount-in-effect: flags onMount inside effect', () => {
     const source = `effect(() => { onMount(() => {}) })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-mount-in-effect")
+    const diags = findByRule(result, 'pyreon/no-mount-in-effect')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-effect-in-mount: flags effect inside onMount", () => {
+  it('pyreon/no-effect-in-mount: flags effect inside onMount', () => {
     const source = `onMount(() => { effect(() => {}) })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-effect-in-mount")
+    const diags = findByRule(result, 'pyreon/no-effect-in-mount')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-dom-in-setup: flags document.querySelector outside onMount", () => {
+  it('pyreon/no-dom-in-setup: flags document.querySelector outside onMount', () => {
     const source = `const el = document.querySelector(".app")`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-dom-in-setup")
+    const diags = findByRule(result, 'pyreon/no-dom-in-setup')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-dom-in-setup: clean inside onMount", () => {
+  it('pyreon/no-dom-in-setup: clean inside onMount', () => {
     const source = `onMount(() => { document.querySelector(".app") })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-dom-in-setup")
+    const diags = findByRule(result, 'pyreon/no-dom-in-setup')
     expect(diags.length).toBe(0)
   })
 })
 
 // ── Performance Rules ───────────────────────────────────────────────────────
 
-describe("Performance rules", () => {
-  it("pyreon/no-eager-import: flags static import of heavy packages", () => {
+describe('Performance rules', () => {
+  it('pyreon/no-eager-import: flags static import of heavy packages', () => {
     const source = `import { Chart } from "@pyreon/charts"`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-eager-import")
+    const diags = findByRule(result, 'pyreon/no-eager-import')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-eager-import: clean for lightweight packages", () => {
+  it('pyreon/no-eager-import: clean for lightweight packages', () => {
     const source = `import { signal } from "@pyreon/reactivity"`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-eager-import")
+    const diags = findByRule(result, 'pyreon/no-eager-import')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-effect-in-for: flags effect() inside <For>", () => {
+  it('pyreon/no-effect-in-for: flags effect() inside <For>', () => {
     const result = lintWith(
-      "pyreon/no-effect-in-for",
+      'pyreon/no-effect-in-for',
       `const App = () => <For each={items}>{r => { effect(() => {}); return <li /> }}</For>`,
     )
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/no-effect-in-for: clean when effect is outside <For>", () => {
+  it('pyreon/no-effect-in-for: clean when effect is outside <For>', () => {
     const result = lintWith(
-      "pyreon/no-effect-in-for",
+      'pyreon/no-effect-in-for',
       `effect(() => {})\nconst App = () => <For each={items}>{r => <li />}</For>`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-large-for-without-by: flags <For> without by prop", () => {
+  it('pyreon/no-large-for-without-by: flags <For> without by prop', () => {
     const result = lintWith(
-      "pyreon/no-large-for-without-by",
+      'pyreon/no-large-for-without-by',
       `const App = () => <For each={items}>{r => <li />}</For>`,
     )
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/no-large-for-without-by: clean with by prop", () => {
+  it('pyreon/no-large-for-without-by: clean with by prop', () => {
     const result = lintWith(
-      "pyreon/no-large-for-without-by",
+      'pyreon/no-large-for-without-by',
       `const App = () => <For each={items} by={r => r.id}>{r => <li />}</For>`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/prefer-show-over-display: flags conditional display style", () => {
+  it('pyreon/prefer-show-over-display: flags conditional display style', () => {
     const result = lintWith(
-      "pyreon/prefer-show-over-display",
+      'pyreon/prefer-show-over-display',
       `const App = () => <div style={{ display: visible ? "block" : "none" }} />`,
     )
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/prefer-show-over-display: clean with static display", () => {
+  it('pyreon/prefer-show-over-display: clean with static display', () => {
     const result = lintWith(
-      "pyreon/prefer-show-over-display",
+      'pyreon/prefer-show-over-display',
       `const App = () => <div style={{ display: "block" }} />`,
     )
     expect(result.diagnostics.length).toBe(0)
@@ -541,248 +541,248 @@ describe("Performance rules", () => {
 
 // ── SSR Rules ───────────────────────────────────────────────────────────────
 
-describe("SSR rules", () => {
-  it("pyreon/no-window-in-ssr: flags window outside onMount", () => {
+describe('SSR rules', () => {
+  it('pyreon/no-window-in-ssr: flags window outside onMount', () => {
     const source = `const w = window.innerWidth`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-window-in-ssr")
+    const diags = findByRule(result, 'pyreon/no-window-in-ssr')
     expect(diags.length).toBeGreaterThanOrEqual(1)
   })
 
-  it("pyreon/no-window-in-ssr: clean inside onMount", () => {
+  it('pyreon/no-window-in-ssr: clean inside onMount', () => {
     const source = `onMount(() => { const w = window.innerWidth })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-window-in-ssr")
+    const diags = findByRule(result, 'pyreon/no-window-in-ssr')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-window-in-ssr: clean with typeof guard", () => {
+  it('pyreon/no-window-in-ssr: clean with typeof guard', () => {
     const source = `if (typeof window !== "undefined") { const w = window.innerWidth }`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-window-in-ssr")
+    const diags = findByRule(result, 'pyreon/no-window-in-ssr')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-mismatch-risk: flags Date.now() in JSX", () => {
+  it('pyreon/no-mismatch-risk: flags Date.now() in JSX', () => {
     const source = `const App = () => <div>{Date.now()}</div>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-mismatch-risk")
+    const diags = findByRule(result, 'pyreon/no-mismatch-risk')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/prefer-request-context: flags module-level signal in server file", () => {
+  it('pyreon/prefer-request-context: flags module-level signal in server file', () => {
     const source = `const state = signal(0)`
-    const result = lintFile("app.server.ts", source, allRules, defaultConfig())
-    const diags = findByRule(result, "pyreon/prefer-request-context")
+    const result = lintFile('app.server.ts', source, allRules, defaultConfig())
+    const diags = findByRule(result, 'pyreon/prefer-request-context')
     expect(diags.length).toBe(1)
   })
 })
 
 // ── Architecture Rules ──────────────────────────────────────────────────────
 
-describe("Architecture rules", () => {
-  it("pyreon/no-deep-import: flags @pyreon/*/src/ imports", () => {
+describe('Architecture rules', () => {
+  it('pyreon/no-deep-import: flags @pyreon/*/src/ imports', () => {
     const source = `import { something } from "@pyreon/core/src/signal"`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-deep-import")
+    const diags = findByRule(result, 'pyreon/no-deep-import')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-deep-import: clean for normal imports", () => {
+  it('pyreon/no-deep-import: clean for normal imports', () => {
     const source = `import { signal } from "@pyreon/reactivity"`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-deep-import")
+    const diags = findByRule(result, 'pyreon/no-deep-import')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/dev-guard-warnings: flags console.warn without __DEV__", () => {
+  it('pyreon/dev-guard-warnings: flags console.warn without __DEV__', () => {
     const source = `console.warn("something")`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/dev-guard-warnings")
+    const diags = findByRule(result, 'pyreon/dev-guard-warnings')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/dev-guard-warnings: clean inside __DEV__ guard", () => {
+  it('pyreon/dev-guard-warnings: clean inside __DEV__ guard', () => {
     const source = `if (__DEV__) { console.warn("something") }`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/dev-guard-warnings")
+    const diags = findByRule(result, 'pyreon/dev-guard-warnings')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/dev-guard-warnings: clean in test files", () => {
+  it('pyreon/dev-guard-warnings: clean in test files', () => {
     const source = `console.warn("test warning")`
-    const result = lintFile("src/tests/foo.test.ts", source, allRules, defaultConfig())
-    const diags = findByRule(result, "pyreon/dev-guard-warnings")
+    const result = lintFile('src/tests/foo.test.ts', source, allRules, defaultConfig())
+    const diags = findByRule(result, 'pyreon/dev-guard-warnings')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-error-without-prefix: flags throw without [Pyreon]", () => {
+  it('pyreon/no-error-without-prefix: flags throw without [Pyreon]', () => {
     const source = `throw new Error("something went wrong")`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-error-without-prefix")
+    const diags = findByRule(result, 'pyreon/no-error-without-prefix')
     expect(diags.length).toBe(1)
     expect(diags[0]?.fix).toBeDefined()
   })
 
-  it("pyreon/no-error-without-prefix: clean with [Pyreon] prefix", () => {
+  it('pyreon/no-error-without-prefix: clean with [Pyreon] prefix', () => {
     const source = `throw new Error("[Pyreon] something went wrong")`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-error-without-prefix")
+    const diags = findByRule(result, 'pyreon/no-error-without-prefix')
     expect(diags.length).toBe(0)
   })
 })
 
 // ── Store Rules ─────────────────────────────────────────────────────────────
 
-describe("Store rules", () => {
-  it("pyreon/no-duplicate-store-id: flags duplicate IDs", () => {
+describe('Store rules', () => {
+  it('pyreon/no-duplicate-store-id: flags duplicate IDs', () => {
     const source = `
 defineStore("counter", () => {})
 defineStore("counter", () => {})
 `
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-duplicate-store-id")
+    const diags = findByRule(result, 'pyreon/no-duplicate-store-id')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-duplicate-store-id: clean with unique IDs", () => {
+  it('pyreon/no-duplicate-store-id: clean with unique IDs', () => {
     const source = `
 defineStore("counter", () => {})
 defineStore("user", () => {})
 `
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-duplicate-store-id")
+    const diags = findByRule(result, 'pyreon/no-duplicate-store-id')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-mutate-store-state: flags store.signal.set()", () => {
-    const result = lintWith("pyreon/no-mutate-store-state", `userStore.count.set(5)`)
+  it('pyreon/no-mutate-store-state: flags store.signal.set()', () => {
+    const result = lintWith('pyreon/no-mutate-store-state', `userStore.count.set(5)`)
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/no-mutate-store-state: clean for non-store .set()", () => {
-    const result = lintWith("pyreon/no-mutate-store-state", `count.set(5)`)
+  it('pyreon/no-mutate-store-state: clean for non-store .set()', () => {
+    const result = lintWith('pyreon/no-mutate-store-state', `count.set(5)`)
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-store-outside-provider: flags store hooks in server files without provider", () => {
+  it('pyreon/no-store-outside-provider: flags store hooks in server files without provider', () => {
     const result = lintWith(
-      "pyreon/no-store-outside-provider",
+      'pyreon/no-store-outside-provider',
       `useCounterStore()`,
-      "app.server.ts",
+      'app.server.ts',
     )
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/no-store-outside-provider: clean when provider is imported", () => {
+  it('pyreon/no-store-outside-provider: clean when provider is imported', () => {
     const result = lintWith(
-      "pyreon/no-store-outside-provider",
+      'pyreon/no-store-outside-provider',
       `import { runWithRequestContext } from "@pyreon/reactivity"\nuseCounterStore()`,
-      "app.server.ts",
+      'app.server.ts',
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-store-outside-provider: clean in non-server files", () => {
-    const result = lintWith("pyreon/no-store-outside-provider", `useCounterStore()`, "app.tsx")
+  it('pyreon/no-store-outside-provider: clean in non-server files', () => {
+    const result = lintWith('pyreon/no-store-outside-provider', `useCounterStore()`, 'app.tsx')
     expect(result.diagnostics.length).toBe(0)
   })
 })
 
 // ── Form Rules ──────────────────────────────────────────────────────────────
 
-describe("Form rules", () => {
-  it("pyreon/no-submit-without-validation: flags useForm with onSubmit but no validators", () => {
+describe('Form rules', () => {
+  it('pyreon/no-submit-without-validation: flags useForm with onSubmit but no validators', () => {
     const source = `const form = useForm({ initialValues: {}, onSubmit: () => {} })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-submit-without-validation")
+    const diags = findByRule(result, 'pyreon/no-submit-without-validation')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-submit-without-validation: clean with validators", () => {
+  it('pyreon/no-submit-without-validation: clean with validators', () => {
     const source = `const form = useForm({ initialValues: {}, onSubmit: () => {}, validators: {} })`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-submit-without-validation")
+    const diags = findByRule(result, 'pyreon/no-submit-without-validation')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/no-unregistered-field: flags useField without register()", () => {
-    const result = lintWith("pyreon/no-unregistered-field", `const name = useField(form, "name")`)
+  it('pyreon/no-unregistered-field: flags useField without register()', () => {
+    const result = lintWith('pyreon/no-unregistered-field', `const name = useField(form, "name")`)
     expect(result.diagnostics.length).toBe(1)
-    expect(result.diagnostics[0]!.message).toContain("register")
+    expect(result.diagnostics[0]!.message).toContain('register')
   })
 
-  it("pyreon/no-unregistered-field: clean when register is called", () => {
+  it('pyreon/no-unregistered-field: clean when register is called', () => {
     const result = lintWith(
-      "pyreon/no-unregistered-field",
+      'pyreon/no-unregistered-field',
       `const name = useField(form, "name")\nname.register()`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/prefer-field-array: flags signal([]) in form files", () => {
+  it('pyreon/prefer-field-array: flags signal([]) in form files', () => {
     const result = lintWith(
-      "pyreon/prefer-field-array",
+      'pyreon/prefer-field-array',
       `import { useForm } from "@pyreon/form"\nconst items = signal([])`,
     )
     expect(result.diagnostics.length).toBe(1)
-    expect(result.diagnostics[0]!.message).toContain("useFieldArray")
+    expect(result.diagnostics[0]!.message).toContain('useFieldArray')
   })
 
-  it("pyreon/prefer-field-array: clean when not in form file", () => {
-    const result = lintWith("pyreon/prefer-field-array", `const items = signal([])`)
+  it('pyreon/prefer-field-array: clean when not in form file', () => {
+    const result = lintWith('pyreon/prefer-field-array', `const items = signal([])`)
     expect(result.diagnostics.length).toBe(0)
   })
 })
 
 // ── Styling Rules ───────────────────────────────────────────────────────────
 
-describe("Styling rules", () => {
-  it("pyreon/no-inline-style-object: flags style={{...}} in JSX", () => {
+describe('Styling rules', () => {
+  it('pyreon/no-inline-style-object: flags style={{...}} in JSX', () => {
     const source = `const App = () => <div style={{ color: "red" }} />`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-inline-style-object")
+    const diags = findByRule(result, 'pyreon/no-inline-style-object')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-dynamic-styled: flags styled() inside function", () => {
+  it('pyreon/no-dynamic-styled: flags styled() inside function', () => {
     const source = `function App() { const Box = styled("div"); return null }`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-dynamic-styled")
+    const diags = findByRule(result, 'pyreon/no-dynamic-styled')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-dynamic-styled: clean at module level", () => {
+  it('pyreon/no-dynamic-styled: clean at module level', () => {
     const source = `const Box = styled("div")`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-dynamic-styled")
+    const diags = findByRule(result, 'pyreon/no-dynamic-styled')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/prefer-cx: flags string concatenation in class attribute", () => {
-    const result = lintWith("pyreon/prefer-cx", `const App = () => <div class={"foo " + bar} />`)
+  it('pyreon/prefer-cx: flags string concatenation in class attribute', () => {
+    const result = lintWith('pyreon/prefer-cx', `const App = () => <div class={"foo " + bar} />`)
     expect(result.diagnostics.length).toBe(1)
-    expect(result.diagnostics[0]!.message).toContain("cx()")
+    expect(result.diagnostics[0]!.message).toContain('cx()')
   })
 
-  it("pyreon/prefer-cx: flags template literal in class attribute", () => {
-    const result = lintWith("pyreon/prefer-cx", "const App = () => <div class={`foo ${bar}`} />")
+  it('pyreon/prefer-cx: flags template literal in class attribute', () => {
+    const result = lintWith('pyreon/prefer-cx', 'const App = () => <div class={`foo ${bar}`} />')
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/prefer-cx: clean with plain string class", () => {
-    const result = lintWith("pyreon/prefer-cx", `const App = () => <div class="foo bar" />`)
+  it('pyreon/prefer-cx: clean with plain string class', () => {
+    const result = lintWith('pyreon/prefer-cx', `const App = () => <div class="foo bar" />`)
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-theme-outside-provider: flags useTheme() without provider import", () => {
-    const result = lintWith("pyreon/no-theme-outside-provider", `const theme = useTheme()`)
+  it('pyreon/no-theme-outside-provider: flags useTheme() without provider import', () => {
+    const result = lintWith('pyreon/no-theme-outside-provider', `const theme = useTheme()`)
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/no-theme-outside-provider: clean when PyreonUI is imported", () => {
+  it('pyreon/no-theme-outside-provider: clean when PyreonUI is imported', () => {
     const result = lintWith(
-      "pyreon/no-theme-outside-provider",
+      'pyreon/no-theme-outside-provider',
       `import { PyreonUI } from "@pyreon/ui-core"\nconst theme = useTheme()`,
     )
     expect(result.diagnostics.length).toBe(0)
@@ -791,253 +791,253 @@ describe("Styling rules", () => {
 
 // ── Hooks Rules ─────────────────────────────────────────────────────────────
 
-describe("Hooks rules", () => {
-  it("pyreon/no-raw-addeventlistener: flags .addEventListener()", () => {
+describe('Hooks rules', () => {
+  it('pyreon/no-raw-addeventlistener: flags .addEventListener()', () => {
     const source = `el.addEventListener("click", handler)`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-raw-addeventlistener")
+    const diags = findByRule(result, 'pyreon/no-raw-addeventlistener')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-raw-setinterval: flags setInterval outside onMount", () => {
+  it('pyreon/no-raw-setinterval: flags setInterval outside onMount', () => {
     const source = `setInterval(() => {}, 1000)`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-raw-setinterval")
+    const diags = findByRule(result, 'pyreon/no-raw-setinterval')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/no-raw-localstorage: flags localStorage.getItem()", () => {
+  it('pyreon/no-raw-localstorage: flags localStorage.getItem()', () => {
     const source = `const v = localStorage.getItem("key")`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/no-raw-localstorage")
+    const diags = findByRule(result, 'pyreon/no-raw-localstorage')
     expect(diags.length).toBe(1)
   })
 })
 
 // ── Accessibility Rules ─────────────────────────────────────────────────────
 
-describe("Accessibility rules", () => {
-  it("pyreon/dialog-a11y: flags <dialog> without aria-label", () => {
+describe('Accessibility rules', () => {
+  it('pyreon/dialog-a11y: flags <dialog> without aria-label', () => {
     const source = `const App = () => <dialog><p>Hello</p></dialog>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/dialog-a11y")
+    const diags = findByRule(result, 'pyreon/dialog-a11y')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/dialog-a11y: clean with aria-label", () => {
+  it('pyreon/dialog-a11y: clean with aria-label', () => {
     const source = `const App = () => <dialog aria-label="My dialog"><p>Hello</p></dialog>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/dialog-a11y")
+    const diags = findByRule(result, 'pyreon/dialog-a11y')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/overlay-a11y: flags <Overlay> without role", () => {
+  it('pyreon/overlay-a11y: flags <Overlay> without role', () => {
     const source = `const App = () => <Overlay><p>Hello</p></Overlay>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/overlay-a11y")
+    const diags = findByRule(result, 'pyreon/overlay-a11y')
     expect(diags.length).toBe(1)
   })
 
-  it("pyreon/overlay-a11y: clean with role", () => {
+  it('pyreon/overlay-a11y: clean with role', () => {
     const source = `const App = () => <Overlay role="dialog"><p>Hello</p></Overlay>`
     const result = lintSource(source)
-    const diags = findByRule(result, "pyreon/overlay-a11y")
+    const diags = findByRule(result, 'pyreon/overlay-a11y')
     expect(diags.length).toBe(0)
   })
 
-  it("pyreon/toast-a11y: flags Toast component without role or aria-live", () => {
-    const result = lintWith("pyreon/toast-a11y", `const App = () => <ToastItem message="hello" />`)
+  it('pyreon/toast-a11y: flags Toast component without role or aria-live', () => {
+    const result = lintWith('pyreon/toast-a11y', `const App = () => <ToastItem message="hello" />`)
     expect(result.diagnostics.length).toBe(1)
-    expect(result.diagnostics[0]!.message).toContain("role")
+    expect(result.diagnostics[0]!.message).toContain('role')
   })
 
-  it("pyreon/toast-a11y: clean with role attribute", () => {
+  it('pyreon/toast-a11y: clean with role attribute', () => {
     const result = lintWith(
-      "pyreon/toast-a11y",
+      'pyreon/toast-a11y',
       `const App = () => <ToastItem role="alert" message="hello" />`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/toast-a11y: clean with aria-live attribute", () => {
+  it('pyreon/toast-a11y: clean with aria-live attribute', () => {
     const result = lintWith(
-      "pyreon/toast-a11y",
+      'pyreon/toast-a11y',
       `const App = () => <ToastItem aria-live="polite" message="hello" />`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/toast-a11y: skips Toaster container", () => {
-    const result = lintWith("pyreon/toast-a11y", `const App = () => <Toaster />`)
+  it('pyreon/toast-a11y: skips Toaster container', () => {
+    const result = lintWith('pyreon/toast-a11y', `const App = () => <Toaster />`)
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/toast-a11y: skips non-toast PascalCase components", () => {
-    const result = lintWith("pyreon/toast-a11y", `const App = () => <Button />`)
+  it('pyreon/toast-a11y: skips non-toast PascalCase components', () => {
+    const result = lintWith('pyreon/toast-a11y', `const App = () => <Button />`)
     expect(result.diagnostics.length).toBe(0)
   })
 })
 
 // ── Router Rules ────────────────────────────────────────────────────────────
 
-describe("Router rules", () => {
-  it("pyreon/no-href-navigation: flags <a href> in router file", () => {
+describe('Router rules', () => {
+  it('pyreon/no-href-navigation: flags <a href> in router file', () => {
     const result = lintWith(
-      "pyreon/no-href-navigation",
+      'pyreon/no-href-navigation',
       `import { Link } from "@pyreon/router"\nconst App = () => <a href="/about">About</a>`,
     )
     expect(result.diagnostics.length).toBe(1)
-    expect(result.diagnostics[0]!.message).toContain("<Link>")
+    expect(result.diagnostics[0]!.message).toContain('<Link>')
   })
 
-  it("pyreon/no-href-navigation: clean for external URLs", () => {
+  it('pyreon/no-href-navigation: clean for external URLs', () => {
     const result = lintWith(
-      "pyreon/no-href-navigation",
+      'pyreon/no-href-navigation',
       `import { Link } from "@pyreon/router"\nconst App = () => <a href="https://example.com">External</a>`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-href-navigation: clean for anchor links", () => {
+  it('pyreon/no-href-navigation: clean for anchor links', () => {
     const result = lintWith(
-      "pyreon/no-href-navigation",
+      'pyreon/no-href-navigation',
       `import { Link } from "@pyreon/router"\nconst App = () => <a href="#section">Jump</a>`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-href-navigation: clean without router import", () => {
+  it('pyreon/no-href-navigation: clean without router import', () => {
     const result = lintWith(
-      "pyreon/no-href-navigation",
+      'pyreon/no-href-navigation',
       `const App = () => <a href="/about">About</a>`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-imperative-navigate-in-render: flags navigate() in component body", () => {
+  it('pyreon/no-imperative-navigate-in-render: flags navigate() in component body', () => {
     const result = lintWith(
-      "pyreon/no-imperative-navigate-in-render",
+      'pyreon/no-imperative-navigate-in-render',
       `const App = () => { navigate("/home"); return <div /> }`,
     )
     expect(result.diagnostics.length).toBe(1)
-    expect(result.diagnostics[0]!.message).toContain("infinite")
+    expect(result.diagnostics[0]!.message).toContain('infinite')
   })
 
-  it("pyreon/no-imperative-navigate-in-render: clean inside onMount", () => {
+  it('pyreon/no-imperative-navigate-in-render: clean inside onMount', () => {
     const result = lintWith(
-      "pyreon/no-imperative-navigate-in-render",
+      'pyreon/no-imperative-navigate-in-render',
       `const App = () => { onMount(() => { navigate("/home") }); return <div /> }`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-imperative-navigate-in-render: clean in non-component", () => {
+  it('pyreon/no-imperative-navigate-in-render: clean in non-component', () => {
     const result = lintWith(
-      "pyreon/no-imperative-navigate-in-render",
+      'pyreon/no-imperative-navigate-in-render',
       `const handle = () => { navigate("/home") }`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-missing-fallback: flags route config without catch-all", () => {
+  it('pyreon/no-missing-fallback: flags route config without catch-all', () => {
     const result = lintWith(
-      "pyreon/no-missing-fallback",
+      'pyreon/no-missing-fallback',
       `import { Router } from "@pyreon/router"\nconst routes = [{ path: "/", component: Home }, { path: "/about", component: About }]`,
     )
     expect(result.diagnostics.length).toBe(1)
-    expect(result.diagnostics[0]!.message).toContain("catch-all")
+    expect(result.diagnostics[0]!.message).toContain('catch-all')
   })
 
-  it("pyreon/no-missing-fallback: clean with catch-all route", () => {
+  it('pyreon/no-missing-fallback: clean with catch-all route', () => {
     const result = lintWith(
-      "pyreon/no-missing-fallback",
+      'pyreon/no-missing-fallback',
       `import { Router } from "@pyreon/router"\nconst routes = [{ path: "/", component: Home }, { path: "*", component: NotFound }]`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/no-missing-fallback: clean without router import", () => {
+  it('pyreon/no-missing-fallback: clean without router import', () => {
     const result = lintWith(
-      "pyreon/no-missing-fallback",
+      'pyreon/no-missing-fallback',
       `const routes = [{ path: "/", component: Home }]`,
     )
     expect(result.diagnostics.length).toBe(0)
   })
 
-  it("pyreon/prefer-use-is-active: flags location.pathname === comparison", () => {
+  it('pyreon/prefer-use-is-active: flags location.pathname === comparison', () => {
     const result = lintWith(
-      "pyreon/prefer-use-is-active",
+      'pyreon/prefer-use-is-active',
       `const active = location.pathname === "/admin"`,
     )
     expect(result.diagnostics.length).toBe(1)
-    expect(result.diagnostics[0]!.message).toContain("useIsActive")
+    expect(result.diagnostics[0]!.message).toContain('useIsActive')
   })
 
-  it("pyreon/prefer-use-is-active: flags route.path === comparison", () => {
-    const result = lintWith("pyreon/prefer-use-is-active", `const active = route.path === "/admin"`)
+  it('pyreon/prefer-use-is-active: flags route.path === comparison', () => {
+    const result = lintWith('pyreon/prefer-use-is-active', `const active = route.path === "/admin"`)
     expect(result.diagnostics.length).toBe(1)
   })
 
-  it("pyreon/prefer-use-is-active: clean for unrelated comparisons", () => {
-    const result = lintWith("pyreon/prefer-use-is-active", `const active = name === "admin"`)
+  it('pyreon/prefer-use-is-active: clean for unrelated comparisons', () => {
+    const result = lintWith('pyreon/prefer-use-is-active', `const active = name === "admin"`)
     expect(result.diagnostics.length).toBe(0)
   })
 })
 
 // ── Config Loading ──────────────────────────────────────────────────────────
 
-describe("Config loading", () => {
-  it("loadConfig returns null when no config file exists", () => {
+describe('Config loading', () => {
+  it('loadConfig returns null when no config file exists', () => {
     // Use a path where there's definitely no config
-    const result = loadConfig("/tmp/nonexistent-pyreon-dir-12345")
+    const result = loadConfig('/tmp/nonexistent-pyreon-dir-12345')
     expect(result).toBeNull()
   })
 })
 
 // ── Ignore Filter ───────────────────────────────────────────────────────────
 
-describe("Ignore filter", () => {
-  it("createIgnoreFilter returns a function", () => {
-    const filter = createIgnoreFilter("/tmp/nonexistent-pyreon-dir-12345")
-    expect(typeof filter).toBe("function")
+describe('Ignore filter', () => {
+  it('createIgnoreFilter returns a function', () => {
+    const filter = createIgnoreFilter('/tmp/nonexistent-pyreon-dir-12345')
+    expect(typeof filter).toBe('function')
   })
 
-  it("filter returns false for paths when no ignore files exist", () => {
-    const filter = createIgnoreFilter("/tmp/nonexistent-pyreon-dir-12345")
-    expect(filter("/tmp/nonexistent-pyreon-dir-12345/src/app.ts")).toBe(false)
+  it('filter returns false for paths when no ignore files exist', () => {
+    const filter = createIgnoreFilter('/tmp/nonexistent-pyreon-dir-12345')
+    expect(filter('/tmp/nonexistent-pyreon-dir-12345/src/app.ts')).toBe(false)
   })
 })
 
 // ── Presets ─────────────────────────────────────────────────────────────────
 
-describe("Presets", () => {
-  it("recommended should include all rules", () => {
-    const config = getPreset("recommended")
-    expect(Object.keys(config.rules).length).toBe(55)
+describe('Presets', () => {
+  it('recommended should include all rules', () => {
+    const config = getPreset('recommended')
+    expect(Object.keys(config.rules).length).toBe(56)
   })
 
-  it("strict should promote all warns to errors", () => {
-    const recommended = getPreset("recommended")
-    const strict = getPreset("strict")
+  it('strict should promote all warns to errors', () => {
+    const recommended = getPreset('recommended')
+    const strict = getPreset('strict')
     for (const [id, sev] of Object.entries(recommended.rules)) {
-      if (sev === "warn") {
-        expect(strict.rules[id]).toBe("error")
+      if (sev === 'warn') {
+        expect(strict.rules[id]).toBe('error')
       }
     }
   })
 
-  it("app should disable library-specific rules", () => {
-    const app = getPreset("app")
-    expect(app.rules["pyreon/dev-guard-warnings"]).toBe("off")
-    expect(app.rules["pyreon/no-error-without-prefix"]).toBe("off")
-    expect(app.rules["pyreon/no-circular-import"]).toBe("off")
-    expect(app.rules["pyreon/no-cross-layer-import"]).toBe("off")
+  it('app should disable library-specific rules', () => {
+    const app = getPreset('app')
+    expect(app.rules['pyreon/dev-guard-warnings']).toBe('off')
+    expect(app.rules['pyreon/no-error-without-prefix']).toBe('off')
+    expect(app.rules['pyreon/no-circular-import']).toBe('off')
+    expect(app.rules['pyreon/no-cross-layer-import']).toBe('off')
   })
 
-  it("lib should have architecture rules as error", () => {
-    const lib = getPreset("lib")
-    expect(lib.rules["pyreon/no-circular-import"]).toBe("error")
-    expect(lib.rules["pyreon/no-cross-layer-import"]).toBe("error")
-    expect(lib.rules["pyreon/dev-guard-warnings"]).toBe("error")
+  it('lib should have architecture rules as error', () => {
+    const lib = getPreset('lib')
+    expect(lib.rules['pyreon/no-circular-import']).toBe('error')
+    expect(lib.rules['pyreon/no-cross-layer-import']).toBe('error')
+    expect(lib.rules['pyreon/dev-guard-warnings']).toBe('error')
   })
 })