@pyreon/compiler 0.24.5 → 0.24.6

package/src/tests/collapse-bail-census.test.ts

@@ -1,330 +0,0 @@
-/**
- * Proposal #1 (collapse tail / partial collapse) — FIRST MEASURABLE STEP.
- *
- * The open-work doc commits: "instrument `scanCollapsibleSites` bail reasons
- * on the real `examples/ui-showcase` + `@pyreon/ui-components` corpus and
- * bucket by bail cause — that quantifies the partial-collapse addressable
- * surface before any code is written (mirrors the E2 '95.3% statically
- * resolvable' measurement that justified the slice)."
- *
- * This test IS that measurement, executed and locked. It does NOT build
- * partial collapse (multi-week, roadmap-scale). It produces the number that
- * tells whoever picks #1 up whether partial collapse is worth the spend.
- *
- * Methodology — every JSX element across the example corpus whose tag is
- * PascalCase AND imported from `@pyreon/ui-components` is a *candidate*. Each
- * candidate is bucketed by its FIRST bail reason (same catalogue order as
- * the production `detectCollapsibleShape`):
- *
- *   collapsible        — no bail; the shipped slice already collapses it
- *   spread             — a `{...x}` attribute
- *   boolean-attr       — a valueless attr (`disabled`)
- *   dynamic-prop       — an `{expr}`-valued attr (incl. `onClick={...}`)
- *   element-child      — a JSX element child
- *   expression-child   — a `{expr}` child
- *
- * The trustworthiness gate (the bisect-equivalent — no fake fix to revert):
- * this file's own "collapsible" count, computed by an INDEPENDENT walk, is
- * asserted EQUAL to the production `scanCollapsibleSites` truth-set over the
- * same files. If the two ever disagree, the census is not measuring what the
- * compiler actually collapses and the number is worthless — the test fails
- * and says so. So the measurement can't silently rot.
- *
- * Partial-collapse addressable surface — among `dynamic-prop` bails,
- * how many bail SOLELY because of `on*` handler props while EVERY other
- * attr is a plain string literal and children are static text. Those are
- * exactly the sites a "collapse the static dimension slice, keep the
- * handler runtime" pass would capture. That ratio is the headline number
- * for the #1 go/no-go decision.
- */
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import { parseSync } from 'oxc-parser'
-import { scanCollapsibleSites } from '../jsx'
-
-const COLLAPSIBLE_SOURCES = new Set(['@pyreon/ui-components'])
-
-// `bun run test` sets cwd to the package dir (packages/core/compiler);
-// repo root is 3 up. Robust to bundler __dirname rewriting.
-const REPO = join(process.cwd(), '..', '..', '..')
-const CORPUS = [
-  'examples/ui-showcase/src',
-  'examples/app-showcase/src',
-  'examples/fundamentals-playground/src',
-].map((p) => join(REPO, p))
-
-function walkTsx(dir: string, out: string[] = []): string[] {
-  let entries: string[]
-  try {
-    entries = readdirSync(dir)
-  } catch {
-    return out
-  }
-  for (const e of entries) {
-    const p = join(dir, e)
-    const st = statSync(p)
-    if (st.isDirectory()) walkTsx(p, out)
-    else if (e.endsWith('.tsx')) out.push(p)
-  }
-  return out
-}
-
-type Bucket =
-  | 'collapsible'
-  | 'spread'
-  | 'boolean-attr'
-  | 'dynamic-prop'
-  | 'element-child'
-  | 'expression-child'
-
-interface SiteClass {
-  bucket: Bucket
-  /** dynamic-prop only: true iff every dynamic attr is `on*` AND all other
-   * attrs are string literals AND children are static text (partial-collapse
-   * addressable). */
-  partialAddressable: boolean
-  /** dynamic-prop only: true iff EXACTLY ONE dynamic attr is a ternary of
-   * two string literals AND every OTHER non-literal attr is an `on*`
-   * handler (which compose orthogonally via the handler-combined
-   * emit), AND children are static text. Counts the subset addressable
-   * by the dynamic-prop collapse PR sequence (PRs #765-#767 plus the
-   * handler-combined follow-up). */
-  dynamicTernaryAddressable: boolean
-}
-
-const isPascal = (t: string): boolean =>
-  !!t && t[0] === t[0]!.toUpperCase() && t[0] !== t[0]!.toLowerCase()
-
-function importTable(program: any): Map<string, string> {
-  const t = new Map<string, string>()
-  for (const s of program.body ?? []) {
-    if (s.type !== 'ImportDeclaration') continue
-    const src = s.source?.value
-    if (typeof src !== 'string') continue
-    for (const sp of s.specifiers ?? []) {
-      if (sp.type === 'ImportSpecifier' && typeof sp.local?.name === 'string')
-        t.set(sp.local.name, src)
-    }
-  }
-  return t
-}
-
-function tagName(node: any): string {
-  const n = node?.openingElement?.name ?? node?.name
-  return n?.type === 'JSXIdentifier' ? n.name : ''
-}
-
-function classifySite(node: any): SiteClass {
-  const opening = node.openingElement ?? node
-  const attrs: any[] = opening.attributes ?? []
-  let sawDynamic = false
-  let everyDynamicIsHandler = true
-  // Dynamic-prop addressable tracking: count ternaries + check shape.
-  // Exactly one ternary-of-two-literals + every other non-literal attr
-  // is either a ternary or an `on*` handler (handlers compose via the
-  // combined `_rsCollapseDynH` emit) → addressable. Note no
-  // `sawHandler` tracking: the original PR 3 no-handler restriction
-  // was lifted by the handler-combined follow-up; handlers no longer
-  // disqualify a site from `dynamicTernaryAddressable`.
-  let ternaryCount = 0
-  let everyDynamicIsTernary = true
-  for (const a of attrs) {
-    if (a.type === 'JSXSpreadAttribute')
-      return { bucket: 'spread', partialAddressable: false, dynamicTernaryAddressable: false }
-    const nm = a.name?.type === 'JSXIdentifier' ? a.name.name : null
-    if (!nm)
-      return { bucket: 'spread', partialAddressable: false, dynamicTernaryAddressable: false }
-    const v = a.value
-    if (!v)
-      return {
-        bucket: 'boolean-attr',
-        partialAddressable: false,
-        dynamicTernaryAddressable: false,
-      }
-    const isStr =
-      v.type === 'StringLiteral' || (v.type === 'Literal' && typeof v.value === 'string')
-    if (!isStr) {
-      sawDynamic = true
-      const isHandler = /^on[A-Z]/.test(nm)
-      if (!isHandler) everyDynamicIsHandler = false
-      // Probe for the ternary-of-two-literals shape (PR 2 detector's
-      // structural shape).
-      const expr = v.type === 'JSXExpressionContainer' ? v.expression : null
-      const isLitStr = (n: any): boolean =>
-        n &&
-        (n.type === 'StringLiteral' || (n.type === 'Literal' && typeof n.value === 'string'))
-      const isTernaryOfLits =
-        expr &&
-        expr.type === 'ConditionalExpression' &&
-        isLitStr(expr.consequent) &&
-        isLitStr(expr.alternate)
-      if (isTernaryOfLits) ternaryCount++
-      else if (!isHandler) everyDynamicIsTernary = false
-    }
-  }
-  // children
-  const kids: any[] = node.children ?? []
-  let staticChildrenOnly = true
-  for (const c of kids) {
-    if (c.type === 'JSXText') continue
-    if (c.type === 'JSXElement' || c.type === 'JSXFragment') staticChildrenOnly = false
-    else staticChildrenOnly = false // JSXExpressionContainer etc.
-  }
-  if (sawDynamic) {
-    const partialAddressable = everyDynamicIsHandler && staticChildrenOnly
-    // Dynamic-collapse claims: EXACTLY 1 ternary, every OTHER dynamic
-    // attr is either a ternary or an `on*` handler (no plain dynamic
-    // shapes like `state={getValue()}`), static children. The
-    // handler-combined follow-up (this PR) lifted the no-handler
-    // restriction by routing handler-bearing dynamic sites to the
-    // `_rsCollapseDynH` runtime helper instead of bailing — closes
-    // the bulk of the 15.4% dynamic-prop bucket (previously the
-    // strict no-handler scope only addressed 0.2% of sites).
-    //
-    // The `everyDynamicIsTernary` flag here is computed in the loop
-    // above as "every non-handler dynamic attr is a ternary"; combined
-    // with `ternaryCount === 1` + `staticChildrenOnly` it precisely
-    // matches what `detectDynamicCollapsibleShape` + `tryDynamicCollapse`
-    // claim. Handlers are NO LONGER excluded — they compose orthogonally.
-    const dynamicTernaryAddressable =
-      ternaryCount === 1 && everyDynamicIsTernary && staticChildrenOnly
-    return { bucket: 'dynamic-prop', partialAddressable, dynamicTernaryAddressable }
-  }
-  // No spread / boolean / dynamic attr. Bail can now only come from children.
-  for (const c of kids) {
-    if (c.type === 'JSXText') continue
-    if (c.type === 'JSXElement' || c.type === 'JSXFragment')
-      return {
-        bucket: 'element-child',
-        partialAddressable: false,
-        dynamicTernaryAddressable: false,
-      }
-    return {
-      bucket: 'expression-child',
-      partialAddressable: false,
-      dynamicTernaryAddressable: false,
-    }
-  }
-  return { bucket: 'collapsible', partialAddressable: false, dynamicTernaryAddressable: false }
-}
-
-describe('proposal #1 — collapse-tail bail-reason census (measurement, not a build)', () => {
-  it('measures the real corpus and locks the partial-collapse addressable surface', () => {
-    const files = CORPUS.flatMap((d) => walkTsx(d))
-    expect(files.length).toBeGreaterThan(150) // sanity: the corpus exists
-
-    const tally: Record<Bucket, number> = {
-      collapsible: 0,
-      spread: 0,
-      'boolean-attr': 0,
-      'dynamic-prop': 0,
-      'element-child': 0,
-      'expression-child': 0,
-    }
-    let candidates = 0
-    let partialAddressable = 0
-    let dynamicTernaryAddressable = 0
-    let myCollapsible = 0
-    let scannerCollapsible = 0
-
-    for (const file of files) {
-      const code = readFileSync(file, 'utf8')
-      let program: any
-      try {
-        program = parseSync(file, code, { sourceType: 'module', lang: 'tsx' }).program
-      } catch {
-        continue
-      }
-      const imports = importTable(program)
-
-      const visit = (node: any): void => {
-        if (!node || typeof node !== 'object') return
-        if (node.type === 'JSXElement') {
-          const tag = tagName(node)
-          if (isPascal(tag) && imports.has(tag) && COLLAPSIBLE_SOURCES.has(imports.get(tag)!)) {
-            candidates++
-            const c = classifySite(node)
-            tally[c.bucket]++
-            if (c.bucket === 'collapsible') myCollapsible++
-            if (c.partialAddressable) partialAddressable++
-            if (c.dynamicTernaryAddressable) dynamicTernaryAddressable++
-          }
-        }
-        for (const k in node) {
-          const v = node[k]
-          if (Array.isArray(v)) for (const x of v) visit(x)
-          else if (v && typeof v === 'object' && typeof v.type === 'string') visit(v)
-        }
-      }
-      visit(program)
-
-      // Production truth-set for the SAME file.
-      scannerCollapsible += scanCollapsibleSites(code, file, COLLAPSIBLE_SOURCES).length
-    }
-
-    // ── Report (the deliverable) ────────────────────────────────────────────
-    const pct = (n: number) => `${((n / candidates) * 100).toFixed(1)}%`
-    // eslint-disable-next-line no-console
-    console.log(
-      [
-        '',
-        `[collapse-bail-census] ${files.length} corpus files, ${candidates} @pyreon/ui-components call sites`,
-        `  collapsible (slice already handles): ${tally.collapsible} (${pct(tally.collapsible)})`,
-        `  bail:spread                        : ${tally.spread} (${pct(tally.spread)})`,
-        `  bail:boolean-attr                  : ${tally['boolean-attr']} (${pct(tally['boolean-attr'])})`,
-        `  bail:dynamic-prop                  : ${tally['dynamic-prop']} (${pct(tally['dynamic-prop'])})`,
-        `  bail:element-child                 : ${tally['element-child']} (${pct(tally['element-child'])})`,
-        `  bail:expression-child              : ${tally['expression-child']} (${pct(tally['expression-child'])})`,
-        `  ── partial-collapse ADDRESSABLE    : ${partialAddressable} (${pct(partialAddressable)} of all sites)`,
-        `     (dynamic-prop bails where every dynamic attr is on*, all else literal, static children)`,
-        `  ── dynamic-collapse ADDRESSABLE    : ${dynamicTernaryAddressable} (${pct(dynamicTernaryAddressable)} of all sites)`,
-        `     (dynamic-prop bails where EXACTLY ONE attr is a ternary-of-two-string-literals,`,
-        `      every other non-literal attr is on* (handlers compose via _rsCollapseDynH),`,
-        `      static children — dynamic-prop sequence #765-#767 + handler-combined follow-up)`,
-        '',
-      ].join('\n'),
-    )
-
-    // ── Trustworthiness gate (bisect-equivalent) ────────────────────────────
-    // This independent walk's "collapsible-equivalent" count MUST equal the
-    // production scanner's truth-set. If they diverge the census is
-    // measuring fiction.
-    //
-    // Per PR 3 (#767) the scanner emits TWO `CollapsibleSite` entries per
-    // dynamic-prop site (one per literal value — the resolver pre-renders
-    // both); the compiler emit still produces ONE collapsed call site. So
-    // the per-site classifier count + 2× the dynamic-addressable count
-    // equals the scanner's per-resolution count. If they diverge, either
-    // the classifier and scanner disagree on which dynamic sites are
-    // addressable, OR the scanner's expansion drifted from this formula.
-    expect(myCollapsible + 2 * dynamicTernaryAddressable).toBe(scannerCollapsible)
-
-    // ── Lock the headline finding (ratchet record) ──────────────────────────
-    // The corpus is real and large; these are the measured facts as of this
-    // PR. They are asserted as RANGES (not exact) so benign corpus churn
-    // doesn't flake the gate, but a structural shift (partial collapse landed,
-    // or the slice's collapsible rate collapsed) trips it for review.
-    expect(candidates).toBeGreaterThan(50)
-    expect(tally.collapsible).toBeGreaterThan(0)
-    // partial-addressable is the #1 go/no-go number — assert it's measured
-    // (>=0 always true; the value is in the logged report). Lock only that
-    // the classifier ran over a non-trivial dynamic-prop population so the
-    // ratio is meaningful, not noise.
-    expect(tally['dynamic-prop'] + tally.collapsible).toBeGreaterThan(0)
-    // PR 4 of the dynamic-prop partial-collapse build: lock that the
-    // dynamic-collapse classifier ran over a meaningful population
-    // (dynamic-prop bucket non-zero). The addressable count is in the
-    // log; we DON'T assert it >0 here because the strict no-handler
-    // PR 3 scope is honestly small in real-world corpora (real Buttons
-    // with `state={cond ? ... : ...}` almost always also carry
-    // `onClick` → BAIL until the handler-combined follow-up). The
-    // dynamic-prop bucket itself is the size of the future surface;
-    // PR 3's no-handler subset is the first measurable step.
-    expect(tally['dynamic-prop']).toBeGreaterThan(0)
-    // The dynamic-addressable count can be 0 in a clean run (no
-    // matching sites in the corpus); just lock that the counter is
-    // wired and consistent with the bucket.
-    expect(dynamicTernaryAddressable).toBeLessThanOrEqual(tally['dynamic-prop'])
-  })
-})

package/src/tests/collapse-key-source-hygiene.test.ts

@@ -1,88 +0,0 @@
-/**
- * Compiler hardening — Round 1.
- *
- * Two locked invariants, one root cause.
- *
- * `rocketstyleCollapseKey` (jsx.ts) and its Vite-plugin twin used to embed
- * RAW C0 control bytes (NUL 0x00 / SOH 0x01) directly inside source string
- * literals as FNV-1a field separators. Three measured consequences:
- *
- *   1. BSD `file(1)` classifies the file as binary `data` (siblings with no
- *      raw C0 are correctly "UTF-8 text").
- *   2. Plain `grep`/`rg` silently skip the file (binary-skip) — the
- *      compiler's primary source became un-greppable.
- *   3. Silent-correctness fragility: a raw NUL/SOH in a `.ts` string literal
- *      is mutable by formatters / editors / copy-paste / git text filters.
- *      If the separator byte is altered, the cache key changes with ZERO
- *      compile error — the "cache key from raw input" anti-pattern family.
- *
- * Fix: escape sequences (`U+0001` SOH / `U+0000` NUL) — byte-identical at runtime
- * (`String.fromCharCode(1)` is identical to the raw byte), so every emitted key is unchanged, but
- * the source is plain UTF-8 text again.
- *
- * Test A pins the ground-truth keys (proves the fix is byte-identical AND
- * locks the algorithm against any future change). Test B is the
- * self-discriminating repo-wide regression gate: before the fix three files
- * carry raw C0 → it fails; after → it passes. Bisect-verified.
- */
-import { execFileSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import { rocketstyleCollapseKey } from '../jsx'
-
-describe('rocketstyleCollapseKey — ground-truth key lock (escape fix is byte-identical)', () => {
-  // Captured from the ORIGINAL raw-byte implementation before the escape fix.
-  // The escape fix MUST reproduce these exactly (proves zero behavior change);
-  // any future algorithm change is also caught here.
-  it('emits the exact pre-fix keys', () => {
-    expect(rocketstyleCollapseKey('Button', { state: 'primary', size: 'lg' }, 'Click')).toBe('zfm01z')
-    expect(rocketstyleCollapseKey('Card', {}, '')).toBe('mzrimv')
-    expect(rocketstyleCollapseKey('Comp', { a: '1' }, '')).toBe('1l6zbih')
-    expect(rocketstyleCollapseKey('Comp', {}, 'a=1')).toBe('zteym7')
-    expect(rocketstyleCollapseKey('日本', { 'aria-label': 'café' }, 'arrow ok')).toBe('vnvy01')
-  })
-
-  it('is order-independent over props (sort) and shape-distinct (separators do their job)', () => {
-    expect(rocketstyleCollapseKey('Button', { state: 'primary', size: 'lg' }, 'Click')).toBe(
-      rocketstyleCollapseKey('Button', { size: 'lg', state: 'primary' }, 'Click'),
-    )
-    // Without NUL field separators, `{a:'1'},''` and `{},'a=1'` would collide.
-    expect(rocketstyleCollapseKey('Comp', { a: '1' }, '')).not.toBe(
-      rocketstyleCollapseKey('Comp', {}, 'a=1'),
-    )
-  })
-})
-
-function repoRoot(): string {
-  let d = resolve(__dirname)
-  while (!existsSync(join(d, '.git')) && dirname(d) !== d) d = dirname(d)
-  return d
-}
-
-describe('source hygiene — no raw C0/DEL control bytes in tracked source', () => {
-  it('every tracked .ts/.tsx/.js/.mjs/.rs file is plain text (no raw NUL/SOH/ESC/DEL)', () => {
-    const root = repoRoot()
-    const files = execFileSync(
-      'git',
-      ['ls-files', '*.ts', '*.tsx', '*.js', '*.mjs', '*.rs'],
-      { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 },
-    )
-      .split('\n')
-      .filter(Boolean)
-
-    const offenders: string[] = []
-    for (const rel of files) {
-      const buf = readFileSync(join(root, rel))
-      for (let i = 0; i < buf.length; i++) {
-        const b = buf[i]!
-        // Allow only tab (9), LF (10), CR (13); flag all other C0 + DEL (127).
-        if ((b < 32 && b !== 9 && b !== 10 && b !== 13) || b === 127) {
-          offenders.push(`${rel} (byte 0x${b.toString(16).padStart(2, '0')} at offset ${i})`)
-          break
-        }
-      }
-    }
-    expect(offenders, `raw control bytes in source — escape them (\\u00NN):\n${offenders.join('\n')}`).toEqual([])
-  })
-})

package/src/tests/component-child-no-wrap.test.ts

@@ -1,204 +0,0 @@
-/**
- * Compiler hardening — JSX child of COMPONENT parent is NOT wrapped in an
- * accessor when the expression is a stable reference (Identifier or simple
- * MemberExpression chain).
- *
- * Reported root cause behind the kinetic Stagger + bokisch.com Intro repro
- * (PR #731 shipped the library-side workaround; this is the upstream fix).
- *
- * Pre-fix the compiler rewrote `<Comp>{children}</Comp>` (where `children`
- * is a local `const` derived from a getter — `const children = childHolder.children`
- * after `splitProps`) as `Comp({ ..., children: () => h.children })`. Receiving
- * components saw `props.children` as a FUNCTION instead of the expected
- * `VNode | VNode[]`. DOM-consuming code routes through `mountChild` which
- * handles function children correctly (via `mountReactive`), so the wrap is
- * invisible there. Libraries that iterate children at the VNode level
- * (kinetic's StaggerRenderer/TransitionItem) or `cloneVNode` them directly
- * were silently broken — the function spread produced `{type: undefined}`
- * and the DOM rendered literal `<undefined>` tags.
- *
- * Fix shape: for JSX children of COMPONENT parents (uppercase tag), skip
- * the accessor wrap when the expression is a stable reference. The
- * compiler's prop-inlining pass still runs (so `children` is replaced with
- * `h.children` at the JSX use site) but the resulting expression is
- * emitted bare. Dynamic shapes (CallExpression, BinaryExpression, etc.)
- * keep the wrap so `<Comp>{count()}</Comp>` and similar patterns stay
- * reactive end-to-end.
- *
- * Note: `transformJSX_JS` returns Pyreon-transformed SOURCE — JSX stays as
- * JSX (the final JSX→jsx() lowering is esbuild's job). So the inlined
- * expression shows up between `{...}` in the emitted text.
- *
- * Bisect: revert the `isComponentTag(...) && isStableReference(expr)`
- * carve-out in `handleJsxExpression` (jsx.ts) → the CONTRACT specs fail
- * (emit reverts to `{() => h.children}`); the wrap-still-fires CONTROL
- * specs stay green (proving the carve-out doesn't touch the call/binary
- * paths).
- */
-import { describe, expect, test } from 'vitest'
-import { transformJSX_JS } from '../jsx'
-
-const t = (src: string): string => transformJSX_JS(src, 'test.tsx').code
-
-describe('JSX transform — component child of stable reference', () => {
-  test('CONTRACT — bare Identifier (splitProps-derived const) is emitted without accessor wrap', () => {
-    // The bokisch.com Intro shape, distilled. `splitProps` registers
-    // `childHolder` as a prop-derived binding; `const children = childHolder.children`
-    // makes `children` prop-derived; the JSX child `{children}` would,
-    // pre-fix, emit `{() => childHolder.children}`. Now emits the inlined
-    // value bare.
-    const src = `
-      const Comp = (props) => {
-        const [childHolder, restHtml] = splitProps(props, ['children'])
-        const children = childHolder.children
-        return <Inner>{children}</Inner>
-      }
-    `
-    const out = t(src)
-    expect(out, 'children must NOT be wrapped in an accessor').not.toContain('() =>')
-    expect(out, 'inlined value must appear bare in JSX child position').toMatch(
-      /<Inner>\s*\{\(?childHolder\.children\)?\}\s*<\/Inner>/,
-    )
-  })
-
-  test('CONTRACT — simple MemberExpression chain is emitted without accessor wrap', () => {
-    const src = `
-      const Comp = (props) => {
-        const [obj] = splitProps(props, ['deep'])
-        return <Inner>{obj.deep.x}</Inner>
-      }
-    `
-    const out = t(src)
-    expect(out, 'member chain must NOT be wrapped in an accessor').not.toContain(
-      '() => obj.deep.x',
-    )
-    expect(out, 'member chain must appear bare').toMatch(
-      /<Inner>\s*\{obj\.deep\.x\}\s*<\/Inner>/,
-    )
-  })
-
-  test('CONTROL — CallExpression child KEEPS the wrap (preserves reactivity)', () => {
-    // `<Comp>{count()}</Comp>` — the user explicitly reads a signal in the
-    // child position. The wrap converts to `() => count()` so the
-    // receiving component can subscribe via mountChild → mountReactive.
-    const src = `
-      const count = signal(0)
-      const Comp = () => <Inner>{count()}</Inner>
-    `
-    const out = t(src)
-    expect(out, 'call-expression child must keep the wrap').toContain('() => count()')
-  })
-
-  test('CONTROL — BinaryExpression child KEEPS the wrap', () => {
-    const src = `
-      const Comp = (props) => {
-        const [own] = splitProps(props, ['a', 'b'])
-        return <Inner>{own.a + own.b}</Inner>
-      }
-    `
-    const out = t(src)
-    expect(out, 'binary-expression child must keep the wrap').toMatch(/\(\)\s*=>/)
-    expect(out).toContain('own.a')
-    expect(out).toContain('own.b')
-  })
-
-  test('CONTROL — DOM-element parent with bare Identifier KEEPS the binding (reactive)', () => {
-    // The carve-out only fires for COMPONENT parents (uppercase tag).
-    // DOM-element children must still go through the reactive binding
-    // path so mountChild/mountReactive can re-evaluate inside an effect.
-    const src = `
-      const Comp = (props) => {
-        const [own] = splitProps(props, ['children'])
-        const children = own.children
-        return <div>{children}</div>
-      }
-    `
-    const out = t(src)
-    // The template path emits this as a reactive binding (_bindText /
-    // _bindDirect / etc.), not a bare text-node. Either way, the
-    // expression must still route through a reactive primitive.
-    expect(out, 'DOM-element child must route through a reactive path').not.toContain(
-      '<div>{own.children}</div>',
-    )
-  })
-
-  test('CONTRACT — TS-cast wrapper (`as VNode[]`) is transparent', () => {
-    // The EXACT shape `createKineticComponent.tsx` ships:
-    //   `<StaggerRenderer>{children as VNode[]}</StaggerRenderer>`
-    // The TS `as` cast wraps `children` as a `TSAsExpression`. Without
-    // unwrapping, the carve-out misses the bokisch reproducer entirely.
-    // The cast is preserved in the emit — esbuild's later TS-strip pass
-    // removes it. Reproducer: pre-fix this test fails with
-    // `expected to NOT contain '() =>'` because the wrap still fires.
-    const src = `
-      const Kinetic = (props) => {
-        const [childHolder] = splitProps(props, ['children'])
-        const children = childHolder.children
-        return <Inner>{children as VNode[]}</Inner>
-      }
-    `
-    const out = t(src)
-    expect(out, 'TS-cast wrapper must not block the carve-out').not.toContain('() =>')
-    // Slice unwraps the TS cast — output is just the inlined value.
-    expect(out).toMatch(/<Inner>\s*\{\(?childHolder\.children\)?\}\s*<\/Inner>/)
-  })
-
-  test('CONTRACT — non-null `!` postfix is transparent', () => {
-    const src = `
-      const Comp = (props) => {
-        const [own] = splitProps(props, ['children'])
-        return <Inner>{own.children!}</Inner>
-      }
-    `
-    const out = t(src)
-    expect(out).not.toContain('() =>')
-    expect(out).toMatch(/<Inner>\s*\{own\.children\}\s*<\/Inner>/)
-  })
-
-  test('CONTRACT — kinetic Stagger reproducer compiles to bare children prop', () => {
-    // Exact shape from `packages/ui-system/kinetic/src/kinetic/createKineticComponent.tsx`.
-    // Pre-fix emit (JSX child position): `{() => childHolder.children}`.
-    // Post-fix emit: `{childHolder.children}` (no wrap).
-    const src = `
-      const Kinetic = (props) => {
-        const [childHolder, restHtml] = splitProps(props, ['children'])
-        const children = childHolder.children
-        return <StaggerRenderer htmlProps={restHtml}>{children}</StaggerRenderer>
-      }
-    `
-    const out = t(src)
-    expect(out).not.toContain('() => childHolder.children')
-    expect(out).not.toContain('() => children')
-    expect(out).toMatch(
-      /<StaggerRenderer[^>]*>\s*\{\(?childHolder\.children\)?\}\s*<\/StaggerRenderer>/,
-    )
-  })
-
-  test('CONTROL — bare SIGNAL identifier KEEPS the wrap (auto-call + wrap is reactive)', () => {
-    // `<Comp>{count}</Comp>` where count is a tracked signal — the user's
-    // deliberate "make this reactive at the call site" pattern. The
-    // compiler auto-calls (`count` → `count()`) AND wraps (`() => count()`)
-    // so the receiving component re-evaluates in its mountReactive scope.
-    // The stable-reference carve-out explicitly excludes signal references.
-    const src = `
-      function C() {
-        const count = signal(0)
-        return <MyComp>{count}</MyComp>
-      }
-    `
-    const out = t(src)
-    expect(out, 'signal child must be wrapped + auto-called').toContain('() => count()')
-  })
-
-  test('CONTROL — already-arrow-wrapped child is unchanged (idempotent)', () => {
-    // Users who explicitly want reactivity write `<Comp>{() => x()}</Comp>`.
-    // The compiler's shouldWrap returns false for ArrowFunctionExpression,
-    // so the carve-out never fires. The user's accessor passes through.
-    const src = `
-      const x = signal('a')
-      const Comp = () => <Inner>{() => x()}</Inner>
-    `
-    const out = t(src)
-    expect(out, 'user-written accessor must pass through').toContain('() => x()')
-  })
-})