@vizejs/vite-plugin 0.428.1 → 0.429.1

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as VizeInspectorLintPlanProvider, c as VizeCompatibilityOptions, d as LoadConfigOptions, f as ResolvedVizeConfig, i as VizeVueFeatures, l as VizeVueVersion, m as UserConfigExport, n as CompiledModule, o as VizeInspectorLintPlanRequest, r as MacroArtifact, s as VizeInspectorOptions, t as VizeOptions, u as ConfigEnv, y as VizeConfig } from "./types-BSmJ5UMW.mjs";
+import { a as VizeInspectorLintPlanProvider, c as VizeCompatibilityOptions, d as LoadConfigOptions, f as ResolvedVizeConfig, i as VizeVueFeatures, l as VizeVueVersion, m as UserConfigExport, n as CompiledModule, o as VizeInspectorLintPlanRequest, r as MacroArtifact, s as VizeInspectorOptions, t as VizeOptions, u as ConfigEnv, y as VizeConfig } from "./types-CwtUr1uY.mjs";
 import { Plugin } from "vite";
 
 //#region src/virtual.d.ts

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as rewriteStaticAssetUrls, t as vize } from "./plugin-CkmrBDhz.mjs";
+import { n as rewriteStaticAssetUrls, t as vize } from "./plugin-DfwtlJyA.mjs";
 import { a as vizeConfigStore, i as resolveConfigExport, n as defineConfig, r as loadConfig, t as VIZE_CONFIG_FILE_ENV } from "./config-PP6EAmWc.mjs";
 //#region src/index.ts
 const __internal = { rewriteStaticAssetUrls };

package/dist/internal/config-bridge.d.mts

@@ -1,4 +1,4 @@
-import { f as ResolvedVizeConfig } from "../types-BSmJ5UMW.mjs";
+import { f as ResolvedVizeConfig } from "../types-CwtUr1uY.mjs";
 import { ResolvedConfig } from "vite";
 
 //#region src/internal/config-bridge.d.ts

package/dist/plugin-Cxx-XPU9.mjs

@@ -0,0 +1,2 @@
+import { t as vize } from "./plugin-DfwtlJyA.mjs";
+export { vize };

package/dist/{plugin-CkmrBDhz.mjs → plugin-DfwtlJyA.mjs}

@@ -232,7 +232,7 @@ function insertBeforeSfcMainDefaultExport(code, insertion, options = {}) {
 	return `${code.slice(0, exportStart)}${insertion}\n${code.slice(exportStart)}`;
 }
 //#endregion
-//#region src/utils/source-map.ts
+//#region ../shared/source-map.ts
 function isSourceMapV3(value) {
 	if (value === null || typeof value !== "object") return false;
 	const map = value;
@@ -279,6 +279,59 @@ function shiftMappedLines(map, atLine, count) {
 		mappings: shifted.join(";")
 	};
 }
+/** Prefix a native JSX module with unmapped generated whole lines.
+* The actual style injection supplies the prefix; authored UTF-16 columns are
+* unchanged because the module resumes at column zero on a new generated line.
+*/
+function prependMappedJsxCode(code, mapJson, prefix) {
+	const output = prefix + code;
+	if (!prefix) return {
+		code: output,
+		map: mapJson ?? null
+	};
+	const map = parseSourceMap(mapJson);
+	if (!map || !prefix.endsWith("\n")) return {
+		code: output,
+		map: null
+	};
+	return {
+		code: output,
+		map: JSON.stringify(shiftMappedLines(map, 0, countNewlines(prefix)))
+	};
+}
+//#endregion
+//#region src/utils/source-map.ts
+/**
+* Keeping the compiler's Source Map v3 document valid through the edits
+* `generateOutput` makes to the emitted module (#3399).
+*
+* The native compiler returns a map for the module it emitted. `generateOutput`
+* then rewrites that module: it prepends a `<style>` injection, splices style
+* imports in after the last static import, inserts CSS-module wiring before the
+* default export, rewrites `export default` to `const _sfc_main =`, and appends
+* `__scopeId`/HMR code. All of those are whole-line insertions or same-line
+* substitutions, which is exactly the class of edit a v3 `mappings` string can
+* absorb without being decoded:
+*
+* - Lines are separated by `;` and each line's segments by `,`.
+* - A segment's generated column is relative to the previous segment **on the
+*   same line** and resets at every line, so an inserted line never disturbs the
+*   columns after it.
+* - The source index/line/column fields are relative to the previous *segment*,
+*   not the previous line, so inserting empty lines between segments leaves
+*   every delta untouched.
+*
+* Shifting generated lines is therefore literally inserting `;` characters, with
+* no VLQ decoding and no chance of a rounding error.
+*
+* Rather than have every call site declare where its edit landed — which would
+* silently rot the first time an edit moves — {@link MappedModule.edit} derives
+* it from the two strings: the common prefix and suffix bound the changed span
+* exactly, and the change in newline count inside that span is the line shift.
+* A same-line substitution comes out as a zero shift (columns within a line are
+* not tracked; a frame still resolves to the right authored line), and an edit
+* that *removes* lines drops the map rather than emit one that is wrong.
+*/
 /**
 * A module's code and the map that describes it, edited together.
 *
@@ -315,6 +368,31 @@ var MappedModule = class {
 	}
 };
 //#endregion
+//#region src/plugin/style-request.ts
+const STYLE_MARKER = ".__vize_style_";
+/** Keep the CSS extension in the path, outside Vue/Nuxt's query metadata. */
+function createStyleVirtualId(id) {
+	const start = id.indexOf("?");
+	const filename = id.slice(0, start);
+	const params = new URLSearchParams(id.slice(start + 1));
+	if (params.has("vize-file") && filename.includes(STYLE_MARKER)) return `${params.get("vize-file") ?? ""}${filename.slice(filename.lastIndexOf(STYLE_MARKER))}?${id.slice(start + 1).replaceAll(".", "%2E")}`;
+	const index = params.get("index") ?? "0";
+	const lang = params.get("lang") || "css";
+	const suffix = params.has("module") ? `.module.${lang}` : `.${lang}`;
+	const source = params.has("vize-file") ? "" : `&${new URLSearchParams({ "vize-file": filename }).toString().replaceAll(".", "%2E")}`;
+	return `${filename}${STYLE_MARKER}${index}${suffix}?${(id.slice(start + 1) + source).replaceAll(".", "%2E")}`;
+}
+/** Recover the authored SFC before native classification and cache lookup. */
+function normalizeStyleVirtualId(id) {
+	const withoutPrefix = id.startsWith("\0") ? id.slice(1) : id;
+	if (!withoutPrefix.includes("?vue")) return id;
+	const start = withoutPrefix.indexOf("?");
+	const query = withoutPrefix.slice(start + 1);
+	const source = new URLSearchParams(query).get("vize-file");
+	if (source && withoutPrefix.slice(0, start).includes(STYLE_MARKER)) return `${source}?${query}`;
+	return withoutPrefix.replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
+}
+//#endregion
 //#region src/utils/css.ts
 function scopeCssForPipeline(css, scopeId) {
 	return scopeViteCssForPipeline(css, scopeId);
@@ -450,12 +528,8 @@ function isCssModule(block) {
 function needsCssPipeline(block) {
 	return block.content.includes("@apply");
 }
-function styleVirtualSuffix(block) {
-	const lang = block.lang ?? "css";
-	return block.module !== false ? `.module.${lang}` : `.${lang}`;
-}
-function createStyleImportUrl(filePath, params, block) {
-	return `${filePath}?${params.toString()}${styleVirtualSuffix(block)}`;
+function createStyleImportUrl(filePath, params) {
+	return createStyleVirtualId(`${filePath}?${params.toString()}`);
 }
 /**
 * Check if any style blocks in the compiled module require delegation to
@@ -586,16 +660,16 @@ function generateOutputWithMap(compiled, options) {
 				if (isCssModule(block)) throw new Error("<style module> is not supported in custom element mode");
 				params.set("inline", "");
 				const bindingName = `_style_${block.index}`;
-				const importUrl = createStyleImportUrl(filePath, params, block);
+				const importUrl = createStyleImportUrl(filePath, params);
 				styleImports.push(`import ${bindingName} from ${JSON.stringify(importUrl)};`);
 				customElementStyleBindings.push(bindingName);
 			} else if (isCssModule(block)) {
 				const bindingName = typeof block.module === "string" ? block.module : "$style";
 				params.set("module", typeof block.module === "string" ? block.module : "");
-				const importUrl = createStyleImportUrl(filePath, params, block);
+				const importUrl = createStyleImportUrl(filePath, params);
 				cssModuleImports.push(`import ${bindingName} from ${JSON.stringify(importUrl)};`);
 			} else {
-				const importUrl = createStyleImportUrl(filePath, params, block);
+				const importUrl = createStyleImportUrl(filePath, params);
 				styleImports.push(`import ${JSON.stringify(importUrl)};`);
 			}
 		}
@@ -636,26 +710,26 @@ function isVizeSsrVirtual(id) {
 function toVirtualId(realPath, ssr = false) {
 	return createViteVirtualId(realPath, ssr);
 }
-function toPluginVisibleVirtualId(realPath, ssr = false, querySuffix = "") {
+function toPluginVisibleVirtualId(realPath, _ssr = false, querySuffix = "") {
 	const params = new URLSearchParams(querySuffix.startsWith("?") ? querySuffix.slice(1) : "");
 	params.delete("vue");
 	params.delete("vize");
 	params.delete("vize-ssr");
 	const rest = params.toString();
-	return `${realPath}.ts?vue&${ssr ? "vize-ssr" : "vize"}${rest ? `&${rest}` : ""}`;
+	return `${realPath}?vue&vize${rest ? `&${rest}` : ""}`;
 }
 /**
 * String pre-gate for {@link fromPluginVisibleVirtualId}, so ordinary module IDs
 * never cross the native boundary (#3427).
 *
-* A non-null result requires `request.path` to end with `.vue.ts` or `.vue.tsx`
+* A non-null result requires `request.path` to end with `.vue`, `.vue.ts` or `.vue.tsx`
 * and `request.querySuffix` to be non-empty. `request.path` is `id` up to the
 * first `?` and `querySuffix` is non-empty exactly when that `?` exists, so both
 * conditions imply these two substring tests. The tests are strictly weaker, so
 * everything the old code accepted still reaches the classifier.
 */
 function mayBePluginVisibleVirtualId(id) {
-	return !id.startsWith("\0") && id.includes(".vue.ts") && id.includes("?");
+	return !id.startsWith("\0") && id.includes(".vue") && id.includes("?");
 }
 function fromPluginVisibleVirtualId(id) {
 	if (!mayBePluginVisibleVirtualId(id)) return null;
@@ -679,7 +753,7 @@ function stripFsPrefix(path) {
 	return path.startsWith("/@fs") ? path.slice(4) : path;
 }
 function isPluginVisibleVueVirtualPath(path) {
-	return path.endsWith(".vue.ts") || path.endsWith(".vue.tsx");
+	return path.endsWith(".vue") || path.endsWith(".vue.ts") || path.endsWith(".vue.tsx");
 }
 function stripPluginVisibleVueVirtualSuffix(path) {
 	if (path.endsWith(".vue.tsx")) return path.slice(0, -4);
@@ -1156,8 +1230,7 @@ function compileJsxModule(filePath, source, options = {}) {
 	let map = result.map ?? null;
 	if (css && !options.ssr) {
 		const styleKey = result.scopedStyles[0].scopeId.replace(/^data-v-/, "");
-		code = prependInlineStyleInjection(code, css, styleKey);
-		map = null;
+		({code, map} = prependMappedJsxCode(code, map, prependInlineStyleInjection("", css, styleKey)));
 	}
 	return {
 		code,
@@ -2320,7 +2393,7 @@ function nativeCssAliasRules(state) {
 	return state.cssAliasRules.length === 0 ? EMPTY_NATIVE_ALIAS_RULES : state.cssAliasRules.map(toNativeCssAliasRule);
 }
 function isPotentialVizeResolveId(id) {
-	return id.startsWith("\0") || id.startsWith("vize:") || id.startsWith("/@fs") || isProjectVueRuntimeRequest(id) || id === "virtual:vize-styles" || id.endsWith(".vue") || id.includes(".vue?") || /\.vue\.tsx?\?/.test(id) || id.includes("?macro=true") || id.includes("?definePage");
+	return id.startsWith("\0") || id.startsWith("vize:") || id.startsWith("/@fs") || isProjectVueRuntimeRequest(id) || id === "virtual:vize-styles" || id.endsWith(".vue") || /\.vue(?:\?|\.__vize_style_)/.test(id) || /\.vue\.tsx?\?/.test(id) || id.includes("?macro=true") || id.includes("?definePage");
 }
 function classifyImporterRequest(importer) {
 	return importer ? classifyVitePluginRequest(importer) : null;
@@ -2426,7 +2499,7 @@ async function resolveIdHook(ctx, state, id, importer, options) {
 			state.logger.log(`resolveId: skipping vitepress-plugin-llms style import ${id}`);
 			return null;
 		}
-		return `${request.normalizedFsId ?? id}${request.styleVirtualSuffix}`;
+		return createStyleVirtualId(request.normalizedFsId ?? id);
 	}
 	if (isBuild && request.normalizedFsId) return request.normalizedFsId;
 	const isMacroImporter = importerRequest?.isMacroVirtualId ?? false;
@@ -2707,8 +2780,8 @@ const SFC_MAIN_DECLARATION = /\b(?:const|let|var)\s+_sfc_main\s*=/;
 * The key must be the module's path relative to the Vite root with POSIX
 * separators, because that is what the client manifest is keyed on.
 */
-function ssrModuleRegistrationCode(filePath, root, helpers = {}) {
-	const moduleId = JSON.stringify(toManifestModuleId(filePath, root));
+function ssrModuleRegistrationCode(filePath, root, helpers = {}, frameworkRoot) {
+	const moduleId = JSON.stringify(frameworkRoot === void 0 ? toManifestModuleId(filePath, root) : path.relative(frameworkRoot, filePath).replace(/\\/g, "/"));
 	const useSSRContext = helpers.useSSRContext ?? "__vize_useSSRContext";
 	const sfcSetup = helpers.sfcSetup ?? "__vize_sfc_setup";
 	return {
@@ -2752,13 +2825,13 @@ function toManifestModuleId(filePath, root) {
 * a boundary placeholder — have no component object to wrap and are returned
 * untouched.
 */
-function appendSsrModuleRegistration(code, filePath, root, isSsr) {
+function appendSsrModuleRegistration(code, filePath, root, isSsr, frameworkRoot) {
 	if (!isSsr || !SFC_MAIN_DECLARATION.test(code)) return code;
 	if (code.includes(REGISTRATION_MARKER)) return code;
 	const { prologue, epilogue } = ssrModuleRegistrationCode(filePath, root, {
 		useSSRContext: freeIdentifier("__vize_useSSRContext", code),
 		sfcSetup: freeIdentifier("__vize_sfc_setup", code)
-	});
+	}, frameworkRoot);
 	return `${prologue}\n${code}\n${epilogue}`;
 }
 /**
@@ -2774,6 +2847,10 @@ function freeIdentifier(base, code) {
 		if (!new RegExp(`\\b${candidate}\\b`).test(code)) return candidate;
 	}
 }
+/** Keep compiler/config root separate from Nuxt's source-relative manifest IDs. */
+function registerSfcModule(state, code, filePath, isSsr) {
+	return appendSsrModuleRegistration(code, filePath, state.root, isSsr, state.mergedOptions.ssrModuleIdRoot);
+}
 //#endregion
 //#region src/plugin/vite-transform.ts
 function createVirtualTypeScriptTransformer(viteApi) {
@@ -2851,10 +2928,12 @@ async function transformVizeVirtualModule(state, code, realPath, ssr, forceTypeS
 }
 //#endregion
 //#region src/plugin/load-style.ts
-function normalizeStyleVirtualId(id) {
-	const withoutPrefix = id.startsWith("\0") ? id.slice(1) : id;
-	if (!withoutPrefix.includes("?vue")) return id;
-	return withoutPrefix.replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
+/** Nuxt can load an emitted CSS entry before loading its owning SFC. */
+function getCompiledStyleSource(state, realPath, ssr) {
+	const cache = getEnvironmentCache(state, ssr);
+	const compiled = cache.get(realPath) ?? state.cache.get(realPath) ?? state.ssrCache.get(realPath);
+	if (compiled || !shouldLoadCompiledVueSfcPath(state, realPath) || !fs.existsSync(realPath)) return compiled;
+	return compileFile(realPath, cache, getCompileOptionsForRequest(state, ssr));
 }
 //#endregion
 //#region src/plugin/load.ts
@@ -2929,7 +3008,7 @@ function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions)
 	rewritten.edit(rewriteDynamicTemplateImports(rewritten.code, state.dynamicImportAliasRules));
 	rewritten.edit(rewriteStaticAssetUrls(rewritten.code, state.dynamicImportAliasRules));
 	rewritten.edit(rewriteImportMetaGlobBase(rewritten.code, realPath, state.root));
-	rewritten.edit(appendSsrModuleRegistration(rewritten.code, realPath, state.root, isSsr));
+	rewritten.edit(registerSfcModule(state, rewritten.code, realPath, isSsr));
 	return {
 		code: rewritten.code,
 		map: rewritten.map
@@ -2965,7 +3044,7 @@ function loadHook(state, id, loadOptions) {
 		const realPath = sourceRequest.vizeVirtualPath ?? sourceRequest.normalizedFsId ?? sourceRequest.normalizedVuePath ?? styleRequest.path;
 		const lang = styleRequest.styleLang ?? null;
 		const scoped = styleRequest.styleScoped ?? null;
-		const fallbackCompiled = loadOptions?.ssr ? state.ssrCache.get(realPath) ?? state.cache.get(realPath) : state.cache.get(realPath) ?? state.ssrCache.get(realPath);
+		const fallbackCompiled = getCompiledStyleSource(state, realPath, !!loadOptions?.ssr);
 		const blockIndex = styleRequest.styleIndex ?? -1;
 		if (fallbackCompiled?.styles && blockIndex >= 0 && blockIndex < fallbackCompiled.styles.length) {
 			const block = fallbackCompiled.styles[blockIndex];
@@ -3068,7 +3147,7 @@ function transformJsxRequest(state, code, id, options) {
 	};
 }
 async function transformHook(state, code, id, options) {
-	if (!id.startsWith("\0") && !id.includes(".vue.ts") && !isJsxComponentPath(id)) return null;
+	if (!id.startsWith("\0") && !id.includes(".vue") && !isJsxComponentPath(id)) return null;
 	const pluginVisibleVirtualPath = fromPluginVisibleVirtualId(id);
 	const jsxResult = transformJsxRequest(state, code, id, { ssr: options?.ssr });
 	if (jsxResult !== void 0) return jsxResult;
@@ -3094,7 +3173,10 @@ function getVueModuleFileCandidates(vueFile) {
 		toVirtualId(vueFile, true),
 		toPluginVisibleVirtualId(vueFile, true),
 		toPluginVisibleVirtualId(vueFile).split("?")[0],
-		vueFile
+		vueFile,
+		`${vueFile}.ts`,
+		`${vueFile}.ts?vue&vize`,
+		`${vueFile}.ts?vue&vize-ssr`
 	];
 	const viteFsCandidates = candidates.flatMap((candidate) => {
 		const viteFsId = toViteFsFileId(candidate);
@@ -3103,7 +3185,11 @@ function getVueModuleFileCandidates(vueFile) {
 	return unique([...candidates, ...viteFsCandidates]);
 }
 function getStyleModuleFileCandidates(styleId) {
-	return unique([styleId, `${styleId}.css`]);
+	return unique([
+		styleId,
+		`${styleId}.css`,
+		createStyleVirtualId(styleId)
+	]);
 }
 async function collectModulesByFile(server, fileIds) {
 	const modules = /* @__PURE__ */ new Set();
@@ -3370,11 +3456,6 @@ function createVueCompatPlugin(state, options) {
 		}
 	};
 }
-function normalizeVirtualStyleId(id) {
-	const withoutPrefix = id.startsWith("\0") ? id.slice(1) : id;
-	if (!withoutPrefix.includes("?vue")) return id;
-	return withoutPrefix.replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
-}
 /**
 * String pre-gate for {@link transformScopedPreprocessorCss} (#3427).
 *
@@ -3383,15 +3464,15 @@ function normalizeVirtualStyleId(id) {
 * not a style query. The native `isVueStyleQuery` is
 * `query.contains("vue&type=style") || query.contains("vue=&type=style")`, both
 * of which contain `type=style`; the query is a substring of the id, and
-* `normalizeVirtualStyleId` only ever deletes characters, so a normalized id
-* that classifies as a style query implies `type=style` in the raw id.
+* `normalizeVirtualStyleId` preserves the query, so a normalized style id
+* implies `type=style` in the raw id.
 */
 function mayBeVueStyleQuery(id) {
 	return id.includes("type=style");
 }
 function transformScopedPreprocessorCss(code, id) {
 	if (!mayBeVueStyleQuery(id)) return null;
-	const request = classifyVitePluginRequest(normalizeVirtualStyleId(id));
+	const request = classifyVitePluginRequest(normalizeStyleVirtualId(id));
 	if (!request.isVueStyleQuery || !request.styleScoped || !request.styleLang || request.styleLang === "css") return null;
 	return scopeCssForPipeline(code, request.styleScoped);
 }
@@ -3939,6 +4020,10 @@ function resolveCompatibilityOptions(options, compilerConfig = {}) {
 function aliasSortKey(find) {
 	return typeof find === "string" ? find.length : find.source.length;
 }
+/** Vite 8 supplies SSR identity through the environment instead of hook arguments. */
+function resolveHookSsr(context, options) {
+	return options?.ssr ?? (context.environment?.name === "ssr" || context.environment?.name === "server");
+}
 //#endregion
 //#region src/plugin/index.ts
 function vize(options = {}) {
@@ -4083,16 +4168,23 @@ function vize(options = {}) {
 				state.logger.log("Cache keys:", [...state.cache.keys()].slice(0, 3));
 			},
 			resolveId(id, importer, options) {
-				return resolveIdHook(this, state, id, importer, options);
+				return resolveIdHook(this, state, id, importer, {
+					...options,
+					ssr: resolveHookSsr(this, options)
+				});
 			},
 			load(id, loadOptions) {
 				return loadHook(state, id, {
 					...loadOptions,
+					ssr: resolveHookSsr(this, loadOptions),
 					addWatchFile: this.addWatchFile.bind(this)
 				});
 			},
 			async transform(code, id, transformOptions) {
-				return transformHook(state, code, id, transformOptions);
+				return transformHook(state, code, id, {
+					...transformOptions,
+					ssr: resolveHookSsr(this, transformOptions)
+				});
 			},
 			async hotUpdate(options) {
 				return handleHotUpdateEnvironmentHook(state, this.environment, options);

package/dist/{types-BSmJ5UMW.d.mts → types-CwtUr1uY.d.mts}

@@ -1158,11 +1158,10 @@ interface VizeOptions extends ExperimentalPluginOptions {
   templateSyntax?: "standard" | "strict" | "quirks";
   /** Vue whitespace strategy, or Vize's narrow Vue 2 line-break migration mode. @default "condense" */
   whitespace?: "condense" | "preserve" | "vue2-line-breaks";
-  /**
-   * Root directory to scan for .vue files
-   * @default Vite's root
-   */
+  /** Root directory to scan for .vue files; defaults to Vite's root. */
   root?: string;
+  /** Framework manifest root; registers relative IDs, including external SFCs. */
+  ssrModuleIdRoot?: string;
   /**
    * Glob patterns to scan for .vue files during pre-compilation
    * Use an empty array to disable startup pre-compilation and compile on demand.

package/dist/vite-plus.d.mts

@@ -1,4 +1,4 @@
-import { _ as LinterConfig, g as FormatterConfig, h as CompilerConfig, m as UserConfigExport, p as UserConfig$1, t as VizeOptions, v as TypeCheckerConfig } from "./types-BSmJ5UMW.mjs";
+import { _ as LinterConfig, g as FormatterConfig, h as CompilerConfig, m as UserConfigExport, p as UserConfig$1, t as VizeOptions, v as TypeCheckerConfig } from "./types-CwtUr1uY.mjs";
 import { ConfigEnv, UserConfig, defineConfig as defineConfig$1 } from "vite-plus";
 
 //#region src/vite-plus/types.d.ts

package/dist/vite-plus.mjs

@@ -321,7 +321,7 @@ function defineConfig(config = {}, integration = {}) {
 		const { options } = metadata;
 		const plugins = compiler === false ? [...vp.plugins ?? []] : await withoutVueCompiler(vp.plugins ?? []);
 		if (compiler !== false) {
-			const { vize } = await import("./plugin-BZN9h1bb.mjs");
+			const { vize } = await import("./plugin-Cxx-XPU9.mjs");
 			plugins.unshift(vize({
 				...compiler,
 				configMode: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.428.1",
+  "version": "0.429.1",
   "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
   "keywords": [
     "compiler",
@@ -51,18 +51,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@vizejs/native": "0.428.1",
-    "@vizejs/unplugin": "0.428.1",
+    "@vizejs/native": "0.429.1",
+    "@vizejs/unplugin": "0.429.1",
     "jsonc-parser": "^3.3.1",
     "oxc-parser": "0.144.0",
     "tinyglobby": "0.2.17",
-    "vize": "0.428.1"
+    "vize": "0.429.1"
   },
   "devDependencies": {
     "@types/node": "25.9.2",
     "typescript": "6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.1.24",
-    "vite-plus": "^0.2.3"
+    "vite-plus": "^0.2.3",
+    "vue": "3.5.35"
   },
   "peerDependencies": {
     "vite": "^7.3.0 || ^8.0.0",

package/dist/plugin-BZN9h1bb.mjs

@@ -1,2 +0,0 @@
-import { t as vize } from "./plugin-CkmrBDhz.mjs";
-export { vize };