@pyreon/lint 0.15.0 → 0.16.0

package/src/rules/index.ts

@@ -55,11 +55,16 @@ import { noSignalInProps } from './reactivity/no-signal-in-props'
 import { noSignalLeak } from './reactivity/no-signal-leak'
 import { noUnbatchedUpdates } from './reactivity/no-unbatched-updates'
 import { preferComputed } from './reactivity/prefer-computed'
+import { storageSignalVForwarding } from './reactivity/storage-signal-v-forwarding'
 // Router
 import { noHrefNavigation } from './router/no-href-navigation'
 import { noImperativeNavigateInRender } from './router/no-imperative-navigate-in-render'
 import { noMissingFallback } from './router/no-missing-fallback'
 import { preferUseIsActive } from './router/prefer-use-is-active'
+// SSG (M3.5)
+import { invalidLoaderExport } from './ssg/invalid-loader-export'
+import { missingGetStaticPaths } from './ssg/missing-get-static-paths'
+import { revalidateNotPureLiteral } from './ssg/revalidate-not-pure-literal'
 import { noMismatchRisk } from './ssr/no-mismatch-risk'
 // SSR
 import { noWindowInSsr } from './ssr/no-window-in-ssr'
@@ -75,7 +80,7 @@ import { noThemeOutsideProvider } from './styling/no-theme-outside-provider'
 import { preferCx } from './styling/prefer-cx'
 
 export const allRules: Rule[] = [
-  // Reactivity (12)
+  // Reactivity (13)
   noAsyncEffect,
   noBareSignalInJsx,
   noContextDestructure,
@@ -88,6 +93,7 @@ export const allRules: Rule[] = [
   noEffectAssignment,
   noSignalLeak,
   noSignalCallWrite,
+  storageSignalVForwarding,
   // JSX (11)
   noMapInJsx,
   useByNotKey,
@@ -149,6 +155,10 @@ export const allRules: Rule[] = [
   noImperativeNavigateInRender,
   noMissingFallback,
   preferUseIsActive,
+  // SSG (3) — M3.5
+  invalidLoaderExport,
+  missingGetStaticPaths,
+  revalidateNotPureLiteral,
 ]
 
 // Re-export all rules individually
@@ -223,6 +233,10 @@ export {
   preferRequestContext,
   preferShowOverDisplay,
   preferUseIsActive,
+  // SSG (M3.5)
+  invalidLoaderExport,
+  missingGetStaticPaths,
+  revalidateNotPureLiteral,
   // Accessibility
   toastA11y,
   useByNotKey,

package/src/rules/reactivity/storage-signal-v-forwarding.ts

@@ -0,0 +1,184 @@
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
+
+/**
+ * Flag signal-wrapper callables that delegate `.direct` to a base signal
+ * but do NOT also forward the internal `_v` field via `Object.defineProperty`.
+ *
+ * Background: the compiler emits `_bindText(source, textNode)` for JSX
+ * shape `{() => signal()}` where `signal` is a callable. `_bindText`'s
+ * fast path reads `source._v` directly (skipping the function call) for
+ * BOTH the initial render AND every subscriber re-run. A wrapper that
+ * delegates `.direct` enables that fast path — but if `_v` is missing,
+ * the binding writes `String(undefined)` → `''` and re-writes empty on
+ * every change. localStorage / sessionStorage / cookies still update;
+ * the DOM stays empty.
+ *
+ * Bug shipped in `@pyreon/storage` from package inception for ~9 months
+ * before being fixed in PR #546. This rule prevents recurrence in:
+ *   - Future framework backends (additional `createStorage` callers,
+ *     new wrapper helpers extracted from the 4 existing factories)
+ *   - User-side custom backends built without `createStorage()`
+ *   - Third-party signal-like adapters
+ *
+ * Detected shapes (per-function scope):
+ *   x.direct = y.direct
+ *   x.direct = (...) => y.direct(...)
+ *   x.direct = function (...) { return y.direct(...) }
+ *
+ * Acceptable companions (in the same function scope):
+ *   Object.defineProperty(x, '_v', { get: () => y._v })
+ *   x._v = y._v
+ *   Object.defineProperty(x, '_v', { value: ... })
+ *
+ * Out of scope: cross-function tracking, identifier aliasing
+ * (`const w = x; w.direct = …; Object.defineProperty(x, '_v', …)`).
+ * The lint heuristic operates at single-function granularity — that's
+ * the level the bug originally lived at (createStorageSignal inside
+ * `packages/fundamentals/storage/src/local.ts`).
+ */
+
+interface ScopeFrame {
+  /** Object identifier → AssignmentExpression node for the `.direct =` site */
+  directAssigns: Map<string, unknown>
+  /** Object identifiers that have `_v` forwarded in this scope */
+  vForwards: Set<string>
+}
+
+function isDirectDelegation(rhs: any): boolean {
+  if (!rhs) return false
+
+  // x.direct = y.direct
+  if (rhs.type === 'MemberExpression' && rhs.property?.name === 'direct') {
+    return true
+  }
+
+  // x.direct = (...) => y.direct(...)
+  // x.direct = function (...) { return y.direct(...) }
+  if (rhs.type === 'ArrowFunctionExpression' || rhs.type === 'FunctionExpression') {
+    const body = rhs.body
+    if (!body) return false
+
+    // Arrow with implicit-return expression body
+    if (body.type !== 'BlockStatement') {
+      return isDirectCall(body)
+    }
+
+    // Block body — look for a single `return y.direct(...)` statement
+    const stmts = body.body
+    if (!stmts || stmts.length !== 1) return false
+    const stmt = stmts[0]
+    if (stmt.type !== 'ReturnStatement') return false
+    return isDirectCall(stmt.argument)
+  }
+
+  return false
+}
+
+function isDirectCall(expr: any): boolean {
+  if (!expr || expr.type !== 'CallExpression') return false
+  const callee = expr.callee
+  return Boolean(
+    callee &&
+      callee.type === 'MemberExpression' &&
+      callee.property?.name === 'direct',
+  )
+}
+
+function getStringLiteralValue(node: any): string | null {
+  if (!node) return null
+  if (node.type === 'Literal' && typeof node.value === 'string') return node.value
+  // oxc emits StringLiteral for plain string literals
+  if (node.type === 'StringLiteral' && typeof node.value === 'string') return node.value
+  return null
+}
+
+export const storageSignalVForwarding: Rule = {
+  meta: {
+    id: 'pyreon/storage-signal-v-forwarding',
+    category: 'reactivity',
+    description:
+      'Signal-wrapper callables delegating `.direct` to a base signal must also forward the internal `_v` field. Without forwarding, the compiler-emitted `_bindText` fast path reads `undefined` and renders empty text post-hydration.',
+    severity: 'error',
+    fixable: false,
+  },
+  create(context) {
+    const stack: ScopeFrame[] = []
+
+    const enter = () => {
+      stack.push({ directAssigns: new Map(), vForwards: new Set() })
+    }
+    const exit = () => {
+      const scope = stack.pop()
+      if (!scope) return
+      for (const [name, node] of scope.directAssigns) {
+        if (scope.vForwards.has(name)) continue
+        context.report({
+          message:
+            `Signal wrapper '${name}' delegates \`.direct\` to a base signal but ` +
+            `does not forward \`_v\`. The compiler-emitted \`_bindText\` fast path reads ` +
+            `\`${name}._v\` directly — without forwarding, the binding writes ` +
+            `\`''\` on initial render AND every subscriber notification, even after ` +
+            `\`.set()\` calls. Add: \`Object.defineProperty(${name}, '_v', ` +
+            `{ get: () => sig._v, configurable: true })\` in the same scope. Reference: ` +
+            `\`packages/fundamentals/storage/src/local.ts:createStorageSignal\` ` +
+            `for the canonical shape.`,
+          span: getSpan(node as { start: number; end: number }),
+        })
+      }
+    }
+
+    const callbacks: VisitorCallbacks = {
+      Program: enter,
+      'Program:exit': exit,
+      FunctionDeclaration: enter,
+      'FunctionDeclaration:exit': exit,
+      FunctionExpression: enter,
+      'FunctionExpression:exit': exit,
+      ArrowFunctionExpression: enter,
+      'ArrowFunctionExpression:exit': exit,
+
+      AssignmentExpression(node: any) {
+        const scope = stack[stack.length - 1]
+        if (!scope) return
+
+        const left = node.left
+        if (left?.type !== 'MemberExpression') return
+        if (left.object?.type !== 'Identifier') return
+        const objName = left.object.name
+
+        const propName = left.property?.name ?? getStringLiteralValue(left.property)
+
+        if (propName === 'direct' && isDirectDelegation(node.right)) {
+          scope.directAssigns.set(objName, node)
+        } else if (propName === '_v') {
+          // Plain `x._v = ...` counts as forwarding (rare but valid)
+          scope.vForwards.add(objName)
+        }
+      },
+
+      CallExpression(node: any) {
+        const scope = stack[stack.length - 1]
+        if (!scope) return
+
+        const callee = node.callee
+        if (!callee || callee.type !== 'MemberExpression') return
+        if (callee.object?.type !== 'Identifier' || callee.object.name !== 'Object') return
+        if (callee.property?.name !== 'defineProperty') return
+
+        const args = node.arguments
+        if (!args || args.length < 2) return
+
+        const target = args[0]
+        if (target?.type !== 'Identifier') return
+
+        const propValue = getStringLiteralValue(args[1])
+        if (propValue !== '_v') return
+
+        scope.vForwards.add(target.name)
+      },
+    }
+
+    return callbacks
+  },
+}

package/src/rules/ssg/index.ts

@@ -0,0 +1,3 @@
+export { invalidLoaderExport } from './invalid-loader-export'
+export { missingGetStaticPaths } from './missing-get-static-paths'
+export { revalidateNotPureLiteral } from './revalidate-not-pure-literal'

package/src/rules/ssg/invalid-loader-export.ts

@@ -0,0 +1,84 @@
+/**
+ * M3.5 — `pyreon/invalid-loader-export`.
+ *
+ * `export const loader = X` where X isn't a function. fs-router treats
+ * `loader` as a callable: `loader(ctx: LoaderContext)`. If the user
+ * exports `loader = { data: ... }` (object) or `loader = await fetch(...)`
+ * (a resolved value) — both occasionally happen when learning the API —
+ * the SSR / SSG runtime crashes with `TypeError: loader is not a
+ * function`, often deep inside the prefetch loop with a stack trace
+ * that doesn't name the route.
+ *
+ * The rule fires on `export const loader = <non-arrow / non-function /
+ * non-identifier>`. Function declarations (`export async function
+ * loader()`) and arrow / function expressions are obviously fine.
+ * Identifier references (`export const loader = myImportedLoader`) are
+ * accepted at lint time — the rule can't resolve the binding's
+ * callability cross-module without a type-check.
+ *
+ * Scoped to route files (`src/routes/`).
+ */
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
+
+const ROUTES_PATH_RE = /[/\\]routes[/\\]/
+
+function isLikelyCallable(node: any): boolean {
+  if (!node) return false
+  // Direct function shapes.
+  if (node.type === 'ArrowFunctionExpression') return true
+  if (node.type === 'FunctionExpression') return true
+  // Identifier — defer to type-check / cross-file resolver. We assume the
+  // binding might be a function and don't flag. Catches the
+  // `export const loader = sharedLoader` pattern.
+  if (node.type === 'Identifier') return true
+  // Call expression — caller pattern (`export const loader =
+  // makeLoader(...)`). Assume the factory returns a function.
+  if (node.type === 'CallExpression') return true
+  // Class methods — `export const loader = MyClass.prototype.fetch`.
+  if (node.type === 'MemberExpression') return true
+  // TS type-as-call (`as Loader<...>`) — strip the cast and re-check.
+  if (node.type === 'TSAsExpression' || node.type === 'TSSatisfiesExpression') {
+    return isLikelyCallable(node.expression)
+  }
+  return false
+}
+
+export const invalidLoaderExport: Rule = {
+  meta: {
+    id: 'pyreon/invalid-loader-export',
+    category: 'ssg',
+    description:
+      '`export const loader` must be a function — non-callable exports crash the SSR runtime with `loader is not a function`.',
+    severity: 'error',
+    fixable: false,
+  },
+  create(context) {
+    const filePath = context.getFilePath()
+    if (!ROUTES_PATH_RE.test(filePath)) return {}
+
+    const callbacks: VisitorCallbacks = {
+      ExportNamedDeclaration(node: any) {
+        const decl = node.declaration
+        if (!decl) return
+        // `export const loader = ...` shape only — function declarations
+        // (`export async function loader()`) are obviously callable.
+        if (decl.type !== 'VariableDeclaration') return
+        for (const declarator of decl.declarations ?? []) {
+          if (declarator.type !== 'VariableDeclarator') continue
+          const id = declarator.id
+          if (id?.type !== 'Identifier' || id.name !== 'loader') continue
+          const init = declarator.init
+          if (!init) continue
+          if (isLikelyCallable(init)) continue
+          context.report({
+            message:
+              '`export const loader` must be a function (arrow, function expression, or identifier reference). Got a non-callable expression — the SSR runtime will crash with `TypeError: loader is not a function`. If you meant to export static data, use `export const meta = { ... }` instead.',
+            span: getSpan(init),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

package/src/rules/ssg/missing-get-static-paths.ts

@@ -0,0 +1,103 @@
+/**
+ * M3.5 — `pyreon/missing-get-static-paths`.
+ *
+ * A dynamic route file (filename contains `[param]` or `[...rest]`)
+ * that lacks an `export const getStaticPaths` (or `export async
+ * function getStaticPaths`). Under `mode: 'ssg'`, the SSG plugin's
+ * auto-detect step SILENTLY SKIPS such routes — `dist/posts/<id>/
+ * index.html` never gets emitted, the user thinks prerendering worked
+ * but production serves 404s on every dynamic URL.
+ *
+ * The rule fires on the route file itself (filename signal alone is
+ * enough — `[id].tsx` / `[...slug].tsx` shapes). Scopes to files under
+ * `src/routes/` because the dynamic-route convention is fs-router-
+ * specific.
+ *
+ * **Skips API routes.** Files under `src/routes/api/` AND any file
+ * that doesn't export a `default` page component are API handlers —
+ * they're runtime-only by definition (fs-router invokes them per
+ * request, never prerenders them), so `getStaticPaths` doesn't apply.
+ * Caught originally in M3.B against `examples/cpa-pw-blog`'s
+ * `api/echo/[...path].ts`. Both checks fire together as defense in
+ * depth: the path check catches the convention, the export-shape
+ * check catches anyone who puts an API route outside `api/`.
+ *
+ * Fires `warn` because dynamic routes that intentionally run as SSR
+ * (mode: 'ssr' / 'isr') don't need `getStaticPaths` — the rule can't
+ * read `vite.config.ts` to know which mode the app uses. The warn
+ * level signals "review whether this is intentional" without blocking
+ * the build.
+ */
+import type { Rule, VisitorCallbacks } from '../../types'
+
+const ROUTES_PATH_RE = /[/\\]routes[/\\]/
+const API_PATH_RE = /[/\\]routes[/\\]api[/\\]/
+const DYNAMIC_FILENAME_RE = /\[.+\]\.(tsx?|jsx?)$/
+const SPECIAL_ROUTE_RE = /[/\\]_(layout|error|loading|404|not-found)\./
+
+export const missingGetStaticPaths: Rule = {
+  meta: {
+    id: 'pyreon/missing-get-static-paths',
+    category: 'ssg',
+    description:
+      'Dynamic route files (`[id].tsx`, `[...slug].tsx`) should export `getStaticPaths` — under `mode: "ssg"` the SSG plugin silently skips routes without it.',
+    severity: 'warn',
+    fixable: false,
+  },
+  create(context) {
+    const filePath = context.getFilePath()
+    if (!ROUTES_PATH_RE.test(filePath)) return {}
+    // Skip API routes (`src/routes/api/`) — they're runtime handlers,
+    // never prerendered. Page-vs-API by file-system convention.
+    if (API_PATH_RE.test(filePath)) return {}
+    if (!DYNAMIC_FILENAME_RE.test(filePath)) return {}
+    if (SPECIAL_ROUTE_RE.test(filePath)) return {}
+
+    let hasGetStaticPaths = false
+    let hasDefaultExport = false
+    let programSpan: { start: number; end: number } | null = null
+
+    const callbacks: VisitorCallbacks = {
+      Program(node: any) {
+        programSpan = { start: node.start ?? 0, end: node.end ?? 0 }
+      },
+      ExportNamedDeclaration(node: any) {
+        const decl = node.declaration
+        if (!decl) return
+        if (decl.type === 'VariableDeclaration') {
+          for (const declarator of decl.declarations ?? []) {
+            if (declarator.type !== 'VariableDeclarator') continue
+            const id = declarator.id
+            if (id?.type === 'Identifier' && id.name === 'getStaticPaths') {
+              hasGetStaticPaths = true
+            }
+          }
+        } else if (decl.type === 'FunctionDeclaration') {
+          if (decl.id?.name === 'getStaticPaths') {
+            hasGetStaticPaths = true
+          }
+        }
+      },
+      ExportDefaultDeclaration() {
+        hasDefaultExport = true
+      },
+      'Program:exit'() {
+        // No `export default` → it's an API route by structure. Skip.
+        // Page routes structurally require a default-exported component
+        // (the fs-router renders `route.component`). Files exporting only
+        // method handlers (`GET` / `POST` / etc.) without a default are
+        // API routes wherever they sit in the tree.
+        if (!hasDefaultExport) return
+        if (hasGetStaticPaths || !programSpan) return
+        context.report({
+          message:
+            'Dynamic route file is missing `export const getStaticPaths` — under `mode: "ssg"` the SSG plugin silently skips this route, so the dist won\'t contain prerendered HTML. Either add `export const getStaticPaths = () => [{ params: { ... } }, ...]` enumerating the concrete values, OR declare the route as runtime-only by switching to `mode: "ssr"` / `mode: "isr"`.',
+          // Report at the start of the file so the diagnostic is visible
+          // in editor gutters without scrolling.
+          span: { start: programSpan.start, end: Math.min(programSpan.start + 1, programSpan.end) },
+        })
+      },
+    }
+    return callbacks
+  },
+}

package/src/rules/ssg/revalidate-not-pure-literal.ts

@@ -0,0 +1,69 @@
+/**
+ * M3.5 — `pyreon/revalidate-not-pure-literal`.
+ *
+ * `export const revalidate = X` where X isn't a numeric literal or
+ * `false`. PR I's `extractLiteralExport` skips non-literal expressions
+ * silently — the build-time ISR manifest (`_pyreon-revalidate.json`)
+ * omits the entry, platform-driven ISR is silently unconfigured for
+ * that route. The user thinks ISR is wired but production stays stale
+ * forever.
+ *
+ * The rule scopes to route files (anything under `src/routes/`) — the
+ * `revalidate` convention only has meaning there. Module-level
+ * `const revalidate = X` in unrelated files is fine.
+ */
+import type { Rule, VisitorCallbacks } from '../../types'
+import { getSpan } from '../../utils/ast'
+
+const ROUTES_PATH_RE = /[/\\]routes[/\\]/
+
+function isLiteralOk(node: any): boolean {
+  if (!node) return false
+  // `60`, `3600`, etc.
+  if (node.type === 'Literal' && typeof node.value === 'number') return true
+  if (node.type === 'NumericLiteral' && typeof node.value === 'number') return true
+  // `false` (oxc emits `Literal` for booleans too; some shapes emit
+  // `BooleanLiteral`). Accept both.
+  if (node.type === 'Literal' && node.value === false) return true
+  if (node.type === 'BooleanLiteral' && node.value === false) return true
+  return false
+}
+
+export const revalidateNotPureLiteral: Rule = {
+  meta: {
+    id: 'pyreon/revalidate-not-pure-literal',
+    category: 'ssg',
+    description:
+      '`export const revalidate = X` must be a numeric literal or `false` — non-literal forms are silently dropped from the build-time ISR manifest (PR I limitation).',
+    severity: 'error',
+    fixable: false,
+  },
+  create(context) {
+    const filePath = context.getFilePath()
+    // Only scope to route files. The `revalidate` convention is fs-router-
+    // specific; module-level `const revalidate = X` in unrelated files is
+    // a different code path.
+    if (!ROUTES_PATH_RE.test(filePath)) return {}
+
+    const callbacks: VisitorCallbacks = {
+      ExportNamedDeclaration(node: any) {
+        const decl = node.declaration
+        if (!decl || decl.type !== 'VariableDeclaration') return
+        for (const declarator of decl.declarations ?? []) {
+          if (declarator.type !== 'VariableDeclarator') continue
+          const id = declarator.id
+          if (id?.type !== 'Identifier' || id.name !== 'revalidate') continue
+          const init = declarator.init
+          if (!init) continue
+          if (isLiteralOk(init)) continue
+          context.report({
+            message:
+              '`export const revalidate` must be a numeric literal (e.g. `60`, `3600`) or `false` — non-literal expressions (variable references, math, function calls, template literals) are silently dropped from the build-time ISR manifest. Inline the value: `export const revalidate = 60`.',
+            span: getSpan(init),
+          })
+        }
+      },
+    }
+    return callbacks
+  },
+}

package/src/runner.ts

@@ -161,8 +161,8 @@ export function lintFile(
     // Validate options against the rule's declared schema. Cached per
     // (rule, options) pair — config doesn't change within a run.
     const cacheKey = `${rule.meta.id}::${JSON.stringify(options)}`
-    let cached = VALIDATION_CACHE.get(cacheKey)
-    if (!cached) {
+    let validation = VALIDATION_CACHE.get(cacheKey)
+    if (!validation) {
       const { errors, warnings } = validateRuleOptions(rule, options)
       const configDiags: ConfigDiagnostic[] = []
       for (const message of warnings) {
@@ -171,17 +171,17 @@ export function lintFile(
       for (const message of errors) {
         configDiags.push({ ruleId: rule.meta.id, severity: 'error', message })
       }
-      cached = { ok: errors.length === 0, diagnostics: configDiags }
-      VALIDATION_CACHE.set(cacheKey, cached)
+      validation = { ok: errors.length === 0, diagnostics: configDiags }
+      VALIDATION_CACHE.set(cacheKey, validation)
     }
     // Surface config diagnostics once per (rule, options) pair: prefer
     // the caller-supplied sink (so `lint()` can put them on LintResult);
     // fall back to stderr for standalone `lintFile` usage.
-    if (cached.diagnostics.length > 0) {
+    if (validation.diagnostics.length > 0) {
       if (configDiagnosticsSink) {
         // Dedupe within the sink by (ruleId, message) so two different rules
         // that happen to produce an identical message don't collapse.
-        for (const d of cached.diagnostics) {
+        for (const d of validation.diagnostics) {
           if (
             !configDiagnosticsSink.some(
               (x) => x.ruleId === d.ruleId && x.message === d.message,
@@ -191,7 +191,7 @@ export function lintFile(
           }
         }
       } else {
-        for (const d of cached.diagnostics) {
+        for (const d of validation.diagnostics) {
           // oxlint-disable-next-line no-console
           const emit = d.severity === 'error' ? console.error : console.warn
           emit(`[pyreon-lint] ${d.message}`)
@@ -199,7 +199,7 @@ export function lintFile(
       }
     }
     // Hard error in options → skip this rule entirely for the run.
-    if (!cached.ok) continue
+    if (!validation.ok) continue
 
     const ctx = createRuleContext(
       rule,

package/src/tests/runner.test.ts

@@ -53,8 +53,8 @@ function lintWith(ruleId: string, source: string, filePath?: string) {
 // ── Rule Metadata ───────────────────────────────────────────────────────────
 
 describe('Rule metadata', () => {
-  it('should have 62 rules', () => {
-    expect(allRules.length).toBe(62)
+  it('should have 66 rules', () => {
+    expect(allRules.length).toBe(66)
   })
 
   it('should have unique rule IDs', () => {
@@ -83,6 +83,7 @@ describe('Rule metadata', () => {
       'hooks',
       'accessibility',
       'router',
+      'ssg',
     ])
     for (const rule of allRules) {
       expect(validCategories.has(rule.meta.category)).toBe(true)
@@ -94,7 +95,7 @@ describe('Rule metadata', () => {
     for (const rule of allRules) {
       counts[rule.meta.category] = (counts[rule.meta.category] ?? 0) + 1
     }
-    expect(counts.reactivity).toBe(12)
+    expect(counts.reactivity).toBe(13)
     expect(counts.jsx).toBe(11)
     expect(counts.lifecycle).toBe(5)
     expect(counts.performance).toBe(4)
@@ -106,6 +107,8 @@ describe('Rule metadata', () => {
     expect(counts.hooks).toBe(3)
     expect(counts.accessibility).toBe(3)
     expect(counts.router).toBe(4)
+    // M3.5 — SSG rules.
+    expect(counts.ssg).toBe(3)
   })
 })
 
@@ -1955,7 +1958,7 @@ describe('Ignore filter', () => {
 describe('Presets', () => {
   it('recommended should include all rules', () => {
     const config = getPreset('recommended')
-    expect(Object.keys(config.rules).length).toBe(62)
+    expect(Object.keys(config.rules).length).toBe(66)
   })
 
   it('strict should promote all warns to errors', () => {
@@ -3020,7 +3023,7 @@ describe('config-file round-trip', () => {
       const base = getPreset('recommended')
       const runtimeCfg: LintConfig = {
         ...base,
-        rules: { ...base.rules, ...(loaded?.rules ?? {}) },
+        rules: { ...base.rules, ...loaded?.rules },
       }
 
       // In an exempt path — rule silent.