@barefootjs/vite 0.30.0

package/src/__tests__/component-dir-entry.test.ts

@@ -0,0 +1,239 @@
+/**
+ * `components` entries widened from `string[]` to `(string | ComponentDirEntry)[]`
+ * (`types.ts`) — per-directory `cssLayerPrefix`/`skipDirs` riding on the
+ * `components` entry itself instead of a 4th/5th top-level plugin option.
+ * See `types.ts`'s docstring and `plugin.ts`'s `normalizeComponents`/
+ * `entryForPath`/`isSkippedByEntry` for the mechanics these tests pin:
+ *
+ *   - a plain string entry stays exactly equivalent to `{ dir: string }`
+ *   - `cssLayerPrefix` reaches compiled output (template AND, for a
+ *     `'use client'` file, the hydration template embedded in client JS)
+ *     only for files under the entry that set it
+ *   - `skipDirs` excludes matching subdirectories from BOTH discovery (the
+ *     eager pass) and the `transform`/watcher gate (the graph pass) — a
+ *     half-fix on just one side is exactly what bit `site/ui`'s
+ *     `PageNavigation.tsx` (imported by pages from a `shared/` dir)
+ *   - precedence: a file reachable under more than one `components` entry
+ *     takes the FIRST entry's options, matching `buildChildNameIndex`'s
+ *     already-documented first-writer-wins rule
+ */
+import { describe, test, expect, afterEach } from 'bun:test'
+import { mkdtemp, rm, mkdir, writeFile, readFile, readdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { testAdapter } from '@barefootjs/jsx'
+import { barefoot } from '../plugin.ts'
+
+// biome-ignore lint: hooks are called directly, bypassing Vite's own
+// dispatch/typing — casting to `any` is the standard way to unit-test a
+// Vite plugin's hooks in isolation (same convention as `plugin.test.ts`).
+type AnyPlugin = any
+
+/** Drives `config` → `configResolved` → (fabricated empty manifest) →
+ * `writeBundle`, the same minimal sequence `plugin.test.ts`'s writeBundle
+ * describe block uses. */
+async function driveBuild(plugin: AnyPlugin, dir: string): Promise<void> {
+  await plugin.config({ root: dir }, { command: 'build', mode: 'production' })
+  await plugin.configResolved({ root: dir, base: '/', build: { outDir: 'dist', manifest: true } })
+  await mkdir(join(dir, 'dist/.vite'), { recursive: true })
+  await writeFile(join(dir, 'dist/.vite/manifest.json'), '{}')
+  await plugin.writeBundle()
+}
+
+/** `config` → `configResolved` only — enough to exercise `transform`
+ * without a real Vite build. */
+async function driveConfig(plugin: AnyPlugin, dir: string): Promise<void> {
+  await plugin.config({ root: dir }, { command: 'build', mode: 'production' })
+  await plugin.configResolved({ root: dir, base: '/', build: { outDir: 'dist', manifest: true } })
+}
+
+const ext = testAdapter.extension
+
+describe('ComponentDirEntry: string entry ≡ { dir } entry', () => {
+  let dir: string
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true })
+  })
+
+  test('same discovery and byte-identical compiled template as a plain string entry', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-entry-string-eq-'))
+    await mkdir(join(dir, 'a'), { recursive: true })
+    await mkdir(join(dir, 'b'), { recursive: true })
+    const source = 'export function Widget() { return <div className="bg-primary p-4">Hi</div> }'
+    await writeFile(join(dir, 'a/Widget.tsx'), source)
+    await writeFile(join(dir, 'b/Widget.tsx'), source)
+
+    const templatesA = join(dir, 'views-a')
+    const templatesB = join(dir, 'views-b')
+    const pluginString = barefoot({ adapter: testAdapter, components: ['a'], templates: templatesA })
+    const pluginObject = barefoot({ adapter: testAdapter, components: [{ dir: 'b' }], templates: templatesB })
+
+    await driveBuild(pluginString, dir)
+    await driveBuild(pluginObject, dir)
+
+    const outString = await readFile(join(templatesA, `Widget${ext}`), 'utf8')
+    const outObject = await readFile(join(templatesB, `Widget${ext}`), 'utf8')
+    expect(outString).toBe(outObject)
+    // Neither carries a cssLayerPrefix — the object form set none.
+    expect(outString).not.toContain('layer-')
+  })
+})
+
+describe('ComponentDirEntry: cssLayerPrefix', () => {
+  let dir: string
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true })
+  })
+
+  test('prefixes static classes in the compiled template only for the entry that set it', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-entry-css-layer-'))
+    await mkdir(join(dir, 'lib'), { recursive: true })
+    await mkdir(join(dir, 'app'), { recursive: true })
+    await writeFile(join(dir, 'lib/Card.tsx'), 'export function Card() { return <div className="bg-primary p-4">Hi</div> }')
+    await writeFile(join(dir, 'app/Panel.tsx'), 'export function Panel() { return <div className="bg-primary p-4">Hi</div> }')
+
+    const templatesDir = join(dir, 'views')
+    const plugin = barefoot({
+      adapter: testAdapter,
+      components: [
+        { dir: 'lib', cssLayerPrefix: 'components' },
+        'app',
+      ],
+      templates: templatesDir,
+    })
+    await driveBuild(plugin, dir)
+
+    const libTpl = await readFile(join(templatesDir, `Card${ext}`), 'utf8')
+    const appTpl = await readFile(join(templatesDir, `Panel${ext}`), 'utf8')
+
+    expect(libTpl).toContain('layer-components:bg-primary')
+    expect(libTpl).toContain('layer-components:p-4')
+    expect(appTpl).not.toContain('layer-')
+    expect(appTpl).toContain('bg-primary p-4')
+  })
+
+  test('reaches the hydration template embedded in compiled client JS too (the `transform` / graph-pass path)', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-entry-css-layer-clientjs-'))
+    await mkdir(join(dir, 'lib'), { recursive: true })
+    const clientSource = [
+      '\'use client\'',
+      'import { createSignal } from \'@barefootjs/client\'',
+      'export function Counter() {',
+      '  const [count, setCount] = createSignal(0)',
+      '  return <div className="bg-primary p-4"><button onClick={() => setCount(count() + 1)}>{count()}</button></div>',
+      '}',
+    ].join('\n')
+    await writeFile(join(dir, 'lib/Counter.tsx'), clientSource)
+
+    const plugin = barefoot({
+      adapter: testAdapter,
+      components: [{ dir: 'lib', cssLayerPrefix: 'components' }],
+      templates: join(dir, 'views'),
+    })
+    await driveConfig(plugin, dir)
+
+    const out = plugin.transform(clientSource, join(dir, 'lib/Counter.tsx'))
+    expect(out).not.toBeNull()
+    expect(out.code).toContain('layer-components:bg-primary')
+    expect(out.code).toContain('layer-components:p-4')
+  })
+})
+
+describe('ComponentDirEntry: skipDirs', () => {
+  let dir: string
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true })
+  })
+
+  test('excludes files under a matching subdirectory name from discovery (the eager pass)', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-entry-skipdirs-discovery-'))
+    await mkdir(join(dir, 'src/components/shared'), { recursive: true })
+    await writeFile(join(dir, 'src/components/Page.tsx'), 'export function Page() { return <p>Hi</p> }')
+    await writeFile(join(dir, 'src/components/shared/Helper.tsx'), 'export function Helper() { return <p>Hi</p> }')
+
+    const templatesDir = join(dir, 'views')
+    const plugin = barefoot({
+      adapter: testAdapter,
+      components: [{ dir: 'src/components', skipDirs: ['shared'] }],
+      templates: templatesDir,
+    })
+    await driveBuild(plugin, dir)
+
+    const emitted = await readdir(templatesDir)
+    expect(emitted).toContain(`Page${ext}`)
+    expect(emitted).not.toContain(`Helper${ext}`)
+  })
+
+  test('also gates the transform path — a file under a skipped subdir is not a component at all, even if directly imported', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-entry-skipdirs-transform-'))
+    await mkdir(join(dir, 'src/components/shared'), { recursive: true })
+
+    const clientTemplate = (name: string) => [
+      '\'use client\'',
+      'import { createSignal } from \'@barefootjs/client\'',
+      `export function ${name}() {`,
+      '  const [x, setX] = createSignal(0)',
+      '  return <button onClick={() => setX(x() + 1)}>{x()}</button>',
+      '}',
+    ].join('\n')
+
+    await writeFile(join(dir, 'src/components/Page.tsx'), clientTemplate('Page'))
+    // Lives inside the skipped `shared/` dir but is still a normal relative
+    // import target from a non-skipped sibling — the exact shape that used
+    // to reach `transform` anyway (discovery skips it, but nothing gated
+    // the graph pass) and got compiled despite being "skipped".
+    await writeFile(join(dir, 'src/components/shared/PageNavigation.tsx'), clientTemplate('PageNavigation'))
+
+    const plugin = barefoot({
+      adapter: testAdapter,
+      components: [{ dir: 'src/components', skipDirs: ['shared'] }],
+      templates: join(dir, 'views'),
+    })
+    await driveConfig(plugin, dir)
+
+    const pageOut = plugin.transform(clientTemplate('Page'), join(dir, 'src/components/Page.tsx'))
+    expect(pageOut).not.toBeNull()
+
+    const skippedOut = plugin.transform(
+      clientTemplate('PageNavigation'),
+      join(dir, 'src/components/shared/PageNavigation.tsx'),
+    )
+    expect(skippedOut).toBeNull()
+  })
+})
+
+describe('ComponentDirEntry: precedence', () => {
+  let dir: string
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true })
+  })
+
+  test('a file reachable under two entries (an outer dir and a nested dir both configured) takes the FIRST entry\'s cssLayerPrefix', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-entry-precedence-'))
+    await mkdir(join(dir, 'src/nested'), { recursive: true })
+    await writeFile(join(dir, 'src/nested/Card.tsx'), 'export function Card() { return <div className="bg-primary">Hi</div> }')
+
+    const templatesDir = join(dir, 'views')
+    const plugin = barefoot({
+      adapter: testAdapter,
+      components: [
+        { dir: 'src', cssLayerPrefix: 'outer' },
+        { dir: 'src/nested', cssLayerPrefix: 'inner' },
+      ],
+      templates: templatesDir,
+    })
+    await driveBuild(plugin, dir)
+
+    // Emitted at `nested/Card...` — `planEmits` mirrors the file's position
+    // under whichever `componentDirs` entry contains it, and since `src`
+    // (the FIRST entry) also matches, that's `src`'s own relative position
+    // (`nested/Card.tsx`), not `src/nested`'s.
+    const tpl = await readFile(join(templatesDir, 'nested', `Card${ext}`), 'utf8')
+    expect(tpl).toContain('layer-outer:bg-primary')
+    expect(tpl).not.toContain('layer-inner:')
+  })
+})

package/src/__tests__/component-manifest.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Coverage of `buildManifestEntry` — the combined `manifest.json` row
+ * builder (see `component-manifest.ts`'s header for the fields
+ * intentionally not included).
+ */
+import { describe, test, expect } from 'bun:test'
+import type { CompileResult, TemplateAdapter } from '@barefootjs/jsx'
+import { buildManifestEntry } from '../component-manifest.ts'
+
+const fakeAdapter = { extension: '.tmpl', templatesPerComponent: false } as TemplateAdapter
+const perComponentAdapter = { extension: '.tmpl', templatesPerComponent: true } as TemplateAdapter
+
+describe('buildManifestEntry', () => {
+  test('single-component, non-templatesPerComponent, no ssrDefaults: absent key, no components map', () => {
+    const result: CompileResult = {
+      files: [{ path: '/x', content: '<button/>', type: 'markedTemplate', componentName: 'Counter' }],
+      errors: [],
+    }
+
+    const row = buildManifestEntry(result, '/src/components/Counter.tsx', ['/src/components'], fakeAdapter)
+
+    expect(row).not.toBeNull()
+    expect(row!.manifestKey).toBe('Counter')
+    expect(row!.entry).toEqual({ markedTemplate: 'Counter.tmpl' })
+    // The absent-key contract matters: a consumer checking
+    // `'ssrDefaults' in entry` (or PHP's `array_key_exists`) must see FALSE
+    // for a component with no SSR defaults, not an empty object — see the
+    // `...(ssrDefaults ? { ssrDefaults } : {})` spread in
+    // `buildManifestEntry`.
+    expect('ssrDefaults' in row!.entry).toBe(false)
+    expect('components' in row!.entry).toBe(false)
+  })
+
+  test('single-component, non-templatesPerComponent, WITH ssrDefaults', () => {
+    const result: CompileResult = {
+      files: [
+        { path: '/x', content: '<button/>', type: 'markedTemplate', componentName: 'Counter' },
+        { path: '/x', content: '{"initial":{"propName":"initial","value":0}}', type: 'ssrDefaults', componentName: 'Counter' },
+      ],
+      errors: [],
+    }
+
+    const row = buildManifestEntry(result, '/src/components/Counter.tsx', ['/src/components'], fakeAdapter)
+
+    expect(row!.entry).toEqual({
+      markedTemplate: 'Counter.tmpl',
+      ssrDefaults: { initial: { propName: 'initial', value: 0 } },
+    })
+  })
+
+  test('templatesPerComponent adapter, single component: top-level fields mirror the components sub-map', () => {
+    const result: CompileResult = {
+      files: [
+        { path: '/x', content: 'body', type: 'markedTemplate', componentName: 'Counter' },
+        { path: '/x', content: '{"initial":{"value":0}}', type: 'ssrDefaults', componentName: 'Counter' },
+      ],
+      errors: [],
+    }
+
+    const row = buildManifestEntry(result, '/src/components/Counter.tsx', ['/src/components'], perComponentAdapter)
+
+    expect(row!.manifestKey).toBe('Counter')
+    expect(row!.entry).toEqual({
+      markedTemplate: 'Counter.tmpl',
+      ssrDefaults: { initial: { value: 0 } },
+      components: {
+        Counter: { markedTemplate: 'Counter.tmpl', ssrDefaults: { initial: { value: 0 } } },
+      },
+    })
+  })
+
+  test('templatesPerComponent adapter, multi-export file: one manifestKey, per-component rows, partial ssrDefaults', () => {
+    const result: CompileResult = {
+      files: [
+        { path: '/x', content: 'toast body', type: 'markedTemplate', componentName: 'Toast' },
+        { path: '/x', content: 'toaster body', type: 'markedTemplate', componentName: 'Toaster' },
+        { path: '/x', content: '{"open":{"value":false}}', type: 'ssrDefaults', componentName: 'Toast' },
+        // Toaster has no ssrDefaults file at all.
+      ],
+      errors: [],
+    }
+
+    const row = buildManifestEntry(
+      result,
+      '/src/components/ui/toast/index.tsx',
+      ['/src/components'],
+      perComponentAdapter,
+    )
+
+    // Neither exported component's name is 'index' (the file's own
+    // basename), so `markedTemplates[0]` is used for a multi-export file
+    // (see `component-manifest.ts`'s "Primary (top-level) template"
+    // comment).
+    expect(row!.manifestKey).toBe('ui/toast/index')
+    expect(row!.entry.markedTemplate).toBe('ui/toast/Toast.tmpl')
+    expect(row!.entry.ssrDefaults).toEqual({ open: { value: false } })
+    expect(row!.entry.components).toEqual({
+      Toast: { markedTemplate: 'ui/toast/Toast.tmpl', ssrDefaults: { open: { value: false } } },
+      Toaster: { markedTemplate: 'ui/toast/Toaster.tmpl' },
+    })
+    expect('ssrDefaults' in row!.entry.components!.Toaster!).toBe(false)
+  })
+
+  test('returns null for a state-only compile with no markedTemplate output', () => {
+    const result: CompileResult = {
+      files: [{ path: '/x', content: 'export const x = 1', type: 'clientJs' }],
+      errors: [],
+    }
+    expect(buildManifestEntry(result, '/src/components/state.tsx', ['/src/components'], fakeAdapter)).toBeNull()
+  })
+
+  test('drops malformed ssrDefaults content instead of throwing', () => {
+    const result: CompileResult = {
+      files: [
+        { path: '/x', content: 'body', type: 'markedTemplate', componentName: 'Counter' },
+        { path: '/x', content: 'not json', type: 'ssrDefaults', componentName: 'Counter' },
+      ],
+      errors: [],
+    }
+
+    const row = buildManifestEntry(result, '/src/components/Counter.tsx', ['/src/components'], fakeAdapter)
+    expect('ssrDefaults' in row!.entry).toBe(false)
+  })
+})

package/src/__tests__/corpus-program.test.ts

@@ -0,0 +1,244 @@
+/**
+ * `CorpusProgramManager` (#2537): one shared `ts.Program` across every
+ * compile, instead of a ~500-600 ms per-file `ts.createProgram` inside
+ * `compileJSX`'s fallback for each type-needing file.
+ *
+ * The unit half exercises the manager's contract directly (gating,
+ * instance reuse, incremental rebuild, in-memory divergence fallback).
+ * The plugin half drives `barefoot()`'s hooks against a temp project with
+ * a fake `node_modules/@barefootjs/form` and pins the two build-breaking
+ * symptoms this exists to fix:
+ *
+ *   - a Reactive<T>-brand importer compiles through the plugin at all
+ *     (BF050 is severity `error` and the plugin throws on error
+ *     diagnostics — pre-fix, this file could not build);
+ *   - zero per-file Program creations across the whole pass, measured by
+ *     the compiler's own `programCreations` counter.
+ */
+import { describe, test, expect, afterEach } from 'bun:test'
+import { mkdtemp, rm, mkdir, writeFile, readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  testAdapter,
+  enableCompilerInstrumentation,
+  disableCompilerInstrumentation,
+  resetCompilerCounters,
+  getCompilerCounters,
+} from '@barefootjs/jsx'
+import { CorpusProgramManager } from '../corpus-program.ts'
+import { barefoot } from '../plugin.ts'
+
+// Same convention as templates-optional.test.ts: hooks are called
+// directly, bypassing Vite's own dispatch/typing.
+type AnyPlugin = any
+
+const NEEDING_SOURCE = `export function List(props: { items: string[] }) {
+  return <ul>{props.items.map(item => <li key={item}>{item}</li>)}</ul>
+}
+`
+
+const PLAIN_SOURCE = `export function Greeting() { return <p>Hi</p> }
+`
+
+describe('CorpusProgramManager', () => {
+  let dir: string
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true })
+  })
+
+  test('returns undefined for a file that needs no type-based detection', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-corpus-unit-'))
+    const abs = join(dir, 'Greeting.tsx')
+    await writeFile(abs, PLAIN_SOURCE)
+
+    const manager = new CorpusProgramManager()
+    manager.seed([{ absPath: abs, content: PLAIN_SOURCE }])
+    expect(manager.programFor(abs, PLAIN_SOURCE)).toBeUndefined()
+  })
+
+  test('seeded needing files share ONE Program instance, reused across calls', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-corpus-unit-'))
+    const a = join(dir, 'A.tsx')
+    const b = join(dir, 'B.tsx')
+    await writeFile(a, NEEDING_SOURCE)
+    await writeFile(b, NEEDING_SOURCE)
+
+    const manager = new CorpusProgramManager()
+    manager.seed([
+      { absPath: a, content: NEEDING_SOURCE },
+      { absPath: b, content: NEEDING_SOURCE },
+    ])
+
+    const programA = manager.programFor(a, NEEDING_SOURCE)
+    const programB = manager.programFor(b, NEEDING_SOURCE)
+    expect(programA).toBeDefined()
+    expect(programA).toBe(programB!)
+    // Re-seeding an unchanged snapshot keeps the same instance — the dev
+    // watcher re-seeds on EVERY pass, so this is what keeps quiet passes
+    // free.
+    manager.seed([
+      { absPath: a, content: NEEDING_SOURCE },
+      { absPath: b, content: NEEDING_SOURCE },
+    ])
+    expect(manager.programFor(a, NEEDING_SOURCE)).toBe(programA!)
+  })
+
+  test('a changed file rebuilds the Program and the rebuilt SourceFile carries the new text', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-corpus-unit-'))
+    const abs = join(dir, 'A.tsx')
+    await writeFile(abs, NEEDING_SOURCE)
+
+    const manager = new CorpusProgramManager()
+    manager.seed([{ absPath: abs, content: NEEDING_SOURCE }])
+    const before = manager.programFor(abs, NEEDING_SOURCE)
+
+    const edited = NEEDING_SOURCE.replace('<ul>', '<ol>').replace('</ul>', '</ol>')
+    await writeFile(abs, edited)
+    const after = manager.programFor(abs, edited)
+
+    expect(after).toBeDefined()
+    expect(after).not.toBe(before!)
+    expect(after!.getSourceFile(abs)?.text).toBe(edited)
+  })
+
+  test('a needing file added after the seed still gets a Program (graph pass reaching a brand-new file)', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-corpus-unit-'))
+    const abs = join(dir, 'Late.tsx')
+
+    const manager = new CorpusProgramManager()
+    manager.seed([])
+    await writeFile(abs, NEEDING_SOURCE)
+    const program = manager.programFor(abs, NEEDING_SOURCE)
+    expect(program).toBeDefined()
+    expect(program!.getSourceFile(abs)?.text).toBe(NEEDING_SOURCE)
+  })
+
+  test('in-memory content diverging from disk falls back to a Program that still matches the in-memory text', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-corpus-unit-'))
+    const abs = join(dir, 'A.tsx')
+    await writeFile(abs, NEEDING_SOURCE)
+
+    const manager = new CorpusProgramManager()
+    manager.seed([{ absPath: abs, content: NEEDING_SOURCE }])
+
+    // Content the caller holds that is NOT what's on disk — the analyzer
+    // discards any Program whose SourceFile text mismatches, so whatever
+    // comes back here MUST carry the in-memory text.
+    const inMemory = NEEDING_SOURCE + '// trailing edit not yet on disk\n'
+    const program = manager.programFor(abs, inMemory)
+    expect(program).toBeDefined()
+    expect(program!.getSourceFile(abs)?.text).toBe(inMemory)
+  })
+})
+
+describe('barefoot() with a Reactive<T>-brand component (the BF050 unblock)', () => {
+  let dir: string
+  let templatesDir: string
+
+  afterEach(async () => {
+    disableCompilerInstrumentation()
+    if (dir) await rm(dir, { recursive: true, force: true })
+    if (templatesDir) await rm(templatesDir, { recursive: true, force: true })
+  })
+
+  /**
+   * A self-contained fake `@barefootjs/form` — same Reactive<T> brand
+   * shape as the real package's types, resolvable from the temp project
+   * without depending on a built `packages/form/dist`.
+   */
+  async function writeFakeFormPackage(root: string): Promise<void> {
+    const pkgDir = join(root, 'node_modules/@barefootjs/form')
+    await mkdir(pkgDir, { recursive: true })
+    await writeFile(
+      join(pkgDir, 'package.json'),
+      JSON.stringify({ name: '@barefootjs/form', version: '0.0.0', types: 'index.d.ts', main: 'index.js' }),
+    )
+    await writeFile(
+      join(pkgDir, 'index.d.ts'),
+      `export type Reactive<T> = T & { readonly __reactive: true };
+export interface FormReturn {
+  isSubmitting: Reactive<() => boolean>;
+  handleSubmit: (e: Event) => Promise<void>;
+}
+export declare function createForm(opts?: unknown): FormReturn;
+`,
+    )
+    await writeFile(join(pkgDir, 'index.js'), 'export function createForm() { return {} }\n')
+  }
+
+  test('builds a form-importing component without BF050, resolves the brand, and creates ZERO per-file Programs', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-corpus-plugin-'))
+    templatesDir = await mkdtemp(join(tmpdir(), 'barefoot-corpus-templates-'))
+    await mkdir(join(dir, 'src/components'), { recursive: true })
+    await writeFakeFormPackage(dir)
+
+    // Multi-export on purpose: pre-fix, the multi-component path masked
+    // BF050 while the single path threw — both shapes must now build.
+    await writeFile(
+      join(dir, 'src/components/Forms.tsx'),
+      `'use client'
+import { createForm } from '@barefootjs/form'
+
+export function ProfileForm() {
+  const form = createForm()
+  return <form onSubmit={form.handleSubmit}><button disabled={form.isSubmitting()}>Save</button></form>
+}
+`,
+    )
+    await writeFile(join(dir, 'src/components/SingleForm.tsx'), `'use client'
+import { createForm } from '@barefootjs/form'
+
+export function SingleForm() {
+  const form = createForm()
+  return <form onSubmit={form.handleSubmit}><button disabled={form.isSubmitting()}>Go</button></form>
+}
+`)
+    await writeFile(join(dir, 'src/components/Greeting.tsx'), PLAIN_SOURCE)
+
+    const plugin: AnyPlugin = barefoot({
+      adapter: testAdapter,
+      components: ['src/components'],
+      templates: templatesDir,
+    })
+
+    enableCompilerInstrumentation()
+    resetCompilerCounters()
+
+    await plugin.config({ root: dir }, { command: 'build', mode: 'production' })
+    await plugin.configResolved({ root: dir, base: '/', build: { outDir: 'dist', manifest: true } })
+
+    // Graph pass over the client files, exactly as Rollup would drive it.
+    const clientJsByName = new Map<string, string>()
+    for (const name of ['Forms.tsx', 'SingleForm.tsx']) {
+      const abs = join(dir, 'src/components', name)
+      const out = plugin.transform(await readFile(abs, 'utf8'), abs)
+      clientJsByName.set(name, out?.code ?? '')
+    }
+
+    await mkdir(join(dir, 'dist/.vite'), { recursive: true })
+    await writeFile(join(dir, 'dist/.vite/manifest.json'), '{}')
+    // Pre-fix this throws `[barefoot] compile failed: ... BF050`.
+    await plugin.writeBundle()
+
+    // The brand resolved through the SHARED Program: `form.isSubmitting()`
+    // auto-defers (#1638). In the CLIENT bundle that means the hydrate
+    // template lambda drops the `disabled` attribute and init wires it
+    // instead — neither happens if the brand collapsed to `any` (the
+    // regex fallback can't classify a library getter, so the attribute
+    // would just render inline). The SSR template is not asserted on:
+    // a JSX-runtime adapter's template re-runs the real component code,
+    // so it legitimately keeps the live attribute expression.
+    for (const clientJs of clientJsByName.values()) {
+      expect(clientJs).toMatch(/\.disabled = !!\(form\.isSubmitting\(\)\)/)
+      expect(clientJs).not.toMatch(/template:.*disabled/)
+    }
+    const template = await readFile(join(templatesDir, 'Forms.test.tsx'), 'utf8')
+    expect(template).toContain('<button')
+
+    // The whole point: no compile anywhere in either pass fell back to a
+    // per-file `ts.createProgram`.
+    expect(getCompilerCounters().programCreations).toBe(0)
+  })
+})