@pyreon/compiler 0.16.0 → 0.19.0

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

@@ -0,0 +1,387 @@
+import { transformDeferInline } from '../defer-inline'
+
+describe('transformDeferInline — basic rewrites', () => {
+  test('rewrites <Defer when={x}><Modal /></Defer> with named import', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+
+export function App() {
+  const open = () => true
+  return <Defer when={open}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).not.toContain("import { Modal } from './Modal'")
+    expect(result.code).toContain(`chunk={() => import('./Modal').then((__m) => ({ default: __m.Modal }))}`)
+    expect(result.code).toContain('{(__C) => <__C />}')
+  })
+
+  test('rewrites with default import', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import Modal from './Modal'
+
+export function App() {
+  return <Defer when={() => true}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).not.toContain('import Modal from')
+    expect(result.code).toContain(`chunk={() => import('./Modal')}`)
+    expect(result.code).not.toContain(`.then((__m) =>`)
+  })
+
+  test('preserves other props on Defer (fallback, when, on)', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+export function App() {
+  return <Defer when={() => true} fallback={<span>loading</span>}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).toContain('when={() => true}')
+    expect(result.code).toContain('fallback={<span>loading</span>}')
+  })
+
+  test('works for on="visible" trigger', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Comments } from './Comments'
+export function Post() {
+  return <Defer on="visible"><Comments /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'post.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).toContain('on="visible"')
+    expect(result.code).toContain(`chunk={() => import('./Comments').then((__m) => ({ default: __m.Comments }))}`)
+  })
+})
+
+describe('transformDeferInline — bail-out cases', () => {
+  test('leaves unchanged when chunk prop is already provided', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+export function App() {
+  return (
+    <Defer chunk={() => import('./Modal')} when={() => true}>
+      {Modal => <Modal />}
+    </Defer>
+  )
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    expect(result.code).toBe(input)
+    expect(result.warnings).toEqual([])
+  })
+
+  test('warns when inline child is also used outside the Defer', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+const eagerCopy = <Modal />
+export function App() {
+  return <Defer when={() => true}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    expect(result.warnings).toHaveLength(1)
+    expect(result.warnings[0]!.code).toBe('defer-inline/import-used-elsewhere')
+  })
+
+  test('warns when inline child is not imported', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+export function App() {
+  return <Defer when={() => true}><LocalThing /></Defer>
+}
+function LocalThing() { return null }
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    expect(result.warnings).toHaveLength(1)
+    expect(result.warnings[0]!.code).toBe('defer-inline/import-not-found')
+  })
+
+  test('skips Defer with multiple children (still requires render-prop form)', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+import { Spinner } from './Spinner'
+export function App() {
+  return <Defer when={() => true}><Modal /><Spinner /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    // v2 now emits a `multiple-children` warning so the author knows to use
+    // the explicit `chunk` form. v1 was silent — that was a footgun.
+    expect(result.changed).toBe(false)
+    expect(result.warnings[0]?.code).toBe('defer-inline/multiple-children')
+  })
+
+  test('fast-path: no Defer in source returns unchanged', () => {
+    const input = `
+import { signal } from '@pyreon/reactivity'
+export const count = signal(0)
+`
+    const result = transformDeferInline(input, 'count.ts')
+    expect(result.changed).toBe(false)
+    expect(result.code).toBe(input)
+  })
+
+  test('does not blow up on syntactically-invalid source — returns unchanged', () => {
+    const input = `import {{{ Defer broken syntax`
+    const result = transformDeferInline(input, 'broken.tsx')
+    expect(result.changed).toBe(false)
+    // Returns the input unchanged; downstream parser will surface the real error.
+    expect(result.code).toBe(input)
+  })
+
+  // v1 bailed on `{ Modal as M }`. v2 handles renamed imports — the
+  // local name in JSX is `M`, but the chunk extracts `__m.Modal` (the
+  // original exported name). See the positive test in the v2 section.
+})
+
+describe('transformDeferInline — v2 capabilities', () => {
+  test('preserves props on inline child', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+export function App() {
+  return <Defer when={() => true}><Modal title="Confirm" size="md" /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).not.toContain("import { Modal }")
+    // Props pass through verbatim. Only the component name is replaced.
+    expect(result.code).toContain('{(__C) => <__C title="Confirm" size="md" />}')
+  })
+
+  test('preserves nested children on inline child (non-self-closing)', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+export function App() {
+  return (
+    <Defer when={() => true}>
+      <Modal title="Hello">
+        <p>nested content</p>
+      </Modal>
+    </Defer>
+  )
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    // Both opening AND closing tag names replaced with __C; nested JSX intact.
+    expect(result.code).toContain('<__C title="Hello">')
+    expect(result.code).toContain('</__C>')
+    expect(result.code).toContain('<p>nested content</p>')
+  })
+
+  test('captures closure variables via render-prop scope (signal in handler)', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { signal } from '@pyreon/reactivity'
+import { Modal } from './Modal'
+
+export function App() {
+  const open = signal(false)
+  const count = signal(0)
+  return (
+    <Defer when={open}>
+      <Modal count={count} onClose={() => open.set(false)} />
+    </Defer>
+  )
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    // The render-prop arrow naturally captures `count` + `open.set` from
+    // the App function's scope — no closure-tracking pass needed, JS
+    // lexical scope just works.
+    expect(result.code).toContain('<__C count={count} onClose={() => open.set(false)} />')
+  })
+
+  test('handles renamed imports — { Modal as M }', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal as M } from './Modal'
+export function App() {
+  return <Defer when={() => true}><M /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    // Local name `M` is used at the JSX site, but the chunk extracts
+    // `__m.Modal` (the original exported name from './Modal').
+    expect(result.code).toContain(`chunk={() => import('./Modal').then((__m) => ({ default: __m.Modal }))}`)
+    expect(result.code).not.toContain("import { Modal as M }")
+    expect(result.code).toContain('{(__C) => <__C />}')
+  })
+
+  test('multi-specifier import: drops only the Defer-targeted binding', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal, OtherThing } from './shared'
+export function App() {
+  const use = OtherThing
+  return <Defer when={() => true}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    // OtherThing is referenced elsewhere — its import must survive.
+    expect(result.code).toContain("OtherThing")
+    expect(result.code).toMatch(/import \{\s*OtherThing\s*\} from '\.\/shared'/)
+    // Modal binding is gone from the import declaration.
+    expect(result.code).not.toMatch(/import \{[^}]*\bModal\b[^}]*\}/)
+    // ...but the dynamic chunk pulls Modal from './shared' (same source).
+    expect(result.code).toContain(`chunk={() => import('./shared').then((__m) => ({ default: __m.Modal }))}`)
+  })
+})
+
+describe('transformDeferInline — multiple Defers in one file', () => {
+  test('rewrites two independent Defers with distinct imports', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+import { Comments } from './Comments'
+export function App() {
+  return (
+    <div>
+      <Defer when={() => true}><Modal /></Defer>
+      <Defer on="visible"><Comments /></Defer>
+    </div>
+  )
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).not.toContain("import { Modal } from './Modal'")
+    expect(result.code).not.toContain("import { Comments } from './Comments'")
+    expect(result.code).toContain(`chunk={() => import('./Modal').then((__m) => ({ default: __m.Modal }))}`)
+    expect(result.code).toContain(`chunk={() => import('./Comments').then((__m) => ({ default: __m.Comments }))}`)
+  })
+})
+
+// Gap 4 from the v2 follow-up roadmap. Namespace imports were the last
+// inline-Defer shape that fell back to the explicit form — closing this
+// gap means EVERY common import shape is supported by the inline form.
+describe('transformDeferInline — namespace imports (v3)', () => {
+  test('rewrites <M.Modal /> with namespace import — chunk extracts __m.Modal', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import * as M from './Modal'
+export function App() {
+  return <Defer when={() => true}><M.Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).toContain(`chunk={() => import('./Modal').then((__m) => ({ default: __m.Modal }))}`)
+    // M.Modal in the JSX replaced with __C (the whole member expression
+    // is the "name" range that gets substituted).
+    expect(result.code).toContain('{(__C) => <__C />}')
+    expect(result.code).not.toContain('import * as M from')
+  })
+
+  test('rewrites with props on member-expression child', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import * as M from './Modal'
+export function App() {
+  return <Defer when={() => true}><M.Modal title="hi" /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).toContain('{(__C) => <__C title="hi" />}')
+  })
+
+  test('non-self-closing member-expression child preserves opening + closing replacement', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import * as M from './Modal'
+export function App() {
+  return <Defer when={() => true}><M.Modal title="hi"><span>body</span></M.Modal></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).toContain('{(__C) => <__C title="hi"><span>body</span></__C>}')
+  })
+
+  test('bails when namespace is referenced elsewhere in the file', () => {
+    // `M` is used for multiple components. Removing the static import
+    // would break the other usage AND the dynamic import becomes a
+    // no-op (Rolldown bundles the module statically when ANY part is
+    // referenced).
+    const input = `
+import { Defer } from '@pyreon/core'
+import * as M from './Modal'
+export function App() {
+  void M.Settings
+  return <Defer when={() => true}><M.Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    expect(result.warnings).toHaveLength(1)
+    expect(result.warnings[0]!.code).toBe('defer-inline/import-used-elsewhere')
+  })
+
+  test('bails on deeper member expression — <M.Sub.X /> not supported', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import * as M from './Modal'
+export function App() {
+  return <Defer when={() => true}><M.Sub.Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    // analyzeChildElement returns null for non-depth-1 member
+    // expressions → no match in findDeferMatches → no warning. The
+    // Defer is left alone; runtime errors with "missing chunk".
+    expect(result.changed).toBe(false)
+  })
+
+  test('bails when member property is lowercase — <M.helper /> is not a component', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import * as M from './lib'
+export function App() {
+  return <Defer when={() => true}><M.helper /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+  })
+
+  test('bails when member expression but import is default (not namespace)', () => {
+    // `import M from './X'` (default) followed by `<M.Modal />` is a
+    // member access on the default-exported component itself, not a
+    // namespace lookup. Different semantics; out of scope. Compiler
+    // emits `unsupported-import-shape` so the author knows why.
+    const input = `
+import { Defer } from '@pyreon/core'
+import M from './Modal'
+export function App() {
+  return <Defer when={() => true}><M.Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    expect(result.warnings).toHaveLength(1)
+    expect(result.warnings[0]!.code).toBe('defer-inline/unsupported-import-shape')
+  })
+})

package/src/tests/detector-tag-consistency.test.ts

@@ -30,6 +30,7 @@ const COMPILER_CODES = [
   'for-missing-by',
   'for-with-key',
   'props-destructured',
+  'props-destructured-body',
   'process-dev-gate',
   'empty-theme',
   'raw-add-event-listener',
@@ -40,6 +41,7 @@ const COMPILER_CODES = [
   'static-return-null-conditional',
   'as-unknown-as-vnodechild',
   'island-never-with-registry-entry',
+  'query-options-as-function',
 ] as const
 type CompilerCode = (typeof COMPILER_CODES)[number]
 

package/src/tests/jsx.test.ts

@@ -283,13 +283,33 @@ describe('JSX transform — component elements', () => {
     expect(result).toContain('_rp(')
   })
 
-  test('spread props on component pass through without _rp wrapping', () => {
+  test('spread props on component are wrapped with _wrapSpread to preserve reactivity', () => {
     const result = t('<Comp {...getProps()} label="hi" />')
-    // Spread should remain as-is
-    expect(result).toContain('{...getProps()}')
+    // Spread argument is wrapped so getter-shaped reactive props survive
+    // esbuild's JS-level object spread in the automatic JSX runtime.
+    expect(result).toContain('{..._wrapSpread(getProps())}')
     // Static label should not be wrapped
     expect(result).not.toContain('_rp(() => "hi")')
   })
+
+  test('spread props on DOM elements are NOT wrapped (handled by template path)', () => {
+    const result = t('<div {...rest} class="x" />')
+    // DOM-element spreads go through the template path's _applyProps.
+    expect(result).toContain('{...rest}')
+    expect(result).not.toContain('_wrapSpread')
+  })
+
+  test('multiple spread sources on a component each get wrapped independently', () => {
+    const result = t('<Comp {...a} {...b} foo="x" />')
+    expect(result).toContain('{..._wrapSpread(a)}')
+    expect(result).toContain('{..._wrapSpread(b)}')
+  })
+
+  test('_wrapSpread emission is idempotent on re-compilation', () => {
+    const result = t('<Comp {..._wrapSpread(rest)} />')
+    // Should not double-wrap.
+    expect(result).not.toContain('_wrapSpread(_wrapSpread(')
+  })
 })
 
 // ─── Spread attributes ──────────────────────────────────────────────────────

package/src/tests/manifest-snapshot.test.ts

@@ -0,0 +1,55 @@
+import {
+  renderApiReferenceEntries,
+  renderLlmsFullSection,
+  renderLlmsTxtLine,
+} from '@pyreon/manifest'
+import manifest from '../manifest'
+
+describe('gen-docs — compiler snapshot', () => {
+  it('renders a llms.txt bullet starting with the package prefix', () => {
+    const line = renderLlmsTxtLine(manifest)
+    expect(line.startsWith('- @pyreon/compiler —')).toBe(true)
+  })
+
+  it('renders a llms-full.txt section with the right header', () => {
+    const section = renderLlmsFullSection(manifest)
+    expect(section.startsWith('## @pyreon/compiler —')).toBe(true)
+    expect(section).toContain('```typescript')
+  })
+
+  it('renders MCP api-reference entries for every api[] item', () => {
+    const record = renderApiReferenceEntries(manifest)
+    expect(Object.keys(record).sort()).toEqual([
+      'compiler/analyzeReactivity',
+      'compiler/auditIslands',
+      'compiler/auditSsg',
+      'compiler/auditTestEnvironment',
+      'compiler/detectPyreonPatterns',
+      'compiler/detectReactPatterns',
+      'compiler/diagnoseError',
+      'compiler/formatIslandAudit',
+      'compiler/formatReactivityLens',
+      'compiler/formatSsgAudit',
+      'compiler/formatTestAudit',
+      'compiler/generateContext',
+      'compiler/hasPyreonPatterns',
+      'compiler/hasReactPatterns',
+      'compiler/migrateReactCode',
+      'compiler/transformDeferInline',
+      'compiler/transformJSX',
+      'compiler/transformJSX_JS',
+    ])
+  })
+
+  it('flags the experimental Reactivity-Lens entries', () => {
+    const r = renderApiReferenceEntries(manifest)
+    expect(r['compiler/analyzeReactivity']?.notes).toContain('[EXPERIMENTAL]')
+    expect(r['compiler/formatReactivityLens']?.notes).toContain('[EXPERIMENTAL]')
+  })
+
+  it('carries the foot-gun catalog into MCP mistakes for flagship APIs', () => {
+    const r = renderApiReferenceEntries(manifest)
+    expect(r['compiler/transformJSX']?.mistakes).toBeTruthy()
+    expect(r['compiler/detectPyreonPatterns']?.mistakes).toContain('fixable')
+  })
+})

package/src/tests/native-equivalence.test.ts

@@ -5,11 +5,23 @@
  * between the two backends.
  */
 import { transformJSX_JS } from '../jsx'
+import type { ReactivitySpan } from '../jsx'
 
 // Load native if available
-let nativeTransform: ((code: string, filename: string, ssr: boolean, knownSignals: string[] | null) => {
-  code: string; usesTemplates?: boolean | null; warnings: Array<{ message: string; line: number; column: number; code: string }>
-}) | null = null
+let nativeTransform:
+  | ((
+      code: string,
+      filename: string,
+      ssr: boolean,
+      knownSignals: string[] | null,
+      reactivityLens?: boolean,
+    ) => {
+      code: string
+      usesTemplates?: boolean | null
+      warnings: Array<{ message: string; line: number; column: number; code: string }>
+      reactivityLens?: ReactivitySpan[] | null
+    })
+  | null = null
 
 try {
   const path = require('node:path')
@@ -39,6 +51,50 @@ function compareSsr(input: string) {
   expect(rs.code).toBe(js.code)
 }
 
+// Reactivity-lens cross-backend gate (Phase 3). Asserts the Rust binary
+// emits the SAME sidecar the JS oracle does. Two contracts:
+//   1. ADDITIVE — `code` is byte-identical with the lens collected vs
+//      not, on BOTH backends (the option never affects codegen).
+//   2. PARITY — the SET of recorded spans is identical JS↔Rust.
+// Spans are compared order-independently: the LSP consumer sorts before
+// rendering, so traversal order is NOT part of the contract — the SET of
+// codegen decisions is. Sorting by (start,end,kind,detail) makes a
+// missing/extra/wrong span fail loudly while ignoring walk order.
+function canon(spans: ReactivitySpan[] | null | undefined): string[] {
+  return (spans ?? [])
+    .map(
+      (s) =>
+        `${s.start}|${s.end}|${s.line}|${s.column}|${s.endLine}|${s.endColumn}|${s.kind}|${s.detail}`,
+    )
+    .sort()
+}
+
+function compareLens(input: string, filename = 'test.tsx') {
+  const jsOff = transformJSX_JS(input, filename)
+  const jsOn = transformJSX_JS(input, filename, { reactivityLens: true })
+  const rsOff = nativeTransform!(input, filename, false, null, false)
+  const rsOn = nativeTransform!(input, filename, false, null, true)
+
+  // (1) additive — collecting the lens never changes emitted code, on
+  // either backend, and both backends still agree on that code.
+  expect(jsOn.code).toBe(jsOff.code)
+  expect(rsOn.code).toBe(rsOff.code)
+  expect(rsOn.code).toBe(jsOn.code)
+
+  // The opt-out path must NOT carry the sidecar (parity with JS, which
+  // omits the field entirely when not collecting).
+  expect(rsOff.reactivityLens == null).toBe(true)
+  expect(jsOff.reactivityLens == null).toBe(true)
+
+  // (2) parity — identical SET of spans.
+  const j = canon(jsOn.reactivityLens)
+  const r = canon(rsOn.reactivityLens)
+  expect(r).toEqual(j)
+  // Guard against the degenerate "both empty → trivially equal" pass:
+  // every fixture below is chosen to produce ≥1 span.
+  expect(j.length).toBeGreaterThan(0)
+}
+
 // ─── Cross-backend equivalence ──────────────────────────────────────────────
 
 describeNative('Native vs JS equivalence — basic', () => {
@@ -729,3 +785,48 @@ describeNative('Native vs JS equivalence — DOM properties', () => {
     compare('<div><input title={x()} /></div>')
   })
 })
+
+// ─── Reactivity-lens parity (Phase 3) ───────────────────────────────────────
+// The Rust binary must emit the SAME sidecar as the JS oracle so the
+// ~80% of users on the native path get the Lens too. Each fixture is
+// chosen to exercise one of the five structural kinds; `compareLens`
+// also asserts the additive guarantee (codegen byte-identical with the
+// option on vs off, both backends) so this block doubles as the native
+// regression guard for "the lens option must never affect output".
+//
+// Bisect-verified: removing ANY of the 6 `ctx.lens(...)` calls in
+// native/src/lib.rs fails the matching fixture below with an
+// array-length / element mismatch in `compareLens`'s parity assertion
+// (e.g. dropping the `reactive-prop` call → `<Comp value={x()} />` fails
+// `expect(r).toEqual(j)` because the Rust set is missing that span);
+// restored → 9/9 pass.
+describeNative('Reactivity-lens — JS↔Rust span parity', () => {
+  test('reactive text child (_bindText)', () =>
+    compareLens('<div>{count()}</div>'))
+
+  test('reactive accessor text child (() => …)', () =>
+    compareLens('<div>{() => count()}</div>'))
+
+  test('static-text child (baked once — the high-precision negative)', () =>
+    compareLens('<div>{someConst}</div>'))
+
+  test('reactive-prop on a component (_rp(() => …))', () =>
+    compareLens('<Comp value={count()} />'))
+
+  test('reactive-attr on a DOM element (live binding)', () =>
+    compareLens('<div><span title={count()}>hi</span></div>'))
+
+  test('hoisted-static (module-scope hoist)', () =>
+    compareLens('<Comp>{<b class="x">hi</b>}</Comp>'))
+
+  test('mixed: reactive + static + prop in one tree', () =>
+    compareLens(
+      '<section><Comp value={count()} /><p>{count()}</p><p>{label}</p></section>',
+    ))
+
+  test('multi-line source — line/column parity across newlines', () =>
+    compareLens('<div>\n  {count()}\n  <span title={other()}>\n  z</span>\n</div>'))
+
+  test('signal auto-call shape — declared signal, bare {count} → reactive', () =>
+    compareLens('const count = signal(0); const App = () => <div>{count}</div>', 'auto.tsx'))
+})