@pyreon/compiler 0.18.0 → 0.20.0

package/src/tests/pyreon-intercept.test.ts

@@ -84,6 +84,137 @@ describe('detectPyreonPatterns', () => {
     })
   })
 
+  describe('props-destructured-body', () => {
+    const only = (code: string) =>
+      detectPyreonPatterns(code).filter((d) => d.code === 'props-destructured-body')
+
+    it('flags `const { x } = props` in an arrow component body', () => {
+      const code = `
+        const Greeting = (props: { name: string }) => {
+          const { name } = props
+          return <div>Hello {name}</div>
+        }
+      `
+      const diags = only(code)
+      expect(diags).toHaveLength(1)
+      expect(diags[0]!.code).toBe('props-destructured-body')
+      expect(diags[0]!.message).toContain('ONCE')
+      expect(diags[0]!.fixable).toBe(false)
+    })
+
+    it('flags it in a function-declaration component', () => {
+      const code = `
+        function Greeting(props: { name: string }) {
+          const { name } = props
+          return <div>Hello {name}</div>
+        }
+      `
+      expect(only(code)).toHaveLength(1)
+    })
+
+    it('flags let / var / alias / default / rest / nested shapes', () => {
+      const code = `
+        const A = (props: any) => { let { a } = props; return <i>{a}</i> }
+        const B = (props: any) => { var { b } = props; return <i>{b}</i> }
+        const C = (props: any) => { const { c: cc } = props; return <i>{cc}</i> }
+        const D = (props: any) => { const { d = 1 } = props; return <i>{d}</i> }
+        const E = (props: any) => { const { ...rest } = props; return <i>{rest.x}</i> }
+        const F = (props: any) => { const { f: { g } } = props; return <i>{g}</i> }
+      `
+      expect(only(code)).toHaveLength(6)
+    })
+
+    it('flags a destructure nested inside a body-scope if-block (still synchronous)', () => {
+      const code = `
+        const Gate = (props: any) => {
+          if (props.cond) { const { x } = props; return <i>{x}</i> }
+          return <i />
+        }
+      `
+      expect(only(code)).toHaveLength(1)
+    })
+
+    it('unwraps `as` / `satisfies` / `!` / parens on the initializer', () => {
+      const code = `
+        const A = (props: any) => { const { a } = props as Props; return <i>{a}</i> }
+        const B = (props: any) => { const { b } = (props); return <i>{b}</i> }
+        const C = (props: any) => { const { c } = props!; return <i>{c}</i> }
+        const D = (props: any) => { const { d } = props satisfies Props; return <i>{d}</i> }
+      `
+      expect(only(code)).toHaveLength(4)
+    })
+
+    it('does NOT flag `const x = props` (alias, no destructure)', () => {
+      const code = `
+        const Greeting = (props: any) => { const p = props; return <div>{p.name}</div> }
+      `
+      expect(only(code)).toEqual([])
+    })
+
+    it('does NOT flag a destructure off a non-props identifier', () => {
+      const code = `
+        const Greeting = (props: any) => {
+          const store = useStore()
+          const { name } = store
+          return <div>{name}{props.x}</div>
+        }
+      `
+      expect(only(code)).toEqual([])
+    })
+
+    it('does NOT flag `const { x } = props.nested` (member, out of canonical scope by design)', () => {
+      const code = `
+        const Greeting = (props: any) => { const { x } = props.nested; return <div>{x}</div> }
+      `
+      expect(only(code)).toEqual([])
+    })
+
+    it('does NOT flag destructures inside nested functions (handler / effect / returned accessor)', () => {
+      const code = `
+        const Handler = (props: any) => {
+          const onClick = () => { const { id } = props; doThing(id) }
+          effect(() => { const { y } = props; track(y) })
+          return <button onClick={onClick}>{() => { const { z } = props; return z }}</button>
+        }
+      `
+      expect(only(code)).toEqual([])
+    })
+
+    it('does NOT flag the returned reactive-accessor fix shape', () => {
+      const code = `
+        const Greeting = (props: any) =>
+          (() => { const { name } = props; return <div>Hello {name}</div> })
+      `
+      // The body is an arrow expression returning a nested accessor — the
+      // destructure lives inside the nested fn, which re-reads props.
+      expect(only(code)).toEqual([])
+    })
+
+    it('does NOT flag the parameter-destructure shape (props-destructured owns it)', () => {
+      const code = `
+        const Greeting = ({ name }: { name: string }) => <div>Hello {name}</div>
+      `
+      const diags = detectPyreonPatterns(code)
+      expect(diags.filter((d) => d.code === 'props-destructured-body')).toEqual([])
+      expect(diags.filter((d) => d.code === 'props-destructured')).toHaveLength(1)
+    })
+
+    it('does NOT flag non-component helpers that destructure an arg named props', () => {
+      const code = `
+        function mergeProps(props: any) { const { a, b } = props; return a + b }
+        const reducer = (props: any) => { const { x } = props; return x }
+      `
+      expect(only(code)).toEqual([])
+    })
+
+    it('does NOT flag a lowercase JSX-returning function (not component-shaped)', () => {
+      const code = `
+        const renderRow = (props: any) => { const { cell } = props; return <td>{cell}</td> }
+      `
+      expect(only(code)).toEqual([])
+    })
+  })
+
   describe('process-dev-gate', () => {
     it('flags typeof process + NODE_ENV production gates', () => {
       const code = `
@@ -624,4 +755,62 @@ describe('detectPyreonPatterns', () => {
       ).toBe(true)
     })
   })
+
+  describe('query-options-as-function', () => {
+    it('flags useQuery with an object-literal first arg', () => {
+      const code = `const q = useQuery({ queryKey: ['user', id()], queryFn: fetchUser })`
+      const diags = detectPyreonPatterns(code)
+      const d = diags.find((x) => x.code === 'query-options-as-function')
+      expect(d).toBeDefined()
+      expect(d!.fixable).toBe(false)
+      expect(d!.message).toContain('FUNCTION')
+      expect(d!.suggested).toBe(
+        "useQuery(() => ({ queryKey: ['user', id()], queryFn: fetchUser }))",
+      )
+    })
+
+    it('flags useInfiniteQuery / useQueries / useSuspenseQuery too', () => {
+      for (const hook of [
+        'useInfiniteQuery',
+        'useQueries',
+        'useSuspenseQuery',
+      ]) {
+        const diags = detectPyreonPatterns(`const r = ${hook}({ queryKey: ['k'] })`)
+        expect(
+          diags.some((d) => d.code === 'query-options-as-function'),
+        ).toBe(true)
+      }
+    })
+
+    it('does NOT flag the correct function form', () => {
+      const code = `const q = useQuery(() => ({ queryKey: ['user', id()], queryFn: fetchUser }))`
+      const diags = detectPyreonPatterns(code)
+      expect(
+        diags.some((d) => d.code === 'query-options-as-function'),
+      ).toBe(false)
+    })
+
+    it('does NOT flag useMutation (options are a plain object by design)', () => {
+      const code = `const m = useMutation({ mutationFn: save, onSuccess })`
+      const diags = detectPyreonPatterns(code)
+      expect(
+        diags.some((d) => d.code === 'query-options-as-function'),
+      ).toBe(false)
+    })
+
+    it('does NOT flag an identifier / call options arg (unprovable)', () => {
+      const code = `const a = useQuery(opts); const b = useQuery(makeOpts())`
+      const diags = detectPyreonPatterns(code)
+      expect(
+        diags.some((d) => d.code === 'query-options-as-function'),
+      ).toBe(false)
+    })
+
+    it('hasPyreonPatterns pre-filter recognizes the object-literal form', () => {
+      expect(hasPyreonPatterns(`useQuery({ queryKey: ['k'] })`)).toBe(true)
+      expect(hasPyreonPatterns(`useQuery(() => ({ queryKey: ['k'] }))`)).toBe(
+        false,
+      )
+    })
+  })
 })

package/src/tests/r13-callback-stmt-equivalence.test.ts

@@ -0,0 +1,58 @@
+/**
+ * Compiler hardening — Round 13 (REAL JS↔Rust divergence, FIXED + bisect).
+ *
+ * R7 (#687) taught the native `collect_prop_derived_idents` to recurse into
+ * callback bodies — but its `collect_pd_in_stmt` only handled
+ * Expression/Return/VarDecl/If/Block, with `_ => {}` skipping
+ * For/While/DoWhile/Switch/Try/Labeled. So a prop-derived const used inside a
+ * callback whose body is one of those shapes still lost reactivity in the
+ * NATIVE backend (preferred in prod) while the JS backend inlined it — the
+ * exact R7 reactivity-loss class, narrower shapes (e.g. `try { return <li
+ * class={c}/> } catch …` in a render callback — plausible defensive render).
+ *
+ * Fix: native/src/lib.rs `collect_pd_in_stmt` now also handles
+ * For/ForIn/ForOf/While/DoWhile/Switch/Try/Labeled, with the SAME
+ * `pd_minus`/`collect_bind_pattern_names` shadow-filter discipline as the
+ * Block/If arms (so loop/catch-param bindings shadow correctly and the
+ * over-substitution clobber is NOT re-introduced — verified by the
+ * catch-param spec).
+ *
+ * Bisect: replace the new arms with `_ => {}` + `bun scripts/build-native.ts`
+ * → these specs fail (Rust emits `class={c}`, JS `class={(p.x+'-b')}`).
+ * Restore + rebuild → all pass. The 180 native-equivalence tests + full
+ * suite remain green (no regression).
+ */
+import { describe, expect, it } from 'vitest'
+import { transformJSX, transformJSX_JS } from '../jsx'
+
+const j = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
+const r = (c: string): string => transformJSX(c, 'c.tsx').code ?? ''
+
+const CASES: Array<[string, string]> = [
+  ['while', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { while(i){ return <li class={c}/> } })}</ul> }`],
+  ['switch', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { switch(i){ default: return <li class={c}/> } })}</ul> }`],
+  ['labeled', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { lbl: { return <li class={c}/> } })}</ul> }`],
+  ['try-catch', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { try { return <li class={c}/> } catch { return null } })}</ul> }`],
+  ['for', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { for(let k=0;k<i;k++){ return <li class={c}/> } })}</ul> }`],
+]
+
+describe('Round 13 — prop-derived inlining inside callback statement shapes is JS≡Rust', () => {
+  for (const [name, src] of CASES) {
+    it(`${name}: native backend matches JS (inlines the prop-derived const)`, () => {
+      expect(r(src)).toBe(j(src))
+      expect(r(src)).toContain("class={(p.x+'-b')}")
+    })
+  }
+
+  it('catch-param shadowing is NOT clobbered (filter discipline, both backends)', () => {
+    const src = `function C(p){ const e=p.x+'-b'; return <ul>{p.i.map(i => { try {} catch (e) { return <li class={e}/> } })}</ul> }`
+    expect(r(src)).toBe(j(src))
+    expect(r(src)).not.toContain("class={(p.x+'-b')}") // `e` is the catch param
+  })
+
+  it('nested const inside a while body shadowing the prop-derived is NOT clobbered (no R2 regression)', () => {
+    const src = `function C(p){ const c=p.x; return <ul>{p.i.map(i => { while(i){ const c=2; return <li>{c}</li> } })}</ul> }`
+    expect(r(src)).toBe(j(src))
+    expect(r(src)).not.toContain('{(p.x)}') // inner `const c=2` shadows — must stay `{c}`
+  })
+})

package/src/tests/r14-ssr-mode-parity.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Compiler hardening — Round 14 (SSR-mode robustness; no bug found).
+ *
+ * Rounds 1–13 were all client-mode. SSR mode (`{ ssr: true }`) disables
+ * template emission (`if (ssr) return false`) and leaves JSX as
+ * accessor-wrapped expressions for the SSR renderer. Probed 8 adversarial
+ * shapes — all emit parseable code, and the correctness-critical contracts
+ * hold in SSR exactly as in client mode: prop-derived consts still inline,
+ * signals still auto-call, and the R11 shadow fix still suppresses a
+ * destructured callback param. This locks SSR-mode parity for the bug fixes
+ * so a future SSR-path change can't silently regress them.
+ */
+import { parseSync } from 'oxc-parser'
+import { describe, expect, it } from 'vitest'
+import { transformJSX_JS } from '../jsx'
+
+const ssr = (c: string): string => transformJSX_JS(c, 'c.tsx', { ssr: true }).code ?? ''
+const parses = (o: string): boolean => {
+  try {
+    return (parseSync('o.tsx', o).errors?.length ?? 0) === 0
+  } catch {
+    return false
+  }
+}
+
+describe('Round 14 — SSR-mode codegen parity', () => {
+  it('SSR never throws / always emits parseable code (8 adversarial shapes)', () => {
+    const shapes = [
+      `function C(p){ return <div class={p.c}>{p.t}</div> }`,
+      `function C(p){ return <div {...p}>{p.k}</div> }`,
+      `function C(p){ return <>{p.a}<span>{p.b}</span></> }`,
+      `function C(){ const h=<h1>T</h1>; return <div>{h}<p>x</p></div> }`,
+      `function C(p){ return <section><h1>{p.t}</h1><p>{p.b}</p></section> }`,
+    ]
+    for (const s of shapes) expect(parses(ssr(s)), s).toBe(true)
+  })
+
+  it('prop-derived const still inlines in SSR (R2/R7 parity)', () => {
+    expect(ssr(`function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i=><li class={c}>{i}</li>)}</ul> }`))
+      .toContain("class={(p.x+'-b')}")
+  })
+
+  it('signal still auto-calls in SSR', () => {
+    expect(ssr(`function C(){ const s=signal(0); return <div>{s}</div> }`)).toContain('s()')
+  })
+
+  it('R11 shadow fix applies in SSR (destructured param NOT auto-called)', () => {
+    expect(ssr(`function C(){ const x=signal(0); return <ul>{[{x:1}].map(({x})=><li>{x}</li>)}</ul> }`))
+      .not.toContain('{x()}')
+  })
+})

package/src/tests/r15-elemconst-propderived.test.ts

@@ -0,0 +1,47 @@
+/**
+ * Compiler hardening — Round 15 (element-const that references a prop-derived
+ * var) — consolidated, deterministic JS-backend characterization.
+ *
+ * Original finding: `const cls = props.x + '-b'; const el = <i class={cls}/>;`
+ * used as a bare `{el}` child sat at the intersection of R2 (prop-derived
+ * inlining) and R9 (element-const → `_mountSlot`). The JS backend substitutes
+ * the element-const's whole initializer into the mount call with the
+ * prop-derived part inlined reactively:
+ *   `_mountSlot((<i class={(props.x + '-b')}/>), …)`
+ *
+ * It was previously tracked by two duplicate, environment-fragile `it.fails`
+ * JS↔Rust divergence locks. The R13 gate/collector fix
+ * (`accesses_props` now recurses arrow/JSX → the element-const's prop-derived
+ * ref is collected) realigned the native backend with JS — so the locks
+ * correctly auto-flipped and were removed (lock→resolved, same lifecycle as
+ * R7/R11/R13). JS↔Rust byte-equivalence is now gated generally by the R20
+ * sweep + R13's own contract; this file keeps only the DETERMINISTIC,
+ * native-independent JS-backend assertions (no `transformJSX` native call →
+ * no build-artifact fragility, stable on every runner).
+ */
+import { describe, expect, it } from 'vitest'
+import { transformJSX_JS } from '../jsx'
+
+const emit = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
+
+const PD_ELEM = `function C(p){ const cls=p.x+'-b'; const el=<i class={cls}/>; return <div>{el}<span class={cls}/></div> }`
+const SIMPLE = `function C(){ const h=<h1>T</h1>; return <div>{h}<p>x</p></div> }`
+const REUSED = `function C(){ const ic=<svg/>; return <div>{ic}<span>{ic}</span></div> }`
+
+describe('Round 15 — element-const × prop-derived (JS backend characterization)', () => {
+  it('JS inlines a prop-derived-referencing element-const into _mountSlot with a reactive class', () => {
+    const out = emit(PD_ELEM)
+    expect(out).toContain("_mountSlot((<i class={(p.x+'-b')}/>)")
+    // the prop-derived class is the reactive form, not the frozen const ref
+    expect(out).not.toMatch(/_mountSlot\(\s*el\b/)
+  })
+
+  it('a simple element-const child routes through _mountSlot (R9 baseline)', () => {
+    expect(emit(SIMPLE)).toContain('_mountSlot(h')
+  })
+
+  it('an element-const reused at two sites routes both through _mountSlot', () => {
+    const out = emit(REUSED)
+    expect(out).toMatch(/_mountSlot\(\s*ic\b/)
+  })
+})

package/src/tests/r19-defer-inline-robust.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Compiler hardening — Round 19 (defer-inline robustness; no bug found).
+ *
+ * `transformDeferInline` (a separate compiler entry, unprobed in rounds
+ * 1–18) rewrites `<Defer when={…}><X/></Defer>` to inline its children.
+ * Probed 10 valid shapes (no-children, multi-child, expr/text child, nested
+ * Defer, self-closing, spread child, comment child, passthrough) + a
+ * malformed input — all valid cases emit parseable code, and malformed input
+ * is passed through unchanged without throwing (same resilience contract as
+ * Round 10). This locks the surface.
+ */
+import { parseSync } from 'oxc-parser'
+import { describe, expect, it } from 'vitest'
+import { transformDeferInline } from '../defer-inline'
+
+const run = (c: string): string => {
+  const r = transformDeferInline(c, 'c.tsx') as { code?: string }
+  return r?.code ?? ''
+}
+const parses = (o: string): boolean => {
+  try {
+    return (parseSync('o.tsx', o).errors?.length ?? 0) === 0
+  } catch {
+    return false
+  }
+}
+
+const VALID: Array<[string, string]> = [
+  ['basic', `import { Modal } from './M'\nfunction C(){ const o=signal(0); return <Defer when={o()}><Modal title="hi"/></Defer> }`],
+  ['passthrough', `function C(){ return <div>{x}</div> }`],
+  ['no-children', `function C(){ return <Defer when={a}></Defer> }`],
+  ['multi-child', `import {A,B} from './x'\nfunction C(){ return <Defer when={c}><A/><B/></Defer> }`],
+  ['expr-child', `function C(){ return <Defer when={c}>{val}</Defer> }`],
+  ['nested-defer', `import {A} from './x'\nfunction C(){ return <Defer when={a}><Defer when={b}><A/></Defer></Defer> }`],
+  ['text-child', `function C(){ return <Defer when={c}>plain text</Defer> }`],
+  ['self-closing', `function C(){ return <Defer when={c}/> }`],
+  ['spread-child', `import {A} from './x'\nfunction C(p){ return <Defer when={c}><A {...p}/></Defer> }`],
+  ['comment-child', `function C(){ return <Defer when={c}>{/* x */}</Defer> }`],
+]
+
+describe('Round 19 — transformDeferInline robustness', () => {
+  for (const [name, src] of VALID) {
+    it(`emits parseable code: ${name}`, () => {
+      let out = ''
+      expect(() => {
+        out = run(src)
+      }).not.toThrow()
+      expect(parses(out)).toBe(true)
+    })
+  }
+  it('malformed input is passed through without throwing (resilience)', () => {
+    expect(() => run(`function C(){ return <Defer when={</Defer> }`)).not.toThrow()
+  })
+})

package/src/tests/r20-backend-equivalence-sweep.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Compiler hardening — Round 20 (JS↔Rust equivalence sweep, R11–R19 corpus).
+ *
+ * The dual backends MUST emit byte-identical output. This sweep locks the
+ * adversarial corpus surfaced in rounds 11–19 where BOTH backends agree, so a
+ * future one-backend change that introduces a divergence (the recurring
+ * R7/R13/R15 one-backend-change failure mode) is caught immediately. R11's
+ * and R13's fixes CONVERGED the backends (R11 brought JS onto the
+ * already-correct Rust; R13's gate/collector fix realigned native with JS,
+ * which also resolved the R15 element-const×prop-derived divergence) — those
+ * shapes must now stay identical, asserted here. The earlier self-
+ * discriminating `it.fails` divergence locks auto-flipped on resolution and
+ * were removed; R15's residual is a deterministic JS-backend
+ * characterization (r15-elemconst-propderived.test.ts).
+ */
+import { describe, expect, it } from 'vitest'
+import { transformJSX, transformJSX_JS } from '../jsx'
+
+const EQUIVALENT: Array<[string, string]> = [
+  // R11 — signal-auto-call shadowing (JS converged to Rust)
+  ['r11-destructured-param', `function C(){ const x = signal(0); return <ul>{[{x:1}].map(({x}) => <li>{x}</li>)}</ul> }`],
+  ['r11-filter-obj-param', `function C(){ const id = signal(0); return <ul>{[{id:1}].filter(({id}) => id > 0).map(r => <li>{r}</li>)}</ul> }`],
+  ['r11-plain-param-shadow', `function C(){ const s = signal(0); return <ul>{[1].map(s => <li>{s}</li>)}</ul> }`],
+  ['r11-direct-signal', `function C(){ const s = signal(0); return <div>{s}</div> }`],
+  ['r11-signal-shadow-sibling', `function C(){ const s = signal(0); return <div>{[1].map(s => <i>{s}</i>)}<b>{s}</b></div> }`],
+  // R16 — knownSignals (cross-module signal) path
+  ['r16-knownsignal-shadow', `function C(){ return <ul>{[{count:1}].map(({count}) => <li>{count}</li>)}</ul> }`],
+  // R15 — element-const interactions that DO converge
+  ['r15-simple-elem-const', `function C(){ const h=<h1>T</h1>; return <div>{h}<p>x</p></div> }`],
+  ['r15-elem-const-reused', `function C(){ const ic=<svg/>; return <div>{ic}<span>{ic}</span></div> }`],
+  // R17 — spread depth
+  ['r17-root-spread-reactive', `function C(p){ const s=signal(0); return <div {...p} onClick={()=>s.set(1)}>{s}</div> }`],
+  ['r17-component-spread-pd', `function C(p){ const c=p.x+'-b'; return <Comp {...p} class={c}/> }`],
+  ['r17-double-spread', `function C(p){ return <div {...p.a} {...p.b}>{p.c}</div> }`],
+  // R18 — hoisting × elementVars
+  ['r18-hoist-vs-elemconst', `function C(){ const e=<b>x</b>; return <div>{<i/>}{e}</div> }`],
+  ['r18-elemconst-reused-3x', `function C(){ const e=<hr/>; return <div>{e}{e}{e}</div> }`],
+  // R13 — the convergent control (return-body callback)
+  ['r13-return-cb', `function C(p){ const c=p.x+'-b'; return <ul>{p.i.map(i => { return <li class={c}>{i}</li> })}</ul> }`],
+  // general
+  ['mixed', `function C(p){ const a=p.x; return <section><h1>{a}</h1>{p.i.map(i=><p key={i.id}>{i.t}</p>)}</section> }`],
+]
+
+describe('Round 20 — JS↔Rust byte-equivalence (R11–R19 corpus)', () => {
+  for (const [name, code] of EQUIVALENT) {
+    it(`${name}: JS ≡ Rust`, () => {
+      expect(transformJSX(code, 'c.tsx').code).toBe(transformJSX_JS(code, 'c.tsx').code)
+    })
+  }
+})

package/src/tests/react-intercept.test.ts

@@ -333,8 +333,8 @@ describe('detectReactPatterns', () => {
     expect(d!.fixable).toBe(true)
   })
 
-  test('detects .value assignment on signal-like variable', () => {
-    const code = 'count.value = 5'
+  test('detects .value assignment on a declared signal', () => {
+    const code = 'const count = signal(0)\ncount.value = 5'
     const diags = detectReactPatterns(code)
     const d = diags.find((d) => d.code === 'dot-value-signal')
     expect(d).toBeDefined()
@@ -343,6 +343,54 @@ describe('detectReactPatterns', () => {
     expect(d!.fixable).toBe(false)
   })
 
+  // ─── dot-value-signal precision (FP-free): only flag tracked signals ──────
+
+  test('flags .value write on signal(), computed(), useSignal(), createSignal()', () => {
+    for (const factory of ['signal', 'computed', 'useSignal', 'createSignal']) {
+      const code = `const s = ${factory}(0)\ns.value = 1`
+      const diags = detectReactPatterns(code)
+      const d = diags.find((d) => d.code === 'dot-value-signal')
+      expect(d, `expected dot-value-signal for ${factory}`).toBeDefined()
+      expect(d!.suggested).toContain('s.set(1)')
+    }
+  })
+
+  test('does NOT flag input.value = "" (DOM element, not a signal)', () => {
+    const code = `const input = document.querySelector("input")\ninput.value = ""`
+    const diags = detectReactPatterns(code)
+    expect(diags.find((d) => d.code === 'dot-value-signal')).toBeUndefined()
+  })
+
+  test('does NOT flag cell.value = x (data object, not a signal)', () => {
+    const code = `const cell = sheet.getCell(1, 1)\ncell.value = "hello"`
+    const diags = detectReactPatterns(code)
+    expect(diags.find((d) => d.code === 'dot-value-signal')).toBeUndefined()
+  })
+
+  test('does NOT flag o.value = y (loop option object, not a signal)', () => {
+    const code = `for (const o of options) { o.value = y }`
+    const diags = detectReactPatterns(code)
+    expect(diags.find((d) => d.code === 'dot-value-signal')).toBeUndefined()
+  })
+
+  test('does NOT flag ref.current.value = z (ref pattern, not a signal)', () => {
+    const code = `const ref = useRef(null)\nref.current.value = 42`
+    const diags = detectReactPatterns(code)
+    expect(diags.find((d) => d.code === 'dot-value-signal')).toBeUndefined()
+  })
+
+  test('does NOT flag bare X.value = n with no signal declaration', () => {
+    const code = 'count.value = 5'
+    const diags = detectReactPatterns(code)
+    expect(diags.find((d) => d.code === 'dot-value-signal')).toBeUndefined()
+  })
+
+  test('does NOT flag .value write on a let/var (mutable, unreliable)', () => {
+    const code = `let maybe = signal(0)\nmaybe = 5\nmaybe.value = 1`
+    const diags = detectReactPatterns(code)
+    expect(diags.find((d) => d.code === 'dot-value-signal')).toBeUndefined()
+  })
+
   test('detects .map() in JSX expression', () => {
     const code = 'const el = <ul>{items.map(item => <li>{item}</li>)}</ul>'
     const diags = detectReactPatterns(code)