@pyreon/compiler 0.19.0 → 0.20.0

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/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(')
+  })
+})