@unhead/vue 3.0.4 → 3.1.0

package/dist/bundler.d.mts

@@ -0,0 +1,26 @@
+import * as _unhead_bundler_framework from '@unhead/bundler/framework';
+import { UnheadFrameworkOptions } from '@unhead/bundler/framework';
+import { U as UnheadVueStreamingOptions } from './shared/vue.B_EhRTsW.mjs';
+import 'unplugin';
+import 'unhead/stream/unplugin';
+
+type UnheadVueOptions = UnheadFrameworkOptions<UnheadVueStreamingOptions>;
+/**
+ * Unified bundler plugin factory for `@unhead/vue`. Returns an object with
+ * per-bundler dispatch methods (`vite`, `webpack`, `rspack`, `rollup`) so a
+ * single call site covers every supported builder.
+ *
+ * @example
+ * ```ts
+ * // vite:
+ * import { Unhead } from '@unhead/vue/bundler'
+ * export default defineConfig({ plugins: [...Unhead({ streaming: true }).vite()] })
+ *
+ * // nuxt kit:
+ * addBuildPlugin(Unhead({ streaming: true }))
+ * ```
+ */
+declare const Unhead: (options?: UnheadFrameworkOptions<UnheadVueStreamingOptions>) => _unhead_bundler_framework.UnheadBundlerFactory;
+
+export { Unhead };
+export type { UnheadVueOptions };

package/dist/bundler.d.ts

@@ -0,0 +1,26 @@
+import * as _unhead_bundler_framework from '@unhead/bundler/framework';
+import { UnheadFrameworkOptions } from '@unhead/bundler/framework';
+import { U as UnheadVueStreamingOptions } from './shared/vue.B_EhRTsW.js';
+import 'unplugin';
+import 'unhead/stream/unplugin';
+
+type UnheadVueOptions = UnheadFrameworkOptions<UnheadVueStreamingOptions>;
+/**
+ * Unified bundler plugin factory for `@unhead/vue`. Returns an object with
+ * per-bundler dispatch methods (`vite`, `webpack`, `rspack`, `rollup`) so a
+ * single call site covers every supported builder.
+ *
+ * @example
+ * ```ts
+ * // vite:
+ * import { Unhead } from '@unhead/vue/bundler'
+ * export default defineConfig({ plugins: [...Unhead({ streaming: true }).vite()] })
+ *
+ * // nuxt kit:
+ * addBuildPlugin(Unhead({ streaming: true }))
+ * ```
+ */
+declare const Unhead: (options?: UnheadFrameworkOptions<UnheadVueStreamingOptions>) => _unhead_bundler_framework.UnheadBundlerFactory;
+
+export { Unhead };
+export type { UnheadVueOptions };

package/dist/bundler.mjs

@@ -0,0 +1,11 @@
+import { createFrameworkPlugin } from '@unhead/bundler/framework';
+import { u as unheadVueStreamingPlugin } from './shared/vue.D3FlIlye.mjs';
+import 'unhead/stream/unplugin';
+import 'unplugin';
+
+const Unhead = createFrameworkPlugin({
+  framework: "@unhead/vue",
+  streamingPlugin: unheadVueStreamingPlugin
+});
+
+export { Unhead };

package/dist/client.mjs

@@ -1,10 +1,11 @@
 import { createDomRenderer, createDebouncedFn, createHead as createHead$1 } from 'unhead/client';
 export { renderDOMHead } from 'unhead/client';
-import { v as vueInstall } from './shared/vue.D51lypTh.mjs';
-export { V as VueHeadMixin } from './shared/vue.C54fV9ES.mjs';
+import { v as vueInstall } from './shared/vue.Kp0sxz0n.mjs';
+export { V as VueHeadMixin } from './shared/vue.BIIm5xba.mjs';
+import 'vue';
+import './shared/vue.Cn5tnr29.mjs';
 import 'unhead/plugins';
 import 'unhead/utils';
-import 'vue';
 import './shared/vue.CkLIG7eN.mjs';
 
 // @__NO_SIDE_EFFECTS__

package/dist/components.mjs

@@ -1,7 +1,8 @@
 import { defineComponent, ref, onBeforeUnmount, watchEffect } from 'vue';
-import { u as useHead } from './shared/vue.D51lypTh.mjs';
+import { u as useHead } from './shared/vue.Cn5tnr29.mjs';
 import 'unhead/plugins';
 import 'unhead/utils';
+import './shared/vue.Kp0sxz0n.mjs';
 import './shared/vue.CkLIG7eN.mjs';
 
 function extractTextContent(children) {

package/dist/index.mjs

@@ -1,8 +1,9 @@
-export { h as headSymbol, i as injectHead, u as useHead, a as useHeadSafe, b as useSeoMeta, c as useServerHead, d as useServerHeadSafe, e as useServerSeoMeta } from './shared/vue.D51lypTh.mjs';
+export { i as injectHead, u as useHead, a as useHeadSafe, b as useSeoMeta, c as useServerHead, d as useServerHeadSafe, e as useServerSeoMeta } from './shared/vue.Cn5tnr29.mjs';
+export { h as headSymbol } from './shared/vue.Kp0sxz0n.mjs';
 export { resolveUnrefHeadInput } from './utils.mjs';
-export { V as VueHeadMixin } from './shared/vue.C54fV9ES.mjs';
+export { V as VueHeadMixin } from './shared/vue.BIIm5xba.mjs';
 export { createUnhead, defineLink, defineScript } from 'unhead';
-export { u as useScript } from './shared/vue.CC8Cvdls.mjs';
+export { u as useScript } from './shared/vue.D__tEKct.mjs';
 import 'unhead/plugins';
 import 'unhead/utils';
 import 'vue';

package/dist/legacy.mjs

@@ -2,13 +2,14 @@ import { DeprecationsPlugin } from 'unhead/legacy';
 import { PromisesPlugin, TemplateParamsPlugin, AliasSortingPlugin } from 'unhead/plugins';
 import { createHead as createHead$1 } from './client.mjs';
 import { createHead as createHead$2 } from './server.mjs';
-export { V as VueHeadMixin } from './shared/vue.C54fV9ES.mjs';
+export { V as VueHeadMixin } from './shared/vue.BIIm5xba.mjs';
 export { renderDOMHead } from 'unhead/client';
-import './shared/vue.D51lypTh.mjs';
-import 'unhead/utils';
-import 'vue';
-import './shared/vue.CkLIG7eN.mjs';
+import './shared/vue.Kp0sxz0n.mjs';
 import 'unhead/server';
+import './shared/vue.CkLIG7eN.mjs';
+import 'vue';
+import './shared/vue.Cn5tnr29.mjs';
+import 'unhead/utils';
 
 const legacyPlugins = [DeprecationsPlugin, PromisesPlugin, TemplateParamsPlugin, AliasSortingPlugin];
 // @__NO_SIDE_EFFECTS__

package/dist/scripts.mjs

@@ -1,7 +1,8 @@
 export { createSpyProxy } from 'unhead/scripts';
-export { u as useScript } from './shared/vue.CC8Cvdls.mjs';
+export { u as useScript } from './shared/vue.D__tEKct.mjs';
 import 'vue';
-import './shared/vue.D51lypTh.mjs';
+import './shared/vue.Cn5tnr29.mjs';
 import 'unhead/plugins';
 import 'unhead/utils';
+import './shared/vue.Kp0sxz0n.mjs';
 import './shared/vue.CkLIG7eN.mjs';

package/dist/server.mjs

@@ -1,11 +1,12 @@
 import { createHead as createHead$1 } from 'unhead/server';
 export { propsToString, renderSSRHead, transformHtmlTemplate } from 'unhead/server';
-import { v as vueInstall } from './shared/vue.D51lypTh.mjs';
+import { v as vueInstall } from './shared/vue.Kp0sxz0n.mjs';
 import { V as VueResolver } from './shared/vue.CkLIG7eN.mjs';
-export { V as VueHeadMixin } from './shared/vue.C54fV9ES.mjs';
+export { V as VueHeadMixin } from './shared/vue.BIIm5xba.mjs';
+import 'vue';
+import './shared/vue.Cn5tnr29.mjs';
 import 'unhead/plugins';
 import 'unhead/utils';
-import 'vue';
 
 // @__NO_SIDE_EFFECTS__
 function createHead(options = {}) {

package/dist/shared/{vue.C54fV9ES.mjs → vue.BIIm5xba.mjs}

@@ -1,5 +1,5 @@
 import { getCurrentInstance } from 'vue';
-import { u as useHead } from './vue.D51lypTh.mjs';
+import { u as useHead } from './vue.Cn5tnr29.mjs';
 
 const VueHeadMixin = {
   created() {

package/dist/shared/vue.B_EhRTsW.d.mts

@@ -0,0 +1,16 @@
+import * as unplugin from 'unplugin';
+import { StreamingPluginOptions } from 'unhead/stream/unplugin';
+
+type UnheadVueStreamingOptions = Pick<StreamingPluginOptions, 'mode'>;
+/**
+ * Bundler-agnostic streaming SSR plugin for `@unhead/vue`.
+ *
+ * Vue does not need a source-level transform: per-chunk head patches are
+ * emitted by `wrapStream` on the server as self-deleting inline scripts.
+ * This plugin exists to wire the client streaming bootstrap (virtual iife
+ * module + `transformIndexHtml` head-prepend on vite).
+ */
+declare const unheadVueStreamingPlugin: unplugin.UnpluginInstance<UnheadVueStreamingOptions | undefined, boolean>;
+
+export { unheadVueStreamingPlugin as u };
+export type { UnheadVueStreamingOptions as U };

package/dist/shared/vue.B_EhRTsW.d.ts

@@ -0,0 +1,16 @@
+import * as unplugin from 'unplugin';
+import { StreamingPluginOptions } from 'unhead/stream/unplugin';
+
+type UnheadVueStreamingOptions = Pick<StreamingPluginOptions, 'mode'>;
+/**
+ * Bundler-agnostic streaming SSR plugin for `@unhead/vue`.
+ *
+ * Vue does not need a source-level transform: per-chunk head patches are
+ * emitted by `wrapStream` on the server as self-deleting inline scripts.
+ * This plugin exists to wire the client streaming bootstrap (virtual iife
+ * module + `transformIndexHtml` head-prepend on vite).
+ */
+declare const unheadVueStreamingPlugin: unplugin.UnpluginInstance<UnheadVueStreamingOptions | undefined, boolean>;
+
+export { unheadVueStreamingPlugin as u };
+export type { UnheadVueStreamingOptions as U };

package/dist/shared/{vue.D51lypTh.mjs → vue.Cn5tnr29.mjs}

@@ -1,21 +1,9 @@
 import { SafeInputPlugin, FlatMetaPlugin } from 'unhead/plugins';
 import { walkResolver } from 'unhead/utils';
 import { hasInjectionContext, inject, ref, getCurrentScope, watchEffect, getCurrentInstance, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
+import { h as headSymbol } from './vue.Kp0sxz0n.mjs';
 import { V as VueResolver } from './vue.CkLIG7eN.mjs';
 
-const headSymbol = "usehead";
-// @__NO_SIDE_EFFECTS__
-function vueInstall(head) {
-  const plugin = {
-    install(app) {
-      app.config.globalProperties.$unhead = head;
-      app.config.globalProperties.$head = head;
-      app.provide(headSymbol, head);
-    }
-  };
-  return plugin.install;
-}
-
 // @__NO_SIDE_EFFECTS__
 function injectHead() {
   if (hasInjectionContext()) {
@@ -82,4 +70,4 @@ const useServerHead = useHead;
 const useServerHeadSafe = useHeadSafe;
 const useServerSeoMeta = useSeoMeta;
 
-export { useHeadSafe as a, useSeoMeta as b, useServerHead as c, useServerHeadSafe as d, useServerSeoMeta as e, headSymbol as h, injectHead as i, useHead as u, vueInstall as v };
+export { useHeadSafe as a, useSeoMeta as b, useServerHead as c, useServerHeadSafe as d, useServerSeoMeta as e, injectHead as i, useHead as u };

package/dist/shared/vue.D3FlIlye.mjs

@@ -0,0 +1,11 @@
+import { buildStreamingPluginOptions } from 'unhead/stream/unplugin';
+import { createUnplugin } from 'unplugin';
+
+const unheadVueStreamingPlugin = createUnplugin(
+  (options = {}) => buildStreamingPluginOptions({
+    framework: "@unhead/vue",
+    mode: options.mode
+  })
+);
+
+export { unheadVueStreamingPlugin as u };

package/dist/shared/{vue.CC8Cvdls.mjs → vue.D__tEKct.mjs}

@@ -1,6 +1,6 @@
 import { useScript as useScript$1 } from 'unhead/scripts';
 import { getCurrentInstance, onMounted, isRef, watch, onScopeDispose, ref } from 'vue';
-import { i as injectHead } from './vue.D51lypTh.mjs';
+import { i as injectHead } from './vue.Cn5tnr29.mjs';
 
 function registerVueScopeHandlers(script, scope) {
   if (!scope) {

package/dist/shared/vue.Kp0sxz0n.mjs

@@ -0,0 +1,14 @@
+const headSymbol = "usehead";
+// @__NO_SIDE_EFFECTS__
+function vueInstall(head) {
+  const plugin = {
+    install(app) {
+      app.config.globalProperties.$unhead = head;
+      app.config.globalProperties.$head = head;
+      app.provide(headSymbol, head);
+    }
+  };
+  return plugin.install;
+}
+
+export { headSymbol as h, vueInstall as v };

package/dist/stream/client.d.mts

@@ -1,17 +1,13 @@
-import * as vue from 'vue';
 import { CreateStreamableClientHeadOptions } from 'unhead/stream/client';
 export { CreateStreamableClientHeadOptions, UnheadStreamQueue } from 'unhead/stream/client';
 export { V as VueHeadMixin } from '../shared/vue.DnywREVF.mjs';
 import { V as VueHeadClient, U as UseHeadInput } from '../shared/vue.CajUUuy2.mjs';
 import 'unhead/types';
+import 'vue';
 
-/**
- * Client-side HeadStream - renders nothing (script already executed during SSR streaming)
- */
-declare const HeadStream: vue.DefineComponent<{}, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 /**
  * Creates a client head by wrapping the core instance from the iife script.
  */
 declare function createStreamableHead(options?: CreateStreamableClientHeadOptions): VueHeadClient<UseHeadInput, boolean> | undefined;
 
-export { HeadStream, VueHeadClient, createStreamableHead };
+export { VueHeadClient, createStreamableHead };

package/dist/stream/client.d.ts

@@ -1,17 +1,13 @@
-import * as vue from 'vue';
 import { CreateStreamableClientHeadOptions } from 'unhead/stream/client';
 export { CreateStreamableClientHeadOptions, UnheadStreamQueue } from 'unhead/stream/client';
 export { V as VueHeadMixin } from '../shared/vue.DnywREVF.js';
 import { V as VueHeadClient, U as UseHeadInput } from '../shared/vue.CajUUuy2.js';
 import 'unhead/types';
+import 'vue';
 
-/**
- * Client-side HeadStream - renders nothing (script already executed during SSR streaming)
- */
-declare const HeadStream: vue.DefineComponent<{}, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 /**
  * Creates a client head by wrapping the core instance from the iife script.
  */
 declare function createStreamableHead(options?: CreateStreamableClientHeadOptions): VueHeadClient<UseHeadInput, boolean> | undefined;
 
-export { HeadStream, VueHeadClient, createStreamableHead };
+export { VueHeadClient, createStreamableHead };

package/dist/stream/client.mjs

@@ -1,17 +1,12 @@
 import { createStreamableHead as createStreamableHead$1 } from 'unhead/stream/client';
-import { defineComponent } from 'vue';
-import { v as vueInstall } from '../shared/vue.D51lypTh.mjs';
+import { v as vueInstall } from '../shared/vue.Kp0sxz0n.mjs';
 import { V as VueResolver } from '../shared/vue.CkLIG7eN.mjs';
-export { V as VueHeadMixin } from '../shared/vue.C54fV9ES.mjs';
+export { V as VueHeadMixin } from '../shared/vue.BIIm5xba.mjs';
+import 'vue';
+import '../shared/vue.Cn5tnr29.mjs';
 import 'unhead/plugins';
 import 'unhead/utils';
 
-const HeadStream = defineComponent({
-  name: "HeadStream",
-  setup() {
-    return () => null;
-  }
-});
 // @__NO_SIDE_EFFECTS__
 function createStreamableHead(options = {}) {
   const head = createStreamableHead$1({
@@ -24,4 +19,4 @@ function createStreamableHead(options = {}) {
   return head;
 }
 
-export { HeadStream, createStreamableHead };
+export { createStreamableHead };

package/dist/stream/server.d.mts

@@ -1,16 +1,9 @@
-import * as vue from 'vue';
 import { WebStreamableHeadContext } from 'unhead/stream/server';
 export { CreateStreamableServerHeadOptions, StreamingTemplateParts, createBootstrapScript, prepareStreamingTemplate, renderSSRHeadShell, renderSSRHeadSuspenseChunk, renderShell, wrapStream } from 'unhead/stream/server';
 import { ResolvableHead, SSRHeadPayload, CreateStreamableServerHeadOptions } from 'unhead/types';
 import { V as VueHeadClient } from '../shared/vue.CajUUuy2.mjs';
+import 'vue';
 
-/**
- * Streaming script component - outputs inline script with current head state.
- * The Vite plugin with streaming: true auto-injects this.
- */
-declare const HeadStream: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 /**
  * Vue-specific context returned by createStreamableHead.
  * Extends WebStreamableHeadContext with Vue-specific head type.
@@ -24,6 +17,17 @@ interface VueStreamableHeadContext extends Omit<WebStreamableHeadContext<Resolva
 /**
  * Creates a head instance configured for Vue streaming SSR.
  *
+ * `wrapStream` is Vue-specific: Vue's `renderToWebStream` flushes chunks in
+ * document order per resolved Suspense boundary, so any head entries added
+ * during a chunk's render can be emitted as a self-deleting inline
+ * `<script>` right after the chunk. The script executes at HTML parse
+ * (updating the client head state progressively) and calls
+ * `document.currentScript.remove()` so the DOM is clean before Vue
+ * hydrates. This pattern is not safe for frameworks with out-of-order
+ * Suspense reveals (React, Solid) or framework-specific chunk formats
+ * (Svelte) — those continue to use an in-tree `<HeadStream />` component
+ * whose output is serialized inside the framework's own stream.
+ *
  * @example
  * ```ts
  * export async function render(url: string, template: string) {
@@ -34,10 +38,7 @@ interface VueStreamableHeadContext extends Omit<WebStreamableHeadContext<Resolva
  *   app.mixin(VueHeadMixin)
  *   router.push(url)
  *
- *   // Create stream first - Vue starts rendering synchronously
  *   const vueStream = renderToWebStream(app)
- *
- *   // Wait for router - by now Vue's sync render has pushed head entries
  *   await router.isReady()
  *
  *   return wrapStream(vueStream, template)
@@ -46,5 +47,5 @@ interface VueStreamableHeadContext extends Omit<WebStreamableHeadContext<Resolva
  */
 declare function createStreamableHead(options?: Omit<CreateStreamableServerHeadOptions, 'propsResolver'>): VueStreamableHeadContext;
 
-export { HeadStream, VueHeadClient, createStreamableHead };
+export { VueHeadClient, createStreamableHead };
 export type { VueStreamableHeadContext };

package/dist/stream/server.d.ts

@@ -1,16 +1,9 @@
-import * as vue from 'vue';
 import { WebStreamableHeadContext } from 'unhead/stream/server';
 export { CreateStreamableServerHeadOptions, StreamingTemplateParts, createBootstrapScript, prepareStreamingTemplate, renderSSRHeadShell, renderSSRHeadSuspenseChunk, renderShell, wrapStream } from 'unhead/stream/server';
 import { ResolvableHead, SSRHeadPayload, CreateStreamableServerHeadOptions } from 'unhead/types';
 import { V as VueHeadClient } from '../shared/vue.CajUUuy2.js';
+import 'vue';
 
-/**
- * Streaming script component - outputs inline script with current head state.
- * The Vite plugin with streaming: true auto-injects this.
- */
-declare const HeadStream: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 /**
  * Vue-specific context returned by createStreamableHead.
  * Extends WebStreamableHeadContext with Vue-specific head type.
@@ -24,6 +17,17 @@ interface VueStreamableHeadContext extends Omit<WebStreamableHeadContext<Resolva
 /**
  * Creates a head instance configured for Vue streaming SSR.
  *
+ * `wrapStream` is Vue-specific: Vue's `renderToWebStream` flushes chunks in
+ * document order per resolved Suspense boundary, so any head entries added
+ * during a chunk's render can be emitted as a self-deleting inline
+ * `<script>` right after the chunk. The script executes at HTML parse
+ * (updating the client head state progressively) and calls
+ * `document.currentScript.remove()` so the DOM is clean before Vue
+ * hydrates. This pattern is not safe for frameworks with out-of-order
+ * Suspense reveals (React, Solid) or framework-specific chunk formats
+ * (Svelte) — those continue to use an in-tree `<HeadStream />` component
+ * whose output is serialized inside the framework's own stream.
+ *
  * @example
  * ```ts
  * export async function render(url: string, template: string) {
@@ -34,10 +38,7 @@ interface VueStreamableHeadContext extends Omit<WebStreamableHeadContext<Resolva
  *   app.mixin(VueHeadMixin)
  *   router.push(url)
  *
- *   // Create stream first - Vue starts rendering synchronously
  *   const vueStream = renderToWebStream(app)
- *
- *   // Wait for router - by now Vue's sync render has pushed head entries
  *   await router.isReady()
  *
  *   return wrapStream(vueStream, template)
@@ -46,5 +47,5 @@ interface VueStreamableHeadContext extends Omit<WebStreamableHeadContext<Resolva
  */
 declare function createStreamableHead(options?: Omit<CreateStreamableServerHeadOptions, 'propsResolver'>): VueStreamableHeadContext;
 
-export { HeadStream, VueHeadClient, createStreamableHead };
+export { VueHeadClient, createStreamableHead };
 export type { VueStreamableHeadContext };

package/dist/stream/server.mjs

@@ -1,25 +1,9 @@
-import { renderSSRHeadSuspenseChunk, createStreamableHead as createStreamableHead$1, wrapStream } from 'unhead/stream/server';
+import { createStreamableHead as createStreamableHead$1, prepareStreamingTemplate, renderSSRHeadSuspenseChunk } from 'unhead/stream/server';
 export { createBootstrapScript, prepareStreamingTemplate, renderSSRHeadShell, renderSSRHeadSuspenseChunk, renderShell, wrapStream } from 'unhead/stream/server';
-import { defineComponent, h } from 'vue';
-import { i as injectHead, v as vueInstall } from '../shared/vue.D51lypTh.mjs';
+import { v as vueInstall } from '../shared/vue.Kp0sxz0n.mjs';
 import { V as VueResolver } from '../shared/vue.CkLIG7eN.mjs';
-import 'unhead/plugins';
-import 'unhead/utils';
+import 'vue';
 
-const HeadStream = defineComponent({
-  name: "HeadStream",
-  setup() {
-    const head = injectHead();
-    return () => {
-      if (!head._shellRendered?.())
-        return null;
-      const update = renderSSRHeadSuspenseChunk(head);
-      if (!update)
-        return null;
-      return h("script", { innerHTML: update });
-    };
-  }
-});
 function createStreamableHead(options = {}) {
   const { head } = createStreamableHead$1({
     ...options,
@@ -27,17 +11,40 @@ function createStreamableHead(options = {}) {
   });
   const vueHead = head;
   vueHead.install = vueInstall(vueHead);
-  let shellRendered = false;
-  vueHead._shellRendered = () => shellRendered;
+  const encoder = new TextEncoder();
+  const flushPatch = (controller) => {
+    const patch = renderSSRHeadSuspenseChunk(vueHead);
+    if (patch)
+      controller.enqueue(encoder.encode(`<script>${patch};document.currentScript.remove()<\/script>`));
+  };
   return {
     head: vueHead,
-    wrapStream: (stream, template) => {
-      const preRenderedState = vueHead.render();
-      vueHead.entries.clear();
-      shellRendered = true;
-      return wrapStream(vueHead, stream, template, preRenderedState);
-    }
+    wrapStream: (stream, template) => new ReadableStream({
+      async start(controller) {
+        try {
+          const { shell, end } = prepareStreamingTemplate(vueHead, template);
+          controller.enqueue(encoder.encode(shell));
+          const reader = stream.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done)
+                break;
+              controller.enqueue(value);
+              flushPatch(controller);
+            }
+          } finally {
+            reader.releaseLock();
+          }
+          flushPatch(controller);
+          controller.enqueue(encoder.encode(end));
+          controller.close();
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+    })
   };
 }
 
-export { HeadStream, createStreamableHead };
+export { createStreamableHead };

package/dist/stream/vite.d.mts

@@ -1,27 +1,14 @@
-import * as vite from 'vite';
-import { StreamingPluginOptions } from 'unhead/stream/vite';
+import { Plugin } from 'vite';
+import { U as UnheadVueStreamingOptions } from '../shared/vue.B_EhRTsW.mjs';
+export { u as unheadVueStreamingPlugin } from '../shared/vue.B_EhRTsW.mjs';
+import 'unplugin';
+import 'unhead/stream/unplugin';
 
 /**
- * Vite plugin for Vue streaming SSR support.
- * Automatically injects HeadStream components into Vue SFC templates.
- *
- * @returns Vite plugin configuration object with:
- *   - `name`: Plugin identifier
- *   - `enforce`: Plugin execution order ('pre')
- *   - `transform`: Transform hook for processing .vue files
- *
- * @example
- * ```ts
- * // vite.config.ts
- * import { unheadVuePlugin } from '@unhead/vue/stream/vite'
- *
- * export default {
- *   plugins: [
- *     unheadVuePlugin()
- *   ]
- * }
- * ```
+ * @deprecated Use `Unhead({ streaming: true }).vite()` from `@unhead/vue/bundler` instead.
+ * The `@unhead/vue/stream/vite` subpath and `unheadVuePlugin` export will be
+ * removed in a future major release.
  */
-declare function unheadVuePlugin(options?: Pick<StreamingPluginOptions, 'mode'>): vite.Plugin<any>;
+declare function unheadVuePlugin(options?: UnheadVueStreamingOptions): Plugin;
 
-export { unheadVuePlugin as default, unheadVuePlugin };
+export { UnheadVueStreamingOptions, unheadVuePlugin as default, unheadVuePlugin };

package/dist/stream/vite.d.ts

@@ -1,27 +1,14 @@
-import * as vite from 'vite';
-import { StreamingPluginOptions } from 'unhead/stream/vite';
+import { Plugin } from 'vite';
+import { U as UnheadVueStreamingOptions } from '../shared/vue.B_EhRTsW.js';
+export { u as unheadVueStreamingPlugin } from '../shared/vue.B_EhRTsW.js';
+import 'unplugin';
+import 'unhead/stream/unplugin';
 
 /**
- * Vite plugin for Vue streaming SSR support.
- * Automatically injects HeadStream components into Vue SFC templates.
- *
- * @returns Vite plugin configuration object with:
- *   - `name`: Plugin identifier
- *   - `enforce`: Plugin execution order ('pre')
- *   - `transform`: Transform hook for processing .vue files
- *
- * @example
- * ```ts
- * // vite.config.ts
- * import { unheadVuePlugin } from '@unhead/vue/stream/vite'
- *
- * export default {
- *   plugins: [
- *     unheadVuePlugin()
- *   ]
- * }
- * ```
+ * @deprecated Use `Unhead({ streaming: true }).vite()` from `@unhead/vue/bundler` instead.
+ * The `@unhead/vue/stream/vite` subpath and `unheadVuePlugin` export will be
+ * removed in a future major release.
  */
-declare function unheadVuePlugin(options?: Pick<StreamingPluginOptions, 'mode'>): vite.Plugin<any>;
+declare function unheadVuePlugin(options?: UnheadVueStreamingOptions): Plugin;
 
-export { unheadVuePlugin as default, unheadVuePlugin };
+export { UnheadVueStreamingOptions, unheadVuePlugin as default, unheadVuePlugin };

package/dist/stream/vite.mjs

@@ -1,70 +1,9 @@
-import MagicString from 'magic-string';
-import { parseAndWalk } from 'oxc-walker';
-import { createStreamingPlugin } from 'unhead/stream/vite';
+import { u as unheadVueStreamingPlugin } from '../shared/vue.D3FlIlye.mjs';
+import 'unhead/stream/unplugin';
+import 'unplugin';
 
-const TEMPLATE_RE = /<template[^>]*>/;
-const SCRIPT_RE = /<script[^>]*>/i;
-const FILTER_RE = /\.vue$/;
-function transform(code, id, isSSR, s) {
-  if (!code.includes("useHead") && !code.includes("useSeoMeta") && !code.includes("useHeadSafe"))
-    return false;
-  const templateMatch = code.match(TEMPLATE_RE);
-  if (!templateMatch)
-    return false;
-  const templateStart = templateMatch.index + templateMatch[0].length;
-  s.appendRight(templateStart, "<HeadStream />");
-  const importPath = `@unhead/vue/stream/${isSSR ? "server" : "client"}`;
-  const scriptMatch = code.match(SCRIPT_RE);
-  if (!scriptMatch)
-    return true;
-  const scriptEnd = scriptMatch.index + scriptMatch[0].length;
-  const scriptCloseIndex = code.indexOf("<\/script>", scriptEnd);
-  if (scriptCloseIndex === -1)
-    return true;
-  const scriptContent = code.slice(scriptEnd, scriptCloseIndex);
-  let existingImport = null;
-  parseAndWalk(scriptContent, id, {
-    parseOptions: { lang: "ts" },
-    enter(node) {
-      if (node.type === "ImportDeclaration" && node.source.value === importPath) {
-        existingImport = {
-          start: scriptEnd + node.start,
-          end: scriptEnd + node.end,
-          specifiers: node.specifiers?.map((spec) => spec.local?.name).filter(Boolean) || []
-        };
-        this.skip();
-      }
-    }
-  });
-  const foundImport = existingImport;
-  if (foundImport) {
-    if (!foundImport.specifiers.includes("HeadStream")) {
-      const inner = foundImport.specifiers.join(", ");
-      const newImports = inner ? `${inner}, HeadStream` : "HeadStream";
-      s.overwrite(foundImport.start, foundImport.end, `import { ${newImports} } from '${importPath}'
-`);
-    }
-  } else {
-    s.appendRight(scriptEnd, `
-import { HeadStream } from '${importPath}'`);
-  }
-  return true;
-}
 function unheadVuePlugin(options) {
-  return createStreamingPlugin({
-    framework: "@unhead/vue",
-    filter: FILTER_RE,
-    mode: options?.mode,
-    transform(code, id, opts) {
-      const s = new MagicString(code);
-      if (!transform(code, id, opts?.ssr ?? false, s))
-        return null;
-      return {
-        code: s.toString(),
-        map: s.generateMap({ includeContent: true, source: id })
-      };
-    }
-  });
+  return unheadVueStreamingPlugin.vite(options);
 }
 
-export { unheadVuePlugin as default, unheadVuePlugin };
+export { unheadVuePlugin as default, unheadVuePlugin, unheadVueStreamingPlugin };

package/dist/vite.d.mts

@@ -1,33 +1,22 @@
-import { VitePluginOptions } from '@unhead/bundler/vite';
-import { StreamingPluginOptions } from 'unhead/stream/vite';
 import { Plugin } from 'vite';
+import { UnheadVueOptions } from './bundler.mjs';
+import '@unhead/bundler/framework';
+import './shared/vue.B_EhRTsW.mjs';
+import 'unplugin';
+import 'unhead/stream/unplugin';
 
-interface UnheadVueViteOptions extends VitePluginOptions {
-    /**
-     * Enable streaming SSR support.
-     * Set to `true` or a config object to enable.
-     * @default false
-     */
-    streaming?: true | Pick<StreamingPluginOptions, 'mode'> | false;
-}
+type UnheadVueViteOptions = UnheadVueOptions;
 /**
- * Unified Vite plugin for `@unhead/vue`.
- *
- * Combines build optimizations (tree-shaking, useSeoMeta transform, minification)
- * with streaming SSR support into a single plugin.
+ * Vite plugin for `@unhead/vue`. Kept for backwards compatibility; prefer
+ * the unified `@unhead/vue/bundler` entry which dispatches to all bundlers.
  *
  * @example
  * ```ts
- * // vite.config.ts
- * import vue from '@vitejs/plugin-vue'
  * import { Unhead } from '@unhead/vue/vite'
- *
- * export default defineConfig({
- *   plugins: [vue(), Unhead()],
- * })
+ * export default defineConfig({ plugins: [...Unhead({ streaming: true })] })
  * ```
  */
-declare function Unhead(options?: UnheadVueViteOptions): Plugin[];
+declare function Unhead(options?: UnheadVueOptions): Plugin[];
 
 export { Unhead };
 export type { UnheadVueViteOptions };

package/dist/vite.d.ts

@@ -1,33 +1,22 @@
-import { VitePluginOptions } from '@unhead/bundler/vite';
-import { StreamingPluginOptions } from 'unhead/stream/vite';
 import { Plugin } from 'vite';
+import { UnheadVueOptions } from './bundler.js';
+import '@unhead/bundler/framework';
+import './shared/vue.B_EhRTsW.js';
+import 'unplugin';
+import 'unhead/stream/unplugin';
 
-interface UnheadVueViteOptions extends VitePluginOptions {
-    /**
-     * Enable streaming SSR support.
-     * Set to `true` or a config object to enable.
-     * @default false
-     */
-    streaming?: true | Pick<StreamingPluginOptions, 'mode'> | false;
-}
+type UnheadVueViteOptions = UnheadVueOptions;
 /**
- * Unified Vite plugin for `@unhead/vue`.
- *
- * Combines build optimizations (tree-shaking, useSeoMeta transform, minification)
- * with streaming SSR support into a single plugin.
+ * Vite plugin for `@unhead/vue`. Kept for backwards compatibility; prefer
+ * the unified `@unhead/vue/bundler` entry which dispatches to all bundlers.
  *
  * @example
  * ```ts
- * // vite.config.ts
- * import vue from '@vitejs/plugin-vue'
  * import { Unhead } from '@unhead/vue/vite'
- *
- * export default defineConfig({
- *   plugins: [vue(), Unhead()],
- * })
+ * export default defineConfig({ plugins: [...Unhead({ streaming: true })] })
  * ```
  */
-declare function Unhead(options?: UnheadVueViteOptions): Plugin[];
+declare function Unhead(options?: UnheadVueOptions): Plugin[];
 
 export { Unhead };
 export type { UnheadVueViteOptions };

package/dist/vite.mjs

@@ -1,16 +1,11 @@
-import { Unhead as Unhead$1 } from '@unhead/bundler/vite';
-import unheadVuePlugin from './stream/vite.mjs';
-import 'magic-string';
-import 'oxc-walker';
-import 'unhead/stream/vite';
+import { Unhead as Unhead$1 } from './bundler.mjs';
+import '@unhead/bundler/framework';
+import './shared/vue.D3FlIlye.mjs';
+import 'unhead/stream/unplugin';
+import 'unplugin';
 
 function Unhead(options = {}) {
-  const plugins = [...Unhead$1({ ...options, _framework: "@unhead/vue" })];
-  if (options.streaming) {
-    const streamingOpts = typeof options.streaming === "object" ? options.streaming : void 0;
-    plugins.push(unheadVuePlugin(streamingOpts));
-  }
-  return plugins;
+  return Unhead$1(options).vite();
 }
 
 export { Unhead };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unhead/vue",
   "type": "module",
-  "version": "3.0.4",
+  "version": "3.1.0",
   "description": "Full-stack <head> manager built for Vue.",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
@@ -61,6 +61,10 @@
       "types": "./dist/scripts.d.ts",
       "default": "./dist/scripts.mjs"
     },
+    "./bundler": {
+      "types": "./dist/bundler.d.ts",
+      "default": "./dist/bundler.mjs"
+    },
     "./vite": {
       "types": "./dist/vite.d.ts",
       "default": "./dist/vite.mjs"
@@ -110,6 +114,9 @@
       "scripts": [
         "dist/scripts"
       ],
+      "bundler": [
+        "dist/bundler"
+      ],
       "vite": [
         "dist/vite"
       ],
@@ -130,11 +137,15 @@
   ],
   "peerDependencies": {
     "vite": ">=6.4.2",
-    "vue": ">=3.5.18"
+    "vue": ">=3.5.18",
+    "webpack": ">=5.0.0"
   },
   "peerDependenciesMeta": {
     "vite": {
       "optional": true
+    },
+    "webpack": {
+      "optional": true
     }
   },
   "build": {
@@ -143,17 +154,15 @@
     ]
   },
   "dependencies": {
-    "hookable": "^6.1.0",
-    "magic-string": "^0.30.21",
-    "oxc-parser": "^0.125.0",
-    "oxc-walker": "^0.7.0",
-    "@unhead/bundler": "3.0.4",
-    "unhead": "3.0.4"
+    "hookable": "^6.1.1",
+    "unplugin": "^3.0.0",
+    "@unhead/bundler": "3.1.0",
+    "unhead": "3.1.0"
   },
   "devDependencies": {
-    "@vue/server-renderer": "^3.5.32",
-    "vite": "^8.0.8",
-    "vue": "^3.5.32"
+    "@vue/server-renderer": "^3.5.33",
+    "vite": "^8.0.10",
+    "vue": "^3.5.33"
   },
   "scripts": {
     "build": "unbuild",