feat(bundler): transpile static inline scripts for Vite targets (#862)

* feat(bundler): transpile static inline scripts for Vite targets

Static inline scripts emitted from useHead bypass Vite's normal transpilation and can ship unsupported syntax. Run literals through Vite's resolved target in MinifyTransform, with an explicit override and opt-out.

* refactor(bundler): centralize inline transform options

Keep the Vite and framework factories on the same defaulting path. Clarify the Vite-only transpilation scope and document target failures.

* test(bundler): verify Vite transform backends

Cover Oxc selection and the esbuild fallback. Document that Nuxt app.head and Nitro-injected HTML sit outside the Vite module graph.

* fix(bundler): handle inline script transform edge cases

* fix(bundler): normalize baseline target on Vite 6

Author: harlan-zw

docs/head/1.guides/build-plugins/0.overview.md

@@ -1,6 +1,6 @@
 ---
 title: Build Plugins
-description: Unified Vite and webpack plugins for Unhead. Build optimizations, tree-shaking, and useSeoMeta transforms in a single plugin call.
+description: Unified Vite and webpack plugins for Unhead. Build optimizations, inline script transpilation, tree-shaking, and useSeoMeta transforms in a single plugin call.
 navigation.title: Overview
 ---
 
@@ -66,7 +66,8 @@ The plugin combines several build-time optimizations:
 
 - **[Tree-shaking](/docs/head/guides/build-plugins/tree-shaking)**: Removes deprecated server composables and `useSchemaOrg` calls from client bundles
 - **[useSeoMeta transform](/docs/head/guides/build-plugins/seo-meta-transform)**: Converts `useSeoMeta()` calls into raw `useHead()` calls at build time
-- **[Minify transform](/docs/head/guides/build-plugins/minify-transform)**: Pre-minify static inline script/style content at build time
+- **[Inline script transform](/docs/head/guides/build-plugins/minify-transform)**: Transpiles static inline scripts to Vite's configured browser target
+- **[Minify transform](/docs/head/guides/build-plugins/minify-transform)**: Optionally pre-minifies static inline script/style content in the same AST pass
 - **Dev validation**: Auto-injects `ValidatePlugin` in dev so head tag warnings surface in the browser console (enabled by default)
 - **[DevTools](/docs/head/guides/build-plugins/devtools)**: Registers Unhead's Vite DevTools integration by default; the panel activates when Vite DevTools is enabled
 
@@ -78,6 +79,8 @@ Unhead({
   treeshake: false,
   // Disable useSeoMeta → useHead transform
   transformSeoMeta: false,
+  // Disable automatic inline script transpilation
+  transformInlineScripts: false,
   // Pre-minify inline script/style content
   minify: { js: createJSMinifier(), css: createCSSMinifier() },
   // File filter (shared across all transforms)
@@ -89,6 +92,7 @@ Unhead({
 | -------- | ------ | --------- | ------------- |
 | `treeshake` | `object \| false` | enabled | [Tree-shake server composables](/docs/head/guides/build-plugins/tree-shaking) from client bundles |
 | `transformSeoMeta` | `object \| false` | enabled | [Transform `useSeoMeta()`](/docs/head/guides/build-plugins/seo-meta-transform) to `useHead()` |
+| `transformInlineScripts` | `object \| false` | enabled | Transpile static inline scripts to Vite's resolved `build.target` |
 | `minify` | `object \| false` | disabled | [Pre-minify static inline script/style](/docs/head/guides/build-plugins/minify-transform) |
 | `validate` | `boolean` | enabled | Auto-inject `ValidatePlugin` in dev for head tag warnings |
 | `devtools` | `object \| false` | included | [Vite DevTools integration](/docs/head/guides/build-plugins/devtools) (dev only) |
@@ -97,6 +101,15 @@ Unhead({
 
 The three transforms accept `false` or an options object. `devtools` follows the same pattern, while `validate` and `sourcemap` are booleans and `filter` is an object.
 
+Inline scripts inherit Vite's resolved `build.target`. Override it without
+changing the target for the rest of the bundle:
+
+```ts
+Unhead({
+  transformInlineScripts: { target: 'chrome77' },
+})
+```
+
 ## Other Bundlers
 
 The Vue, React, Svelte, and Solid.js packages expose a unified `/bundler` entry with per-bundler methods:
@@ -110,3 +123,5 @@ export default {
 ```
 
 The bundler entry also exposes `.rspack()` and `.rollup()`. Validation and DevTools injection are Vite-only. Rollup cannot infer whether it is building for the client or server, so target-dependent transforms remain conservative; use `.vite()` or `.webpack()` when you need target-aware optimization.
+
+Inline script target inheritance is Vite-only. Rollup has no browser target contract. Unplugin provides the webpack and Rspack targets, but not their transpilers, so Unhead cannot apply those targets to an inline string. Existing explicit minifier configuration is unchanged.

docs/head/1.guides/build-plugins/3.minify-transform.md

@@ -1,12 +1,67 @@
 ---
-title: Minify Transform
-description: Pre-minify static inline script and style content inside useHead() calls at build time using rolldown, esbuild, or lightningcss.
-navigation.title: Minify Transform
+title: Inline Code Transform
+description: Transpile static inline scripts and optionally minify static inline script and style content inside useHead() calls at build time.
+navigation.title: Inline Code Transform
 ---
 
-The minify transform processes static string literals in `useHead()` script and style tags at build time. It supports Rolldown or esbuild for JavaScript and Lightning CSS for CSS, without adding those tools to the SSR runtime bundle. The transform is disabled until you provide a minifier.
+**Quick Answer:** Static inline scripts inside `useHead()` inherit Vite's
+configured `build.target`. The same AST pass can optionally minify script and
+style strings using rolldown, esbuild, or lightningcss.
 
-## Transformation
+## Inline Script Transpilation
+
+Inline scripts are HTML strings, so the normal application bundling pipeline
+cannot see the JavaScript inside them. The Unhead build plugin finds static
+`innerHTML` and `textContent` values and runs them through Vite's JavaScript
+transform using the resolved browser target:
+
+Transpilation is available only through the Vite integration. Webpack, Rspack,
+and Rollup leave inline script syntax unchanged, while configured JavaScript and
+CSS minifiers still run.
+
+```ts [vite.config.ts]
+import { Unhead } from '@unhead/vue/vite'
+
+export default defineConfig({
+  build: {
+    target: 'chrome77',
+  },
+  plugins: [Unhead()],
+})
+```
+
+```ts [Source]
+useHead({
+  script: [{
+    textContent: 'window.theme = storage?.theme ?? "light"',
+  }],
+})
+```
+
+The inline script now uses the same target as the application bundle.
+
+To override the target only for inline scripts, or opt out entirely:
+
+```ts
+Unhead({
+  transformInlineScripts: { target: 'chrome77' },
+  // transformInlineScripts: false,
+})
+```
+
+Only static string and expression-free template literals can be transformed at
+build time. Dynamic strings remain unchanged. Scripts with a JavaScript MIME
+type, `type="module"`, an empty type, or no type are eligible. Other script types
+are data blocks and remain unchanged. If Vite cannot safely transform a script
+for the configured target, the build fails instead of shipping code that violates
+that target.
+
+Nuxt's `app.head` configuration and HTML inserted from Nitro render hooks are
+created outside the Vite application module graph, so this transform cannot
+process them. Module authors should use `onPrehydrate` for pre-hydration code or
+ship script text that already supports their minimum browser target.
+
+## Minification
 
 The transform finds `innerHTML` and `textContent` properties on `script` and `style` objects inside `useHead()` calls, then minifies them at build time:
 
@@ -36,10 +91,11 @@ useHead({
 ::
 
 The transform minifies `application/json`, `application/ld+json`, `speculationrules`, and `importmap` script types with Unhead's built-in JSON minifier. It ignores strings shorter than 20 characters and dynamic content, including template literals with expressions.
+JavaScript transpilation has no minimum length.
 
 ## Setup
 
-The minify transform is disabled by default. Enable it by providing minifier functions:
+Minification is disabled by default. Enable it by providing minifier functions:
 
 ```ts
 import { Unhead } from '@unhead/vue/vite'

packages/bundler/README.md

@@ -9,6 +9,7 @@
 ## Features
 
 - 🛠️ Build-time optimizations for Unhead
+- 🎯 Transpile static inline scripts to Vite's configured browser target
 - 🌲 Tree-shake server composables from client bundles
 - ⚡ Transform `useSeoMeta` calls for better performance
 - 📦 Support for Vite, Webpack, and other bundlers
@@ -53,6 +54,9 @@ interface UnpluginOptions {
 
   // Transform useSeoMeta calls for better performance
   useSeoMetaTransform?: boolean | UseSeoMetaTransformOptions
+
+  // Vite: transpile static inline scripts to build.target (enabled by default)
+  transformInlineScripts?: false | { target?: string | string[] | false }
 }
 ```