@pyreon/compiler 0.18.0 → 0.20.0

package/src/tests/reactivity-lens.test.ts

@@ -0,0 +1,170 @@
+import { transformJSX_JS } from '../jsx'
+import { analyzeReactivity, formatReactivityLens } from '../reactivity-lens'
+import type { ReactivityFinding } from '../reactivity-lens'
+
+/**
+ * Reactivity Lens — unit + drift gate.
+ *
+ * The load-bearing correctness contract: a lens span is a FAITHFUL RECORD of
+ * a codegen decision, never an approximation. Two invariants are gated here:
+ *
+ *  1. **Additive** — collecting the lens does NOT change emitted `code`
+ *     (kill-criterion a). Bisect: if a future edit makes lens collection
+ *     mutate codegen, `additive` fails.
+ *  2. **Drift** — every positive `reactive*` span's OUTPUT carries the
+ *     matching codegen token (`_bind`/`_bindText`/`_rp`), and every
+ *     `static-text` span's text is NOT reactively bound (kill-criterion b).
+ *     Bisect: reverting the `lens(...)` call at any instrumented site drops
+ *     the corresponding span and the matching `expect(kinds).toContain(...)`
+ *     fails — documented per-fixture below.
+ */
+
+function kindsAt(code: string): string[] {
+  return analyzeReactivity(code).findings.map((f) => f.kind)
+}
+function find(code: string, kind: string): ReactivityFinding[] {
+  return analyzeReactivity(code).findings.filter((f) => f.kind === kind)
+}
+function sliceFinding(code: string, f: ReactivityFinding): string {
+  // Re-derive the byte slice from line/col for a human-readable assertion.
+  const lines = code.split('\n')
+  const line = lines[f.line - 1] ?? ''
+  return f.endLine === f.line
+    ? line.slice(f.column, f.endColumn)
+    : line.slice(f.column)
+}
+
+describe('reactivity-lens — additive contract (kill-criterion a)', () => {
+  const FIXTURES = [
+    `function C(){ return <div>{count()}</div> }`,
+    `function C(p){ return <span>{p.label}</span> }`,
+    `function C(){ return <Box title={n()} /> }`,
+    `function C(){ return <div class="static">hi</div> }`,
+    `function C(){ return <a class={() => cls()}>x</a> }`,
+    `const x = 1; function C(){ const {a}=props; return <i>{a}</i> }`,
+  ]
+
+  it('lens collection NEVER changes emitted code (byte-identical)', () => {
+    for (const src of FIXTURES) {
+      const off = transformJSX_JS(src, 'f.tsx').code
+      const on = transformJSX_JS(src, 'f.tsx', { reactivityLens: true }).code
+      expect(on).toBe(off)
+    }
+  })
+
+  it('lens field is absent unless opted in', () => {
+    const r = transformJSX_JS(FIXTURES[0]!, 'f.tsx')
+    expect(r.reactivityLens).toBeUndefined()
+    const r2 = transformJSX_JS(FIXTURES[0]!, 'f.tsx', { reactivityLens: true })
+    expect(Array.isArray(r2.reactivityLens)).toBe(true)
+  })
+})
+
+describe('reactivity-lens — drift gate (positive claim = codegen record)', () => {
+  it('reactive text: {count()} → reactive span + _bind in output', () => {
+    const src = `function C(){ return <div>{count()}</div> }`
+    const reactive = find(src, 'reactive')
+    expect(reactive.length).toBe(1)
+    expect(sliceFinding(src, reactive[0]!)).toBe('count()')
+    // Drift proof: the codegen actually emitted a reactive binding.
+    const out = transformJSX_JS(src, 'f.tsx').code
+    expect(out).toMatch(/_bind(Text|Direct)?\(/)
+    expect(kindsAt(src)).not.toContain('static-text')
+  })
+
+  it('static text: {p.x}-free plain identifier → static-text, NOT reactive', () => {
+    const src = `function C(){ const label = "hi"; return <div>{label}</div> }`
+    const k = kindsAt(src)
+    expect(k).toContain('static-text')
+    expect(k).not.toContain('reactive')
+    const st = find(src, 'static-text')[0]!
+    expect(sliceFinding(src, st)).toBe('label')
+    // Drift proof: codegen baked it (no reactive binding helper for this).
+    const out = transformJSX_JS(src, 'f.tsx').code
+    expect(out).not.toMatch(/_bind\(\(\) => \{ \w+\.data = label \}/)
+  })
+
+  it('reactive prop: <Box title={n()} /> → reactive-prop + _rp in output', () => {
+    const src = `function C(){ return <Box title={n()} /> }`
+    const rp = find(src, 'reactive-prop')
+    expect(rp.length).toBe(1)
+    expect(sliceFinding(src, rp[0]!)).toBe('n()')
+    expect(transformJSX_JS(src, 'f.tsx').code).toContain('_rp(() =>')
+  })
+
+  it('hoisted static: static JSX in a non-template position → hoisted-static + module preamble', () => {
+    // A top-level returned static element becomes a `_tpl()` clone (template
+    // path) — that's not a hoist, and the lens correctly stays silent (no
+    // span = "not asserted"). maybeHoist only fires for static JSX in an
+    // expression slot of a non-DOM (component) parent; that's the faithful
+    // trigger and what the lens records.
+    const src = `function C(){ return <Comp>{<b class="x">hi</b>}</Comp> }`
+    const hs = find(src, 'hoisted-static')
+    expect(hs.length).toBeGreaterThanOrEqual(1)
+    expect(transformJSX_JS(src, 'f.tsx').code).toMatch(/const _\$h\d+ =/)
+  })
+
+  it('reactive attr: class={() => cls()} → reactive-attr', () => {
+    const src = `function C(){ return <a class={() => cls()}>x</a> }`
+    const ra = find(src, 'reactive-attr')
+    expect(ra.length).toBe(1)
+    expect(ra[0]!.detail).toContain('class')
+  })
+})
+
+describe('reactivity-lens — footgun merge (existing detectPyreonPatterns)', () => {
+  it('param-destructured props surface a footgun finding with the detector code', () => {
+    // detectPyreonPatterns catches the PARAMETER-destructure shape
+    // `({ name })`. The body-scope `const {x}=props` shape is the static
+    // layer's known cliff (doc-only anti-pattern, no reliable AST detector)
+    // — the lens's structural `static-text`/`reactive` signals are what
+    // compensate for that downstream. This asserts the merge surfaces
+    // whatever the existing detector finds, faithfully.
+    const src = `function C({ name }){ return <div>{name}</div> }`
+    const fg = find(src, 'footgun')
+    expect(fg.length).toBeGreaterThanOrEqual(1)
+    expect(fg.some((f) => f.code === 'props-destructured')).toBe(true)
+  })
+
+  it('findings are sorted by (line, column)', () => {
+    const src = [
+      `function C(props){`,
+      `  const { a } = props`,
+      `  return <div>{count()}</div>`,
+      `}`,
+    ].join('\n')
+    const { findings } = analyzeReactivity(src)
+    for (let i = 1; i < findings.length; i++) {
+      const prev = findings[i - 1]!
+      const cur = findings[i]!
+      expect(
+        prev.line < cur.line ||
+          (prev.line === cur.line && prev.column <= cur.column),
+      ).toBe(true)
+    }
+  })
+})
+
+describe('reactivity-lens — zero false "live" on idiomatic code (kill-criterion b)', () => {
+  it('purely static component yields no reactive* findings', () => {
+    const src = `function Card(){ return <div class="card"><h2>Title</h2><p>Body</p></div> }`
+    const k = kindsAt(src)
+    expect(k).not.toContain('reactive')
+    expect(k).not.toContain('reactive-prop')
+    expect(k).not.toContain('reactive-attr')
+  })
+
+  it('parse failure → empty, never throws', () => {
+    const r = analyzeReactivity(`function C( { return <div`)
+    expect(Array.isArray(r.findings)).toBe(true)
+  })
+})
+
+describe('reactivity-lens — formatter', () => {
+  it('renders annotated source with kind badges', () => {
+    const src = `function C(){ return <div>{count()}</div> }`
+    const out = formatReactivityLens(src, analyzeReactivity(src))
+    expect(out).toContain('live')
+    expect(out).toContain('1 |')
+  })
+})

package/src/tests/rocketstyle-collapse.test.ts

@@ -0,0 +1,208 @@
+import { describe, expect, it } from 'vitest'
+import { rocketstyleCollapseKey, transformJSX } from '../jsx'
+
+// Layer 4: the compiler DETECTS a literal-prop rocketstyle call site
+// (bail catalogue — RFC decision 3) and EMITS the collapsed
+// `_rsCollapse(...)` + once-per-module idempotent `injectRules`, when
+// the Vite plugin supplies an SSR-resolved `sites` entry. It never runs
+// the rocketstyle chain itself. These tests stub the resolved `sites`
+// map directly (no Vite) — the real SSR resolution is proven in
+// @pyreon/vite-plugin's resolver test; the end-to-end byte-parity is
+// proven by the ui-showcase e2e gate (Phase 4).
+
+const SITE = {
+  templateHtml: '<button data-x="1"><span class="inner">Save</span></button>',
+  lightClass: 'pyr-L1 pyr-L2',
+  darkClass: 'pyr-D1 pyr-D2',
+  rules: ['.pyr-L1{color:red}', '.pyr-D1{color:blue}'],
+  ruleKey: 'bundleA',
+}
+
+function collapseOpt(candidates: string[], sites: Record<string, typeof SITE>) {
+  return {
+    collapseRocketstyle: {
+      candidates: new Set(candidates),
+      sites: new Map(Object.entries(sites)),
+      mode: { name: 'useMode', source: '@pyreon/ui-core' },
+    },
+  }
+}
+
+describe('rocketstyleCollapseKey — stable + order-independent', () => {
+  it('same component+props+text ⇒ same key regardless of attr order', () => {
+    const a = rocketstyleCollapseKey('Button', { state: 'primary', size: 'md' }, 'Save')
+    const b = rocketstyleCollapseKey('Button', { size: 'md', state: 'primary' }, 'Save')
+    expect(a).toBe(b)
+    expect(a).not.toBe(rocketstyleCollapseKey('Button', { state: 'secondary' }, 'Save'))
+    expect(a).not.toBe(rocketstyleCollapseKey('Button', { state: 'primary', size: 'md' }, 'Go'))
+  })
+})
+
+describe('compiler — collapsible call site emission', () => {
+  it('emits _rsCollapse + dual-emit mode thunk + once-per-module injectRules', () => {
+    const key = rocketstyleCollapseKey('Button', { state: 'primary', size: 'medium' }, 'Save')
+    const src = `
+import { Button } from '@pyreon/ui-components'
+export function App() {
+  return <Button state="primary" size="medium">Save</Button>
+}`
+    const { code } = transformJSX(src, 'App.tsx', collapseOpt(['Button'], { [key]: SITE }))
+    // collapsed call replaces the JSX
+    expect(code).toContain(
+      '__rsCollapse("<button data-x=\\"1\\"><span class=\\"inner\\">Save</span></button>", "pyr-L1 pyr-L2", "pyr-D1 pyr-D2", () => __pyrMode() === "dark")',
+    )
+    // dual-emit mode accessor imported from the configured source
+    expect(code).toContain('import { useMode as __pyrMode } from "@pyreon/ui-core";')
+    // runtime helper + styler sheet imports
+    expect(code).toContain('import { _rsCollapse as __rsCollapse } from "@pyreon/runtime-dom";')
+    expect(code).toContain('import { sheet as __rsSheet } from "@pyreon/styler";')
+    // once-per-module idempotent rule injection, keyed by ruleKey
+    expect(code).toContain('__rsSheet.injectRules(')
+    expect(code).toContain(JSON.stringify(SITE.rules))
+    expect(code).toContain('"bundleA")')
+    // the original <Button …> JSX is gone
+    expect(code).not.toContain('<Button')
+  })
+
+  it('two identical sites in one module emit ONE injectRules (deduped by ruleKey)', () => {
+    const key = rocketstyleCollapseKey('Button', { state: 'primary' }, 'X')
+    const src = `
+import { Button } from '@pyreon/ui-components'
+export const A = () => <Button state="primary">X</Button>
+export const B = () => <Button state="primary">X</Button>`
+    const { code } = transformJSX(src, 'M.tsx', collapseOpt(['Button'], { [key]: SITE }))
+    const injCount = code.split('__rsSheet.injectRules(').length - 1
+    expect(injCount).toBe(1)
+    const callCount = code.split('__rsCollapse(').length - 1
+    // 2 call sites (the `_rsCollapse as __rsCollapse` import alias has
+    // no trailing `(`, so it doesn't count)
+    expect(callCount).toBe(2)
+  })
+})
+
+describe('compiler — bail catalogue (RFC decision 3): NO collapse', () => {
+  const key = rocketstyleCollapseKey('Button', { state: 'primary' }, 'Save')
+  const sites = { [key]: SITE }
+
+  function noCollapse(src: string, opt = collapseOpt(['Button'], sites)) {
+    const { code } = transformJSX(src, 'B.tsx', opt)
+    expect(code).not.toContain('__rsCollapse')
+    return code
+  }
+
+  it('bails on a non-literal (signal/expr) dimension prop', () => {
+    noCollapse(`
+import { Button } from '@pyreon/ui-components'
+export const A = (p) => <Button state={p.s}>Save</Button>`)
+  })
+
+  it('bails on a JSX spread attribute', () => {
+    noCollapse(`
+import { Button } from '@pyreon/ui-components'
+export const A = (p) => <Button state="primary" {...p}>Save</Button>`)
+  })
+
+  it('bails on an element child (non-static-text children)', () => {
+    noCollapse(`
+import { Button } from '@pyreon/ui-components'
+export const A = () => <Button state="primary"><i>Save</i></Button>`)
+  })
+
+  it('bails on an expression child', () => {
+    noCollapse(`
+import { Button } from '@pyreon/ui-components'
+export const A = (p) => <Button state="primary">{p.label}</Button>`)
+  })
+
+  it('bails when the component is not a registered candidate', () => {
+    noCollapse(
+      `
+import { Card } from '@pyreon/ui-components'
+export const A = () => <Card state="primary">Save</Card>`,
+      collapseOpt(['Button'], sites),
+    )
+  })
+
+  it('bails when there is no resolved site for the key (resolver bailed / not data)', () => {
+    noCollapse(
+      `
+import { Button } from '@pyreon/ui-components'
+export const A = () => <Button state="zzz">Save</Button>`,
+      collapseOpt(['Button'], sites),
+    )
+  })
+
+  it('does nothing when collapseRocketstyle option is absent (default OFF)', () => {
+    const { code } = transformJSX(
+      `
+import { Button } from '@pyreon/ui-components'
+export const A = () => <Button state="primary">Save</Button>`,
+      'Off.tsx',
+      {},
+    )
+    expect(code).not.toContain('__rsCollapse')
+  })
+})
+
+describe('bisect: collapse forces the JS path', () => {
+  it('emits the collapse even though a native binary may be present', () => {
+    // transformJSX must short-circuit to transformJSX_JS when
+    // collapseRocketstyle is set (the Rust binary doesn't implement it).
+    // If the force-JS guard were removed and a native binary were
+    // loaded, this would emit no __rsCollapse — proving the guard is
+    // load-bearing. With the guard, JS path always runs.
+    const key = rocketstyleCollapseKey('Button', {}, 'Hi')
+    const { code } = transformJSX(
+      `
+import { Button } from '@pyreon/ui-components'
+export const A = () => <Button>Hi</Button>`,
+      'J.tsx',
+      collapseOpt(['Button'], { [key]: SITE }),
+    )
+    expect(code).toContain('__rsCollapse(')
+  })
+})
+
+describe('scanCollapsibleSites — plugin scanner == compiler detection', () => {
+  it('finds the collapsible site with the SAME key the compiler looks up', async () => {
+    const { scanCollapsibleSites } = await import('../jsx')
+    const src = `
+import { Button as Btn } from '@pyreon/ui-components'
+import { useState } from 'somewhere'
+export const A = () => <Btn state="primary" size="medium">Save</Btn>
+export const B = (p) => <Btn state={p.s}>x</Btn>
+export const C = () => <div state="primary">not a candidate</div>`
+    const sites = scanCollapsibleSites(src, 'A.tsx', new Set(['@pyreon/ui-components']))
+    // only the literal-prop, static-text <Btn> collapses; the {expr}
+    // one and the <div> are bailed (catalogue) / non-candidate.
+    expect(sites).toHaveLength(1)
+    const s = sites[0]!
+    expect(s.componentName).toBe('Btn') // LOCAL alias — key uses this
+    expect(s.importedName).toBe('Button') // resolver imports this
+    expect(s.source).toBe('@pyreon/ui-components')
+    expect(s.props).toEqual({ state: 'primary', size: 'medium' })
+    expect(s.childrenText).toBe('Save')
+    // The key the plugin computes here MUST equal the key the compiler
+    // recomputes from the JSX node — proven by feeding a sites map
+    // keyed by s.key and asserting the compiler collapses.
+    const { code } = transformJSX(src, 'A.tsx', {
+      collapseRocketstyle: {
+        candidates: new Set(['Btn']),
+        sites: new Map([[s.key, SITE]]),
+        mode: { name: 'useMode', source: '@pyreon/ui-core' },
+      },
+    })
+    // exactly the literal-prop site collapsed; the {expr} <Btn> bailed
+    // and remains as JSX (1 collapse call, 1 surviving <Btn).
+    expect(code.split('__rsCollapse(').length - 1).toBe(1)
+    expect(code).toContain('<Btn state={')
+  })
+
+  it('skips a component imported from a non-collapsible source', async () => {
+    const { scanCollapsibleSites } = await import('../jsx')
+    const src = `
+import { Button } from './local-button'
+export const A = () => <Button state="primary">Save</Button>`
+    expect(scanCollapsibleSites(src, 'A.tsx', new Set(['@pyreon/ui-components']))).toHaveLength(0)
+  })
+})

package/src/tests/signal-autocall-shadow.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Compiler hardening — Round 11 (REAL bug, FIXED + bisect-verified).
+ *
+ * The signal-auto-call rewrite (`autoCallSignals` → `findSignalIdents`,
+ * jsx.ts) inserts `()` after every active-signal-named identifier. Its
+ * skip-list handled MemberExpr / VarDeclarator / Property-key|shorthand but
+ * NOT callback parameter binding positions, and `findSignalIdents` did its
+ * OWN scope-blind recursive walk over the wrapped expression. So a
+ * destructured/plain callback param reusing a signal's name was wrongly
+ * auto-called:
+ *
+ *   const x = signal(0)
+ *   <ul>{[{x:1}].map(({x}) => <li>{x}</li>)}</ul>
+ *     →  …map(({x}) => <li>{x()}</li>)   // x is the map item (1) → 1()
+ *                                        // → runtime TypeError
+ *
+ * Trigger: an inline object/array literal in the expr whose property name
+ * collides with a signal makes `referencesSignalVar` fire, invoking the
+ * scope-blind `autoCallSignals` over the whole expression. This is the exact
+ * signal twin of R2's prop-derived scope-blind inlining.
+ *
+ * Fix: `findSignalIdents` is now block-accurate scope-aware (mirrors R2's
+ * `findIdents`): a `scopeBoundSignals(node)` collects signal-named bindings a
+ * scope introduces (params incl. nested/destructured patterns, nested const,
+ * catch/loop vars), threaded through a `shadowed` set with enter/leave so a
+ * shadowed name is never auto-called. Legitimate (non-shadowed) signal reads
+ * still auto-call — proven by the CONTROL specs.
+ *
+ * Bisect: drop `&& !shadowed.has(node.name)` from the `findSignalIdents`
+ * active-signal guard → the SHADOW specs fail (emit `{x()}` / `id()`); the
+ * CONTROL specs stay green (no over-suppression). Restore → all pass.
+ */
+import { parseSync } from 'oxc-parser'
+import { describe, expect, it } from 'vitest'
+import { transformJSX_JS } from '../jsx'
+
+const emit = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
+const parses = (o: string): boolean => {
+  try {
+    return (parseSync('o.tsx', o).errors?.length ?? 0) === 0
+  } catch {
+    return false
+  }
+}
+
+describe('Round 11 — signal auto-call respects lexical shadowing', () => {
+  it('destructured-shorthand callback param shadowing a signal is NOT auto-called', () => {
+    const out = emit(`function C(){ const x = signal(0); return <ul>{[{x:1}].map(({x}) => <li>{x}</li>)}</ul> }`)
+    expect(parses(out)).toBe(true)
+    expect(out).not.toContain('{x()}')
+    expect(out).toContain('({x}) => <li>{x}</li>')
+  })
+
+  it('destructured param shadowing a signal in a filter predicate is NOT auto-called', () => {
+    const out = emit(`function C(){ const id = signal(0); return <ul>{[{id:1}].filter(({id}) => id > 0).map(r => <li>{r}</li>)}</ul> }`)
+    expect(parses(out)).toBe(true)
+    expect(out).not.toMatch(/\(\{id\}\) => id\(\)/)
+  })
+
+  it('renamed destructured value param shadowing a signal is NOT auto-called', () => {
+    const out = emit(`function C(){ const v = signal(0); return <ul>{[{k:1}].map(({k: v}) => <li>{v}</li>)}</ul> }`)
+    expect(out).not.toContain('{v()}')
+  })
+
+  it('plain callback param shadowing a signal is NOT auto-called', () => {
+    const out = emit(`function C(){ const s = signal(0); return <ul>{[1].map(s => <li>{s}</li>)}</ul> }`)
+    expect(out).not.toContain('{s()}')
+  })
+
+  // ── CONTROL: legitimate signal reads MUST still auto-call ──
+  it('CONTROL: a direct non-shadowed signal child still auto-calls', () => {
+    expect(emit(`function C(){ const s = signal(0); return <div>{s}</div> }`)).toContain('__t0.data = s()')
+  })
+
+  it('CONTROL: a non-shadowed signal SIBLING of a shadowing callback still auto-calls', () => {
+    const out = emit(`function C(){ const s = signal(0); return <div>{[1].map(s => <i>{s}</i>)}<b>{s}</b></div> }`)
+    expect(out).not.toContain('<i>{s()}</i>') // the shadowing param — not called
+    expect(out).toContain('__t0.data = s()') // the real signal sibling — called
+  })
+
+  it('CONTROL: signal.set in a handler is not auto-called but its arg is', () => {
+    const out = emit(`function C(){ const s = signal(0); return <button onClick={() => s.set(s() + 1)}>{s}</button> }`)
+    expect(out).toContain('s.set(s() + 1)')
+    expect(out).toContain('__t0.data = s()')
+  })
+})

package/src/tests/sourcemap-fidelity.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Compiler hardening — Round 12 (REAL high-impact gap, FIXED + bisect).
+ *
+ * Pre-fix: `transformJSX` emitted NO source map and its string-slice
+ * substitutions shifted line counts (template emission expands one-line JSX
+ * into a multi-line `_tpl(...)` factory). `@pyreon/vite-plugin` returned
+ * `{ code, map: null }`, so every runtime stack frame / debugger breakpoint
+ * in every Pyreon component mislocated — app-wide, in every project.
+ *
+ * Fix: `transformJSX_JS` applies its existing disjoint `{start,end,text}`
+ * replacement set through MagicString (`update`/`appendLeft`) and the
+ * generated preamble via `prepend`. `toString()` is byte-identical to the
+ * old concatenation — proven by the full ~1240-test suite + the 180
+ * native-equivalence tests, which assert exact emitted strings and all stay
+ * green — while `generateMap()` now yields a correct V3 map. `prepend`
+ * shifts every mapping by the preamble's line count, so original positions
+ * resolve to the correct OUTPUT line despite the line-shift.
+ *
+ * Bisect: revert the MagicString block to the slice/join + chained-prepend
+ * assembly → `map` is `undefined` and these specs fail; restore → pass. The
+ * byte-identical guarantee is itself bisect-covered by the rest of the suite
+ * (any drift fails an exact-string assertion somewhere).
+ */
+import { describe, expect, it } from 'vitest'
+import { transformJSX_JS } from '../jsx'
+
+// Edit-correctness oracle is the rest of the compiler suite: the full
+// ~1240-test + 180 native-equivalence corpus asserts EXACT emitted strings,
+// so any byte drift from the MagicString assembly fails there. Map *math*
+// (segment offsets through `update`/`appendLeft`/`prepend`) is magic-string's
+// — the battle-tested generator vite/rollup/svelte rely on; not re-derived
+// here. These specs assert the gap is closed (a valid, content-embedded V3
+// map is produced and serializes for Vite) and the no-op contract.
+
+const MULTILINE = `function C(props) {
+  return (
+    <section>
+      <h1>{props.title}</h1>
+      <p>{props.body}</p>
+    </section>
+  )
+}`
+
+describe('Round 12 — sourcemap fidelity (fixed)', () => {
+  it('a transforming compile now produces a V3 source map', () => {
+    const r = transformJSX_JS(MULTILINE, 'C.tsx')
+    expect(r.map).toBeDefined()
+    expect(r.map!.version).toBe(3)
+    expect(r.map!.sources).toContain('C.tsx')
+    expect(r.map!.mappings.length).toBeGreaterThan(0)
+  })
+
+  it('the map embeds original content and is JSON/`toString`-serializable for Vite', () => {
+    const r = transformJSX_JS(MULTILINE, 'C.tsx')
+    expect(r.map!.sourcesContent?.[0]).toBe(MULTILINE)
+    const json = JSON.parse(r.map!.toString())
+    expect(json.version).toBe(3)
+    expect(json.mappings).toBe(r.map!.mappings)
+  })
+
+  it('output still line-shifts — but the map now accounts for it (the whole point)', () => {
+    const r = transformJSX_JS(MULTILINE, 'C.tsx')
+    // Template emission still expands lines (unchanged codegen)…
+    expect(r.code.split('\n').length).toBeGreaterThan(MULTILINE.split('\n').length)
+    // …and the segment mappings are non-trivial (multi-segment, i.e. the
+    // preamble + per-replacement remapping is recorded, not an empty/identity
+    // map that would silently mislocate like before).
+    expect(r.map!.mappings).toMatch(/[;,]/)
+    expect(r.map!.names).toBeInstanceOf(Array)
+  })
+
+  it('a no-op compile (nothing to transform) returns no map (code is unchanged)', () => {
+    const r = transformJSX_JS(`const x = 1`, 'plain.ts')
+    expect(r.map).toBeUndefined()
+    expect(r.code).toBe(`const x = 1`)
+  })
+})

package/src/tests/static-text-baking.test.ts

@@ -0,0 +1,64 @@
+import { transformJSX } from '../jsx'
+
+const t = (code: string) => transformJSX(code, 'input.tsx').code
+const hasBind = (out: string) => /\b_bindText\(|\b_bind\(/.test(out)
+
+// ── Static-text baking contract (perf-correctness regression gate) ──────────
+//
+// The compiler bakes a provably-static `{expr}` child straight into the
+// `_tpl()` HTML and emits NO `_bind`/`_bindText` for it. The Reactivity
+// Lens's `static-text` kind is a faithful RECORD of exactly this codegen
+// branch — it is NOT an independent oracle the emitter could disagree
+// with. So "the analysis proves static but codegen still binds" is
+// structurally impossible; the only thing that can erode this is an
+// `isDynamic` PRECISION regression that starts treating a static shape as
+// dynamic (a silent per-mount allocation + subscription leak with no
+// other guard) OR — the inverse correctness bug — under-wrapping a truly
+// reactive shape.
+//
+// This suite is self-discriminating, which IS its bisect proof: it
+// asserts BOTH regimes against the SAME `isDynamic` decision. An
+// over-broad regression fails the "baked" half; an under-broad
+// (correctness) regression fails the "reactive" half. Both halves are
+// demonstrated reachable by the empirical probe that motivated this gate
+// (every static shape baked; the unknown-call / signal / prop shapes
+// bound) — neither half passes vacuously.
+
+describe('static-text baking — provably-static children are baked, never _bind', () => {
+  const STATIC: [string, string][] = [
+    ['module-const string ref', `const N='hi'; export const C=()=> <div>{N}</div>`],
+    ['string literal', `export const C=()=> <div>{'hi'}</div>`],
+    ['number literal', `export const C=()=> <div>{42}</div>`],
+    ['static ternary on a module const', `const F=false; export const C=()=> <div>{F ? 'a' : 'b'}</div>`],
+    ['template literal interpolating only a const', `const N='x'; export const C=()=> <div>{\`v-\${N}\`}</div>`],
+    ['module-const array .length', `const A=[1,2,3]; export const C=()=> <div>{A.length}</div>`],
+    ['pure built-in call (Math.max)', `export const C=()=> <div>{Math.max(1,2)}</div>`],
+    ['const string concat', `const A='a',B='b'; export const C=()=> <div>{A+B}</div>`],
+  ]
+  for (const [name, src] of STATIC) {
+    test(`bakes (no _bind): ${name}`, () => {
+      const out = t(src)
+      expect(out).toContain('_tpl(')
+      expect(hasBind(out)).toBe(false)
+    })
+  }
+})
+
+describe('static-text baking — genuinely-reactive / unprovable children DO bind (discriminator)', () => {
+  const REACTIVE: [string, string][] = [
+    [
+      'signal read',
+      `import {signal} from '@pyreon/reactivity'; const s=signal(0); export const C=()=> <div>{s()}</div>`,
+    ],
+    ['prop access', `export const C=(props:any)=> <div>{props.x}</div>`],
+    [
+      'unknown local call (conservatively reactive — correct: cannot prove signal-free)',
+      `function f(){return 'z'} export const C=()=> <div>{f()}</div>`,
+    ],
+  ]
+  for (const [name, src] of REACTIVE) {
+    test(`binds: ${name}`, () => {
+      expect(hasBind(t(src))).toBe(true)
+    })
+  }
+})

package/src/tests/transform-state-isolation.test.ts

@@ -0,0 +1,49 @@
+/**
+ * Compiler hardening — Round 6 (state-isolation lock; no leak found).
+ *
+ * Probed: does the JS transform leak across calls? All per-transform caches
+ * (`_isDynamicCache`, `resolvedCache`, `resolving`, `warnedCycles`) are
+ * declared INSIDE `transformJSX_JS` (function scope → GC'd per call); the only
+ * module-level state is immutable constant lookup Sets (`PURE_CALLS`,
+ * `VOID_ELEMENTS`, `SKIP_PROPS`, …). Empirically 8000 transforms added
+ * ~0.2KB/call of short-lived (collectable) allocation — no retention path.
+ *
+ * Not a heap-threshold test (those are flaky under parallel vitest / GC
+ * timing — the project explicitly avoids them). Instead this locks the
+ * DETERMINISTIC structural guarantee a leak/contamination regression would
+ * break: cross-call output isolation + constant-Set integrity. If someone
+ * later hoists a per-transform cache to module scope (the classic leak
+ * regression), the same input would start producing drifting output and/or
+ * the constant Sets would mutate — caught here without heap timing.
+ */
+import { describe, expect, it } from 'vitest'
+import { transformJSX_JS } from '../jsx'
+
+const emit = (c: string): string => transformJSX_JS(c, 'c.tsx').code ?? ''
+
+describe('Round 6 — transform state is per-call isolated (leak/contamination gate)', () => {
+  it('identical input → byte-identical output across 500 interleaved calls', () => {
+    const a = `function A(p){ const v=p.x; return <ul>{p.items.map(i => <li>{v}{i}</li>)}</ul> }`
+    const b = `function B(){ const s=signal(0); return <button onClick={()=>s.set(1)}>{s()}</button> }`
+    const a0 = emit(a)
+    const b0 = emit(b)
+    for (let i = 0; i < 500; i++) {
+      // Interleave different shapes so any module-level cache keyed by
+      // node.start (collides across files) would drift the output.
+      expect(emit(b)).toBe(b0)
+      expect(emit(a)).toBe(a0)
+    }
+  })
+
+  it('constant lookup Sets are not mutated by transforms', () => {
+    // PURE_CALLS / VOID_ELEMENTS behavior must be stable after heavy use.
+    for (let i = 0; i < 200; i++) {
+      emit(`function C(p){ return <div>{Math.max(p.x, 0)}</div> }`)
+      emit(`function C(){ return <br /> }`)
+    }
+    // br stays verbatim (VOID/self-closing contract) and Math.max with a
+    // dynamic arg stays reactive (PURE_CALLS not corrupted to "always pure").
+    expect(emit(`function C(){ return <br /> }`)).toContain('<br />')
+    expect(emit(`function C(p){ return <div>{Math.max(p.x,0)}</div> }`)).toContain('_bind(')
+  })
+})