@barefootjs/vite 0.30.0

package/src/__tests__/debounced-serial-runner.test.ts

@@ -0,0 +1,131 @@
+import { describe, test, expect } from 'bun:test'
+import { createDebouncedSerialRunner } from '../debounced-serial-runner.ts'
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(r => setTimeout(r, ms))
+}
+
+/** A controllable async task: `resolveCall(n)` releases the nth call, and
+ * `activeCount`/`maxActiveCount` track how many calls were in flight at
+ * once — the thing this whole module exists to keep at 1. */
+function controllableTask() {
+  const calls: Array<{ resolve: () => void }> = []
+  let activeCount = 0
+  let maxActiveCount = 0
+
+  const task = () =>
+    new Promise<void>(resolvePromise => {
+      activeCount++
+      maxActiveCount = Math.max(maxActiveCount, activeCount)
+      calls.push({
+        resolve: () => {
+          activeCount--
+          resolvePromise()
+        },
+      })
+    })
+
+  return {
+    task,
+    resolveCall(n: number) {
+      calls[n]?.resolve()
+    },
+    get callCount() {
+      return calls.length
+    },
+    get maxActiveCount() {
+      return maxActiveCount
+    },
+  }
+}
+
+describe('createDebouncedSerialRunner', () => {
+  test('a single trigger() runs the task once, after the debounce window', async () => {
+    let calls = 0
+    const runner = createDebouncedSerialRunner(async () => { calls++ }, 20, () => {})
+
+    runner.trigger()
+    expect(calls).toBe(0) // debounced — not yet
+    await sleep(60)
+    expect(calls).toBe(1)
+  })
+
+  test('a burst of trigger() calls within the debounce window collapses into ONE run', async () => {
+    let calls = 0
+    const runner = createDebouncedSerialRunner(async () => { calls++ }, 30, () => {})
+
+    for (let i = 0; i < 10; i++) {
+      runner.trigger()
+      await sleep(5) // well under the 30ms debounce — keeps re-arming it
+    }
+    await sleep(80)
+    expect(calls).toBe(1)
+  })
+
+  test('trigger() during an in-flight run does NOT start a second, overlapping call', async () => {
+    const c = controllableTask()
+    const runner = createDebouncedSerialRunner(c.task, 10, () => {})
+
+    runner.trigger()
+    await sleep(30) // debounce fires, first call starts and is now stuck awaiting resolveCall(0)
+    expect(c.callCount).toBe(1)
+
+    // A change arrives mid-pass.
+    runner.trigger()
+    await sleep(30) // long past the debounce window — but the first call is still in flight
+    expect(c.callCount).toBe(1) // no second call started while the first is running
+
+    c.resolveCall(0)
+    await sleep(20) // the queued follow-up now gets its turn
+    expect(c.callCount).toBe(2)
+
+    c.resolveCall(1)
+    await sleep(20)
+    expect(c.maxActiveCount).toBe(1) // never more than one task in flight, at any point
+  })
+
+  test('several trigger() calls while a run is in flight coalesce into exactly ONE follow-up, not one per trigger', async () => {
+    const c = controllableTask()
+    const runner = createDebouncedSerialRunner(c.task, 10, () => {})
+
+    runner.trigger()
+    await sleep(30)
+    expect(c.callCount).toBe(1)
+
+    // Five more changes land while the first pass is still running.
+    for (let i = 0; i < 5; i++) {
+      runner.trigger()
+      await sleep(15) // each spaced past the debounce window on its own
+    }
+
+    c.resolveCall(0)
+    await sleep(30)
+    expect(c.callCount).toBe(2) // exactly one follow-up, not five
+
+    c.resolveCall(1)
+    await sleep(20)
+    expect(c.callCount).toBe(2) // and nothing further queued after that
+  })
+
+  test('a rejected task is reported via onError and does not wedge future runs', async () => {
+    let calls = 0
+    const errors: unknown[] = []
+    const runner = createDebouncedSerialRunner(
+      async () => {
+        calls++
+        if (calls === 1) throw new Error('boom')
+      },
+      10,
+      err => errors.push(err),
+    )
+
+    runner.trigger()
+    await sleep(30)
+    expect(calls).toBe(1)
+    expect(errors).toHaveLength(1)
+
+    runner.trigger()
+    await sleep(30)
+    expect(calls).toBe(2) // the runner recovered — a later trigger still runs
+  })
+})

package/src/__tests__/dev-server.test.ts

@@ -0,0 +1,138 @@
+import { describe, test, expect } from 'bun:test'
+import type { ViteDevServer } from 'vite'
+import {
+  DEFAULT_DEV_CORS_ORIGIN,
+  DEV_ARTIFACT_MARKER_CONTENT,
+  DEV_ARTIFACT_MARKER_FILENAME,
+  devModuleUrl,
+  devRequestPath,
+  devScriptAssets,
+  resolveDevOrigin,
+} from '../dev-server.ts'
+
+describe('devRequestPath', () => {
+  test('a file under root becomes a root-relative path, no leading slash', () => {
+    expect(devRequestPath({ root: '/proj/app' }, '/proj/app/src/components/Counter.tsx')).toBe(
+      'src/components/Counter.tsx',
+    )
+  })
+
+  test('a file OUTSIDE root uses the /@fs/ absolute-path passthrough (no leading slash)', () => {
+    // The realistic layout this plugin has to support: an app's
+    // `vite.config.ts` root is the backend app dir, while `components`
+    // lives in a sibling `ui/`-style directory.
+    expect(devRequestPath({ root: '/proj/app' }, '/proj/ui/components/Counter.tsx')).toBe(
+      '@fs/proj/ui/components/Counter.tsx',
+    )
+  })
+
+  test('root itself resolves to the empty path', () => {
+    expect(devRequestPath({ root: '/proj/app' }, '/proj/app')).toBe('')
+  })
+})
+
+describe('devModuleUrl', () => {
+  test('joins origin + base + request path for an in-root file', () => {
+    expect(
+      devModuleUrl({ root: '/proj/app', base: '/' }, 'http://localhost:5173', '/proj/app/src/components/Counter.tsx'),
+    ).toBe('http://localhost:5173/src/components/Counter.tsx')
+  })
+
+  test('honors a non-default base', () => {
+    expect(
+      devModuleUrl(
+        { root: '/proj/app', base: '/static/build/' },
+        'http://localhost:5173',
+        '/proj/app/src/components/Counter.tsx',
+      ),
+    ).toBe('http://localhost:5173/static/build/src/components/Counter.tsx')
+  })
+
+  test('honors base together with an out-of-root /@fs/ path', () => {
+    expect(
+      devModuleUrl(
+        { root: '/proj/app', base: '/static/build/' },
+        'http://localhost:5173',
+        '/proj/ui/components/Counter.tsx',
+      ),
+    ).toBe('http://localhost:5173/static/build/@fs/proj/ui/components/Counter.tsx')
+  })
+})
+
+describe('devScriptAssets', () => {
+  test('returns [@vite/client, the component module URL], in that order', () => {
+    const config = { root: '/proj/app', base: '/' }
+    expect(devScriptAssets(config, 'http://localhost:5173', '/proj/app/src/components/Counter.tsx')).toEqual([
+      'http://localhost:5173/@vite/client',
+      'http://localhost:5173/src/components/Counter.tsx',
+    ])
+  })
+})
+
+describe('resolveDevOrigin', () => {
+  function fakeServer(overrides: {
+    origin?: string
+    port?: number
+    address?: { port: number } | string | null
+  }): ViteDevServer {
+    return {
+      config: {
+        server: {
+          origin: overrides.origin,
+          port: overrides.port,
+        },
+      },
+      httpServer:
+        overrides.address === undefined
+          ? null
+          : ({ address: () => overrides.address } as unknown as ViteDevServer['httpServer']),
+      // biome-ignore lint: minimal fake, only the fields resolveDevOrigin reads are real
+    } as any
+  }
+
+  test('returns the user-configured origin unchanged when set', () => {
+    const server = fakeServer({ origin: 'https://example.com' })
+    expect(resolveDevOrigin(server)).toBe('https://example.com')
+  })
+
+  test('derives from the ACTUAL bound port (httpServer.address()), not the configured port', () => {
+    // The case `strictPort: false` (the default) makes this matter: Vite
+    // auto-increments past an in-use configured port.
+    const server = fakeServer({ port: 5173, address: { port: 5174 } })
+    expect(resolveDevOrigin(server)).toBe('http://localhost:5174')
+  })
+
+  test('writes the computed default back onto server.config.server.origin', () => {
+    const server = fakeServer({ port: 5173, address: { port: 5174 } })
+    resolveDevOrigin(server)
+    expect(server.config.server.origin).toBe('http://localhost:5174')
+  })
+
+  test('falls back to the configured port when there is no httpServer (middleware mode)', () => {
+    const server = fakeServer({ port: 5173 })
+    expect(resolveDevOrigin(server)).toBe('http://localhost:5173')
+  })
+})
+
+describe('DEFAULT_DEV_CORS_ORIGIN', () => {
+  test('matches localhost and 127.0.0.1 at any port', () => {
+    expect(DEFAULT_DEV_CORS_ORIGIN.test('http://localhost:3010')).toBe(true)
+    expect(DEFAULT_DEV_CORS_ORIGIN.test('https://127.0.0.1:8080')).toBe(true)
+    expect(DEFAULT_DEV_CORS_ORIGIN.test('http://localhost')).toBe(true)
+  })
+
+  test('does NOT match an arbitrary remote origin', () => {
+    expect(DEFAULT_DEV_CORS_ORIGIN.test('https://evil.example.com')).toBe(false)
+  })
+})
+
+describe('dev-artifact marker', () => {
+  test('filename is a dotfile so it does not read as a template', () => {
+    expect(DEV_ARTIFACT_MARKER_FILENAME.startsWith('.')).toBe(true)
+  })
+
+  test('content warns against committing/deploying and names the fix', () => {
+    expect(DEV_ARTIFACT_MARKER_CONTENT).toContain('DEV BUILD OUTPUT')
+    expect(DEV_ARTIFACT_MARKER_CONTENT).toContain('vite build')
+  })
+})

package/src/__tests__/discover.test.ts

@@ -0,0 +1,148 @@
+import { describe, test, expect, afterEach } from 'bun:test'
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { buildChildNameIndex, hasUseClientDirective, discoverComponentFiles, discoverComponents } from '../discover.ts'
+
+describe('hasUseClientDirective', () => {
+  test('detects a leading double-quoted directive', () => {
+    expect(hasUseClientDirective('"use client"\nexport function A() {}')).toBe(true)
+  })
+
+  test('detects a leading single-quoted directive', () => {
+    expect(hasUseClientDirective("'use client'\nexport function A() {}")).toBe(true)
+  })
+
+  test('skips leading block comments before the directive', () => {
+    expect(hasUseClientDirective('/* c */\n\'use client\'\nexport function A() {}')).toBe(true)
+  })
+
+  test('skips leading line comments before the directive', () => {
+    expect(hasUseClientDirective('// c\n\'use client\'\nexport function A() {}')).toBe(true)
+  })
+
+  test('returns false for a server-only file', () => {
+    expect(hasUseClientDirective('export function A() { return <div/> }')).toBe(false)
+  })
+
+  test('returns false when the directive is not the first statement', () => {
+    expect(hasUseClientDirective('const x = 1\n\'use client\'')).toBe(false)
+  })
+})
+
+describe('discoverComponentFiles', () => {
+  let dir: string
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true })
+  })
+
+  test('finds nested .tsx files and skips test/spec/preview variants', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-discover-'))
+    await mkdir(join(dir, 'nested'), { recursive: true })
+    await writeFile(join(dir, 'A.tsx'), 'export function A() {}')
+    await writeFile(join(dir, 'A.test.tsx'), 'export function A() {}')
+    await writeFile(join(dir, 'A.spec.tsx'), 'export function A() {}')
+    await writeFile(join(dir, 'A.preview.tsx'), 'export function A() {}')
+    await writeFile(join(dir, 'nested', 'B.tsx'), 'export function B() {}')
+    await writeFile(join(dir, 'not-a-component.ts'), 'export const x = 1')
+
+    const found = await discoverComponentFiles(dir)
+    const basenames = found.map(f => f.slice(dir.length + 1)).sort()
+    expect(basenames).toEqual(['A.tsx', 'nested/B.tsx'])
+  })
+
+  test('returns an empty array for a missing directory', async () => {
+    const found = await discoverComponentFiles(join(tmpdir(), 'does-not-exist-barefoot-vite'))
+    expect(found).toEqual([])
+  })
+})
+
+describe('discoverComponents', () => {
+  let dir: string
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true })
+  })
+
+  test('classifies each discovered file as client or server-only', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-discover-classify-'))
+    await writeFile(join(dir, 'Client.tsx'), '\'use client\'\nexport function Client() {}')
+    await writeFile(join(dir, 'Server.tsx'), 'export function Server() {}')
+
+    const found = await discoverComponents([dir], p => Bun.file(p).text())
+    const byName = Object.fromEntries(found.map(f => [f.absPath.slice(dir.length + 1), f.isClient]))
+    expect(byName['Client.tsx']).toBe(true)
+    expect(byName['Server.tsx']).toBe(false)
+  })
+})
+
+describe('buildChildNameIndex', () => {
+  test('keys \'use client\' files by their exported component names', () => {
+    const index = buildChildNameIndex([
+      { absPath: '/proj/components/TodoItem.tsx', isClient: true, exportedComponents: ['TodoItem'] },
+      { absPath: '/proj/blog/LikeButton.tsx', isClient: true, exportedComponents: ['LikeButton'] },
+    ])
+    expect(index.get('TodoItem')).toBe('/proj/components/TodoItem.tsx')
+    expect(index.get('LikeButton')).toBe('/proj/blog/LikeButton.tsx')
+  })
+
+  // The regression this index was rebuilt for. Keyed on the basename, an
+  // `index.tsx` exporting several components resolved only as `index`, so
+  // every `@bf-child:<Name>` marker into it fell through to the no-op
+  // module and the child silently never hydrated.
+  test('a file exporting several components is reachable by EVERY name, not by its basename', () => {
+    const index = buildChildNameIndex([
+      {
+        absPath: '/proj/components/icon/index.tsx',
+        isClient: true,
+        exportedComponents: ['CopyIcon', 'CheckIcon'],
+      },
+    ])
+    expect(index.get('CopyIcon')).toBe('/proj/components/icon/index.tsx')
+    expect(index.get('CheckIcon')).toBe('/proj/components/icon/index.tsx')
+    expect(index.has('index')).toBe(false)
+  })
+
+  // Wider than the multi-export case: keyed on the basename, EVERY
+  // colocated `index.tsx` collided on the single key "index" — so even a
+  // single-export `ui/button/index.tsx` was unreachable as a marker target.
+  test('single-export colocated index.tsx files resolve by name, and never collide on "index"', () => {
+    const index = buildChildNameIndex([
+      { absPath: '/proj/ui/button/index.tsx', isClient: true, exportedComponents: ['Button'] },
+      { absPath: '/proj/ui/toggle/index.tsx', isClient: true, exportedComponents: ['Toggle'] },
+    ])
+    expect(index.get('Button')).toBe('/proj/ui/button/index.tsx')
+    expect(index.get('Toggle')).toBe('/proj/ui/toggle/index.tsx')
+    expect(index.has('index')).toBe(false)
+  })
+
+  test('first writer wins on a duplicate name, so an earlier components dir shadows a later one', () => {
+    const index = buildChildNameIndex([
+      { absPath: '/proj/a/Button.tsx', isClient: true, exportedComponents: ['Button'] },
+      { absPath: '/proj/b/Button.tsx', isClient: true, exportedComponents: ['Button'] },
+    ])
+    expect(index.get('Button')).toBe('/proj/a/Button.tsx')
+  })
+
+  test('falls back to the basename when no exports were parsed, keeping the old convention working', () => {
+    const index = buildChildNameIndex([
+      { absPath: '/proj/components/Widget.tsx', isClient: true, exportedComponents: [] },
+    ])
+    expect(index.get('Widget')).toBe('/proj/components/Widget.tsx')
+  })
+
+  test('excludes server-only files — a @bf-child marker only ever names an interactive component', () => {
+    const index = buildChildNameIndex([
+      { absPath: '/proj/components/ServerOnly.tsx', isClient: false, exportedComponents: [] },
+    ])
+    expect(index.has('ServerOnly')).toBe(false)
+  })
+
+  test('accepts a .ts extension too', () => {
+    const index = buildChildNameIndex([
+      { absPath: '/proj/components/Widget.ts', isClient: true, exportedComponents: ['Widget'] },
+    ])
+    expect(index.get('Widget')).toBe('/proj/components/Widget.ts')
+  })
+})

package/src/__tests__/e2e-vite-build.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Real end-to-end coverage: actually runs `vite build` (via Vite's Node
+ * API — the same function the `vite` CLI binary itself calls) against the
+ * small fixture project under `../../e2e-fixture`, then asserts BOTH
+ * halves of the design:
+ *
+ *   - the client-asset half: Vite/Rollup produced hashed JS assets, and
+ *     the shared `@barefootjs/client` runtime collapsed into ONE shared
+ *     chunk imported by every entry (not duplicated per entry) — the
+ *     exact behavior the spike (R1/R3) proved.
+ *   - the template half: the emitted Go template for the `'use client'`
+ *     component contains a `{{.Scripts.Register "…"}}` call pointing at
+ *     the REAL, hashed, `base`-prefixed manifest URL, and the server-only
+ *     component (never reachable from Rollup's module graph) still got a
+ *     template, with no script registration at all.
+ *
+ * A plugin that only passes mocked unit tests hasn't been shown to work —
+ * this is the test that shows it.
+ */
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test'
+import { build } from 'vite'
+import { mkdtemp, rm, readFile, readdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { GoTemplateAdapter } from '@barefootjs/go-template/adapter'
+import { barefoot } from '../plugin.ts'
+
+const FIXTURE_ROOT = resolve(import.meta.dirname, '../../e2e-fixture')
+
+describe('e2e: vite build', () => {
+  let outDir: string
+  let templatesDir: string
+
+  beforeAll(async () => {
+    outDir = await mkdtemp(join(tmpdir(), 'barefoot-vite-dist-'))
+    templatesDir = await mkdtemp(join(tmpdir(), 'barefoot-vite-views-'))
+
+    await build({
+      configFile: false,
+      root: FIXTURE_ROOT,
+      base: '/static/build/',
+      logLevel: 'warn',
+      build: {
+        outDir,
+        emptyOutDir: true,
+      },
+      plugins: [
+        barefoot({
+          adapter: new GoTemplateAdapter({ packageName: 'main' }),
+          components: ['src/components'],
+          templates: templatesDir,
+        }),
+      ],
+    })
+  }, 60_000)
+
+  afterAll(async () => {
+    await rm(outDir, { recursive: true, force: true })
+    await rm(templatesDir, { recursive: true, force: true })
+  })
+
+  test('emits a manifest with hashed entries for every "use client" component', async () => {
+    const manifest = JSON.parse(await readFile(resolve(outDir, '.vite/manifest.json'), 'utf8'))
+    const keys = Object.keys(manifest)
+    expect(keys.some(k => k.endsWith('Counter.tsx'))).toBe(true)
+    expect(keys.some(k => k.endsWith('SharedCounter.tsx'))).toBe(true)
+    expect(keys.some(k => k.endsWith('counterState.tsx'))).toBe(true)
+    // Greeting.tsx has no 'use client' directive — never an entry.
+    expect(keys.some(k => k.endsWith('Greeting.tsx'))).toBe(false)
+  })
+
+  test('the runtime collapses into one shared chunk imported by every client entry', async () => {
+    const manifest = JSON.parse(await readFile(resolve(outDir, '.vite/manifest.json'), 'utf8'))
+    const counterKey = Object.keys(manifest).find(k => k.endsWith('Counter.tsx') && !k.includes('Shared'))!
+    const sharedCounterKey = Object.keys(manifest).find(k => k.endsWith('SharedCounter.tsx'))!
+
+    const counterEntry = manifest[counterKey]
+    const sharedCounterEntry = manifest[sharedCounterKey]
+    expect(counterEntry.imports?.length).toBeGreaterThan(0)
+    expect(sharedCounterEntry.imports?.length).toBeGreaterThan(0)
+
+    // Both entries' shared-chunk import sets intersect on at least one
+    // chunk (the runtime) — i.e. it's a SHARED chunk, not duplicated.
+    const shared = (counterEntry.imports ?? []).filter((k: string) => (sharedCounterEntry.imports ?? []).includes(k))
+    expect(shared.length).toBeGreaterThan(0)
+
+    // That shared chunk is a real file on disk under outDir.
+    for (const key of shared) {
+      const file = manifest[key].file
+      const content = await readFile(resolve(outDir, file), 'utf8')
+      expect(content.length).toBeGreaterThan(0)
+    }
+  })
+
+  test('SharedCounter\'s relative "./counterState.client.js" import resolved to the real counterState chunk (resolveId shim, R2)', async () => {
+    const manifest = JSON.parse(await readFile(resolve(outDir, '.vite/manifest.json'), 'utf8'))
+    const sharedCounterKey = Object.keys(manifest).find(k => k.endsWith('SharedCounter.tsx'))!
+    const stateKey = Object.keys(manifest).find(k => k.endsWith('counterState.tsx'))!
+    const sharedCounterEntry = manifest[sharedCounterKey]
+
+    // counterState.tsx is itself a rollupOptions.input entry (it has 'use
+    // client' too) AND is import-reachable from SharedCounter — Rollup
+    // resolves both to the identical module id, so SharedCounter's
+    // manifest row lists it directly as an entry-to-entry import.
+    expect(sharedCounterEntry.imports).toContain(stateKey)
+  })
+
+  test('the built client JS is plain JS Vite/esbuild could bundle and minify without re-parsing JSX (R1)', async () => {
+    const manifest = JSON.parse(await readFile(resolve(outDir, '.vite/manifest.json'), 'utf8'))
+    const counterKey = Object.keys(manifest).find(k => k.endsWith('Counter.tsx') && !k.includes('Shared'))!
+    const file = manifest[counterKey].file
+    const content = await readFile(resolve(outDir, file), 'utf8')
+    // Production build output is minified — identifiers like `hydrate` get
+    // renamed, so assert on what survives minification instead: the
+    // hydration template's literal markup (proof this went through as
+    // plain JS, not raw JSX esbuild would have needed a JSX transform for)
+    // and the total absence of the 'use client' directive / JSX attribute
+    // syntax a live JSX expression would still carry.
+    expect(content).toContain('<button bf="s1">')
+    expect(content).not.toContain('use client')
+    expect(content).not.toMatch(/onClick=\{/)
+  })
+
+  test('emits a Go template for the "use client" component with the real hashed, base-prefixed script URL', async () => {
+    const manifest = JSON.parse(await readFile(resolve(outDir, '.vite/manifest.json'), 'utf8'))
+    const counterKey = Object.keys(manifest).find(k => k.endsWith('Counter.tsx') && !k.includes('Shared'))!
+    const expectedUrl = `/static/build/${manifest[counterKey].file}`
+
+    const template = await readFile(resolve(templatesDir, 'Counter.tmpl'), 'utf8')
+    expect(template).toContain(`{{.Scripts.Register "${expectedUrl}"}}`)
+  })
+
+  test('a sibling-imported child rendered inside a CSR .map() loop resolves to a REAL import, not the raw @bf-child: marker', async () => {
+    const manifest = JSON.parse(await readFile(resolve(outDir, '.vite/manifest.json'), 'utf8'))
+    const loopParentKey = Object.keys(manifest).find(k => k.endsWith('LoopParent.tsx'))!
+    const loopChildKey = Object.keys(manifest).find(k => k.endsWith('LoopChild.tsx'))!
+
+    // LoopChild is independently a Rollup entry (every 'use client' file is)
+    // AND reachable from LoopParent's own compiled output — proof the
+    // `@bf-child:LoopChild` marker resolved to LoopChild's real module
+    // instead of the unresolvable literal string, and that Rollup wired an
+    // entry-to-entry import rather than leaving it external.
+    expect(manifest[loopParentKey].imports).toContain(loopChildKey)
+
+    const parentContent = await readFile(resolve(outDir, manifest[loopParentKey].file), 'utf8')
+    expect(parentContent).not.toContain('@bf-child')
+    expect(parentContent).not.toContain('bf-child')
+  })
+
+  test('emits a template for the server-only component (never in the Rollup graph) with NO script registration', async () => {
+    const manifest = JSON.parse(await readFile(resolve(outDir, '.vite/manifest.json'), 'utf8'))
+    expect(Object.keys(manifest).some(k => k.endsWith('Greeting.tsx'))).toBe(false)
+
+    const template = await readFile(resolve(templatesDir, 'Greeting.tmpl'), 'utf8')
+    expect(template).not.toContain('Scripts.Register')
+    expect(template).toContain('Hello')
+  })
+
+  test('the templates dir mirrors every discovered component, client and server-only alike', async () => {
+    const files = await readdir(templatesDir)
+    expect(files).toContain('Counter.tmpl')
+    expect(files).toContain('SharedCounter.tmpl')
+    expect(files).toContain('Greeting.tmpl')
+  })
+
+  test('writes a combined manifest.json alongside the per-component templates, keyed by component name with markedTemplate + ssrDefaults (#2494 review)', async () => {
+    const manifest = JSON.parse(await readFile(resolve(templatesDir, 'manifest.json'), 'utf8'))
+
+    // Keyed by component name (GoTemplateAdapter isn't `templatesPerComponent`,
+    // so no `components` sub-map is expected — see `component-manifest.ts`).
+    // Counter's own `count` signal seeds a literal SSR default even with no
+    // backing prop (`ssrDefaults` covers every signal needing an in-template
+    // seed, not only optional-prop-derived ones); Greeting's required `name`
+    // prop reference seeds a `{ propName, value: null }` row the same way.
+    expect(manifest.Counter).toEqual({ markedTemplate: 'Counter.tmpl', ssrDefaults: { count: { value: 0 } } })
+    expect(manifest.Greeting).toEqual({
+      markedTemplate: 'Greeting.tmpl',
+      ssrDefaults: { name: { propName: 'name', value: null } },
+    })
+    expect('components' in manifest.Counter).toBe(false)
+    // The absent-key contract itself (no entry carries `ssrDefaults: {}`)
+    // is covered precisely, on fabricated input, by
+    // `component-manifest.test.ts` — this test's job is just proving the
+    // combined file actually lands on disk from a REAL build.
+  })
+
+  test('a production build leaves no dev-reload sentinel behind (see e2e-vite-dev.test.ts for the dev-side write)', async () => {
+    const sentinel = await readFile(resolve(templatesDir, '..', '.dev', 'build-id'), 'utf8').catch(() => null)
+    expect(sentinel).toBeNull()
+  })
+})