@barefootjs/jsx 0.21.4 → 0.23.0

package/src/__tests__/reactive-factory-inlining.test.ts

@@ -176,14 +176,26 @@ describe('Reactive factory inlining (#931)', () => {
   })
 
   test('non-tuple single-value destructure is NOT treated as a factory call', () => {
-    // Guard against false positives: `const { x } = obj()` should be left alone.
+    // Guard against false positives: `const { x } = obj()` should be left
+    // alone when `obj` is an ordinary (non-reactive) function.
+    //
+    // Correction (#2325): this fixture previously destructured `createSignal`
+    // itself with a TUPLE pattern (`const [count, setCount] = createSignal(0)`),
+    // which never exercised an object destructure at all — it was already
+    // covered by the `callee === 'createSignal'` skip in
+    // `validateReactiveFactoryCalls`. Rewritten to genuinely exercise the
+    // object-destructure path now that it performs real factory-shape
+    // dispatch (#2325 §4c).
     const source = `
       'use client'
-      import { createSignal } from '@barefootjs/client'
+
+      function getConfig() {
+        return { x: 1 }
+      }
 
       export function Comp() {
-        const [count, setCount] = createSignal(0)
-        return <p>{count()}</p>
+        const { x } = getConfig()
+        return <p>{x}</p>
       }
     `
 
@@ -193,3 +205,280 @@ describe('Reactive factory inlining (#931)', () => {
     expect(bf110).toBeUndefined()
   })
 })
+
+describe('Object-return reactive factories (#2325)', () => {
+  test('object-return factory: full destructure { count, setCount }', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      function createCounter(initial: number) {
+        const [count, setCount] = createSignal(initial)
+        return { count, setCount }
+      }
+
+      export function Counter() {
+        const { count, setCount } = createCounter(0)
+        return <button onClick={() => setCount(count() + 1)}>{count()}</button>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Counter.tsx')
+    expect(ctx.signals.length).toBe(1)
+    expect(ctx.signals[0].getter).toBe('count')
+    expect(ctx.signals[0].setter).toBe('setCount')
+
+    const result = compileJSX(source, 'Counter.tsx', { adapter })
+    expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+    const clientJs = result.files.find(f => f.type === 'clientJs')
+    expect(clientJs).toBeDefined()
+    expect(clientJs!.content).toContain('createSignal')
+  })
+
+  test('object-return factory: subset destructure suffix-renames the undestructured setter (C4)', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      function createCounter(initial: number) {
+        const [count, setCount] = createSignal(initial)
+        return { count, setCount }
+      }
+
+      export function Display() {
+        const { count } = createCounter(0)
+        return <p>{count()}</p>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Display.tsx')
+    expect(ctx.signals.length).toBe(1)
+    expect(ctx.signals[0].getter).toBe('count')
+
+    const result = compileJSX(source, 'Display.tsx', { adapter })
+    expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+    const clientJs = result.files.find(f => f.type === 'clientJs')!.content
+    // The setter was never destructured — it must still be suffix-renamed
+    // (not left as a bare, unresolved `setCount`).
+    expect(clientJs).toMatch(/setCount_\w+/)
+  })
+
+  test('object-return factory: custom setter wrapper (localStorage-backed signal)', () => {
+    // Matches the createPersistentSignal shape from PR #930.
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      function createPersistentSignal(key: string, initial: string) {
+        const [v, setV] = createSignal(initial)
+        const setAndStore = (next: string) => {
+          setV(next)
+          localStorage.setItem(key, next)
+        }
+        return { v, setAndStore }
+      }
+
+      export function Store() {
+        const { v, setAndStore } = createPersistentSignal('k', 'hello')
+        return <button onClick={() => setAndStore('world')}>{v()}</button>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Store.tsx')
+    expect(ctx.signals.length).toBe(1)
+    expect(ctx.signals[0].getter).toBe('v')
+
+    const result = compileJSX(source, 'Store.tsx', { adapter })
+    expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+    const clientJs = result.files.find(f => f.type === 'clientJs')!.content
+    expect(clientJs).toContain('createSignal')
+    expect(clientJs).toContain("localStorage.setItem('k'")
+  })
+
+  test('object-return factory: two subset-destructure call sites stay hygienic (C4)', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      function createPair(initial: number) {
+        const [count, setCount] = createSignal(initial)
+        return { count, setCount }
+      }
+
+      export function Two() {
+        const { count } = createPair(0)
+        const { setCount } = createPair(10)
+        return <p>{count()}</p>
+      }
+    `
+
+    const result = compileJSX(source, 'Two.tsx', { adapter })
+    expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+    const clientJs = result.files.find(f => f.type === 'clientJs')!.content
+    expect(clientJs.match(/createSignal\(/g)?.length).toBe(2)
+    // Per-call-site-unique suffixed internal names: the first call site
+    // suffix-renames its undestructured `setCount`, the second suffix-
+    // renames its undestructured `count` — distinct call sites must not
+    // collide on either name.
+    expect(clientJs).toMatch(/setCount_bf\d+/)
+    expect(clientJs).toMatch(/count_bf\d+/)
+  })
+
+  test('object-return factory: mixed signal + memo body', () => {
+    const source = `
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+
+      function createCounter(initial: number) {
+        const [count, setCount] = createSignal(initial)
+        const double = createMemo(() => count() * 2)
+        return { count, setCount, double }
+      }
+
+      export function Counter() {
+        const { count, setCount, double } = createCounter(0)
+        return <button onClick={() => setCount(count() + 1)}>{double()}</button>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Counter.tsx')
+    expect(ctx.signals.length).toBe(1)
+    expect(ctx.memos.length).toBe(1)
+    expect(ctx.memos[0].name).toBe('double')
+
+    const result = compileJSX(source, 'Counter.tsx', { adapter })
+    expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+  })
+
+  test('BF110: object destructure of an unknown imported callee emits a diagnostic', () => {
+    // Regression-locks the closed silent-failure hole: an unresolvable
+    // relative import whose name looks reactive-factory-shaped.
+    const source = `
+      'use client'
+      import { useExternal } from './external'
+
+      export function Gadget() {
+        const { value, setValue } = useExternal('key')
+        return <button onClick={() => setValue('x')}>{value()}</button>
+      }
+    `
+
+    const result = compileJSX(source, 'Gadget.tsx', { adapter })
+    const bf110 = result.errors.find(e => e.code === 'BF110')
+    expect(bf110).toBeDefined()
+    expect(bf110!.message).toContain('useExternal')
+  })
+
+  test('BF111: non-shorthand factory return emits a diagnostic, no inlining', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      function createCounter(initial: number) {
+        const [count, setCount] = createSignal(initial)
+        return { count: count, setCount }
+      }
+
+      export function Counter() {
+        const { count, setCount } = createCounter(0)
+        return <button onClick={() => setCount(count() + 1)}>{count()}</button>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Counter.tsx')
+    expect(ctx.signals.length).toBe(0)
+
+    const result = compileJSX(source, 'Counter.tsx', { adapter })
+    const bf111 = result.errors.find(e => e.code === 'BF111')
+    expect(bf111).toBeDefined()
+  })
+
+  test('BF111: non-shorthand call-site destructure of a shorthand factory emits a diagnostic, no inlining', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      function createCounter(initial: number) {
+        const [count, setCount] = createSignal(initial)
+        return { count, setCount }
+      }
+
+      export function Counter() {
+        const { count: c, setCount } = createCounter(0)
+        return <button onClick={() => setCount(c() + 1)}>{c()}</button>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Counter.tsx')
+    expect(ctx.signals.length).toBe(0)
+
+    const result = compileJSX(source, 'Counter.tsx', { adapter })
+    const bf111 = result.errors.find(e => e.code === 'BF111')
+    expect(bf111).toBeDefined()
+  })
+
+  test('BF110 (not BF111): object destructure with a rename of a TUPLE-return factory reports the tuple mismatch', () => {
+    // A tuple-return factory destructured as an object is never valid,
+    // regardless of whether the object pattern is shorthand or uses a
+    // rename/default/rest element — it should always get the "this
+    // factory returns a tuple" BF110 message, not the shorthand-only
+    // BF111 guidance (which only makes sense for object-return factories).
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      function createCounter(initial: number) {
+        const [count, setCount] = createSignal(initial)
+        return [count, setCount] as const
+      }
+
+      export function Counter() {
+        const { count: c, setCount } = createCounter(0)
+        return <button onClick={() => setCount(c() + 1)}>{c()}</button>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Counter.tsx')
+    expect(ctx.signals.length).toBe(0)
+
+    const result = compileJSX(source, 'Counter.tsx', { adapter })
+    const bf110 = result.errors.find(e => e.code === 'BF110')
+    expect(bf110).toBeDefined()
+    expect(bf110!.message).toContain('returns a tuple')
+    expect(result.errors.find(e => e.code === 'BF111')).toBeUndefined()
+  })
+
+  test('guard: plain-function object destructure is not flagged (false-positive guard)', () => {
+    const source = `
+      'use client'
+
+      function parseConfig() {
+        return { data: 42 }
+      }
+
+      export function Comp() {
+        const { data } = parseConfig()
+        return <p>{data}</p>
+      }
+    `
+
+    const result = compileJSX(source, 'Comp.tsx', { adapter })
+    expect(result.errors.find(e => e.code === 'BF110')).toBeUndefined()
+    expect(result.errors.find(e => e.code === 'BF111')).toBeUndefined()
+  })
+
+  test('guard: object destructure of a @barefootjs-scoped import is not flagged (false-positive guard)', () => {
+    const source = `
+      'use client'
+      import { loadItems } from '@barefootjs/something'
+
+      export function Comp() {
+        const { items } = loadItems()
+        return <p>{items}</p>
+      }
+    `
+
+    const result = compileJSX(source, 'Comp.tsx', { adapter })
+    expect(result.errors.find(e => e.code === 'BF110')).toBeUndefined()
+  })
+})

package/src/__tests__/to-locale-date-lowering.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Literal-locale `toLocaleDateString` sugar (#2324 slice 2). Covers the
+ * build-time pattern derivation's structural gate, the matcher's
+ * accept/decline table (only the explicit-input literal shape lowers; every
+ * implicit-environment or runtime-value shape declines to BF021), the
+ * BF021-exemption round trip through the real registry, and the client-JS
+ * rewrite to `formatDate(recv, pattern, tz)` (mirrors
+ * `date-lowering.test.ts`'s #2292 section).
+ */
+import { describe, test, expect } from 'bun:test'
+import { compileJSX, type ComponentIR } from '../index'
+import { TestAdapter } from '../adapters/test-adapter'
+import { parseExpression, type ParsedExpr } from '../expression-parser'
+import {
+  resolveLocaleDatePattern,
+  matchToLocaleDateStringCall,
+  toLocaleDatePlugin,
+} from '../to-locale-date-lowering'
+import { ErrorCodes } from '../errors'
+
+function compile(src: string) {
+  return compileJSX(src.trimStart(), 'T.tsx', { adapter: new TestAdapter(), outputIR: true })
+}
+
+function metadata(src: string): ComponentIR['metadata'] {
+  const result = compile(src)
+  const ir = JSON.parse(result.files.find((f) => f.type === 'ir')!.content) as ComponentIR
+  return ir.metadata
+}
+
+function callParts(expr: string): { callee: ParsedExpr; args: ParsedExpr[] } {
+  const parsed = parseExpression(expr)
+  if (parsed.kind !== 'call') throw new Error(`expected a call expression, got ${parsed.kind}`)
+  return { callee: parsed.callee, args: parsed.args }
+}
+
+const DATE_PROP_SRC = `
+export function Foo({ createdAt }: { createdAt: Date }) {
+  return <div>{createdAt.toLocaleDateString('en-US', { timeZone: 'UTC' })}</div>
+}
+`
+
+describe('resolveLocaleDatePattern (build-time derivation)', () => {
+  test('derives numeric default patterns per locale', () => {
+    expect(resolveLocaleDatePattern('en-US')).toBe('M/D/YYYY')
+    expect(resolveLocaleDatePattern('ja-JP')).toBe('YYYY/M/D')
+    expect(resolveLocaleDatePattern('en-GB')).toBe('DD/MM/YYYY')
+  })
+
+  test('declines non-gregorian / non-latin-digit defaults (ar-SA) and invalid tags', () => {
+    expect(resolveLocaleDatePattern('ar-SA')).toBeNull()
+    expect(resolveLocaleDatePattern('not a locale !!')).toBeNull()
+  })
+})
+
+describe('matchToLocaleDateStringCall accept/decline table', () => {
+  const md = metadata(DATE_PROP_SRC)
+
+  function match(expr: string) {
+    const { callee, args } = callParts(expr)
+    return matchToLocaleDateStringCall(callee, args, md)
+  }
+
+  test('literal locale + literal UTC timeZone lowers to format_date with the frozen pattern', () => {
+    const node = match(`createdAt.toLocaleDateString('en-US', { timeZone: 'UTC' })`)
+    expect(node).toEqual({
+      kind: 'helper-call',
+      helper: 'format_date',
+      args: [
+        { kind: 'identifier', name: 'createdAt' },
+        { kind: 'literal', value: 'M/D/YYYY', literalType: 'string' },
+        { kind: 'literal', value: 'UTC', literalType: 'string' },
+      ],
+    })
+  })
+
+  test('a fixed ±HH:MM offset timeZone is admitted', () => {
+    const node = match(`createdAt.toLocaleDateString('ja-JP', { timeZone: '+09:00' })`)
+    expect(node).toMatchObject({
+      helper: 'format_date',
+      args: [
+        { kind: 'identifier', name: 'createdAt' },
+        { kind: 'literal', value: 'YYYY/M/D' },
+        { kind: 'literal', value: '+09:00' },
+      ],
+    })
+  })
+
+  test('implicit-environment and runtime-value shapes all decline', () => {
+    // zero-arg / locale-only: reads host locale and/or timezone
+    expect(match(`createdAt.toLocaleDateString()`)).toBeNull()
+    expect(match(`createdAt.toLocaleDateString('ja-JP')`)).toBeNull()
+    // non-literal locale: no build-time CLDR resolution
+    expect(match(`createdAt.toLocaleDateString(locale, { timeZone: 'UTC' })`)).toBeNull()
+    // IANA zone name: host-tzdata coupling
+    expect(match(`createdAt.toLocaleDateString('ja-JP', { timeZone: 'Asia/Tokyo' })`)).toBeNull()
+    // non-literal timeZone
+    expect(match(`createdAt.toLocaleDateString('ja-JP', { timeZone: tz })`)).toBeNull()
+    // out-of-range fixed offsets: real toLocaleDateString throws RangeError
+    // on these, so lowering them would diverge from JS semantics
+    expect(match(`createdAt.toLocaleDateString('ja-JP', { timeZone: '+25:00' })`)).toBeNull()
+    expect(match(`createdAt.toLocaleDateString('ja-JP', { timeZone: '+99:99' })`)).toBeNull()
+    expect(match(`createdAt.toLocaleDateString('ja-JP', { timeZone: '-12:60' })`)).toBeNull()
+    // options beyond timeZone: the name-table stage, not this slice
+    expect(match(`createdAt.toLocaleDateString('ja-JP', { timeZone: 'UTC', month: 'long' })`)).toBeNull()
+    expect(match(`createdAt.toLocaleDateString('ja-JP', { dateStyle: 'long' })`)).toBeNull()
+    // unrepresentable locale default
+    expect(match(`createdAt.toLocaleDateString('ar-SA', { timeZone: 'UTC' })`)).toBeNull()
+  })
+
+  test('a non-Date receiver never activates the plugin', () => {
+    const stringMd = metadata(`
+      export function Foo({ label }: { label: string }) {
+        return <div>{label}</div>
+      }
+    `)
+    expect(toLocaleDatePlugin.prepare(stringMd)).toBeNull()
+  })
+})
+
+describe('BF021 exemption round trip (#2273 seam)', () => {
+  test('the claimed literal shape compiles clean; the runtime-locale shape still fires BF021', () => {
+    const clean = compile(DATE_PROP_SRC)
+    expect(clean.errors.filter((e) => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)).toEqual([])
+
+    const refused = compile(`
+      export function Foo({ createdAt, locale }: { createdAt: Date; locale: string }) {
+        return <div>{createdAt.toLocaleDateString(locale, { timeZone: 'UTC' })}</div>
+      }
+    `)
+    const bf021 = refused.errors.filter((e) => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+    expect(bf021.length).toBeGreaterThan(0)
+    // the refusal now points at the explicit-input forms
+    expect(bf021[0].suggestion?.message).toContain('formatDate')
+  })
+
+  test('the zero-arg form (date-method-uncatalogued shape) still fires BF021', () => {
+    const refused = compile(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{createdAt.toLocaleDateString()}</div>
+      }
+    `)
+    expect(refused.errors.some((e) => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)).toBe(true)
+  })
+})
+
+describe('client-JS rewrite (#2292-style parity)', () => {
+  function clientJs(src: string): string {
+    const result = compileJSX(src.trimStart(), 'T.tsx', { adapter: new TestAdapter() })
+    return result.files.find((f) => f.type === 'clientJs')!.content
+  }
+
+  test('rewrites the literal shape to formatDate with the frozen pattern and auto-imports it', () => {
+    const js = clientJs(DATE_PROP_SRC)
+    expect(js).toContain('formatDate(_p.createdAt, "M/D/YYYY", "UTC")')
+    expect(js).toMatch(/import\s*\{[^}]*\bformatDate\b[^}]*\}\s*from\s*'@barefootjs\/client\/runtime'/)
+  })
+
+  test('rewrites inside a reactive effect for a signal-conditioned expression', () => {
+    const js = clientJs(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        const [suffix, setSuffix] = createSignal('')
+        return <div onClick={() => setSuffix('!')}>{createdAt.toLocaleDateString('ja-JP', { timeZone: '+09:00' }) + suffix()}</div>
+      }
+    `)
+    expect(js).toContain('formatDate(_p.createdAt, "YYYY/M/D", "+09:00")')
+    expect(js).not.toContain('toLocaleDateString')
+  })
+
+  test('leaves the declined runtime-locale shape raw', () => {
+    const js = clientJs(`
+      export function Foo({ createdAt, locale }: { createdAt: Date; locale: string }) {
+        return <div>{/* @client */ createdAt.toLocaleDateString(locale, { timeZone: 'UTC' })}</div>
+      }
+    `)
+    expect(js).toContain('toLocaleDateString(')
+    expect(js).not.toContain('formatDate(')
+  })
+})

package/src/adapters/env-signal.ts

@@ -117,7 +117,7 @@ export function importsSearchParams(metadata: IRMetadata): boolean {
 export function queryHrefLocalNames(metadata: IRMetadata): Set<string> {
   const names = new Set<string>()
   for (const imp of metadata.imports) {
-    if (!QUERY_HREF_SOURCES.has(imp.source) || imp.isTypeOnly) continue
+    if (!CLIENT_HELPER_SOURCES.has(imp.source) || imp.isTypeOnly) continue
     for (const s of imp.specifiers) {
       if (s.isTypeOnly || s.isNamespace || s.isDefault) continue
       if (s.name === 'queryHref') names.add(s.alias ?? s.name)
@@ -126,12 +126,35 @@ export function queryHrefLocalNames(metadata: IRMetadata): Set<string> {
   return names
 }
 
-/** Entry points that re-export `queryHref` (main + the runtime re-export). */
-const QUERY_HREF_SOURCES: ReadonlySet<string> = new Set([
+/**
+ * Entry points that re-export the pure client helpers with an SSR lowering
+ * (`queryHref` #2042, `formatDate` #2324) — the main entry and the runtime
+ * re-export. Importing from either must enable the lowering.
+ */
+const CLIENT_HELPER_SOURCES: ReadonlySet<string> = new Set([
   '@barefootjs/client',
   '@barefootjs/client/runtime',
 ])
 
+/**
+ * The local binding name(s) that `formatDate` is imported under in this
+ * component (#2324) — the pure-function date formatter an adapter lowers to
+ * its `format_date` helper (spec/template-helpers.md). Same resolution rules
+ * as {@link queryHrefLocalNames}: matched by exported name, gated on the LOCAL
+ * alias, accepted from both the main entry and the runtime re-export.
+ */
+export function formatDateLocalNames(metadata: IRMetadata): Set<string> {
+  const names = new Set<string>()
+  for (const imp of metadata.imports) {
+    if (!CLIENT_HELPER_SOURCES.has(imp.source) || imp.isTypeOnly) continue
+    for (const s of imp.specifiers) {
+      if (s.isTypeOnly || s.isNamespace || s.isDefault) continue
+      if (s.name === 'formatDate') names.add(s.alias ?? s.name)
+    }
+  }
+  return names
+}
+
 /**
  * Recognise a `<binding>().<method>(<args>)` env-signal method call from a
  * `call` node's callee + args, where `<binding>` is one of the local names

package/src/analyzer-context.ts

@@ -22,6 +22,7 @@ import type {
   ParamInfo,
   PropertyInfo,
   ReactiveFactoryInfo,
+  DeclinedReactiveFactory,
 } from './types.ts'
 import { type ExcludeRange, collectAllTypeRanges, reconstructWithoutTypes } from './strip-types.ts'
 
@@ -146,15 +147,26 @@ export interface AnalyzerContext {
   /** Maps multi-return JSX helper functions for conditional inlining at call sites. */
   jsxMultiReturnFunctions: Map<string, MultiReturnJsxInfo>
   /**
-   * Maps function names to reactive-factory info (#931). A reactive factory
-   * is a same-file helper whose body declares reactive primitives and
-   * returns a tuple of identifiers, e.g.
+   * Maps factory-call-site-local names to reactive-factory info (#931,
+   * #2325). A reactive factory is a helper whose body declares reactive
+   * primitives and returns a tuple or shorthand-object of identifiers, e.g.
    *   `function createCounter(initial) { const [c,s] = createSignal(initial); return [c, s] as const }`.
    * When a component destructures the result of a factory call, the factory
    * body is inlined at the call site so the compiler sees ordinary
-   * `createSignal` declarations.
+   * `createSignal` declarations. Populated by `analyzeComponent` from the
+   * factory prescan (same-file declarations plus relative-imported
+   * factories resolved by `prescanImportedReactiveFactories`); consumed by
+   * `validateReactiveFactoryCalls`.
    */
   reactiveFactories: Map<string, ReactiveFactoryInfo>
+  /** Factories recognized but declined for inlining, keyed by call-site-local name (#2325). */
+  declinedReactiveFactories: Map<string, DeclinedReactiveFactory>
+  /** Module-scope helpers (same-file or resolved import) whose body contains a
+   *  reactive primitive call but whose shape is not an inlinable factory. */
+  reactiveShapedHelpers: Set<string>
+  /** Imported destructured-callee names whose helper file was resolved, read,
+   *  and found reactive-free / factory-free — proven safe to leave alone. */
+  cleanFactoryImports: Set<string>
   /**
    * Intermediate `const s = createSignal(...)` tuples awaiting `s[0]`/`s[1]`
    * extraction. Flushed into `signals` at the end of visitComponentBody.
@@ -247,6 +259,9 @@ export function createAnalyzerContext(
     jsxFunctions: new Map(),
     jsxMultiReturnFunctions: new Map(),
     reactiveFactories: new Map(),
+    declinedReactiveFactories: new Map(),
+    reactiveShapedHelpers: new Set(),
+    cleanFactoryImports: new Set(),
     signalTupleRefs: new Map(),
 
     propsType: null,