@vizejs/vite-plugin 0.58.0 → 0.59.0

package/dist/index.mjs

@@ -0,0 +1,1265 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { CONFIG_FILE_NAMES, defineConfig, loadConfig } from "vize";
+import { glob } from "tinyglobby";
+import * as native from "@vizejs/native";
+import { pathToFileURL } from "node:url";
+import { transformWithOxc } from "vite";
+//#region src/hmr.ts
+function didHashChange(prevHash, nextHash) {
+	return prevHash !== nextHash;
+}
+function hasHmrChanges(prev, next) {
+	if (!prev) return true;
+	return didHashChange(prev.scriptHash, next.scriptHash) || didHashChange(prev.templateHash, next.templateHash) || didHashChange(prev.styleHash, next.styleHash);
+}
+/**
+* Detect the type of HMR update needed based on content hash changes.
+*
+* @param prev - Previously compiled module (undefined if first compile)
+* @param next - Newly compiled module
+* @returns The type of HMR update needed
+*/
+function detectHmrUpdateType(prev, next) {
+	if (!prev) return "full-reload";
+	if (didHashChange(prev.scriptHash, next.scriptHash)) return "full-reload";
+	const templateChanged = didHashChange(prev.templateHash, next.templateHash);
+	if (didHashChange(prev.styleHash, next.styleHash) && !templateChanged) return "style-only";
+	if (templateChanged) return "template-only";
+	return "full-reload";
+}
+/**
+* Generate HMR-aware code output based on update type.
+*/
+function generateHmrCode(scopeId, updateType) {
+	return `
+if (import.meta.hot) {
+  _sfc_main.__hmrId = ${JSON.stringify(scopeId)};
+  _sfc_main.__hmrUpdateType = ${JSON.stringify(updateType)};
+
+  import.meta.hot.accept((mod) => {
+    if (!mod) return;
+    const { default: updated } = mod;
+    if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+      const updateType = updated.__hmrUpdateType || 'full-reload';
+      if (updateType === 'template-only') {
+        __VUE_HMR_RUNTIME__.rerender(updated.__hmrId, updated.render);
+      } else {
+        __VUE_HMR_RUNTIME__.reload(updated.__hmrId, updated);
+      }
+    }
+  });
+
+  import.meta.hot.on('vize:update', (data) => {
+    if (data.id !== _sfc_main.__hmrId) return;
+
+    if (data.type === 'style-only') {
+      // Update styles without remounting component
+      const styleId = 'vize-style-' + _sfc_main.__hmrId;
+      const styleEl = document.getElementById(styleId);
+      if (styleEl && data.css) {
+        styleEl.textContent = data.css;
+      }
+    }
+  });
+
+  if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+    __VUE_HMR_RUNTIME__.createRecord(_sfc_main.__hmrId, _sfc_main);
+  }
+}`;
+}
+//#endregion
+//#region src/utils/css.ts
+/**
+* Resolve CSS @import statements by inlining the imported files,
+* then resolve @custom-media definitions within the combined CSS.
+*
+* This is necessary because Vize embeds CSS as a JS string via
+* document.createElement('style'), bypassing Vite's CSS pipeline.
+*/
+function resolveCssImports(css, importer, aliasRules, isDev, devUrlBase) {
+	const customMedia = /* @__PURE__ */ new Map();
+	const importRegex = /^@import\s+(?:"([^"]+)"|'([^']+)');?\s*$/gm;
+	let result = css;
+	result = result.replace(importRegex, (_match, dqPath, sqPath) => {
+		const importPath = dqPath || sqPath;
+		if (!importPath) return _match;
+		const resolved = resolveCssPath(importPath, importer, aliasRules);
+		if (!resolved || !fs.existsSync(resolved)) return _match;
+		try {
+			const content = fs.readFileSync(resolved, "utf-8");
+			parseCustomMedia(content, customMedia);
+			return content;
+		} catch {
+			return _match;
+		}
+	});
+	parseCustomMedia(result, customMedia);
+	result = result.replace(/^@custom-media\s+[^;]+;\s*$/gm, "");
+	if (customMedia.size > 0) for (const [name, query] of customMedia) {
+		const escaped = name.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+		result = result.replace(new RegExp(`\\(${escaped}\\)`, "g"), query);
+	}
+	if (isDev) result = result.replace(/url\(\s*(["']?)([^"')]+)\1\s*\)/g, (_match, quote, urlPath) => {
+		const trimmed = urlPath.trim();
+		if (trimmed.startsWith("data:") || trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("/@fs/")) return _match;
+		const resolved = resolveCssPath(trimmed, importer, aliasRules);
+		if (resolved && fs.existsSync(resolved)) {
+			const normalized = resolved.replace(/\\/g, "/");
+			const base = devUrlBase ?? "/";
+			return `url("${base.endsWith("/") ? base : base + "/"}@fs${normalized}")`;
+		}
+		return _match;
+	});
+	result = result.replace(/:deep\(([^()]*(?:\([^()]*\))*[^()]*)\)/g, "$1");
+	result = result.replace(/\n{3,}/g, "\n\n");
+	return result;
+}
+function parseCustomMedia(css, map) {
+	const re = /@custom-media\s+(--[\w-]+)\s+(.+?)\s*;/g;
+	let m;
+	while ((m = re.exec(css)) !== null) map.set(m[1], m[2]);
+}
+function resolveCssPath(importPath, importer, aliasRules) {
+	for (const rule of aliasRules) if (importPath.startsWith(rule.find)) {
+		const resolved = importPath.replace(rule.find, rule.replacement);
+		return path.resolve(resolved);
+	}
+	if (importPath.startsWith(".")) {
+		const dir = path.dirname(importer);
+		return path.resolve(dir, importPath);
+	}
+	if (path.isAbsolute(importPath)) return importPath;
+	return null;
+}
+//#endregion
+//#region src/utils/index.ts
+/** Known CSS preprocessor languages that must be delegated to Vite */
+const PREPROCESSOR_LANGS = new Set([
+	"scss",
+	"sass",
+	"less",
+	"stylus",
+	"styl"
+]);
+/** Check if a style block requires Vite's preprocessor pipeline */
+function needsPreprocessor(block) {
+	return block.lang !== null && PREPROCESSOR_LANGS.has(block.lang);
+}
+/** Check if a style block uses CSS Modules */
+function isCssModule(block) {
+	return block.module !== false;
+}
+/**
+* Check if any style blocks in the compiled module require delegation to
+* Vite's CSS pipeline (preprocessor or CSS Modules).
+*/
+function hasDelegatedStyles(compiled) {
+	if (!compiled.styles) return false;
+	return compiled.styles.some((s) => needsPreprocessor(s) || isCssModule(s));
+}
+function supportsTemplateOnlyHmr(output) {
+	return /(?:^|\n)(?:_sfc_main|__sfc__)\.render\s*=\s*render\b/m.test(output);
+}
+function generateScopeId(filename) {
+	return createHash("sha256").update(filename).digest("hex").slice(0, 8);
+}
+function createFilter(include, exclude) {
+	const includePatterns = include ? Array.isArray(include) ? include : [include] : [/\.vue$/];
+	const excludePatterns = exclude ? Array.isArray(exclude) ? exclude : [exclude] : [/node_modules/];
+	return (id) => {
+		const matchInclude = includePatterns.some((pattern) => typeof pattern === "string" ? id.includes(pattern) : pattern.test(id));
+		const matchExclude = excludePatterns.some((pattern) => typeof pattern === "string" ? id.includes(pattern) : pattern.test(id));
+		return matchInclude && !matchExclude;
+	};
+}
+function generateOutput(compiled, options) {
+	const { isProduction, isDev, hmrUpdateType, extractCss, filePath } = options;
+	let output = compiled.code;
+	const exportDefaultRegex = /^export default /m;
+	const hasExportDefault = exportDefaultRegex.test(output);
+	const hasNamedRenderExport = /^export function render\b/m.test(output);
+	const hasNamedSsrRenderExport = /^export function ssrRender\b/m.test(output);
+	const hasSfcMainDefined = /\bconst\s+_sfc_main\s*=/.test(output);
+	if (hasExportDefault && !hasSfcMainDefined) {
+		output = output.replace(exportDefaultRegex, "const _sfc_main = ");
+		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
+		output += "\nexport default _sfc_main;";
+	} else if (hasExportDefault && hasSfcMainDefined) {
+		if (compiled.hasScoped && compiled.scopeId) output = output.replace(/^export default _sfc_main/m, `_sfc_main.__scopeId = "data-v-${compiled.scopeId}";\nexport default _sfc_main`);
+	} else if (!hasExportDefault && !hasSfcMainDefined && hasNamedRenderExport) {
+		output += "\nconst _sfc_main = {};";
+		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
+		output += "\n_sfc_main.render = render;";
+		output += "\nexport default _sfc_main;";
+	} else if (!hasExportDefault && !hasSfcMainDefined && hasNamedSsrRenderExport) {
+		output += "\nconst _sfc_main = {};";
+		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
+		output += "\n_sfc_main.ssrRender = ssrRender;";
+		output += "\nexport default _sfc_main;";
+	}
+	if (hasDelegatedStyles(compiled) && filePath) {
+		const styleImports = [];
+		const cssModuleImports = [];
+		for (const block of compiled.styles) {
+			const lang = block.lang ?? "css";
+			const params = new URLSearchParams();
+			params.set("vue", "");
+			params.set("type", "style");
+			params.set("index", String(block.index));
+			if (block.scoped) params.set("scoped", `data-v-${compiled.scopeId}`);
+			params.set("lang", lang);
+			if (isCssModule(block)) {
+				const bindingName = typeof block.module === "string" ? block.module : "$style";
+				params.set("module", typeof block.module === "string" ? block.module : "");
+				const importUrl = `${filePath}?${params.toString()}`;
+				cssModuleImports.push(`import ${bindingName} from ${JSON.stringify(importUrl)};`);
+			} else {
+				const importUrl = `${filePath}?${params.toString()}`;
+				styleImports.push(`import ${JSON.stringify(importUrl)};`);
+			}
+		}
+		const allImports = [...styleImports, ...cssModuleImports].join("\n");
+		if (allImports) output = allImports + "\n" + output;
+		if (cssModuleImports.length > 0) {
+			const moduleBindings = [];
+			for (const block of compiled.styles) if (isCssModule(block)) {
+				const bindingName = typeof block.module === "string" ? block.module : "$style";
+				moduleBindings.push({
+					name: bindingName,
+					bindingName
+				});
+			}
+			const cssModuleSetup = moduleBindings.map((m) => `_sfc_main.__cssModules = _sfc_main.__cssModules || {};\n_sfc_main.__cssModules[${JSON.stringify(m.name)}] = ${m.bindingName};`).join("\n");
+			output = output.replace(/^export default _sfc_main;/m, `${cssModuleSetup}\nexport default _sfc_main;`);
+		}
+	} else if (compiled.css && !(isProduction && extractCss)) output = `
+export const __vize_css__ = ${JSON.stringify(compiled.css)};
+const __vize_css_id__ = ${JSON.stringify(`vize-style-${compiled.scopeId}`)};
+(function() {
+  if (typeof document !== 'undefined') {
+    let style = document.getElementById(__vize_css_id__);
+    if (!style) {
+      style = document.createElement('style');
+      style.id = __vize_css_id__;
+      style.textContent = __vize_css__;
+      document.head.appendChild(style);
+    } else {
+      style.textContent = __vize_css__;
+    }
+  }
+})();
+${output}`;
+	if (!isProduction && isDev && hasExportDefault) {
+		const effectiveHmrUpdateType = hmrUpdateType === "template-only" && !supportsTemplateOnlyHmr(output) ? "full-reload" : hmrUpdateType ?? "full-reload";
+		output += generateHmrCode(compiled.scopeId, effectiveHmrUpdateType);
+	}
+	return output;
+}
+const VIZE_SSR_PREFIX = "\0vize-ssr:";
+const RESOLVED_CSS_MODULE = "\0vize:all-styles.css";
+/** Check if a module ID is a vize-compiled virtual module */
+function isVizeVirtual(id) {
+	const pathPart = id.startsWith("\0vize-ssr:") ? id.slice(10) : id.slice(1);
+	return id.startsWith("\0") && pathPart.endsWith(".vue.ts");
+}
+function isVizeSsrVirtual(id) {
+	return id.startsWith(VIZE_SSR_PREFIX);
+}
+/** Create a virtual module ID from a real .vue file path */
+function toVirtualId(realPath, ssr = false) {
+	return ssr ? `${VIZE_SSR_PREFIX}${realPath}.ts` : "\0" + realPath + ".ts";
+}
+/** Extract the real .vue file path from a virtual module ID */
+function fromVirtualId(virtualId) {
+	const prefix = isVizeSsrVirtual(virtualId) ? 10 : 1;
+	return virtualId.slice(prefix, -3);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function toBrowserImportPrefix(replacement) {
+	const normalized = replacement.replace(/\\/g, "/");
+	if (normalized.startsWith("/@fs/")) return normalized;
+	if (path.isAbsolute(replacement) && fs.existsSync(replacement)) return `/@fs${normalized}`;
+	return normalized;
+}
+function normalizeFsIdForBuild(id) {
+	const [pathPart, queryPart] = id.split("?");
+	if (!pathPart.startsWith("/@fs/")) return id;
+	const normalizedPath = pathPart.slice(4);
+	return queryPart ? `${normalizedPath}?${queryPart}` : normalizedPath;
+}
+function rewriteDynamicTemplateImports(code, aliasRules) {
+	let rewritten = code;
+	for (const rule of aliasRules) {
+		const pattern = new RegExp(`\\bimport\\s*\\(\\s*\`${escapeRegExp(rule.fromPrefix)}`, "g");
+		rewritten = rewritten.replace(pattern, `import(/* @vite-ignore */ \`${rule.toPrefix}`);
+	}
+	rewritten = rewritten.replace(/\bimport\s*\(\s*`/g, "import(/* @vite-ignore */ `");
+	return rewritten;
+}
+//#endregion
+//#region src/transform.ts
+/**
+* Code transformation utilities for Vize.
+*
+* Handles static asset URL rewriting, Vite define replacements, and
+* provides the debug logger.
+*/
+/**
+* Rewrite static asset URLs in compiled template output.
+*
+* Transforms property values like `src: "@/assets/logo.svg"` into import
+* statements hoisted to the top of the module, so Vite's module resolution
+* pipeline handles alias expansion and asset hashing in both dev and build.
+*/
+const SCRIPT_EXTENSIONS = /\.(js|mjs|cjs|ts|mts|cts|jsx|tsx)$/i;
+function rewriteStaticAssetUrls(code, aliasRules) {
+	let rewritten = code;
+	const imports = [];
+	let counter = 0;
+	for (const rule of aliasRules) {
+		const pattern = new RegExp(`("?src"?\\s*:\\s*)(?:"(${escapeRegExp(rule.fromPrefix)}[^"]+)"|'(${escapeRegExp(rule.fromPrefix)}[^']+)')`, "g");
+		rewritten = rewritten.replace(pattern, (match, prefix, dqPath, sqPath) => {
+			const fullPath = dqPath || sqPath;
+			if (fullPath && SCRIPT_EXTENSIONS.test(fullPath)) return match;
+			const varName = `__vize_static_${counter++}`;
+			imports.push(`import ${varName} from ${JSON.stringify(fullPath)};`);
+			return `${prefix}${varName}`;
+		});
+	}
+	if (imports.length > 0) rewritten = imports.join("\n") + "\n" + rewritten;
+	return rewritten;
+}
+/**
+* Built-in Vite/Vue/Nuxt define keys that are handled by Vite's own transform pipeline.
+* These must NOT be replaced by the vize plugin because:
+* 1. Nuxt runs both client and server Vite builds, each with different values
+*    (e.g., import.meta.server = true on server, false on client).
+* 2. Vite's import.meta transform already handles these correctly per-environment.
+*/
+const BUILTIN_DEFINE_PREFIXES = [
+	"import.meta.server",
+	"import.meta.client",
+	"import.meta.dev",
+	"import.meta.test",
+	"import.meta.prerender",
+	"import.meta.env",
+	"import.meta.hot",
+	"__VUE_",
+	"__NUXT_",
+	"process.env"
+];
+function isBuiltinDefine(key) {
+	return BUILTIN_DEFINE_PREFIXES.some((prefix) => key === prefix || key.startsWith(prefix + ".") || key.startsWith(prefix + "_"));
+}
+/**
+* Apply Vite define replacements to code.
+* Replaces keys like `import.meta.vfFeatures.photoSection` with their values.
+* Uses word-boundary-aware matching to avoid replacing inside strings or partial matches.
+*/
+function applyDefineReplacements(code, defines) {
+	const sortedKeys = Object.keys(defines).sort((a, b) => b.length - a.length);
+	let result = code;
+	for (const key of sortedKeys) {
+		if (!result.includes(key)) continue;
+		const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const re = new RegExp(escaped + "(?![\\w$.])", "g");
+		result = result.replace(re, defines[key]);
+	}
+	return result;
+}
+function createLogger(debug) {
+	return {
+		log: (...args) => debug && console.log("[vize]", ...args),
+		info: (...args) => console.log("[vize]", ...args),
+		warn: (...args) => console.warn("[vize]", ...args),
+		error: (...args) => console.error("[vize]", ...args)
+	};
+}
+[...CONFIG_FILE_NAMES];
+/**
+* Shared config store for inter-plugin communication.
+* Key = project root, Value = resolved VizeConfig.
+* Used by musea() and other plugins to access the unified config.
+*/
+const vizeConfigStore = /* @__PURE__ */ new Map();
+//#endregion
+//#region src/compile-options.ts
+function buildCompileFileOptions(filePath, source, options) {
+	const scopeId = /<style[^>]*\bscoped\b/.test(source) ? `data-v-${generateScopeId(filePath)}` : void 0;
+	return {
+		filename: filePath,
+		sourceMap: options.sourceMap,
+		ssr: options.ssr,
+		vapor: options.vapor,
+		scopeId
+	};
+}
+function buildCompileBatchOptions(options) {
+	return {
+		ssr: options.ssr,
+		vapor: options.vapor
+	};
+}
+//#endregion
+//#region src/compiler.ts
+const { compileSfc, compileSfcBatchWithResults } = native;
+/**
+* Extract style block metadata from a Vue SFC source string.
+* Parses `<style>` tags to determine lang, scoped, and module attributes.
+*/
+function extractStyleBlocks(source) {
+	const blocks = [];
+	const styleRegex = /<style([^>]*)>([\s\S]*?)<\/style>/gi;
+	let match;
+	let index = 0;
+	while ((match = styleRegex.exec(source)) !== null) {
+		const attrs = match[1];
+		const content = match[2];
+		const lang = attrs.match(/\blang=["']([^"']+)["']/)?.[1] ?? null;
+		const scoped = /\bscoped\b/.test(attrs);
+		const moduleMatch = attrs.match(/\bmodule(?:=["']([^"']+)["'])?/);
+		const isModule = moduleMatch ? moduleMatch[1] || true : false;
+		blocks.push({
+			content,
+			lang,
+			scoped,
+			module: isModule,
+			index
+		});
+		index++;
+	}
+	return blocks;
+}
+function compileFile(filePath, cache, options, source) {
+	const content = source ?? fs.readFileSync(filePath, "utf-8");
+	const scopeId = generateScopeId(filePath);
+	const hasScoped = /<style[^>]*\bscoped\b/.test(content);
+	const result = compileSfc(content, buildCompileFileOptions(filePath, content, options));
+	if (result.errors.length > 0) {
+		const errorMsg = result.errors.join("\n");
+		console.error(`[vize] Compilation error in ${filePath}:\n${errorMsg}`);
+	}
+	if (result.warnings.length > 0) result.warnings.forEach((warning) => {
+		console.warn(`[vize] Warning in ${filePath}: ${warning}`);
+	});
+	const styles = extractStyleBlocks(content);
+	const compiled = {
+		code: result.code,
+		css: result.css,
+		scopeId,
+		hasScoped,
+		templateHash: result.templateHash,
+		styleHash: result.styleHash,
+		scriptHash: result.scriptHash,
+		styles
+	};
+	cache.set(filePath, compiled);
+	return compiled;
+}
+/**
+* Batch compile multiple files in parallel using native Rust multithreading.
+* Returns per-file results with content hashes for HMR.
+*/
+function compileBatch(files, cache, options) {
+	const result = compileSfcBatchWithResults(files.map((f) => ({
+		path: f.path,
+		source: f.source
+	})), buildCompileBatchOptions(options));
+	const sourceMap = /* @__PURE__ */ new Map();
+	for (const f of files) sourceMap.set(f.path, f.source);
+	for (const fileResult of result.results) {
+		if (fileResult.errors.length === 0) {
+			const source = sourceMap.get(fileResult.path);
+			const styles = source ? extractStyleBlocks(source) : void 0;
+			cache.set(fileResult.path, {
+				code: fileResult.code,
+				css: fileResult.css,
+				scopeId: fileResult.scopeId,
+				hasScoped: fileResult.hasScoped,
+				templateHash: fileResult.templateHash,
+				styleHash: fileResult.styleHash,
+				scriptHash: fileResult.scriptHash,
+				styles
+			});
+		}
+		if (fileResult.errors.length > 0) console.error(`[vize] Compilation error in ${fileResult.path}:\n${fileResult.errors.join("\n")}`);
+		if (fileResult.warnings.length > 0) fileResult.warnings.forEach((warning) => {
+			console.warn(`[vize] Warning in ${fileResult.path}: ${warning}`);
+		});
+	}
+	return result;
+}
+//#endregion
+//#region src/plugin/state.ts
+function hasFileMetadataChanged(previous, next) {
+	return previous === void 0 || previous.mtimeMs !== next.mtimeMs || previous.size !== next.size;
+}
+function diffPrecompileFiles(files, currentMetadata, previousMetadata) {
+	const changedFiles = [];
+	const seenFiles = new Set(files);
+	for (const file of files) {
+		const metadata = currentMetadata.get(file);
+		if (!metadata || hasFileMetadataChanged(previousMetadata.get(file), metadata)) changedFiles.push(file);
+	}
+	const deletedFiles = [];
+	for (const file of previousMetadata.keys()) if (!seenFiles.has(file)) deletedFiles.push(file);
+	return {
+		changedFiles,
+		deletedFiles
+	};
+}
+function getEnvironmentCache(state, ssr) {
+	return ssr ? state.ssrCache : state.cache;
+}
+function getCompileOptionsForRequest(state, ssr) {
+	return {
+		sourceMap: state.mergedOptions?.sourceMap ?? !state.isProduction,
+		ssr,
+		vapor: !ssr && (state.mergedOptions?.vapor ?? false)
+	};
+}
+/**
+* Pre-compile all Vue files matching scan patterns.
+*/
+async function compileAll(state) {
+	const startTime = performance.now();
+	const files = await glob(state.scanPatterns, {
+		cwd: state.root,
+		ignore: state.ignorePatterns,
+		absolute: true
+	});
+	const currentMetadata = /* @__PURE__ */ new Map();
+	for (const file of files) try {
+		const stat = fs.statSync(file);
+		currentMetadata.set(file, {
+			mtimeMs: stat.mtimeMs,
+			size: stat.size
+		});
+	} catch (e) {
+		state.logger.error(`Failed to stat ${file}:`, e);
+	}
+	const { changedFiles, deletedFiles } = diffPrecompileFiles(files, currentMetadata, state.precompileMetadata);
+	const cachedFileCount = files.length - changedFiles.length;
+	for (const file of deletedFiles) {
+		state.cache.delete(file);
+		state.ssrCache.delete(file);
+		state.collectedCss.delete(file);
+		state.precompileMetadata.delete(file);
+		state.pendingHmrUpdateTypes.delete(file);
+	}
+	state.logger.info(`Pre-compiling ${files.length} Vue files... (${changedFiles.length} changed, ${cachedFileCount} cached, ${deletedFiles.length} removed)`);
+	if (changedFiles.length === 0) {
+		const elapsed = (performance.now() - startTime).toFixed(2);
+		state.logger.info(`Pre-compilation complete: cache reused (${elapsed}ms)`);
+		return;
+	}
+	const fileContents = [];
+	for (const file of changedFiles) try {
+		const source = fs.readFileSync(file, "utf-8");
+		fileContents.push({
+			path: file,
+			source
+		});
+	} catch (e) {
+		state.logger.error(`Failed to read ${file}:`, e);
+	}
+	const result = compileBatch(fileContents, state.cache, {
+		ssr: false,
+		vapor: state.mergedOptions.vapor ?? false
+	});
+	for (const file of changedFiles) {
+		state.collectedCss.delete(file);
+		state.pendingHmrUpdateTypes.delete(file);
+	}
+	for (const fileResult of result.results) {
+		const metadata = currentMetadata.get(fileResult.path);
+		if (fileResult.errors.length > 0) {
+			state.cache.delete(fileResult.path);
+			state.collectedCss.delete(fileResult.path);
+			state.precompileMetadata.delete(fileResult.path);
+			continue;
+		}
+		if (metadata) state.precompileMetadata.set(fileResult.path, metadata);
+		if (state.isProduction && fileResult.css) {
+			const cached = state.cache.get(fileResult.path);
+			if (cached && !hasDelegatedStyles(cached)) state.collectedCss.set(fileResult.path, resolveCssImports(fileResult.css, fileResult.path, state.cssAliasRules, false));
+		}
+	}
+	const elapsed = (performance.now() - startTime).toFixed(2);
+	state.logger.info(`Pre-compilation complete: ${result.successCount} recompiled, ${cachedFileCount} reused, ${result.failedCount} failed (${elapsed}ms, native batch: ${result.timeMs.toFixed(2)}ms)`);
+}
+//#endregion
+//#region src/plugin/resolve.ts
+function resolveVuePath(state, id, importer) {
+	let resolved;
+	if (id.startsWith("/@fs/")) resolved = id.slice(4);
+	else if (id.startsWith("/") && !fs.existsSync(id)) resolved = path.resolve(state.root, id.slice(1));
+	else if (path.isAbsolute(id)) resolved = id;
+	else if (importer) {
+		const realImporter = isVizeVirtual(importer) ? fromVirtualId(importer) : importer;
+		resolved = path.resolve(path.dirname(realImporter), id);
+	} else resolved = path.resolve(state.root, id);
+	if (!path.isAbsolute(resolved)) resolved = path.resolve(state.root, resolved);
+	return path.normalize(resolved);
+}
+function normalizeRequireBase(importer) {
+	if (!importer) return null;
+	let normalized = importer;
+	if (isVizeVirtual(normalized)) normalized = fromVirtualId(normalized);
+	else if (normalized.startsWith("\0") && normalized.endsWith("?macro=true")) normalized = normalized.slice(1).replace("?macro=true", "");
+	return normalized.split("?")[0] ?? null;
+}
+function resolveBareImportWithNode(state, id, importer) {
+	const [request, queryPart] = id.split("?");
+	const querySuffix = queryPart ? `?${queryPart}` : "";
+	const candidates = [normalizeRequireBase(importer), path.join(state.root, "package.json")].filter((candidate) => candidate != null);
+	const seen = /* @__PURE__ */ new Set();
+	for (const candidate of candidates) {
+		if (seen.has(candidate)) continue;
+		seen.add(candidate);
+		try {
+			return `${createRequire(candidate).resolve(request)}${querySuffix}`;
+		} catch {}
+	}
+	return null;
+}
+async function resolveIdHook(ctx, state, id, importer, options) {
+	const isBuild = state.server === null;
+	const isSsrRequest = !!options?.ssr || (importer ? isVizeSsrVirtual(importer) : false);
+	if (id.startsWith("\0")) {
+		if (isVizeVirtual(id)) {
+			if (isSsrRequest && !isVizeSsrVirtual(id)) return toVirtualId(fromVirtualId(id), true);
+			return null;
+		}
+		if (id.startsWith("\0vize:")) {
+			const rawPath = id.slice(6);
+			const cleanPath = rawPath.endsWith(".ts") ? rawPath.slice(0, -3) : rawPath;
+			if (!cleanPath.endsWith(".vue")) {
+				state.logger.log(`resolveId: redirecting legacy virtual ID to ${cleanPath}`);
+				return cleanPath;
+			}
+		}
+		const cleanPath = id.slice(1);
+		if (cleanPath.startsWith("/") && !cleanPath.endsWith(".vue.ts")) {
+			const [pathPart, queryPart] = cleanPath.split("?");
+			const querySuffix = queryPart ? `?${queryPart}` : "";
+			state.logger.log(`resolveId: redirecting \0-prefixed non-vue ID to ${pathPart}${querySuffix}`);
+			const redirected = pathPart + querySuffix;
+			return isBuild ? normalizeFsIdForBuild(redirected) : redirected;
+		}
+		return null;
+	}
+	if (id.startsWith("vize:")) {
+		let realPath = id.slice(5);
+		if (realPath.endsWith(".ts")) realPath = realPath.slice(0, -3);
+		state.logger.log(`resolveId: redirecting stale vize: ID to ${realPath}`);
+		const resolved = await ctx.resolve(realPath, importer, { skipSelf: true });
+		if (resolved && isBuild && resolved.id.startsWith("/@fs/")) return {
+			...resolved,
+			id: normalizeFsIdForBuild(resolved.id)
+		};
+		return resolved;
+	}
+	if (id === "virtual:vize-styles") return RESOLVED_CSS_MODULE;
+	if (isBuild && id.startsWith("/@fs/")) return normalizeFsIdForBuild(id);
+	if (id.includes("?macro=true")) {
+		const filePath = id.split("?")[0];
+		const resolved = resolveVuePath(state, filePath, importer);
+		if (resolved && fs.existsSync(resolved)) return `\0${resolved}?macro=true`;
+	}
+	if (id.includes("?vue&type=style") || id.includes("?vue=&type=style")) {
+		const params = new URLSearchParams(id.split("?")[1]);
+		const lang = params.get("lang") || "css";
+		if (params.has("module")) return `\0${id}.module.${lang}`;
+		return `\0${id}.${lang}`;
+	}
+	const isMacroImporter = importer?.startsWith("\0") && importer?.endsWith("?macro=true");
+	if (importer && (isVizeVirtual(importer) || isMacroImporter)) {
+		const cleanImporter = isMacroImporter ? importer.slice(1).replace("?macro=true", "") : fromVirtualId(importer);
+		state.logger.log(`resolveId from virtual: id=${id}, cleanImporter=${cleanImporter}`);
+		if (id.startsWith("#")) try {
+			return await ctx.resolve(id, cleanImporter, { skipSelf: true });
+		} catch {
+			return null;
+		}
+		if (!id.endsWith(".vue")) {
+			if (!id.startsWith("./") && !id.startsWith("../") && !id.startsWith("/")) {
+				if (!state.cssAliasRules.some((rule) => id === rule.find || id.startsWith(rule.find + "/"))) {
+					try {
+						const resolved = await ctx.resolve(id, cleanImporter, { skipSelf: true });
+						if (resolved) {
+							state.logger.log(`resolveId: resolved bare ${id} to ${resolved.id} via Vite resolver`);
+							if (isBuild && resolved.id.startsWith("/@fs/")) return {
+								...resolved,
+								id: normalizeFsIdForBuild(resolved.id)
+							};
+							return resolved;
+						}
+					} catch {}
+					const nodeResolved = resolveBareImportWithNode(state, id, cleanImporter);
+					if (nodeResolved) {
+						state.logger.log(`resolveId: resolved bare ${id} to ${nodeResolved} via Node fallback`);
+						return nodeResolved;
+					}
+				}
+				return null;
+			}
+			try {
+				const resolved = await ctx.resolve(id, cleanImporter, { skipSelf: true });
+				if (resolved) {
+					state.logger.log(`resolveId: resolved ${id} to ${resolved.id} via Vite resolver`);
+					if (isBuild && resolved.id.startsWith("/@fs/")) return {
+						...resolved,
+						id: normalizeFsIdForBuild(resolved.id)
+					};
+					return resolved;
+				}
+			} catch {}
+			if (id.startsWith("./") || id.startsWith("../")) {
+				const [pathPart, queryPart] = id.split("?");
+				const querySuffix = queryPart ? `?${queryPart}` : "";
+				const resolved = path.resolve(path.dirname(cleanImporter), pathPart);
+				for (const ext of [
+					"",
+					".ts",
+					".tsx",
+					".js",
+					".jsx",
+					".json"
+				]) {
+					const candidate = resolved + ext;
+					if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+						const finalPath = candidate + querySuffix;
+						state.logger.log(`resolveId: resolved relative ${id} to ${finalPath}`);
+						return finalPath;
+					}
+				}
+				if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) for (const indexFile of [
+					"/index.ts",
+					"/index.tsx",
+					"/index.js",
+					"/index.jsx"
+				]) {
+					const candidate = resolved + indexFile;
+					if (fs.existsSync(candidate)) {
+						const finalPath = candidate + querySuffix;
+						state.logger.log(`resolveId: resolved directory ${id} to ${finalPath}`);
+						return finalPath;
+					}
+				}
+			}
+			return null;
+		}
+	}
+	if (id.endsWith(".vue")) {
+		const handleNodeModules = state.initialized ? state.mergedOptions.handleNodeModulesVue ?? true : true;
+		if (!handleNodeModules && id.includes("node_modules")) {
+			state.logger.log(`resolveId: skipping node_modules import ${id}`);
+			return null;
+		}
+		const resolved = resolveVuePath(state, id, importer);
+		const isNodeModulesPath = resolved.includes("node_modules");
+		if (!handleNodeModules && isNodeModulesPath) {
+			state.logger.log(`resolveId: skipping node_modules path ${resolved}`);
+			return null;
+		}
+		if (state.filter && !isNodeModulesPath && !state.filter(resolved)) {
+			state.logger.log(`resolveId: skipping filtered path ${resolved}`);
+			return null;
+		}
+		const hasCache = state.cache.has(resolved);
+		const fileExists = fs.existsSync(resolved);
+		state.logger.log(`resolveId: id=${id}, resolved=${resolved}, hasCache=${hasCache}, fileExists=${fileExists}, importer=${importer ?? "none"}`);
+		if (hasCache || fileExists) return toVirtualId(resolved, isSsrRequest);
+		if (!fileExists && !path.isAbsolute(id)) {
+			const viteResolved = await ctx.resolve(id, importer, { skipSelf: true });
+			if (viteResolved && viteResolved.id.endsWith(".vue")) {
+				const realPath = viteResolved.id;
+				if ((realPath.includes("node_modules") ? handleNodeModules : state.filter(realPath)) && (state.cache.has(realPath) || fs.existsSync(realPath))) {
+					state.logger.log(`resolveId: resolved via Vite fallback ${id} to ${realPath}`);
+					return toVirtualId(realPath, isSsrRequest);
+				}
+			}
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/plugin/load.ts
+const SERVER_PLACEHOLDER_CODE = `import { createElementBlock, defineComponent } from "vue";
+export default defineComponent({
+  name: "ServerPlaceholder",
+  render() {
+    return createElementBlock("div");
+  }
+});
+`;
+function getBoundaryPlaceholderCode(realPath, ssr) {
+	if (ssr && realPath.endsWith(".client.vue")) return SERVER_PLACEHOLDER_CODE;
+	if (!ssr && realPath.endsWith(".server.vue")) return SERVER_PLACEHOLDER_CODE;
+	return null;
+}
+function getOxcDumpPath(root, realPath) {
+	const dumpDir = path.resolve(root || process.cwd(), "__agent_only", "oxc-dumps");
+	fs.mkdirSync(dumpDir, { recursive: true });
+	return path.join(dumpDir, `vize-oxc-error-${path.basename(realPath)}.ts`);
+}
+function loadHook(state, id, loadOptions) {
+	const currentBase = loadOptions?.ssr ? state.serverViteBase : state.clientViteBase;
+	if (id === "\0vize:all-styles.css") return Array.from(state.collectedCss.values()).join("\n\n");
+	let styleId = id;
+	if (id.startsWith("\0") && id.includes("?vue")) styleId = id.slice(1).replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
+	if (styleId.includes("?vue&type=style") || styleId.includes("?vue=&type=style")) {
+		const [filename, queryString] = styleId.split("?");
+		const realPath = isVizeVirtual(filename) ? fromVirtualId(filename) : filename;
+		const params = new URLSearchParams(queryString);
+		const indexStr = params.get("index");
+		const lang = params.get("lang");
+		params.has("module");
+		const scoped = params.get("scoped");
+		const fallbackCompiled = state.cache.get(realPath) ?? state.ssrCache.get(realPath);
+		const blockIndex = indexStr !== null ? parseInt(indexStr, 10) : -1;
+		if (fallbackCompiled?.styles && blockIndex >= 0 && blockIndex < fallbackCompiled.styles.length) {
+			const block = fallbackCompiled.styles[blockIndex];
+			let styleContent = block.content;
+			if (scoped && block.scoped && lang && lang !== "css") {
+				const lines = styleContent.split("\n");
+				const hoisted = [];
+				const body = [];
+				for (const line of lines) {
+					const trimmed = line.trimStart();
+					if (trimmed.startsWith("@use ") || trimmed.startsWith("@forward ") || trimmed.startsWith("@import ")) hoisted.push(line);
+					else body.push(line);
+				}
+				const bodyContent = body.join("\n");
+				styleContent = `${hoisted.length > 0 ? hoisted.join("\n") + "\n\n" : ""}[${scoped}] {\n${bodyContent}\n}`;
+			}
+			return {
+				code: styleContent,
+				map: null
+			};
+		}
+		if (fallbackCompiled?.css) return resolveCssImports(fallbackCompiled.css, realPath, state.cssAliasRules, state.server !== null, currentBase);
+		return "";
+	}
+	if (id.startsWith("\0") && id.endsWith("?macro=true")) {
+		const realPath = id.slice(1).replace("?macro=true", "");
+		if (fs.existsSync(realPath)) {
+			const setupMatch = fs.readFileSync(realPath, "utf-8").match(/<script\s+setup[^>]*>([\s\S]*?)<\/script>/);
+			if (setupMatch) return {
+				code: `${setupMatch[1]}\nexport default {}`,
+				map: null
+			};
+		}
+		return {
+			code: "export default {}",
+			map: null
+		};
+	}
+	if (isVizeVirtual(id)) {
+		const realPath = fromVirtualId(id);
+		const isSsr = isVizeSsrVirtual(id) || !!loadOptions?.ssr;
+		if (!realPath.endsWith(".vue")) {
+			state.logger.log(`load: skipping non-vue virtual module ${realPath}`);
+			return null;
+		}
+		const placeholderCode = getBoundaryPlaceholderCode(realPath, !!loadOptions?.ssr);
+		if (placeholderCode) {
+			state.logger.log(`load: using boundary placeholder for ${realPath}`);
+			return {
+				code: placeholderCode,
+				map: null
+			};
+		}
+		const cache = getEnvironmentCache(state, isSsr);
+		let compiled = cache.get(realPath);
+		if (!compiled && fs.existsSync(realPath)) {
+			state.logger.log(`load: on-demand compiling ${realPath}`);
+			compiled = compileFile(realPath, cache, getCompileOptionsForRequest(state, isSsr));
+		}
+		if (compiled) {
+			const hasDelegated = hasDelegatedStyles(compiled);
+			const pendingHmrUpdateType = loadOptions?.ssr ? void 0 : state.pendingHmrUpdateTypes.get(realPath);
+			if (compiled.css && !hasDelegated) compiled = {
+				...compiled,
+				css: resolveCssImports(compiled.css, realPath, state.cssAliasRules, state.server !== null, currentBase)
+			};
+			const output = rewriteStaticAssetUrls(rewriteDynamicTemplateImports(generateOutput(compiled, {
+				isProduction: state.isProduction,
+				isDev: state.server !== null && !isSsr,
+				hmrUpdateType: pendingHmrUpdateType,
+				extractCss: state.extractCss,
+				filePath: realPath
+			}), state.dynamicImportAliasRules), state.dynamicImportAliasRules);
+			if (!loadOptions?.ssr) state.pendingHmrUpdateTypes.delete(realPath);
+			return {
+				code: output,
+				map: null
+			};
+		}
+	}
+	if (id.startsWith("\0")) {
+		const afterPrefix = id.startsWith("\0vize:") ? id.slice(6) : id.slice(1);
+		if (afterPrefix.includes("?commonjs-")) return null;
+		const [pathPart, queryPart] = afterPrefix.split("?");
+		const querySuffix = queryPart ? `?${queryPart}` : "";
+		const fsPath = pathPart.startsWith("/@fs/") ? pathPart.slice(4) : pathPart;
+		if (fsPath.startsWith("/") && fs.existsSync(fsPath) && fs.statSync(fsPath).isFile()) {
+			const importPath = state.server === null ? `${pathToFileURL(fsPath).href}${querySuffix}` : "/@fs" + fsPath + querySuffix;
+			state.logger.log(`load: proxying \0-prefixed file ${id} -> re-export from ${importPath}`);
+			return `export { default } from ${JSON.stringify(importPath)};\nexport * from ${JSON.stringify(importPath)};`;
+		}
+	}
+	return null;
+}
+async function transformHook(state, code, id, options) {
+	const isMacro = id.startsWith("\0") && id.endsWith("?macro=true");
+	if (isVizeVirtual(id) || isMacro) {
+		const realPath = isMacro ? id.slice(1).replace("?macro=true", "") : fromVirtualId(id);
+		try {
+			const result = await transformWithOxc(code, realPath, { lang: "ts" });
+			const defines = options?.ssr ? state.serverViteDefine : state.clientViteDefine;
+			let transformed = result.code;
+			if (Object.keys(defines).length > 0) transformed = applyDefineReplacements(transformed, defines);
+			return {
+				code: transformed,
+				map: result.map
+			};
+		} catch (e) {
+			state.logger.error(`transformWithOxc failed for ${realPath}:`, e);
+			const dumpPath = getOxcDumpPath(state.root, realPath);
+			fs.writeFileSync(dumpPath, code, "utf-8");
+			state.logger.error(`Dumped failing code to ${dumpPath}`);
+			return {
+				code: "export default {}",
+				map: null
+			};
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/plugin/hmr.ts
+async function handleHotUpdateHook(state, ctx) {
+	const { file, server, read } = ctx;
+	if (file.endsWith(".vue") && state.filter(file)) try {
+		const source = await read();
+		const prevCompiled = state.cache.get(file);
+		compileFile(file, state.cache, getCompileOptionsForRequest(state, false), source);
+		state.ssrCache.delete(file);
+		const newCompiled = state.cache.get(file);
+		try {
+			const stat = fs.statSync(file);
+			state.precompileMetadata.set(file, {
+				mtimeMs: stat.mtimeMs,
+				size: stat.size
+			});
+		} catch {
+			state.precompileMetadata.delete(file);
+		}
+		if (!hasHmrChanges(prevCompiled, newCompiled)) {
+			state.pendingHmrUpdateTypes.delete(file);
+			state.logger.log(`Re-compiled: ${path.relative(state.root, file)} (no-op)`);
+			return [];
+		}
+		const updateType = detectHmrUpdateType(prevCompiled, newCompiled);
+		state.logger.log(`Re-compiled: ${path.relative(state.root, file)} (${updateType})`);
+		const virtualId = toVirtualId(file);
+		const modules = server.moduleGraph.getModulesByFile(virtualId) ?? server.moduleGraph.getModulesByFile(file);
+		const hasDelegated = hasDelegatedStyles(newCompiled);
+		if (hasDelegated && updateType === "style-only") {
+			const affectedModules = /* @__PURE__ */ new Set();
+			for (const block of newCompiled.styles ?? []) {
+				const params = new URLSearchParams();
+				params.set("vue", "");
+				params.set("type", "style");
+				params.set("index", String(block.index));
+				if (block.scoped) params.set("scoped", `data-v-${newCompiled.scopeId}`);
+				params.set("lang", block.lang ?? "css");
+				if (block.module !== false) params.set("module", typeof block.module === "string" ? block.module : "");
+				const styleId = `${file}?${params.toString()}`;
+				const styleMods = server.moduleGraph.getModulesByFile(styleId);
+				if (styleMods) for (const mod of styleMods) affectedModules.add(mod);
+			}
+			if (affectedModules.size > 0) return [...affectedModules];
+			if (modules) return [...modules];
+			return [];
+		}
+		if (updateType === "style-only" && newCompiled.css && !hasDelegated) {
+			state.pendingHmrUpdateTypes.delete(file);
+			server.ws.send({
+				type: "custom",
+				event: "vize:update",
+				data: {
+					id: newCompiled.scopeId,
+					type: "style-only",
+					css: resolveCssImports(newCompiled.css, file, state.cssAliasRules, true, state.clientViteBase)
+				}
+			});
+			return [];
+		}
+		if (modules) {
+			state.pendingHmrUpdateTypes.set(file, updateType);
+			return [...modules];
+		}
+		state.pendingHmrUpdateTypes.delete(file);
+	} catch (e) {
+		state.logger.error(`Re-compilation failed for ${file}:`, e);
+	}
+}
+function handleGenerateBundleHook(state, emitFile) {
+	if (!state.extractCss || state.collectedCss.size === 0) return;
+	const allCss = Array.from(state.collectedCss.values()).join("\n\n");
+	if (allCss.trim()) {
+		emitFile({
+			type: "asset",
+			fileName: "assets/vize-components.css",
+			source: allCss
+		});
+		state.logger.log(`Extracted CSS to assets/vize-components.css (${state.collectedCss.size} components)`);
+	}
+}
+//#endregion
+//#region src/plugin/compat.ts
+function createVueCompatPlugin(state) {
+	let compilerSfc = null;
+	const loadCompilerSfc = () => {
+		if (!compilerSfc) try {
+			compilerSfc = createRequire(import.meta.url)("@vue/compiler-sfc");
+		} catch {
+			compilerSfc = { parse: () => ({
+				descriptor: {},
+				errors: []
+			}) };
+		}
+		return compilerSfc;
+	};
+	return {
+		name: "vite:vue",
+		api: { get options() {
+			return {
+				compiler: loadCompilerSfc(),
+				isProduction: state.isProduction ?? false,
+				root: state.root ?? process.cwd(),
+				template: {}
+			};
+		} }
+	};
+}
+function createPostTransformPlugin(state) {
+	return {
+		name: "vize:post-transform",
+		enforce: "post",
+		async transform(code, id, transformOptions) {
+			if (!id.endsWith(".vue") && !id.endsWith(".vue.ts") && !id.includes("node_modules") && id.endsWith(".setup.ts") && /<script\s+setup[\s>]/.test(code)) {
+				state.logger.log(`post-transform: compiling virtual SFC content from ${id}`);
+				try {
+					const isSsr = !!transformOptions?.ssr;
+					const result = await transformWithOxc(generateOutput(compileFile(id, getEnvironmentCache(state, isSsr), getCompileOptionsForRequest(state, isSsr), code), {
+						isProduction: state.isProduction,
+						isDev: state.server !== null,
+						extractCss: state.extractCss,
+						filePath: id
+					}), id, { lang: "ts" });
+					const defines = transformOptions?.ssr ? state.serverViteDefine : state.clientViteDefine;
+					let transformed = result.code;
+					if (Object.keys(defines).length > 0) transformed = applyDefineReplacements(transformed, defines);
+					return {
+						code: transformed,
+						map: result.map
+					};
+				} catch (e) {
+					state.logger.error(`Virtual SFC compilation failed for ${id}:`, e);
+				}
+			}
+			return null;
+		}
+	};
+}
+//#endregion
+//#region src/plugin/index.ts
+function vize(options = {}) {
+	const state = {
+		cache: /* @__PURE__ */ new Map(),
+		ssrCache: /* @__PURE__ */ new Map(),
+		collectedCss: /* @__PURE__ */ new Map(),
+		precompileMetadata: /* @__PURE__ */ new Map(),
+		pendingHmrUpdateTypes: /* @__PURE__ */ new Map(),
+		isProduction: false,
+		root: "",
+		clientViteBase: "/",
+		serverViteBase: "/",
+		server: null,
+		filter: () => true,
+		scanPatterns: null,
+		ignorePatterns: [],
+		mergedOptions: options,
+		initialized: false,
+		dynamicImportAliasRules: [],
+		cssAliasRules: [],
+		extractCss: false,
+		clientViteDefine: {},
+		serverViteDefine: {},
+		logger: createLogger(options.debug ?? false)
+	};
+	return [
+		createVueCompatPlugin(state),
+		{
+			name: "vite-plugin-vize",
+			enforce: "pre",
+			config(userConfig, env) {
+				const cssModules = userConfig.css?.modules;
+				if (cssModules && typeof cssModules.generateScopedName === "function") {
+					const origFn = cssModules.generateScopedName;
+					cssModules.generateScopedName = function(name, filename, css) {
+						let clean = filename;
+						const nulIdx = clean.indexOf("\0");
+						if (nulIdx >= 0) clean = clean.slice(nulIdx + 1);
+						clean = clean.replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
+						if (clean.includes("?")) clean = clean.split("?")[0];
+						return origFn.call(this, name, clean, css);
+					};
+				}
+				return {
+					define: {
+						__VUE_OPTIONS_API__: true,
+						__VUE_PROD_DEVTOOLS__: env.command === "serve",
+						__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: false
+					},
+					optimizeDeps: { exclude: ["virtual:vize-styles"] }
+				};
+			},
+			async configResolved(resolvedConfig) {
+				state.root = options.root ?? resolvedConfig.root;
+				state.isProduction = options.isProduction ?? resolvedConfig.isProduction;
+				const isSsrBuild = !!resolvedConfig.build?.ssr;
+				const currentBase = resolvedConfig.command === "serve" ? options.devUrlBase ?? resolvedConfig.base ?? "/" : resolvedConfig.base ?? "/";
+				if (isSsrBuild) state.serverViteBase = currentBase;
+				else state.clientViteBase = currentBase;
+				state.extractCss = state.isProduction;
+				const isSsr = !!resolvedConfig.build?.ssr;
+				const envDefine = {};
+				if (resolvedConfig.define) for (const [key, value] of Object.entries(resolvedConfig.define)) {
+					if (isBuiltinDefine(key)) continue;
+					if (typeof value === "string") envDefine[key] = value;
+					else envDefine[key] = JSON.stringify(value);
+				}
+				if (isSsr) state.serverViteDefine = envDefine;
+				else state.clientViteDefine = envDefine;
+				const configEnv = {
+					mode: resolvedConfig.mode,
+					command: resolvedConfig.command === "build" ? "build" : "serve",
+					isSsrBuild: !!resolvedConfig.build?.ssr
+				};
+				let fileConfig = null;
+				if (options.configMode !== false) try {
+					fileConfig = await loadConfig(state.root, {
+						mode: options.configMode ?? "root",
+						configFile: options.configFile,
+						env: configEnv
+					});
+					if (fileConfig) {
+						state.logger.log("Loaded config from vize.config file");
+						vizeConfigStore.set(state.root, fileConfig);
+					}
+				} catch (error) {
+					state.logger.warn(`Failed to load vize config from ${options.configFile ?? state.root}:`, error);
+				}
+				const viteConfig = fileConfig?.vite ?? {};
+				const compilerConfig = fileConfig?.compiler ?? {};
+				state.mergedOptions = {
+					...options,
+					ssr: options.ssr ?? compilerConfig.ssr ?? false,
+					sourceMap: options.sourceMap ?? compilerConfig.sourceMap,
+					vapor: options.vapor ?? compilerConfig.vapor ?? false,
+					include: options.include ?? viteConfig.include,
+					exclude: options.exclude ?? viteConfig.exclude,
+					scanPatterns: options.scanPatterns ?? viteConfig.scanPatterns,
+					ignorePatterns: options.ignorePatterns ?? viteConfig.ignorePatterns
+				};
+				state.dynamicImportAliasRules = [];
+				for (const alias of resolvedConfig.resolve.alias) {
+					if (typeof alias.find !== "string" || typeof alias.replacement !== "string") continue;
+					const fromPrefix = alias.find.endsWith("/") ? alias.find : `${alias.find}/`;
+					const replacement = toBrowserImportPrefix(alias.replacement);
+					const toPrefix = replacement.endsWith("/") ? replacement : `${replacement}/`;
+					state.dynamicImportAliasRules.push({
+						fromPrefix,
+						toPrefix
+					});
+				}
+				state.dynamicImportAliasRules.sort((a, b) => b.fromPrefix.length - a.fromPrefix.length);
+				state.cssAliasRules = [];
+				for (const alias of resolvedConfig.resolve.alias) {
+					if (typeof alias.find !== "string" || typeof alias.replacement !== "string") continue;
+					state.cssAliasRules.push({
+						find: alias.find,
+						replacement: alias.replacement
+					});
+				}
+				state.cssAliasRules.sort((a, b) => b.find.length - a.find.length);
+				state.filter = createFilter(state.mergedOptions.include, state.mergedOptions.exclude);
+				state.scanPatterns = state.mergedOptions.scanPatterns ?? ["**/*.vue"];
+				state.ignorePatterns = state.mergedOptions.ignorePatterns ?? [
+					"node_modules/**",
+					"dist/**",
+					".git/**"
+				];
+				state.initialized = true;
+			},
+			configureServer(devServer) {
+				state.server = devServer;
+				devServer.middlewares.use((req, _res, next) => {
+					if (req.url && req.url.includes("__x00__")) {
+						const [urlPath, queryPart] = req.url.split("?");
+						let cleanedPath = urlPath.replace(/__x00__/g, "");
+						cleanedPath = cleanedPath.replace(/^\/@id\/\//, "/@fs/");
+						if (cleanedPath.startsWith("/@fs/")) {
+							const fsPath = cleanedPath.slice(4);
+							if (fsPath.startsWith("/") && fs.existsSync(fsPath) && fs.statSync(fsPath).isFile() && !fsPath.endsWith(".vue.ts")) {
+								const cleaned = queryPart ? `${cleanedPath}?${queryPart}` : cleanedPath;
+								if (cleaned !== req.url) {
+									state.logger.log(`middleware: rewriting ${req.url} -> ${cleaned}`);
+									req.url = cleaned;
+								}
+							}
+						}
+					}
+					next();
+				});
+			},
+			async buildStart() {
+				if (!state.scanPatterns) return;
+				await compileAll(state);
+				state.logger.log("Cache keys:", [...state.cache.keys()].slice(0, 3));
+			},
+			resolveId(id, importer, options) {
+				return resolveIdHook(this, state, id, importer, options);
+			},
+			load(id, loadOptions) {
+				return loadHook(state, id, loadOptions);
+			},
+			async transform(code, id, transformOptions) {
+				return transformHook(state, code, id, transformOptions);
+			},
+			async handleHotUpdate(ctx) {
+				return handleHotUpdateHook(state, ctx);
+			},
+			generateBundle() {
+				handleGenerateBundleHook(state, this.emitFile.bind(this));
+			}
+		},
+		createPostTransformPlugin(state)
+	];
+}
+//#endregion
+//#region src/index.ts
+const __internal = { rewriteStaticAssetUrls };
+var src_default = vize;
+//#endregion
+export { __internal, rewriteStaticAssetUrls as __internal_rewriteStaticAssetUrls, src_default as default, defineConfig, loadConfig, vize, vizeConfigStore };