@pyreon/lint 0.11.5 → 0.11.7

package/src/rules/reactivity/prefer-computed.ts

@@ -1,18 +1,18 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo, isSetCall } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo, isSetCall } from '../../utils/ast'
 
 export const preferComputed: Rule = {
   meta: {
-    id: "pyreon/prefer-computed",
-    category: "reactivity",
-    description: "Suggest computed() when an effect only contains a single .set() call.",
-    severity: "warn",
+    id: 'pyreon/prefer-computed',
+    category: 'reactivity',
+    description: 'Suggest computed() when an effect only contains a single .set() call.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (!isCallTo(node, "effect")) return
+        if (!isCallTo(node, 'effect')) return
         const args = node.arguments
         if (!args || args.length === 0) return
 
@@ -20,30 +20,30 @@ export const preferComputed: Rule = {
         if (!fn) return
 
         let body: any = null
-        if (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression") {
+        if (fn.type === 'ArrowFunctionExpression' || fn.type === 'FunctionExpression') {
           body = fn.body
         }
         if (!body) return
 
         // Arrow with expression body: effect(() => x.set(y))
-        if (body.type === "CallExpression" && isSetCall(body)) {
+        if (body.type === 'CallExpression' && isSetCall(body)) {
           context.report({
             message:
-              "Effect contains a single `.set()` — consider using `computed()` instead for derived values.",
+              'Effect contains a single `.set()` — consider using `computed()` instead for derived values.',
             span: getSpan(node),
           })
           return
         }
 
         // Block body with single statement: effect(() => { x.set(y) })
-        if (body.type === "BlockStatement") {
+        if (body.type === 'BlockStatement') {
           const stmts = body.body
           if (stmts && stmts.length === 1) {
             const stmt = stmts[0]
-            if (stmt.type === "ExpressionStatement" && isSetCall(stmt.expression)) {
+            if (stmt.type === 'ExpressionStatement' && isSetCall(stmt.expression)) {
               context.report({
                 message:
-                  "Effect contains a single `.set()` — consider using `computed()` instead for derived values.",
+                  'Effect contains a single `.set()` — consider using `computed()` instead for derived values.',
                 span: getSpan(node),
               })
             }

package/src/rules/router/index.ts

@@ -1,4 +1,4 @@
-export { noHrefNavigation } from "./no-href-navigation"
-export { noImperativeNavigateInRender } from "./no-imperative-navigate-in-render"
-export { noMissingFallback } from "./no-missing-fallback"
-export { preferUseIsActive } from "./prefer-use-is-active"
+export { noHrefNavigation } from './no-href-navigation'
+export { noImperativeNavigateInRender } from './no-imperative-navigate-in-render'
+export { noMissingFallback } from './no-missing-fallback'
+export { preferUseIsActive } from './prefer-use-is-active'

package/src/rules/router/no-href-navigation.ts

@@ -1,16 +1,16 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getJSXAttribute, getSpan } from "../../utils/ast"
-import { extractImportInfo } from "../../utils/imports"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getJSXAttribute, getSpan } from '../../utils/ast'
+import { extractImportInfo } from '../../utils/imports'
 
-const EXTERNAL_PREFIXES = ["http://", "https://", "mailto:", "tel:"]
+const EXTERNAL_PREFIXES = ['http://', 'https://', 'mailto:', 'tel:']
 
 export const noHrefNavigation: Rule = {
   meta: {
-    id: "pyreon/no-href-navigation",
-    category: "router",
+    id: 'pyreon/no-href-navigation',
+    category: 'router',
     description:
-      "Warn when `<a href>` is used in files that import @pyreon/router — use `<Link>` instead.",
-    severity: "warn",
+      'Warn when `<a href>` is used in files that import @pyreon/router — use `<Link>` instead.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -19,29 +19,29 @@ export const noHrefNavigation: Rule = {
     const callbacks: VisitorCallbacks = {
       ImportDeclaration(node: any) {
         const info = extractImportInfo(node)
-        if (info && info.source === "@pyreon/router") {
+        if (info && info.source === '@pyreon/router') {
           importsRouter = true
         }
       },
       JSXOpeningElement(node: any) {
         if (!importsRouter) return
         const name = node.name
-        if (!name || name.type !== "JSXIdentifier" || name.name !== "a") return
+        if (!name || name.type !== 'JSXIdentifier' || name.name !== 'a') return
 
-        const hrefAttr = getJSXAttribute(node, "href")
+        const hrefAttr = getJSXAttribute(node, 'href')
         if (!hrefAttr) return
 
         // Get the href value
         const value = hrefAttr.value
-        if (value?.type === "Literal" && typeof value.value === "string") {
+        if (value?.type === 'Literal' && typeof value.value === 'string') {
           const href: string = value.value
           // Skip external URLs and anchor links
-          if (href.startsWith("#") || EXTERNAL_PREFIXES.some((p) => href.startsWith(p))) return
+          if (href.startsWith('#') || EXTERNAL_PREFIXES.some((p) => href.startsWith(p))) return
         }
 
         context.report({
           message:
-            "`<a href>` in a router file — use `<Link>` or `<RouterLink>` for client-side navigation.",
+            '`<a href>` in a router file — use `<Link>` or `<RouterLink>` for client-side navigation.',
           span: getSpan(node),
         })
       },

package/src/rules/router/no-imperative-navigate-in-render.ts

@@ -1,13 +1,13 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo, isMemberCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo, isMemberCallTo } from '../../utils/ast'
 
 export const noImperativeNavigateInRender: Rule = {
   meta: {
-    id: "pyreon/no-imperative-navigate-in-render",
-    category: "router",
+    id: 'pyreon/no-imperative-navigate-in-render',
+    category: 'router',
     description:
-      "Error when navigate() or router.push() is called at the top level of a component — causes infinite render loops.",
-    severity: "error",
+      'Error when navigate() or router.push() is called at the top level of a component — causes infinite render loops.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
@@ -20,27 +20,27 @@ export const noImperativeNavigateInRender: Rule = {
 
     const callbacks: VisitorCallbacks = {
       FunctionDeclaration(node: any) {
-        const name: string = node.id?.name ?? ""
+        const name: string = node.id?.name ?? ''
         if (/^[A-Z]/.test(name)) {
           componentBodyDepth++
         }
       },
-      "FunctionDeclaration:exit"(node: any) {
-        const name: string = node.id?.name ?? ""
+      'FunctionDeclaration:exit'(node: any) {
+        const name: string = node.id?.name ?? ''
         if (/^[A-Z]/.test(name)) {
           componentBodyDepth--
         }
       },
       // For arrow functions, we use VariableDeclarator to detect component assignment
       VariableDeclarator(node: any) {
-        const name: string = node.id?.name ?? ""
-        if (/^[A-Z]/.test(name) && node.init?.type === "ArrowFunctionExpression") {
+        const name: string = node.id?.name ?? ''
+        if (/^[A-Z]/.test(name) && node.init?.type === 'ArrowFunctionExpression') {
           componentBodyDepth++
         }
       },
-      "VariableDeclarator:exit"(node: any) {
-        const name: string = node.id?.name ?? ""
-        if (/^[A-Z]/.test(name) && node.init?.type === "ArrowFunctionExpression") {
+      'VariableDeclarator:exit'(node: any) {
+        const name: string = node.id?.name ?? ''
+        if (/^[A-Z]/.test(name) && node.init?.type === 'ArrowFunctionExpression') {
           componentBodyDepth--
         }
       },
@@ -56,15 +56,15 @@ export const noImperativeNavigateInRender: Rule = {
         // Only report if we're in a component body and NOT inside a safe callback
         if (safeDepth > 0) return
 
-        if (isCallTo(node, "navigate") || isMemberCallTo(node, "router", "push")) {
+        if (isCallTo(node, 'navigate') || isMemberCallTo(node, 'router', 'push')) {
           context.report({
             message:
-              "Imperative navigation at the top level of a component — this runs on every render and causes infinite loops. Move inside `onMount`, `effect`, or an event handler.",
+              'Imperative navigation at the top level of a component — this runs on every render and causes infinite loops. Move inside `onMount`, `effect`, or an event handler.',
             span: getSpan(node),
           })
         }
       },
-      "CallExpression:exit"(node: any) {
+      'CallExpression:exit'(node: any) {
         if (componentBodyDepth <= 0) return
         if (isSafeWrapperCall(node)) {
           safeDepth--
@@ -77,7 +77,7 @@ export const noImperativeNavigateInRender: Rule = {
 
 function isSafeWrapperCall(node: any): boolean {
   const callee = node.callee
-  if (!callee || callee.type !== "Identifier") return false
+  if (!callee || callee.type !== 'Identifier') return false
   const name: string = callee.name
-  return name === "onMount" || name === "effect" || name === "onUnmount"
+  return name === 'onMount' || name === 'effect' || name === 'onUnmount'
 }

package/src/rules/router/no-missing-fallback.ts

@@ -1,27 +1,27 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
-import { extractImportInfo } from "../../utils/imports"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
+import { extractImportInfo } from '../../utils/imports'
 
 function isCatchAllPath(value: string): boolean {
-  return value === "*" || value.endsWith("*")
+  return value === '*' || value.endsWith('*')
 }
 
 function getPathValue(prop: any): string | null {
   const key = prop.key
   if (!key) return null
-  const keyName = key.type === "Identifier" ? key.name : null
-  if (keyName !== "path") return null
+  const keyName = key.type === 'Identifier' ? key.name : null
+  if (keyName !== 'path') return null
   const val = prop.value
-  if (val?.type === "Literal" && typeof val.value === "string") {
+  if (val?.type === 'Literal' && typeof val.value === 'string') {
     return val.value
   }
   return null
 }
 
 function hasPathProperty(obj: any): boolean {
-  if (!obj || obj.type !== "ObjectExpression") return false
+  if (!obj || obj.type !== 'ObjectExpression') return false
   for (const prop of obj.properties ?? []) {
-    if (prop.type !== "Property") continue
+    if (prop.type !== 'Property') continue
     if (getPathValue(prop) !== null) return true
   }
   return false
@@ -29,9 +29,9 @@ function hasPathProperty(obj: any): boolean {
 
 function hasCatchAllRoute(elements: any[]): boolean {
   for (const elem of elements) {
-    if (!elem || elem.type !== "ObjectExpression") continue
+    if (!elem || elem.type !== 'ObjectExpression') continue
     for (const prop of elem.properties ?? []) {
-      if (prop.type !== "Property") continue
+      if (prop.type !== 'Property') continue
       const pathVal = getPathValue(prop)
       if (pathVal !== null && isCatchAllPath(pathVal)) return true
     }
@@ -41,11 +41,11 @@ function hasCatchAllRoute(elements: any[]): boolean {
 
 export const noMissingFallback: Rule = {
   meta: {
-    id: "pyreon/no-missing-fallback",
-    category: "router",
+    id: 'pyreon/no-missing-fallback',
+    category: 'router',
     description:
       'Warn when route config has no catch-all route (`path: "*"` or `path: "/:rest*"`).',
-    severity: "warn",
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -56,7 +56,7 @@ export const noMissingFallback: Rule = {
     const callbacks: VisitorCallbacks = {
       ImportDeclaration(node: any) {
         const info = extractImportInfo(node)
-        if (info && info.source === "@pyreon/router") {
+        if (info && info.source === '@pyreon/router') {
           importsRouter = true
         }
       },
@@ -73,7 +73,7 @@ export const noMissingFallback: Rule = {
           foundCatchAll = true
         }
       },
-      "Program:exit"() {
+      'Program:exit'() {
         if (!importsRouter || !routeArraySpan || foundCatchAll) return
         context.report({
           message:

package/src/rules/router/prefer-use-is-active.ts

@@ -1,25 +1,25 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const preferUseIsActive: Rule = {
   meta: {
-    id: "pyreon/prefer-use-is-active",
-    category: "router",
+    id: 'pyreon/prefer-use-is-active',
+    category: 'router',
     description:
       'Suggest useIsActive() instead of `location.pathname === "/foo"` or `route.path === "/foo"` patterns.',
-    severity: "info",
+    severity: 'info',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       BinaryExpression(node: any) {
-        if (node.operator !== "===" && node.operator !== "==") return
+        if (node.operator !== '===' && node.operator !== '==') return
 
         // Check both sides for location.pathname or route.path
         if (isPathComparison(node.left) || isPathComparison(node.right)) {
           context.report({
             message:
-              "Manual path comparison — use `useIsActive()` for reactive route matching with segment-aware prefix matching.",
+              'Manual path comparison — use `useIsActive()` for reactive route matching with segment-aware prefix matching.',
             span: getSpan(node),
           })
         }
@@ -30,16 +30,16 @@ export const preferUseIsActive: Rule = {
 }
 
 function isPathComparison(node: any): boolean {
-  if (!node || node.type !== "MemberExpression") return false
+  if (!node || node.type !== 'MemberExpression') return false
   const obj = node.object
   const prop = node.property
-  if (!obj || !prop || prop.type !== "Identifier") return false
+  if (!obj || !prop || prop.type !== 'Identifier') return false
 
   // location.pathname
-  if (obj.type === "Identifier" && obj.name === "location" && prop.name === "pathname") return true
+  if (obj.type === 'Identifier' && obj.name === 'location' && prop.name === 'pathname') return true
 
   // route.path
-  if (obj.type === "Identifier" && obj.name === "route" && prop.name === "path") return true
+  if (obj.type === 'Identifier' && obj.name === 'route' && prop.name === 'path') return true
 
   return false
 }

package/src/rules/ssr/no-mismatch-risk.ts

@@ -1,13 +1,13 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isMemberCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isMemberCallTo } from '../../utils/ast'
 
 export const noMismatchRisk: Rule = {
   meta: {
-    id: "pyreon/no-mismatch-risk",
-    category: "ssr",
+    id: 'pyreon/no-mismatch-risk',
+    category: 'ssr',
     description:
-      "Warn about non-deterministic calls (Date.now, Math.random, crypto.randomUUID) in JSX context that cause hydration mismatches.",
-    severity: "warn",
+      'Warn about non-deterministic calls (Date.now, Math.random, crypto.randomUUID) in JSX context that cause hydration mismatches.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
@@ -16,22 +16,22 @@ export const noMismatchRisk: Rule = {
       JSXElement() {
         jsxDepth++
       },
-      "JSXElement:exit"() {
+      'JSXElement:exit'() {
         jsxDepth--
       },
       JSXFragment() {
         jsxDepth++
       },
-      "JSXFragment:exit"() {
+      'JSXFragment:exit'() {
         jsxDepth--
       },
       CallExpression(node: any) {
         if (jsxDepth === 0) return
 
         if (
-          isMemberCallTo(node, "Date", "now") ||
-          isMemberCallTo(node, "Math", "random") ||
-          isMemberCallTo(node, "crypto", "randomUUID")
+          isMemberCallTo(node, 'Date', 'now') ||
+          isMemberCallTo(node, 'Math', 'random') ||
+          isMemberCallTo(node, 'crypto', 'randomUUID')
         ) {
           const callee = node.callee
           const name = `${callee.object.name}.${callee.property.name}`

package/src/rules/ssr/no-window-in-ssr.ts

@@ -1,13 +1,13 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
-import { BROWSER_GLOBALS } from "../../utils/imports"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
+import { BROWSER_GLOBALS } from '../../utils/imports'
 
 export const noWindowInSsr: Rule = {
   meta: {
-    id: "pyreon/no-window-in-ssr",
-    category: "ssr",
-    description: "Disallow browser globals outside onMount/effect/typeof guards — they break SSR.",
-    severity: "error",
+    id: 'pyreon/no-window-in-ssr',
+    category: 'ssr',
+    description: 'Disallow browser globals outside onMount/effect/typeof guards — they break SSR.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
@@ -16,12 +16,12 @@ export const noWindowInSsr: Rule = {
 
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (isCallTo(node, "onMount") || isCallTo(node, "effect")) {
+        if (isCallTo(node, 'onMount') || isCallTo(node, 'effect')) {
           safeDepth++
         }
       },
-      "CallExpression:exit"(node: any) {
-        if (isCallTo(node, "onMount") || isCallTo(node, "effect")) {
+      'CallExpression:exit'(node: any) {
+        if (isCallTo(node, 'onMount') || isCallTo(node, 'effect')) {
           safeDepth--
         }
       },
@@ -29,19 +29,19 @@ export const noWindowInSsr: Rule = {
         // typeof window !== "undefined"
         const test = node.test
         if (
-          test?.type === "BinaryExpression" &&
-          test.left?.type === "UnaryExpression" &&
-          test.left.operator === "typeof"
+          test?.type === 'BinaryExpression' &&
+          test.left?.type === 'UnaryExpression' &&
+          test.left.operator === 'typeof'
         ) {
           typeofGuardDepth++
         }
       },
-      "IfStatement:exit"(node: any) {
+      'IfStatement:exit'(node: any) {
         const test = node.test
         if (
-          test?.type === "BinaryExpression" &&
-          test.left?.type === "UnaryExpression" &&
-          test.left.operator === "typeof"
+          test?.type === 'BinaryExpression' &&
+          test.left?.type === 'UnaryExpression' &&
+          test.left.operator === 'typeof'
         ) {
           typeofGuardDepth--
         }
@@ -51,18 +51,18 @@ export const noWindowInSsr: Rule = {
         if (!BROWSER_GLOBALS.has(node.name)) return
 
         // Skip typeof expressions: typeof window
-        if (parent?.type === "UnaryExpression" && parent.operator === "typeof") return
+        if (parent?.type === 'UnaryExpression' && parent.operator === 'typeof') return
 
         // Skip import specifiers
         if (
-          parent?.type === "ImportSpecifier" ||
-          parent?.type === "ImportDefaultSpecifier" ||
-          parent?.type === "ImportNamespaceSpecifier"
+          parent?.type === 'ImportSpecifier' ||
+          parent?.type === 'ImportDefaultSpecifier' ||
+          parent?.type === 'ImportNamespaceSpecifier'
         )
           return
 
         // Skip property access on member expressions (only flag when used as the object)
-        if (parent?.type === "MemberExpression" && parent.property === node && !parent.computed)
+        if (parent?.type === 'MemberExpression' && parent.property === node && !parent.computed)
           return
 
         context.report({

package/src/rules/ssr/prefer-request-context.ts

@@ -1,22 +1,22 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
 
 export const preferRequestContext: Rule = {
   meta: {
-    id: "pyreon/prefer-request-context",
-    category: "ssr",
+    id: 'pyreon/prefer-request-context',
+    category: 'ssr',
     description:
-      "Warn about module-level signal()/createStore() in server files — use request context instead.",
-    severity: "warn",
+      'Warn about module-level signal()/createStore() in server files — use request context instead.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const filePath = context.getFilePath()
     const isServerFile =
-      filePath.includes("server") ||
-      filePath.includes(".server.") ||
-      filePath.endsWith("server.ts") ||
-      filePath.endsWith("server.tsx")
+      filePath.includes('server') ||
+      filePath.includes('.server.') ||
+      filePath.endsWith('server.ts') ||
+      filePath.endsWith('server.tsx')
 
     if (!isServerFile) return {}
 
@@ -25,24 +25,24 @@ export const preferRequestContext: Rule = {
       FunctionDeclaration() {
         functionDepth++
       },
-      "FunctionDeclaration:exit"() {
+      'FunctionDeclaration:exit'() {
         functionDepth--
       },
       FunctionExpression() {
         functionDepth++
       },
-      "FunctionExpression:exit"() {
+      'FunctionExpression:exit'() {
         functionDepth--
       },
       ArrowFunctionExpression() {
         functionDepth++
       },
-      "ArrowFunctionExpression:exit"() {
+      'ArrowFunctionExpression:exit'() {
         functionDepth--
       },
       CallExpression(node: any) {
         if (functionDepth > 0) return // only flag module-level calls
-        if (isCallTo(node, "signal") || isCallTo(node, "createStore")) {
+        if (isCallTo(node, 'signal') || isCallTo(node, 'createStore')) {
           const name = node.callee.name
           context.report({
             message: `Module-level \`${name}()\` in a server file — this state is shared across all requests. Use \`runWithRequestContext()\` for per-request isolation.`,

package/src/rules/store/no-duplicate-store-id.ts

@@ -1,12 +1,12 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan, isCallTo } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan, isCallTo } from '../../utils/ast'
 
 export const noDuplicateStoreId: Rule = {
   meta: {
-    id: "pyreon/no-duplicate-store-id",
-    category: "store",
-    description: "Disallow duplicate defineStore() IDs in the same file.",
-    severity: "error",
+    id: 'pyreon/no-duplicate-store-id',
+    category: 'store',
+    description: 'Disallow duplicate defineStore() IDs in the same file.',
+    severity: 'error',
     fixable: false,
   },
   create(context) {
@@ -14,7 +14,7 @@ export const noDuplicateStoreId: Rule = {
 
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
-        if (!isCallTo(node, "defineStore")) return
+        if (!isCallTo(node, 'defineStore')) return
         const args = node.arguments
         if (!args || args.length === 0) return
 
@@ -22,11 +22,11 @@ export const noDuplicateStoreId: Rule = {
         if (!firstArg) return
 
         let id: string | null = null
-        if (firstArg.type === "Literal" || firstArg.type === "StringLiteral") {
+        if (firstArg.type === 'Literal' || firstArg.type === 'StringLiteral') {
           id = firstArg.value as string
         }
 
-        if (typeof id !== "string") return
+        if (typeof id !== 'string') return
 
         if (storeIds.has(id)) {
           context.report({

package/src/rules/store/no-mutate-store-state.ts

@@ -1,30 +1,30 @@
-import type { Rule, VisitorCallbacks } from "../../types"
-import { getSpan } from "../../utils/ast"
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
 
 export const noMutateStoreState: Rule = {
   meta: {
-    id: "pyreon/no-mutate-store-state",
-    category: "store",
-    description: "Warn when directly calling .set() on store signals — use store actions instead.",
-    severity: "warn",
+    id: 'pyreon/no-mutate-store-state',
+    category: 'store',
+    description: 'Warn when directly calling .set() on store signals — use store actions instead.',
+    severity: 'warn',
     fixable: false,
   },
   create(context) {
     const callbacks: VisitorCallbacks = {
       CallExpression(node: any) {
         const callee = node.callee
-        if (!callee || callee.type !== "MemberExpression") return
-        if (callee.property?.type !== "Identifier" || callee.property.name !== "set") return
+        if (!callee || callee.type !== 'MemberExpression') return
+        if (callee.property?.type !== 'Identifier' || callee.property.name !== 'set') return
 
         // Check for store.signal.set() pattern — member.member.set()
         const obj = callee.object
-        if (!obj || obj.type !== "MemberExpression") return
+        if (!obj || obj.type !== 'MemberExpression') return
         const outerObj = obj.object
-        if (!outerObj || outerObj.type !== "Identifier") return
+        if (!outerObj || outerObj.type !== 'Identifier') return
 
         const name: string = outerObj.name
         // Heuristic: if the outer object name contains "store" (case-insensitive)
-        if (name.toLowerCase().includes("store")) {
+        if (name.toLowerCase().includes('store')) {
           context.report({
             message: `Direct \`.set()\` on store state \`${name}\` — use store actions to mutate state for better traceability.`,
             span: getSpan(node),