@barefootjs/go-template 0.30.6 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.30.6",
+  "version": "0.31.0",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,9 +17,9 @@
     "./test-render": {
       "bun": "./src/test-render.ts"
     },
-    "./build": {
-      "types": "./dist/build.d.ts",
-      "import": "./dist/build.js"
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
     }
   },
   "files": [
@@ -28,7 +28,7 @@
   ],
   "scripts": {
     "build": "bun run build:js && bun run build:types",
-    "build:js": "bun build ./src/index.ts ./src/adapter/index.ts ./src/build.ts --root ./src --outdir ./dist --format esm --external @barefootjs/jsx --external @barefootjs/shared --external typescript",
+    "build:js": "bun build ./src/index.ts ./src/adapter/index.ts --root ./src --outdir ./dist --format esm --external @barefootjs/jsx --external @barefootjs/shared --external @barefootjs/vite --external vite --external typescript && bun build ./src/vite.ts --outfile ./dist/vite.js --format esm --target node --external @barefootjs/vite --external vite --external typescript",
     "build:types": "tsgo --emitDeclarationOnly --outDir ./dist",
     "test": "bun test",
     "clean": "rm -rf dist",
@@ -49,14 +49,27 @@
     "directory": "packages/adapter-go-template"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.30.6"
+    "@barefootjs/shared": "0.31.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
-    "typescript": "^5.0.0"
+    "@barefootjs/vite": ">=0.2.0",
+    "typescript": "^5.0.0",
+    "vite": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@barefootjs/vite": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.30.6"
+    "@barefootjs/client": "0.31.0",
+    "@barefootjs/jsx": "0.31.0",
+    "@barefootjs/vite": "0.31.0",
+    "vite": "^6.0.0"
   }
 }

package/src/__tests__/go-template-adapter.test.ts

@@ -5619,3 +5619,148 @@ export function C({ items, enabled }: { items: Item[]; enabled: boolean }) {
     }
   })
 })
+
+describe('GoTemplateAdapter - scriptAssets (Vite late-binding)', () => {
+  const CLIENT_COMPONENT = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function Counter() {
+  const [count, setCount] = createSignal(0)
+  return <button onClick={() => setCount(count() + 1)}>{count()}</button>
+}
+`
+
+  test('emits one {{.Scripts.Register}} per URL, in order, when scriptAssets is set', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js', '/assets/counter-def456.js'],
+    })
+    const runtimeIdx = template.indexOf('{{.Scripts.Register "/assets/runtime-abc123.js"}}')
+    const compIdx = template.indexOf('{{.Scripts.Register "/assets/counter-def456.js"}}')
+    expect(runtimeIdx).toBeGreaterThanOrEqual(0)
+    expect(compIdx).toBeGreaterThanOrEqual(0)
+    expect(runtimeIdx).toBeLessThan(compIdx)
+    expect(template).toContain('{{if .Scripts}}')
+    expect(template).not.toContain('/static/client/barefoot.js')
+    expect(template).not.toContain('Counter.client.js')
+  })
+
+  test('emits a single registration for a single-element scriptAssets array', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      scriptAssets: ['/assets/only-one.js'],
+    })
+    expect(template).toContain('{{.Scripts.Register "/assets/only-one.js"}}')
+    expect(template.match(/\.Scripts\.Register/g)?.length).toBe(1)
+  })
+
+  test('an empty scriptAssets array emits no script registrations', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, { scriptAssets: [] })
+    expect(template).not.toContain('.Scripts.Register')
+    expect(template).not.toContain('{{if .Scripts}}')
+  })
+
+  test('skipScriptRegistration still wins when scriptAssets is also set', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      skipScriptRegistration: true,
+      scriptAssets: ['/assets/should-not-appear.js'],
+    })
+    expect(template).not.toContain('.Scripts.Register')
+  })
+
+  test('absent scriptAssets falls back to adapter-computed script paths', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const computed = new GoTemplateAdapter().generate(ir).template
+    const explicitUndefined = new GoTemplateAdapter().generate(ir, { scriptAssets: undefined }).template
+    expect(computed).toContain('{{.Scripts.Register "/static/client/barefoot.js"}}')
+    expect(computed).toContain('{{.Scripts.Register "/static/client/Counter.client.js"}}')
+    expect(explicitUndefined).toBe(computed)
+  })
+})
+
+describe('GoTemplateAdapter - preloadAssets', () => {
+  const CLIENT_COMPONENT = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function Counter() {
+  const [count, setCount] = createSignal(0)
+  return <button onClick={() => setCount(count() + 1)}>{count()}</button>
+}
+`
+
+  test('non-empty preloadAssets + non-empty scriptAssets: preload registrations emitted, in order, before script registrations', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js', '/assets/counter-def456.js'],
+      preloadAssets: ['/assets/index-pre1.js', '/assets/shared-pre2.js'],
+    })
+    const pre1Idx = template.indexOf('{{.Scripts.RegisterPreload "/assets/index-pre1.js"}}')
+    const pre2Idx = template.indexOf('{{.Scripts.RegisterPreload "/assets/shared-pre2.js"}}')
+    const script1Idx = template.indexOf('{{.Scripts.Register "/assets/runtime-abc123.js"}}')
+    const script2Idx = template.indexOf('{{.Scripts.Register "/assets/counter-def456.js"}}')
+    expect(pre1Idx).toBeGreaterThanOrEqual(0)
+    expect(pre2Idx).toBeGreaterThan(pre1Idx)
+    expect(script1Idx).toBeGreaterThan(pre2Idx)
+    expect(script2Idx).toBeGreaterThan(script1Idx)
+  })
+
+  test('preloadAssets: [] emits no preload registration', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js'],
+      preloadAssets: [],
+    })
+    expect(template).not.toContain('RegisterPreload')
+    expect(template).toContain('{{.Scripts.Register "/assets/runtime-abc123.js"}}')
+  })
+
+  test('preloadAssets: undefined emits no preload registration', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js'],
+      preloadAssets: undefined,
+    })
+    expect(template).not.toContain('RegisterPreload')
+    expect(template).toContain('{{.Scripts.Register "/assets/runtime-abc123.js"}}')
+  })
+
+  test('preloadAssets non-empty but scriptAssets: [] emits no preload registration (preloads are only meaningful alongside a real script)', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      scriptAssets: [],
+      preloadAssets: ['/assets/index-pre1.js'],
+    })
+    expect(template).not.toContain('RegisterPreload')
+    expect(template).not.toContain('.Scripts.Register')
+  })
+
+  test('skipScriptRegistration: true suppresses both preloads and scripts', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      skipScriptRegistration: true,
+      scriptAssets: ['/assets/runtime-abc123.js'],
+      preloadAssets: ['/assets/index-pre1.js'],
+    })
+    expect(template).not.toContain('RegisterPreload')
+    expect(template).not.toContain('.Scripts.Register')
+  })
+
+  // Regression guard: a previous attempt emitted a literal
+  // `<link rel="modulepreload">` tag directly into the component template,
+  // which injected a rendered DOM node before the component's root and
+  // broke hydration across all eight integrations (blade, erb,
+  // go-template, jinja, mojolicious, rust, twig, xslate). Preload hints
+  // must ONLY ever be emitted as no-output register statements (here,
+  // `{{.Scripts.RegisterPreload "..."}}`) that the adapter's runtime later
+  // renders itself — never as literal markup baked into the template.
+  test('never emits a literal <link tag into the template', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new GoTemplateAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js'],
+      preloadAssets: ['/assets/index-pre1.js'],
+    })
+    expect(template).not.toContain('<link')
+  })
+})

package/src/__tests__/{build.test.ts → go-types.test.ts}

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { combineGoTypes, deduplicateGoTypes } from '../build'
+import { combineGoTypes, deduplicateGoTypes } from '../go-types'
 
 describe('combineGoTypes stdlib imports', () => {
   // The combined types file strips each component's own import block and

package/src/__tests__/vite.test.ts

@@ -0,0 +1,278 @@
+/**
+ * Coverage of `@barefootjs/go-template/vite`'s `barefoot()`:
+ *
+ * - one real `vite build()` end to end (mirrors `packages/vite`'s own
+ *   `e2e-vite-build.test.ts` rigor — a plugin that only passes mocked unit
+ *   tests hasn't been shown to work) against a checked-in fixture (not a
+ *   system tmpdir) so `@barefootjs/client` resolves through the
+ *   monorepo's real node_modules symlinks;
+ * - the `afterEmit`-driven `components.go` combining behavior (empty
+ *   `types`, write-if-changed) exercised by calling the returned plugin's
+ *   own hooks directly, same style as `packages/vite`'s `plugin.test.ts` —
+ *   `compileCanonical` never resolves `@barefootjs/client` as a real
+ *   import (it's plain JSX→JS codegen, not a module load), so these don't
+ *   need the fixture's real dependency graph at all.
+ */
+import { describe, test, expect, afterEach } from 'bun:test'
+import { build } from 'vite'
+import { mkdtemp, rm, mkdir, writeFile, readFile, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { barefoot, barefoot as defaultBarefoot } from '../vite.ts'
+
+// biome-ignore lint: hooks are called directly, bypassing Vite's own
+// dispatch/typing — the same cast `packages/vite/src/__tests__/
+// plugin.test.ts` uses to unit-test a Vite plugin's hooks in isolation.
+type AnyPlugin = any
+
+const FIXTURE_ROOT = resolve(import.meta.dirname, '../../e2e-fixture')
+
+describe('@barefootjs/go-template/vite: real vite build', () => {
+  afterEach(async () => {
+    await rm(join(FIXTURE_ROOT, 'components.go'), { force: true })
+  })
+
+  test('exports the same function as both named `barefoot` and default', () => {
+    expect(defaultBarefoot).toBe(barefoot)
+  })
+
+  test('returns a single-element plugin array when `assets` is omitted', () => {
+    const plugins = barefoot({ components: ['src/components'], templates: 'views' })
+    expect(plugins).toHaveLength(1)
+  })
+
+  // core's `barefoot()` attaches `api.options` (see `BarefootPluginApi`) to
+  // the SAME plugin object this wrapper returns unchanged as `plugins[0]`
+  // — this pins that composition doesn't lose it, for either array shape
+  // (`assets` omitted vs. present, which adds a SECOND, unrelated
+  // companion plugin alongside it).
+  test('surfaces core\'s plugin.api.options unchanged on the returned plugin, with the GoTemplateAdapter it constructed', () => {
+    const plugins = barefoot({ components: ['src/components', '../shared/blog'], templates: 'views' }) as any[]
+    const core = plugins[0]
+    expect(core.name).toBe('barefoot')
+    expect(core.api.options.components).toEqual(['src/components', '../shared/blog'])
+    expect(core.api.options.templates).toBe('views')
+    expect(core.api.options.adapter.constructor.name).toBe('GoTemplateAdapter')
+  })
+
+  test('still surfaces api.options on plugins[0] when `assets` adds a second companion plugin', () => {
+    const plugins = barefoot({
+      components: ['src/components'],
+      templates: 'views',
+      assets: { Bootstrap: 'client/bootstrap.ts' },
+    }) as any[]
+    expect(plugins).toHaveLength(2)
+    expect(plugins[0].api.options.components).toEqual(['src/components'])
+  })
+
+  test('writes a compilable combined components.go after `vite build`, using the SAME combineGoTypes as ./build', async () => {
+    const outDir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-dist-'))
+    const templatesDir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-views-'))
+
+    try {
+      await build({
+        configFile: false,
+        root: FIXTURE_ROOT,
+        base: '/static/build/',
+        logLevel: 'warn',
+        build: { outDir, emptyOutDir: true },
+        plugins: [
+          barefoot({
+            components: ['src/components'],
+            templates: templatesDir,
+            packageName: 'main',
+            typesOutputFile: 'components.go',
+          }),
+        ],
+      })
+
+      // Template got its scriptAssets baked in, same as core alone would do.
+      const template = await readFile(join(templatesDir, 'Counter.tmpl'), 'utf8')
+      expect(template).toContain('Scripts.Register')
+
+      // components.go exists, is combined (one package header, randomID
+      // defined), and compiles-shaped (no per-component leftover headers).
+      const componentsGo = await readFile(join(FIXTURE_ROOT, 'components.go'), 'utf8')
+      expect(componentsGo).toContain('package main')
+      expect(componentsGo).toContain('func randomID(n int) string {')
+      expect(componentsGo).toContain('CounterProps')
+      expect(componentsGo.match(/^package main$/gm)).toHaveLength(1)
+    } finally {
+      await rm(outDir, { recursive: true, force: true })
+      await rm(templatesDir, { recursive: true, force: true })
+    }
+  }, 60_000)
+
+  test('`assets` resolves a non-component entry\'s manifest-hashed URL into the `production`-tagged, gitignored sibling file', async () => {
+    const outDir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-dist-assets-'))
+    const templatesDir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-views-assets-'))
+    // A real `build()` is the `mode: 'build'` pass, so this writes the
+    // PRODUCTION-tagged sibling (`bf_assets_prod.go`), not the dev-tagged
+    // `bf_assets.go` default filename — see writeAssetMap's mode branch.
+    const assetsGoPath = join(FIXTURE_ROOT, 'bf_assets_prod.go')
+
+    try {
+      await build({
+        configFile: false,
+        root: FIXTURE_ROOT,
+        base: '/static/build/',
+        logLevel: 'warn',
+        build: {
+          outDir,
+          emptyOutDir: true,
+          // Registering the non-component entry is the CALLER's job (stock
+          // Vite config) — `assets` below only resolves the URL Vite
+          // already bundled it to, it doesn't request the bundling.
+          rollupOptions: { input: { bootstrap: resolve(FIXTURE_ROOT, 'client/bootstrap.ts') } },
+        },
+        plugins: barefoot({
+          components: ['src/components'],
+          templates: templatesDir,
+          assets: { Bootstrap: 'client/bootstrap.ts' },
+        }),
+      })
+
+      const manifest = JSON.parse(await readFile(join(outDir, '.vite/manifest.json'), 'utf8'))
+      const expectedUrl = `/static/build/${manifest['client/bootstrap.ts'].file}`
+
+      const content = await readFile(assetsGoPath, 'utf8')
+      expect(content).toContain('//go:build production')
+      expect(content).toContain('package main')
+      expect(content).toContain(`"Bootstrap": ${JSON.stringify(expectedUrl)}`)
+
+      // The dev-tagged default filename must NOT be touched by a build pass
+      // — that file only gets (re)written by the dev pass, and a stray
+      // build-triggered write to it would defeat its "stable, safe to
+      // commit" property (see the module docstring).
+      await expect(readFile(join(FIXTURE_ROOT, 'bf_assets.go'), 'utf8')).rejects.toThrow()
+    } finally {
+      await rm(outDir, { recursive: true, force: true })
+      await rm(templatesDir, { recursive: true, force: true })
+      await rm(assetsGoPath, { force: true })
+    }
+  }, 60_000)
+
+  test('`assets` throws an actionable error when the entry was never registered as a Rollup input', async () => {
+    const outDir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-dist-assets-missing-'))
+    const templatesDir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-views-assets-missing-'))
+
+    try {
+      await expect(
+        build({
+          configFile: false,
+          root: FIXTURE_ROOT,
+          base: '/static/build/',
+          logLevel: 'silent',
+          build: { outDir, emptyOutDir: true },
+          plugins: barefoot({
+            components: ['src/components'],
+            templates: templatesDir,
+            assets: { Bootstrap: 'client/bootstrap.ts' },
+          }),
+        }),
+      ).rejects.toThrow(/was not found in the build manifest/)
+    } finally {
+      await rm(outDir, { recursive: true, force: true })
+      await rm(templatesDir, { recursive: true, force: true })
+      await rm(join(FIXTURE_ROOT, 'bf_assets_prod.go'), { force: true })
+    }
+  }, 60_000)
+})
+
+describe('@barefootjs/go-template/vite: afterEmit → components.go, via direct hook calls', () => {
+  let dir: string
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true })
+  })
+
+  async function setup(): Promise<{ plugin: AnyPlugin; templatesDir: string; componentsGoPath: string }> {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-hooks-'))
+    await mkdir(join(dir, 'src/components'), { recursive: true })
+    await writeFile(
+      join(dir, 'src/components/Counter.tsx'),
+      '\'use client\'\nimport { createSignal } from \'@barefootjs/client\'\nexport function Counter(props: { initial: number }) {\n  const [count] = createSignal(props.initial)\n  return <button>{count()}</button>\n}\n',
+    )
+
+    const templatesDir = join(dir, 'internal/views')
+    const plugin: AnyPlugin = barefoot({ components: ['src/components'], templates: templatesDir })[0]
+    await plugin.config({ root: dir }, { command: 'build', mode: 'production' })
+    plugin.configResolved({ root: dir, base: '/static/build/', build: { outDir: 'dist', manifest: true } })
+
+    await mkdir(join(dir, 'dist/.vite'), { recursive: true })
+    await writeFile(
+      join(dir, 'dist/.vite/manifest.json'),
+      JSON.stringify({ 'src/components/Counter.tsx': { file: 'assets/Counter-abc123.js', isEntry: true } }),
+    )
+
+    return { plugin, templatesDir, componentsGoPath: join(dir, 'components.go') }
+  }
+
+  test('combines the discovered component\'s types into components.go', async () => {
+    const { plugin, componentsGoPath } = await setup()
+    await plugin.writeBundle()
+
+    const content = await readFile(componentsGoPath, 'utf8')
+    expect(content).toContain('package main')
+    expect(content).toContain('CounterProps')
+    expect(content).toContain('func randomID(n int) string {')
+  })
+
+  test('does not write components.go when no discovered component produces `types` (ctx.types.size === 0)', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-hooks-notypes-'))
+    await mkdir(join(dir, 'src/components'), { recursive: true }) // deliberately empty
+
+    const templatesDir = join(dir, 'internal/views')
+    const plugin: AnyPlugin = barefoot({ components: ['src/components'], templates: templatesDir })[0]
+    await plugin.config({ root: dir }, { command: 'build', mode: 'production' })
+    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()
+
+    await expect(readFile(join(dir, 'components.go'), 'utf8')).rejects.toThrow()
+  })
+
+  test('write-if-changed: a second pass with identical output does not rewrite components.go', async () => {
+    const { plugin, componentsGoPath } = await setup()
+
+    await plugin.writeBundle()
+    const firstMtime = (await stat(componentsGoPath)).mtimeMs
+
+    await new Promise(r => setTimeout(r, 20))
+    await plugin.writeBundle()
+    const secondMtime = (await stat(componentsGoPath)).mtimeMs
+
+    expect(secondMtime).toBe(firstMtime)
+  })
+
+  test('honors manualTypes and transformTypes', async () => {
+    dir = await mkdtemp(join(tmpdir(), 'barefoot-go-vite-hooks-manual-'))
+    await mkdir(join(dir, 'src/components'), { recursive: true })
+    await writeFile(join(dir, 'src/components/Greeting.tsx'), 'export function Greeting() { return <p>Hi</p> }\n')
+
+    const templatesDir = join(dir, 'internal/views')
+    const plugin: AnyPlugin = barefoot({
+      components: ['src/components'],
+      templates: templatesDir,
+      // manualTypes is appended verbatim, AFTER transformTypes runs on the
+      // component-derived content (see `combineGoTypes`), so app-specific
+      // hand-written types are never mangled by a transform meant for
+      // generated code.
+      manualTypes: '// app-specific hand-written type\ntype AppOnly struct{}',
+      transformTypes: types => types.replace(/GreetingProps/g, 'GreetingPropsRenamed'),
+    })[0]
+    await plugin.config({ root: dir }, { command: 'build', mode: 'production' })
+    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()
+
+    const content = await readFile(join(dir, 'components.go'), 'utf8')
+    expect(content).toContain('type AppOnly struct{}')
+    expect(content).toContain('GreetingPropsRenamed')
+    expect(content).not.toMatch(/\btype GreetingProps struct/)
+  })
+})

package/src/adapter/go-template-adapter.ts

@@ -189,7 +189,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   // Sentinel marking a parent-scope `bf-s` slot inside a hoisted-JSX children
   // bake (see `extractScopedHtmlChildren`). Can't appear in real HTML text.
   private static readonly SCOPE_SENTINEL = '__BF_SCOPE_SENTINEL__'
-  importMapInjection = 'html-snippet' as const
 
   // `renderFilterExpr` recursion state. `filterExprDepth` lets the outer call
   // reset `filterExprUnsupported` per independent filter expression; the flag,
@@ -492,7 +491,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     const scriptRegistrations = options?.skipScriptRegistration
       ? ''
-      : this.generateScriptRegistrations(ir, options?.scriptBaseName)
+      : this.generateScriptRegistrations(ir, options?.scriptBaseName, options?.scriptAssets, options?.preloadAssets)
 
     let template = `{{define "${this.state.componentName}"}}\n${scriptRegistrations}${templateBody}\n{{end}}\n`
     // Companion children defines execute with the parent's data via `bf_tmpl`.
@@ -611,11 +610,37 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   /**
-   * Script registration code for the template start. Reads `.Scripts` (on every
-   * Props struct) and guards the registrations with `{{if .Scripts}}` for a nil
-   * collector.
+   * Script (and modulepreload) registration code for the template start.
+   * Reads `.Scripts` (on every Props struct) and guards the registrations
+   * with `{{if .Scripts}}` for a nil collector.
    */
-  private generateScriptRegistrations(ir: ComponentIR, scriptBaseName?: string): string {
+  private generateScriptRegistrations(
+    ir: ComponentIR,
+    scriptBaseName?: string,
+    scriptAssets?: string[],
+    preloadAssets?: string[],
+  ): string {
+    // `scriptAssets`, when present (including `[]`), fully supersedes the
+    // adapter-computed `barefootJsPath` / `clientJsBasePath` fallback pair
+    // below — see `AdapterGenerateOptions.scriptAssets`. The caller (e.g.
+    // the Vite plugin) has already decided the exact ordered URL list,
+    // including whether any script is needed at all.
+    if (scriptAssets) {
+      if (scriptAssets.length === 0) return ''
+      // `preloadAssets` is only meaningful alongside a non-empty
+      // `scriptAssets` (see `AdapterGenerateOptions.preloadAssets`), and
+      // every preload registration is emitted BEFORE every script
+      // registration — a hint that arrives after the script it describes
+      // is useless. `RegisterPreload`, like `Register`, is a no-output
+      // statement: the `<link rel="modulepreload">` tag itself is only
+      // ever rendered by `BfScripts` (runtime/bf.go), never here.
+      const preloadRegistrations = (preloadAssets ?? []).map(
+        (url) => `{{.Scripts.RegisterPreload "${url}"}}`,
+      )
+      const registrations = scriptAssets.map((url) => `{{.Scripts.Register "${url}"}}`)
+      return `{{if .Scripts}}${preloadRegistrations.join('')}${registrations.join('')}{{end}}\n`
+    }
+
     const hasInteractivity = hasClientInteractivity(ir)
 
     if (!hasInteractivity) {

package/src/{build.ts → go-types.ts}

@@ -1,21 +1,5 @@
-// Go template build config factory for barefoot.config.ts
-
-import type { BuildOptions, PostBuildContext } from '@barefootjs/jsx'
-import { GoTemplateAdapter } from './adapter/index.ts'
-import type { GoTemplateAdapterOptions } from './adapter/index.ts'
-
-export interface GoTemplateBuildOptions extends BuildOptions {
-  /** Adapter-specific options passed to GoTemplateAdapter */
-  adapterOptions?: GoTemplateAdapterOptions
-  /** Output path for combined Go types file (relative to projectDir, default: 'components.go') */
-  typesOutputFile?: string
-  /** Transform the combined types string before writing (for app-specific type fixes) */
-  transformTypes?: (types: string) => string
-  /** Manual type definitions to append (app-specific types not generated from components) */
-  manualTypes?: string
-}
-
-// ── Go type helpers ──────────────────────────────────────────────────────
+// Go type-combination helpers shared by the Vite plugin's post-emit hook
+// (`vite.ts`'s `combineGoTypes` call, writing `components.go`).
 
 /**
  * Strip Go package header and import block, returning only type definitions.
@@ -205,71 +189,3 @@ export function combineGoTypes(options: {
 
   return parts.join('\n') + '\n'
 }
-
-// ── Config factory ───────────────────────────────────────────────────────
-
-/**
- * Create a BarefootBuildConfig for Go html/template projects.
- *
- * Uses structural typing — does not import BarefootBuildConfig to avoid
- * circular dependency between @barefootjs/go-template and @barefootjs/cli.
- */
-export function createConfig(options: GoTemplateBuildOptions = {}) {
-  const packageName = options.adapterOptions?.packageName ?? 'main'
-  const typesOutputFile = options.typesOutputFile ?? 'components.go'
-
-  const postBuild = async (ctx: PostBuildContext) => {
-    if (ctx.types.size === 0) return
-
-    const content = combineGoTypes({
-      types: ctx.types,
-      packageName,
-      manualTypes: options.manualTypes,
-      transformTypes: options.transformTypes,
-    })
-
-    if (content) {
-      const { resolve } = await import('node:path')
-      const { readFile, writeFile } = await import('node:fs/promises')
-      const outPath = resolve(ctx.projectDir, typesOutputFile)
-      // Write only when content changed so cache-hit builds don't trip the
-      // dev-reload sentinel (ctx.markChanged) and trigger a spurious reload.
-      // Use node:fs/promises (not Bun.*) so this hook runs under either
-      // runtime — the published `barefoot` CLI bin starts via Node.
-      const prev = await readFile(outPath, 'utf-8').catch(() => null)
-      if (prev !== content) {
-        await writeFile(outPath, content)
-        ctx.markChanged?.()
-        console.log(`Generated: ${typesOutputFile}`)
-      }
-    }
-  }
-
-  // Chain user's postBuild with Go types generation
-  const userPostBuild = options.postBuild
-  const combinedPostBuild = userPostBuild
-    ? async (ctx: PostBuildContext) => {
-        await postBuild(ctx)
-        await userPostBuild(ctx)
-      }
-    : postBuild
-
-  return {
-    adapter: new GoTemplateAdapter(options.adapterOptions),
-    paths: options.paths,
-    components: options.components,
-    outDir: options.outDir,
-    minify: options.minify,
-    contentHash: options.contentHash,
-    externals: options.externals,
-    externalsBasePath: options.externalsBasePath,
-    bundleEntries: options.bundleEntries,
-    localImportPrefixes: options.localImportPrefixes,
-    outputLayout: options.outputLayout ?? {
-      templates: 'templates',
-      clientJs: 'client',
-      runtime: 'client',
-    },
-    postBuild: combinedPostBuild,
-  }
-}

package/src/test-render.ts

@@ -8,7 +8,7 @@
 import { compileJSX } from '@barefootjs/jsx'
 import type { TemplateAdapter, ComponentIR, ParsedExpr } from '@barefootjs/jsx'
 import { GoTemplateAdapter } from './adapter/go-template-adapter.ts'
-import { deduplicateGoTypes } from './build.ts'
+import { deduplicateGoTypes } from './go-types.ts'
 import { capitalizeFieldName, goFieldNameForKey, loopKeyToGoFieldPath } from './adapter/lib/go-naming.ts'
 import { findNestedComponents } from './adapter/analysis/component-tree.ts'
 import type { NestedComponentInfo } from './adapter/lib/types.ts'
@@ -258,7 +258,7 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
   }
 
   // Merge entry + sibling + child type blocks through the same
-  // `deduplicateGoTypes` helper `bf build` uses. Duplicates arise in two
+  // `deduplicateGoTypes` helper `vite.ts`'s `combineGoTypes` uses. Duplicates arise in two
   // ways (#1896): a multi-component file emits its module-scope shared
   // types (a context-value struct, a data `type Payment = …`) once per
   // component IR — both across the entry source's own sibling exports