@pyreon/compiler 0.24.5 → 0.24.6

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

@@ -1,387 +0,0 @@
-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/depth-stress.test.ts

@@ -1,16 +0,0 @@
-import { transformJSX } from '../jsx'
-
-const t = (code: string) => transformJSX(code, 'input.tsx').code
-
-describe('T0.2 — chain depth stress test', () => {
-  for (const depth of [4, 5, 10, 20, 50]) {
-    test(`depth ${depth} chain compiles without crashing`, () => {
-      const lines = ['const v0 = props.x']
-      for (let i = 1; i <= depth; i++) lines.push(`const v${i} = v${i - 1} + 1`)
-      const code = `function Comp(props) { ${lines.join('; ')}; return <div>{v${depth}}</div> }`
-      const result = t(code)
-      expect(result).toContain('props.x')
-      expect(result).toContain('_bind')
-    })
-  }
-})

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

@@ -1,101 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-// Drift guard between Pyreon's static detectors (compiler + lint) and the
-// `[detector: <code>]` annotations on `.claude/rules/anti-patterns.md`.
-// Without this test, a new bullet can land without a detector tag, or
-// a detector code can be renamed without updating the doc. Either
-// direction is a silent inconsistency — consumers read the doc and
-// expect the detector to back it up.
-//
-// The test does one thing: every `[detector: CODE]` tag in the doc
-// must reference a known detector (compiler PyreonDiagnosticCode OR
-// @pyreon/lint rule ID without the `pyreon/` prefix), and every
-// compiler PyreonDiagnosticCode must appear at least once in the doc
-// so the tag-documentation loop is closed.
-//
-// Lint rules are NOT required to appear in anti-patterns.md (some are
-// stylistic, not anti-pattern shaped). When they DO appear with a
-// `[detector:]` tag, the tag must match the rule ID's local part.
-
-const HERE = dirname(fileURLToPath(import.meta.url))
-const REPO_ROOT = resolve(HERE, '../../../../../')
-const ANTI_PATTERNS_PATH = resolve(REPO_ROOT, '.claude/rules/anti-patterns.md')
-
-// Kept in sync with the `PyreonDiagnosticCode` union in
-// `pyreon-intercept.ts`. When adding a new code, ALSO add a bullet
-// (with the `[detector: <code>]` tag) to `anti-patterns.md`.
-const COMPILER_CODES = [
-  'for-missing-by',
-  'for-with-key',
-  'props-destructured',
-  'props-destructured-body',
-  'process-dev-gate',
-  'empty-theme',
-  'raw-add-event-listener',
-  'raw-remove-event-listener',
-  'date-math-random-id',
-  'on-click-undefined',
-  'signal-write-as-call',
-  '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]
-
-// `@pyreon/lint` rule IDs that may appear as `[detector:]` tags. Listed
-// WITHOUT the `pyreon/` prefix (the tag convention strips it for
-// readability). Add the rule ID here when documenting a new lint rule
-// in anti-patterns.md.
-const LINT_RULE_DETECTORS = [
-  'storage-signal-v-forwarding',
-] as const
-
-function readAntiPatterns(): string {
-  return readFileSync(ANTI_PATTERNS_PATH, 'utf8')
-}
-
-function extractDetectorTags(doc: string): string[] {
-  const re = /\[detector:\s*([a-z-/ ]+?)\]/gi
-  const found: string[] = []
-  for (const m of doc.matchAll(re)) {
-    // Some bullets document multiple codes on one pattern, e.g.
-    // `[detector: raw-add-event-listener / raw-remove-event-listener]`.
-    const raw = m[1]!
-    for (const code of raw.split('/')) {
-      const trimmed = code.trim()
-      if (trimmed) found.push(trimmed)
-    }
-  }
-  return found
-}
-
-describe('anti-patterns.md detector tags vs static detectors', () => {
-  const doc = readAntiPatterns()
-  const tags = extractDetectorTags(doc)
-
-  it('every [detector: CODE] tag references a known detector (compiler or lint)', () => {
-    const validCodes = new Set<string>([...COMPILER_CODES, ...LINT_RULE_DETECTORS])
-    const unknown = tags.filter((t) => !validCodes.has(t) && t !== 'N/A')
-    expect(unknown).toEqual([])
-  })
-
-  it('every PyreonDiagnosticCode appears at least once as a [detector:] tag', () => {
-    const tagSet = new Set(tags)
-    const missing: CompilerCode[] = []
-    for (const code of COMPILER_CODES) {
-      if (!tagSet.has(code)) missing.push(code)
-    }
-    // If this fails, add a bullet for the new detector code to
-    // `.claude/rules/anti-patterns.md` with the `[detector: <code>]`
-    // suffix. The doc is the human-readable catalog; the detector is
-    // the static enforcement arm — they have to name each other.
-    expect(missing).toEqual([])
-  })
-
-  it('reports at least as many tags as compiler detector codes (multi-code bullets allowed)', () => {
-    expect(tags.length).toBeGreaterThanOrEqual(COMPILER_CODES.length)
-  })
-})

package/src/tests/dynamic-collapse-detector.test.ts

@@ -1,164 +0,0 @@
-/**
- * PR 2 of the dynamic-prop partial-collapse build (`.claude/plans/open-work-2026-q3.md`
- * → #1 dynamic-prop bucket = 15.3% of all real-corpus sites; the
- * next-bigger bite after the just-shipped `on*`-handler partial-collapse
- * via `detectPartialCollapsibleShape` + `_rsCollapseH` + emit).
- *
- * Mirrors `detectPartialCollapsibleShape`'s "extend the bail catalogue
- * with ONE relaxation" pattern (see that detector's docstring + tests).
- * The single relaxation: a `JSXExpressionContainer` whose expression is
- * a `ConditionalExpression` with BOTH branches being `StringLiteral` is
- * acceptable as a "ternary-of-two-literals" dynamic prop. Captured as a
- * `DynamicCollapsibleProp` with cond source span + the two literal
- * values, so PR 3's resolver can pre-render BOTH values via the
- * existing SSR pipeline and PR 3's emit can dispatch via the cond.
- *
- * Contract under test:
- *
- *   - literal-prop + ONE ternary-of-two-literals + optional `on*` handlers
- *     + static-text children → { props, dynamicProp, handlers, childrenText }
- *   - ZERO ternaries (literal-only) → null (defers to full / on*-only paths)
- *   - 2+ ternaries → null (multi-axis combinatorics is separable scope)
- *   - ternary with ANY non-literal branch (template literal, identifier,
- *     non-string literal, computed expr) → null
- *   - spread / boolean attr / element child / expression child → null
- *   - cond span (`condStart`/`condEnd`) slices the EXACT source of the
- *     ternary's test expression (load-bearing for PR 3's emit, which
- *     re-emits `code.slice(condStart, condEnd)` into `_rsCollapseDyn`)
- *
- * Bisect-verify (documented in the PR body): replace the body of
- * `detectDynamicCollapsibleShape` with `return null` → the POSITIVE
- * specs fail with `expected null to be …`; the NEGATIVE specs still
- * pass. Restore → all pass. That asymmetry proves the positive
- * assertions are load-bearing on the ternary-relaxation logic.
- */
-import { describe, expect, it } from 'vitest'
-import { parseSync } from 'oxc-parser'
-import { detectDynamicCollapsibleShape } from '../jsx'
-
-function firstJsxElement(code: string): any {
-  const { program } = parseSync('input.tsx', code, { sourceType: 'module', lang: 'tsx' })
-  let found: any = null
-  const visit = (node: any): void => {
-    if (found || !node || typeof node !== 'object') return
-    if (node.type === 'JSXElement') {
-      found = node
-      return
-    }
-    for (const k in node) {
-      const v = node[k]
-      if (Array.isArray(v)) for (const c of v) visit(c)
-      else if (v && typeof v === 'object' && typeof v.type === 'string') visit(v)
-    }
-  }
-  visit(program)
-  return found
-}
-
-const detect = (code: string) => detectDynamicCollapsibleShape(firstJsxElement(code), 'Button')
-
-describe('detectDynamicCollapsibleShape — PR 2 (ternary-of-two-literals dynamic-prop subset)', () => {
-  // ── POSITIVE: the dynamic-collapsible subset ────────────────────────────
-  it('claims a literal-prop site with ONE ternary-of-two-literals', () => {
-    const code = 'const x = <Button state={cond ? "primary" : "secondary"} size="medium">Save</Button>'
-    const r = detect(code)
-    expect(r).not.toBeNull()
-    expect(r!.props).toEqual({ size: 'medium' })
-    expect(r!.childrenText).toBe('Save')
-    expect(r!.handlers).toEqual([])
-    expect(r!.dynamicProp.name).toBe('state')
-    expect(r!.dynamicProp.valueTruthy).toBe('primary')
-    expect(r!.dynamicProp.valueFalsy).toBe('secondary')
-    expect(code.slice(r!.dynamicProp.condStart, r!.dynamicProp.condEnd)).toBe('cond')
-  })
-
-  it('captures the EXACT cond span for a complex condition', () => {
-    // The condStart/condEnd MUST slice the original source of the test
-    // expression so PR 3's emit can re-thread it into the dispatcher
-    // verbatim (paren-wrapped to keep it a single expr like the
-    // on*-handler emit does for arrow bodies).
-    const code = 'const x = <Btn state={user.role === "admin" ? "primary" : "danger"}>Go</Btn>'
-    const r = detect(code)
-    expect(r).not.toBeNull()
-    expect(code.slice(r!.dynamicProp.condStart, r!.dynamicProp.condEnd)).toBe(
-      'user.role === "admin"',
-    )
-  })
-
-  it('composes with on*-handler relaxation — one ternary + one handler', () => {
-    // Real-corpus shape: a Button with state={cond ? ... : ...} almost
-    // always also has an onClick. PR 3's emit will route to a combined
-    // helper when handlers are non-empty; this PR (detector) just
-    // carries both for the dispatcher's sake.
-    const code =
-      'const x = <Button state={cond ? "primary" : "secondary"} onClick={go}>Save</Button>'
-    const r = detect(code)
-    expect(r).not.toBeNull()
-    expect(r!.dynamicProp.name).toBe('state')
-    expect(r!.handlers.map((h) => h.name)).toEqual(['onClick'])
-  })
-
-  it('handles ternary on a non-state dim prop (size, variant, …)', () => {
-    const code = 'const x = <Button size={isLarge ? "large" : "medium"}>S</Button>'
-    const r = detect(code)
-    expect(r).not.toBeNull()
-    expect(r!.dynamicProp.name).toBe('size')
-    expect(r!.dynamicProp.valueTruthy).toBe('large')
-    expect(r!.dynamicProp.valueFalsy).toBe('medium')
-  })
-
-  it('trims static-text children (parity with the rest of the family)', () => {
-    const code =
-      'const x = <Button state={c ? "a" : "b"}>\n  Save\n</Button>'
-    const r = detect(code)
-    expect(r).not.toBeNull()
-    expect(r!.childrenText).toBe('Save')
-  })
-
-  // ── NEGATIVE: every uncertain shape bails (null) ────────────────────────
-  it('returns null for ZERO ternaries (defers to full / on*-only paths)', () => {
-    // Load-bearing separation: a fully-literal site is the FULL-collapse
-    // shape; on*-handler-only is the partial-collapse shape. The
-    // dynamic-prop detector must NOT claim either, so the three
-    // detectors never both/all-three fire on one site.
-    expect(detect('const x = <Button state="primary">Save</Button>')).toBeNull()
-    expect(detect('const x = <Button state="primary" onClick={h}>Save</Button>')).toBeNull()
-  })
-
-  it('returns null for 2+ ternaries (multi-axis combinatorics is separable scope)', () => {
-    const code =
-      'const x = <Button state={a ? "x" : "y"} size={b ? "small" : "large"}>S</Button>'
-    expect(detect(code)).toBeNull()
-  })
-
-  it('returns null for a ternary with a NON-string-literal branch', () => {
-    // TemplateLiteral, Identifier, numeric/boolean literal — none of
-    // these are statically resolvable to a known dimension value.
-    expect(detect('const x = <Button state={c ? `pri` : "sec"}>S</Button>')).toBeNull()
-    expect(detect('const x = <Button state={c ? maybePrimary : "sec"}>S</Button>')).toBeNull()
-    expect(detect('const x = <Button state={c ? "pri" : 1}>S</Button>')).toBeNull()
-  })
-
-  it('returns null for a non-ternary dynamic prop alongside literals', () => {
-    // Signal-call / function-call / arbitrary expression — not statically
-    // enumerable, no resolution possible.
-    expect(detect('const x = <Button state={getMy()} size="medium">S</Button>')).toBeNull()
-    expect(detect('const x = <Button state={sig()} size="medium">S</Button>')).toBeNull()
-  })
-
-  it('returns null for a spread attribute', () => {
-    expect(detect('const x = <Button {...rest} state={c ? "a" : "b"}>X</Button>')).toBeNull()
-  })
-
-  it('returns null for a boolean attribute', () => {
-    expect(detect('const x = <Button disabled state={c ? "a" : "b"}>X</Button>')).toBeNull()
-  })
-
-  it('returns null for an element child', () => {
-    expect(detect('const x = <Button state={c ? "a" : "b"}><span /></Button>')).toBeNull()
-  })
-
-  it('returns null for an expression child', () => {
-    expect(detect('const x = <Button state={c ? "a" : "b"}>{label}</Button>')).toBeNull()
-  })
-})