@barefootjs/mojolicious 0.30.6 → 0.31.0

package/lib/BarefootJS/Backend/Mojo.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Mojo;
-our $VERSION = "0.30.5";
+our $VERSION = "0.30.6";
 use Mojo::Base -base, -signatures;
 
 use Mojo::ByteStream qw(b);

package/lib/Mojolicious/Plugin/BarefootJS/DevReload.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS::DevReload;
-our $VERSION = "0.30.5";
+our $VERSION = "0.30.6";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 =head1 NAME

package/lib/Mojolicious/Plugin/BarefootJS.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS;
-our $VERSION = "0.30.5";
+our $VERSION = "0.30.6";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 use Mojo::File qw(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.30.6",
+  "version": "0.31.0",
   "description": "Mojolicious EP template adapter for BarefootJS - generates .html.ep 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": [
@@ -29,7 +29,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 typescript --external @barefootjs/vite --external vite && 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",
@@ -52,14 +52,27 @@
     "directory": "packages/adapter-mojolicious"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.30.6"
+    "@barefootjs/shared": "0.31.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "@barefootjs/vite": ">=0.2.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/jsx": "0.31.0",
+    "@barefootjs/vite": "0.31.0",
+    "@barefootjs/client": "0.31.0",
+    "vite": "^6.0.0"
   }
 }

package/src/__tests__/mojo-adapter.test.ts

@@ -2133,3 +2133,146 @@ export function Parent() {
     expect(template).not.toContain('$bf_prop_data')
   })
 })
+
+describe('MojoAdapter - scriptAssets (Vite late-binding, PR1)', () => {
+  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 register_script per URL, in order, when scriptAssets is set', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new MojoAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js', '/assets/counter-def456.js'],
+    })
+    const runtimeIdx = template.indexOf("bf->register_script('/assets/runtime-abc123.js')")
+    const compIdx = template.indexOf("bf->register_script('/assets/counter-def456.js')")
+    expect(runtimeIdx).toBeGreaterThanOrEqual(0)
+    expect(compIdx).toBeGreaterThanOrEqual(0)
+    expect(runtimeIdx).toBeLessThan(compIdx)
+    expect(template).not.toContain('/static/components/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 MojoAdapter().generate(ir, {
+      scriptAssets: ['/assets/only-one.js'],
+    })
+    expect(template).toContain("bf->register_script('/assets/only-one.js')")
+    expect(template.match(/register_script/g)?.length).toBe(1)
+  })
+
+  test('an empty scriptAssets array emits no script registrations', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new MojoAdapter().generate(ir, { scriptAssets: [] })
+    expect(template).not.toContain('register_script')
+  })
+
+  test('skipScriptRegistration still wins when scriptAssets is also set', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new MojoAdapter().generate(ir, {
+      skipScriptRegistration: true,
+      scriptAssets: ['/assets/should-not-appear.js'],
+    })
+    expect(template).not.toContain('register_script')
+  })
+
+  test('absent scriptAssets falls back to adapter-computed script paths', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const computed = new MojoAdapter().generate(ir).template
+    const explicitUndefined = new MojoAdapter().generate(ir, { scriptAssets: undefined }).template
+    expect(computed).toContain("bf->register_script('/static/components/barefoot.js')")
+    expect(computed).toContain("bf->register_script('/static/components/Counter.client.js')")
+    expect(explicitUndefined).toBe(computed)
+  })
+})
+
+describe('MojoAdapter - 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 MojoAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js', '/assets/counter-def456.js'],
+      preloadAssets: ['/assets/index-pre1.js', '/assets/shared-pre2.js'],
+    })
+    const pre1Idx = template.indexOf("% bf->register_preload('/assets/index-pre1.js');")
+    const pre2Idx = template.indexOf("% bf->register_preload('/assets/shared-pre2.js');")
+    const script1Idx = template.indexOf("% bf->register_script('/assets/runtime-abc123.js');")
+    const script2Idx = template.indexOf("% bf->register_script('/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 MojoAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js'],
+      preloadAssets: [],
+    })
+    expect(template).not.toContain('register_preload')
+    expect(template).toContain("bf->register_script('/assets/runtime-abc123.js')")
+  })
+
+  test('preloadAssets: undefined emits no preload registration', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new MojoAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js'],
+      preloadAssets: undefined,
+    })
+    expect(template).not.toContain('register_preload')
+    expect(template).toContain("bf->register_script('/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 MojoAdapter().generate(ir, {
+      scriptAssets: [],
+      preloadAssets: ['/assets/index-pre1.js'],
+    })
+    expect(template).not.toContain('register_preload')
+    expect(template).not.toContain('register_script')
+  })
+
+  test('skipScriptRegistration: true suppresses both preloads and scripts', () => {
+    const ir = compileToIR(CLIENT_COMPONENT)
+    const { template } = new MojoAdapter().generate(ir, {
+      skipScriptRegistration: true,
+      scriptAssets: ['/assets/runtime-abc123.js'],
+      preloadAssets: ['/assets/index-pre1.js'],
+    })
+    expect(template).not.toContain('register_preload')
+    expect(template).not.toContain('register_script')
+  })
+
+  // 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,
+  // `% bf->register_preload('...');`) 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 MojoAdapter().generate(ir, {
+      scriptAssets: ['/assets/runtime-abc123.js'],
+      preloadAssets: ['/assets/index-pre1.js'],
+    })
+    expect(template).not.toContain('<link')
+  })
+})

package/src/__tests__/multi-component-registry.test.ts

@@ -12,9 +12,9 @@
 // This is the in-repo equivalent of the issue's repro: `bf add toast` →
 // render a <Toast>-using component on mojo → expect 200 with toast markup.
 // It boots a real Mojolicious app with the production plugin against
-// compiler-produced templates plus a manifest in the shape `bf build` now
+// compiler-produced templates plus a manifest in the shape `@barefootjs/vite`
 // emits (per-component rows under `components` — pinned on the emitter side
-// by packages/cli/src/__tests__/build-manifest-components.test.ts).
+// by packages/vite/src/__tests__/component-manifest.test.ts).
 //
 // Runs only when `perl` with Mojolicious is installed (same skip policy as
 // stock-route.test.ts, which this file mirrors).
@@ -176,7 +176,7 @@ describe.skipIf(!PERL_AVAILABLE)('Mojo multi-component registry modules (#2132)'
     if (!probeTemplate) throw new Error('probe compile produced no template')
     writeFileSync(path.join(appDir, 'dist/templates/ToastProbe.html.ep'), probeTemplate.content)
 
-    // Same entry shape `bf build` writes to dist/templates/manifest.json
+    // Same entry shape `@barefootjs/vite` writes to dist/templates/manifest.json
     // (see build-manifest-components.test.ts for the emitter pin).
     writeFileSync(
       path.join(appDir, 'dist/templates/manifest.json'),

package/src/__tests__/scaffold.test.ts

@@ -4,8 +4,8 @@
 // cross-adapter contract defined in `create-barefootjs` and the
 // Mojo-specific wiring:
 //
-//   - `barefoot.config.ts` targets `@barefootjs/mojolicious/build` and
-//     uses `clientJsBasePath: '/static/components/'`.
+//   - `vite.config.ts` targets `@barefootjs/mojolicious/vite` and
+//     uses `base: '/static/components/'`.
 //   - `app.pl` forwards `/static/*` URLs to the on-disk static paths
 //     (Mojolicious's built-in dispatcher does not honour URL prefixes,
 //     so the explicit routes are load-bearing — without them every
@@ -116,7 +116,7 @@ describe.skipIf(!INTEGRATION)(
 
     describe('app.pl serves static assets', () => {
       // Mojolicious's built-in static dispatcher does not honour URL
-      // prefixes. The scaffold's `barefoot.config.ts` and layout `<link>`s
+      // prefixes. The scaffold's `vite.config.ts` and layout `<link>`s
       // all reference `/static/*` URLs, so `app.pl` needs explicit
       // forwarding routes — without them every stylesheet and client bundle
       // 404s in the browser even though the SSR HTML rendered correctly.
@@ -176,10 +176,10 @@ describe.skipIf(!INTEGRATION)(
         expect(app).not.toContain("app->home->child('dist/templates/manifest.json')")
       })
 
-      test('barefoot.config.ts targets the mojolicious adapter', () => {
-        const cfg = readFileSync(path.join(projectDir, 'barefoot.config.ts'), 'utf-8')
-        expect(cfg).toContain("from '@barefootjs/mojolicious/build'")
-        expect(cfg).toContain("clientJsBasePath: '/static/components/'")
+      test('vite.config.ts targets the mojolicious adapter', () => {
+        const cfg = readFileSync(path.join(projectDir, 'vite.config.ts'), 'utf-8')
+        expect(cfg).toContain("from '@barefootjs/mojolicious/vite'")
+        expect(cfg).toContain("base: '/static/components/'")
       })
 
       test('layout stylesheets point at /static/*.css', () => {

package/src/__tests__/stock-route.test.ts

@@ -1,7 +1,7 @@
 // Stock-route smoke test for the Mojo scaffold contract (#2126).
 //
-// The scaffold's happy path is: `npm run dev` (which starts `bf build
-// --watch` and morbo *concurrently*), then open `/`. That page renders a
+// The scaffold's happy path is: `npm run dev` (which starts `vite dev`
+// and morbo *concurrently*), then open `/`. That page renders a
 // component whose EP template reads props/signals as bare scalars
 // (`% my $count = ($initial // 0);`), and Mojo templates compile under
 // `use strict` — so every one of those scalars must be declared by the
@@ -114,8 +114,8 @@ __DATA__
 //   manifest-at-boot   — the manifest exists before the app loads
 //                        (server restarted after a completed build).
 //   manifest-after-boot — the app loads first, the manifest appears
-//                        afterwards (the concurrent `bf build --watch`
-//                        + morbo dev race on a fresh scaffold).
+//                        afterwards (the concurrent `vite dev` +
+//                        morbo dev race on a fresh scaffold).
 const SMOKE_PL = `use Mojo::Base -strict;
 use Test::More;
 use Test::Mojo;
@@ -161,7 +161,8 @@ describe.skipIf(!PERL_AVAILABLE)('Mojo scaffold stock route (#2126)', () => {
     if (!template || !ssrDefaults) throw new Error('compileJSX produced no template/ssrDefaults')
 
     writeFileSync(path.join(appDir, 'dist/templates/Counter.html.ep'), template.content)
-    // Same entry shape `bf build` writes to dist/templates/manifest.json.
+    // Same entry shape `@barefootjs/vite` writes to
+    // dist/templates/manifest.json.
     writeFileSync(
       path.join(appDir, 'manifest.staged.json'),
       JSON.stringify({

package/src/__tests__/vite.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Coverage of `@barefootjs/mojolicious/vite`'s `barefoot()`:
+ *
+ * - one real `vite build()` end to end (mirrors `@barefootjs/go-template/
+ *   vite`, `@barefootjs/hono/vite`, `@barefootjs/blade/vite`'s,
+ *   `@barefootjs/jinja/vite`'s, and `@barefootjs/erb/vite`'s own
+ *   `vite.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 `assets` → generated `bf-assets.json` behavior, exercised the same
+ *   way (a real build, since it needs the real manifest Vite writes).
+ *
+ * Unlike Go, there is no `afterEmit`-driven type-combination step to test
+ * here (see `vite.ts`'s module docstring) — `MojoAdapter.generate()` never
+ * produces a `types` section at all, so `barefoot()` always returns a
+ * single-element array unless `assets` is set.
+ */
+import { describe, test, expect } from 'bun:test'
+import { build } from 'vite'
+import { mkdtemp, rm, readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { barefoot, barefoot as defaultBarefoot } from '../vite.ts'
+
+const FIXTURE_ROOT = resolve(import.meta.dirname, '../../e2e-fixture')
+
+describe('@barefootjs/mojolicious/vite: real vite build', () => {
+  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)
+  })
+
+  test('writes a self-contained .html.ep template with scriptAssets baked in, same as core alone would do', async () => {
+    const outDir = await mkdtemp(join(tmpdir(), 'barefoot-mojolicious-vite-dist-'))
+    const templatesDir = await mkdtemp(join(tmpdir(), 'barefoot-mojolicious-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,
+        }),
+      })
+
+      const template = await readFile(join(templatesDir, 'Counter.html.ep'), 'utf8')
+      expect(template).toContain("bf->register_script(")
+    } 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 a generated JSON asset map', async () => {
+    const outDir = await mkdtemp(join(tmpdir(), 'barefoot-mojolicious-vite-dist-assets-'))
+    const templatesDir = await mkdtemp(join(tmpdir(), 'barefoot-mojolicious-vite-views-assets-'))
+    const assetsPath = join(FIXTURE_ROOT, 'dist/bf-assets.json')
+
+    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 = JSON.parse(await readFile(assetsPath, 'utf8'))
+      expect(content).toEqual({ Bootstrap: expectedUrl })
+    } finally {
+      await rm(outDir, { recursive: true, force: true })
+      await rm(templatesDir, { recursive: true, force: true })
+      await rm(join(FIXTURE_ROOT, 'dist'), { recursive: true, 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-mojolicious-vite-dist-assets-missing-'))
+    const templatesDir = await mkdtemp(join(tmpdir(), 'barefoot-mojolicious-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, 'dist'), { recursive: true, force: true })
+    }
+  }, 60_000)
+})

package/src/adapter/expr/emitters.ts

@@ -77,19 +77,37 @@ const PREDICATE_METHODS: ReadonlySet<string> = new Set([
 ])
 
 export class MojoFilterEmitter implements ParsedExprEmitter {
+  // Plain field declarations + assignment, NOT TS constructor-parameter-
+  // property shorthand: Vite's `bundleConfigFile` externalizes any bare
+  // (non-relative) import when loading `vite.config.ts` (see
+  // `@barefootjs/mojolicious/vite`'s docstring), so this file can be loaded
+  // directly by Node's OWN native TypeScript type-stripping (enabled by
+  // default since Node 22.18/23.6) rather than esbuild — and Node's
+  // strip-only mode does not support parameter properties (`SyntaxError
+  // [ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX]`), only plain type annotations.
+  private readonly param: string
+  private readonly localVarMap: Map<string, string>
+  // Reports whether a getter/prop name is string-typed, so `===`/`!==`
+  // against it lowers to `eq`/`ne` (#1672). Defaults to "never" for callers
+  // that don't thread it through.
+  private readonly isStringName: (n: string) => boolean
+  // Records a BF101 for nested callback shapes this emitter can only
+  // degrade — `find*` and the non-predicate methods (#2038). Optional so
+  // emitter construction stays possible without an adapter; a missing hook
+  // keeps the old silent-degrade emit.
+  private readonly onUnsupported?: (message: string, reason?: string) => void
+
   constructor(
-    private readonly param: string,
-    private readonly localVarMap: Map<string, string>,
-    // Reports whether a getter/prop name is string-typed, so `===`/`!==`
-    // against it lowers to `eq`/`ne` (#1672). Defaults to "never" for callers
-    // that don't thread it through.
-    private readonly isStringName: (n: string) => boolean = () => false,
-    // Records a BF101 for nested callback shapes this emitter can only
-    // degrade — `find*` and the non-predicate methods (#2038). Optional so
-    // emitter construction stays possible without an adapter; a missing hook
-    // keeps the old silent-degrade emit.
-    private readonly onUnsupported?: (message: string, reason?: string) => void,
-  ) {}
+    param: string,
+    localVarMap: Map<string, string>,
+    isStringName: (n: string) => boolean = () => false,
+    onUnsupported?: (message: string, reason?: string) => void,
+  ) {
+    this.param = param
+    this.localVarMap = localVarMap
+    this.isStringName = isStringName
+    this.onUnsupported = onUnsupported
+  }
 
   identifier(name: string): string {
     if (name === this.param) return `$${this.param}`
@@ -296,7 +314,13 @@ export class MojoFilterEmitter implements ParsedExprEmitter {
  *     shapes the AST can't classify still emit something coherent.
  */
 export class MojoTopLevelEmitter implements ParsedExprEmitter {
-  constructor(private readonly ctx: MojoEmitContext) {}
+  // Plain field + assignment, not a parameter property — see
+  // `MojoFilterEmitter`'s constructor comment above for why.
+  private readonly ctx: MojoEmitContext
+
+  constructor(ctx: MojoEmitContext) {
+    this.ctx = ctx
+  }
 
   identifier(name: string): string {
     // `undefined` / `null` nested inside a larger expression tree

package/src/adapter/mojo-adapter.ts

@@ -144,9 +144,6 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   name = 'mojolicious'
   extension = '.html.ep'
   templatesPerComponent = true
-  // Template-string target with no component layer: `bf build` emits a static
-  // `barefoot-importmap.html` to `%= include` into the page <head> (#1644).
-  importMapInjection = 'html-snippet' as const
 
   /**
    * Identifier-path callees the Mojo runtime can render in template
@@ -323,7 +320,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     // Generate script registration
     const scriptReg = options?.skipScriptRegistration
       ? ''
-      : this.generateScriptRegistrations(ir, options?.scriptBaseName)
+      : this.generateScriptRegistrations(ir, options?.scriptBaseName, options?.scriptAssets, options?.preloadAssets)
 
     // SSR context consumers (`const x = useContext(Ctx)`): seed each local
     // from the active provider value (or the `createContext` default) so the
@@ -467,7 +464,32 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   // Script Registration
   // ===========================================================================
 
-  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` pair — 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. `% ...;` is a no-output EP statement line, same as
+      // `register_script` below — `register_preload`'s return value is
+      // never printed.
+      const lines = (preloadAssets ?? []).map((url) => `% bf->register_preload('${url}');`)
+      lines.push(...scriptAssets.map((url) => `% bf->register_script('${url}');`))
+      lines.push('')
+      return lines.join('\n')
+    }
+
     const hasInteractivity = hasClientInteractivity(ir)
     if (!hasInteractivity) return ''