@vizejs/vite-plugin 0.12.0 → 0.14.0

package/dist/index.js

@@ -1,11 +1,11 @@
-import { transformWithOxc } from "vite";
-import path from "node:path";
 import fs from "node:fs";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import path from "node:path";
 import { glob } from "tinyglobby";
 import * as native from "@vizejs/native";
-import { createHash } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { transformWithOxc } from "vite";
+import { createRequire } from "node:module";
 
 //#region src/hmr.ts
 /**
@@ -67,7 +67,73 @@ if (import.meta.hot) {
 }
 
 //#endregion
-//#region src/utils.ts
+//#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 = 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 ?? "/";
+			const prefix = base.endsWith("/") ? base : base + "/";
+			return `url("${prefix}@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",
@@ -178,162 +244,122 @@ ${output}`;
 	if (!isProduction && isDev && hasExportDefault) output += generateHmrCode(compiled.scopeId, hmrUpdateType ?? "full-reload");
 	return output;
 }
-/**
-* 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 = 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 ?? "/";
-			const prefix = base.endsWith("/") ? base : base + "/";
-			return `url("${prefix}@fs${normalized}")`;
-		}
-		return _match;
-	});
-	result = result.replace(/:deep\(([^()]*(?:\([^()]*\))*[^()]*)\)/g, "$1");
-	result = result.replace(/\n{3,}/g, "\n\n");
-	return result;
+
+//#endregion
+//#region src/virtual.ts
+const LEGACY_VIZE_PREFIX = "\0vize:";
+const VIRTUAL_CSS_MODULE = "virtual:vize-styles";
+const RESOLVED_CSS_MODULE = "\0vize:all-styles.css";
+/** Check if a module ID is a vize-compiled virtual module */
+function isVizeVirtual(id) {
+	return id.startsWith("\0") && id.endsWith(".vue.ts");
 }
-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]);
+/** Create a virtual module ID from a real .vue file path */
+function toVirtualId(realPath) {
+	return "\0" + realPath + ".ts";
 }
-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);
+/** Extract the real .vue file path from a virtual module ID */
+function fromVirtualId(virtualId) {
+	return virtualId.slice(1, -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}`);
 	}
-	if (path.isAbsolute(importPath)) return importPath;
-	return null;
+	rewritten = rewritten.replace(/\bimport\s*\(\s*`/g, "import(/* @vite-ignore */ `");
+	return rewritten;
 }
 
 //#endregion
-//#region src/compiler.ts
-const { compileSfc, compileSfcBatchWithResults } = native;
+//#region src/transform.ts
 /**
-* Extract style block metadata from a Vue SFC source string.
-* Parses `<style>` tags to determine lang, scoped, and module attributes.
+* 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.
 */
-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(?:=["']([^"']+)["'])?\b/);
-		const isModule = moduleMatch ? moduleMatch[1] || true : false;
-		blocks.push({
-			content,
-			lang,
-			scoped,
-			module: isModule,
-			index
+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}`;
 		});
-		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, {
-		filename: filePath,
-		sourceMap: options.sourceMap,
-		ssr: options.ssr,
-		scopeId: hasScoped ? `data-v-${scopeId}` : void 0
-	});
-	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,
-		styles
-	};
-	cache.set(filePath, compiled);
-	return compiled;
+	if (imports.length > 0) rewritten = imports.join("\n") + "\n" + rewritten;
+	return rewritten;
 }
 /**
-* Batch compile multiple files in parallel using native Rust multithreading.
-* Returns per-file results with content hashes for HMR.
+* 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.
 */
-function compileBatch(files, cache, options) {
-	const inputs = files.map((f) => ({
-		path: f.path,
-		source: f.source
-	}));
-	const result = compileSfcBatchWithResults(inputs, { ssr: options.ssr });
-	const sourceMap = 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}`);
-		});
+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)
+	};
+}
 
 //#endregion
 //#region src/config.ts
@@ -413,189 +439,603 @@ async function loadConfigFile(configPath, env) {
 const vizeConfigStore = new Map();
 
 //#endregion
-//#region src/virtual.ts
-const LEGACY_VIZE_PREFIX = "\0vize:";
-const VIRTUAL_CSS_MODULE = "virtual:vize-styles";
-const RESOLVED_CSS_MODULE = "\0vize:all-styles.css";
-/** Check if a module ID is a vize-compiled virtual module */
-function isVizeVirtual(id) {
-	return id.startsWith("\0") && id.endsWith(".vue.ts");
-}
-/** Create a virtual module ID from a real .vue file path */
-function toVirtualId(realPath) {
-	return "\0" + realPath + ".ts";
-}
-/** Extract the real .vue file path from a virtual module ID */
-function fromVirtualId(virtualId) {
-	return virtualId.slice(1, -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;
+//#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(?:=["']([^"']+)["'])?\b/);
+		const isModule = moduleMatch ? moduleMatch[1] || true : false;
+		blocks.push({
+			content,
+			lang,
+			scoped,
+			module: isModule,
+			index
+		});
+		index++;
+	}
+	return blocks;
 }
-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 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, {
+		filename: filePath,
+		sourceMap: options.sourceMap,
+		ssr: options.ssr,
+		scopeId: hasScoped ? `data-v-${scopeId}` : void 0
+	});
+	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,
+		styles
+	};
+	cache.set(filePath, compiled);
+	return compiled;
 }
-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}`);
+/**
+* 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 inputs = files.map((f) => ({
+		path: f.path,
+		source: f.source
+	}));
+	const result = compileSfcBatchWithResults(inputs, { ssr: options.ssr });
+	const sourceMap = 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}`);
+		});
 	}
-	rewritten = rewritten.replace(/\bimport\s*\(\s*`/g, "import(/* @vite-ignore */ `");
-	return rewritten;
+	return result;
 }
 
 //#endregion
-//#region src/transform.ts
+//#region src/plugin/state.ts
 /**
-* 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.
+* Pre-compile all Vue files matching scan patterns.
 */
-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}`;
+async function compileAll(state) {
+	const startTime = performance.now();
+	const files = await glob(state.scanPatterns, {
+		cwd: state.root,
+		ignore: state.ignorePatterns,
+		absolute: true
+	});
+	state.logger.info(`Pre-compiling ${files.length} Vue files...`);
+	const fileContents = [];
+	for (const file of files) try {
+		const source = fs.readFileSync(file, "utf-8");
+		fileContents.push({
+			path: file,
+			source
 		});
+	} catch (e) {
+		state.logger.error(`Failed to read ${file}:`, e);
 	}
-	if (imports.length > 0) rewritten = imports.join("\n") + "\n" + rewritten;
-	return rewritten;
+	const result = compileBatch(fileContents, state.cache, { ssr: state.mergedOptions.ssr ?? false });
+	if (state.isProduction) {
+		for (const fileResult of result.results) if (fileResult.css) {
+			const cached = state.cache.get(fileResult.path);
+			const hasDelegated = cached?.styles?.some((s) => s.lang !== null && [
+				"scss",
+				"sass",
+				"less",
+				"stylus",
+				"styl"
+			].includes(s.lang) || s.module !== false);
+			if (!hasDelegated) 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} succeeded, ${result.failedCount} failed (${elapsed}ms, native batch: ${result.timeMs.toFixed(2)}ms)`);
 }
-/**
-* 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 + "_"));
+
+//#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);
 }
-/**
-* 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]);
+async function resolveIdHook(ctx, state, id, importer) {
+	const isBuild = state.server === null;
+	if (id.startsWith("\0")) {
+		if (isVizeVirtual(id)) return null;
+		if (id.startsWith(LEGACY_VIZE_PREFIX)) {
+			const rawPath = id.slice(LEGACY_VIZE_PREFIX.length);
+			const cleanPath$1 = rawPath.endsWith(".ts") ? rawPath.slice(0, -3) : rawPath;
+			if (!cleanPath$1.endsWith(".vue")) {
+				state.logger.log(`resolveId: redirecting legacy virtual ID to ${cleanPath$1}`);
+				return cleanPath$1;
+			}
+		}
+		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;
 	}
-	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)
-	};
+	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_CSS_MODULE) 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("/")) {
+				const matchesAlias = state.cssAliasRules.some((rule) => id === rule.find || id.startsWith(rule.find + "/"));
+				if (!matchesAlias) 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 {}
+				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);
+		if (!fileExists && !path.isAbsolute(id)) {
+			const viteResolved = await ctx.resolve(id, importer, { skipSelf: true });
+			if (viteResolved && viteResolved.id.endsWith(".vue")) {
+				const realPath = viteResolved.id;
+				const isResolvedNodeModules = realPath.includes("node_modules");
+				if ((isResolvedNodeModules ? 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);
+				}
+			}
+		}
+	}
+	return null;
 }
 
 //#endregion
-//#region src/plugin.ts
-function vize(options = {}) {
-	const cache = new Map();
-	const collectedCss = new Map();
-	let isProduction;
-	let root;
-	let clientViteBase = "/";
-	let serverViteBase = "/";
-	let server = null;
-	let filter;
-	let scanPatterns;
-	let ignorePatterns;
-	let mergedOptions;
-	let initialized = false;
-	let dynamicImportAliasRules = [];
-	let cssAliasRules = [];
-	let extractCss = false;
-	let clientViteDefine = {};
-	let serverViteDefine = {};
-	const logger = createLogger(options.debug ?? false);
-	async function compileAll() {
-		const startTime = performance.now();
-		const files = await glob(scanPatterns, {
-			cwd: root,
-			ignore: ignorePatterns,
-			absolute: true
-		});
-		logger.info(`Pre-compiling ${files.length} Vue files...`);
-		const fileContents = [];
-		for (const file of files) try {
-			const source = fs.readFileSync(file, "utf-8");
-			fileContents.push({
-				path: file,
-				source
+//#region src/plugin/load.ts
+function loadHook(state, id, loadOptions) {
+	const currentBase = loadOptions?.ssr ? state.serverViteBase : state.clientViteBase;
+	if (id === RESOLVED_CSS_MODULE) {
+		const allCss = Array.from(state.collectedCss.values()).join("\n\n");
+		return allCss;
+	}
+	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");
+		const _hasModule = params.has("module");
+		const scoped = params.get("scoped");
+		const compiled = state.cache.get(realPath);
+		const blockIndex = indexStr !== null ? parseInt(indexStr, 10) : -1;
+		if (compiled?.styles && blockIndex >= 0 && blockIndex < compiled.styles.length) {
+			const block = compiled.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");
+				const hoistedContent = hoisted.length > 0 ? hoisted.join("\n") + "\n\n" : "";
+				styleContent = `${hoistedContent}[${scoped}] {\n${bodyContent}\n}`;
+			}
+			return {
+				code: styleContent,
+				map: null
+			};
+		}
+		if (compiled?.css) return resolveCssImports(compiled.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 source = fs.readFileSync(realPath, "utf-8");
+			const setupMatch = source.match(/<script\s+setup[^>]*>([\s\S]*?)<\/script>/);
+			if (setupMatch) {
+				const scriptContent = setupMatch[1];
+				return {
+					code: `${scriptContent}\nexport default {}`,
+					map: null
+				};
+			}
+		}
+		return {
+			code: "export default {}",
+			map: null
+		};
+	}
+	if (isVizeVirtual(id)) {
+		const realPath = fromVirtualId(id);
+		if (!realPath.endsWith(".vue")) {
+			state.logger.log(`load: skipping non-vue virtual module ${realPath}`);
+			return null;
+		}
+		let compiled = state.cache.get(realPath);
+		if (!compiled && fs.existsSync(realPath)) {
+			state.logger.log(`load: on-demand compiling ${realPath}`);
+			compiled = compileFile(realPath, state.cache, {
+				sourceMap: state.mergedOptions?.sourceMap ?? !(state.isProduction ?? false),
+				ssr: state.mergedOptions?.ssr ?? false
 			});
+		}
+		if (compiled) {
+			const hasDelegated = compiled.styles?.some((s) => s.lang !== null && [
+				"scss",
+				"sass",
+				"less",
+				"stylus",
+				"styl"
+			].includes(s.lang) || s.module !== false);
+			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,
+				extractCss: state.extractCss,
+				filePath: realPath
+			}), state.dynamicImportAliasRules), state.dynamicImportAliasRules);
+			return {
+				code: output,
+				map: null
+			};
+		}
+	}
+	if (id.startsWith("\0")) {
+		const afterPrefix = id.startsWith(LEGACY_VIZE_PREFIX) ? id.slice(LEGACY_VIZE_PREFIX.length) : 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) {
-			logger.error(`Failed to read ${file}:`, e);
+			state.logger.error(`transformWithOxc failed for ${realPath}:`, e);
+			const dumpPath = `/tmp/vize-oxc-error-${path.basename(realPath)}.ts`;
+			fs.writeFileSync(dumpPath, code, "utf-8");
+			state.logger.error(`Dumped failing code to ${dumpPath}`);
+			return {
+				code: "export default {}",
+				map: null
+			};
 		}
-		const result = compileBatch(fileContents, cache, { ssr: mergedOptions.ssr ?? false });
-		if (isProduction) {
-			for (const fileResult of result.results) if (fileResult.css) {
-				const cached = cache.get(fileResult.path);
-				const hasDelegated = cached?.styles?.some((s) => s.lang !== null && [
-					"scss",
-					"sass",
-					"less",
-					"stylus",
-					"styl"
-				].includes(s.lang) || s.module !== false);
-				if (!hasDelegated) collectedCss.set(fileResult.path, resolveCssImports(fileResult.css, fileResult.path, cssAliasRules, false));
+	}
+	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, {
+			sourceMap: state.mergedOptions?.sourceMap ?? !state.isProduction,
+			ssr: state.mergedOptions?.ssr ?? false
+		}, source);
+		const newCompiled = state.cache.get(file);
+		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 = newCompiled.styles?.some((s) => s.lang !== null && [
+			"scss",
+			"sass",
+			"less",
+			"stylus",
+			"styl"
+		].includes(s.lang) || s.module !== false);
+		if (hasDelegated && updateType === "style-only") {
+			const affectedModules = 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 (modules) for (const mod of modules) affectedModules.add(mod);
+			if (affectedModules.size > 0) return [...affectedModules];
+		}
+		if (updateType === "style-only" && newCompiled.css && !hasDelegated) {
+			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 [];
 		}
-		const elapsed = (performance.now() - startTime).toFixed(2);
-		logger.info(`Pre-compilation complete: ${result.successCount} succeeded, ${result.failedCount} failed (${elapsed}ms, native batch: ${result.timeMs.toFixed(2)}ms)`);
+		if (modules) return [...modules];
+	} catch (e) {
+		state.logger.error(`Re-compilation failed for ${file}:`, e);
 	}
-	function resolveVuePath(id, importer) {
-		let resolved;
-		if (id.startsWith("/@fs/")) resolved = id.slice(4);
-		else if (id.startsWith("/") && !fs.existsSync(id)) resolved = path.resolve(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(root, id);
-		if (!path.isAbsolute(resolved)) resolved = path.resolve(root, resolved);
-		return path.normalize(resolved);
+}
+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 {
+			const require = createRequire(import.meta.url);
+			compilerSfc = require("@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 compiled = compileFile(id, state.cache, {
+						sourceMap: state.mergedOptions?.sourceMap ?? !(state.isProduction ?? false),
+						ssr: state.mergedOptions?.ssr ?? false
+					}, code);
+					const output = generateOutput(compiled, {
+						isProduction: state.isProduction,
+						isDev: state.server !== null,
+						extractCss: state.extractCss,
+						filePath: id
+					});
+					const result = await transformWithOxc(output, 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: new Map(),
+		collectedCss: 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)
+	};
 	const mainPlugin = {
 		name: "vite-plugin-vize",
 		enforce: "pre",
@@ -610,12 +1050,12 @@ function vize(options = {}) {
 			};
 		},
 		async configResolved(resolvedConfig) {
-			root = options.root ?? resolvedConfig.root;
-			isProduction = options.isProduction ?? resolvedConfig.isProduction;
+			state.root = options.root ?? resolvedConfig.root;
+			state.isProduction = options.isProduction ?? resolvedConfig.isProduction;
 			const isSsrBuild = !!resolvedConfig.build?.ssr;
-			if (isSsrBuild) serverViteBase = resolvedConfig.base ?? "/";
-			else clientViteBase = resolvedConfig.base ?? "/";
-			extractCss = isProduction;
+			if (isSsrBuild) state.serverViteBase = resolvedConfig.base ?? "/";
+			else state.clientViteBase = resolvedConfig.base ?? "/";
+			state.extractCss = state.isProduction;
 			const isSsr = !!resolvedConfig.build?.ssr;
 			const envDefine = {};
 			if (resolvedConfig.define) for (const [key, value] of Object.entries(resolvedConfig.define)) {
@@ -623,8 +1063,8 @@ function vize(options = {}) {
 				if (typeof value === "string") envDefine[key] = value;
 				else envDefine[key] = JSON.stringify(value);
 			}
-			if (isSsr) serverViteDefine = envDefine;
-			else clientViteDefine = envDefine;
+			if (isSsr) state.serverViteDefine = envDefine;
+			else state.clientViteDefine = envDefine;
 			const configEnv = {
 				mode: resolvedConfig.mode,
 				command: resolvedConfig.command === "build" ? "build" : "serve",
@@ -632,19 +1072,19 @@ function vize(options = {}) {
 			};
 			let fileConfig = null;
 			if (options.configMode !== false) {
-				fileConfig = await loadConfig(root, {
+				fileConfig = await loadConfig(state.root, {
 					mode: options.configMode ?? "root",
 					configFile: options.configFile,
 					env: configEnv
 				});
 				if (fileConfig) {
-					logger.log("Loaded config from vize.config file");
-					vizeConfigStore.set(root, fileConfig);
+					state.logger.log("Loaded config from vize.config file");
+					vizeConfigStore.set(state.root, fileConfig);
 				}
 			}
 			const viteConfig = fileConfig?.vite ?? {};
 			const compilerConfig = fileConfig?.compiler ?? {};
-			mergedOptions = {
+			state.mergedOptions = {
 				...options,
 				ssr: options.ssr ?? compilerConfig.ssr ?? false,
 				sourceMap: options.sourceMap ?? compilerConfig.sourceMap,
@@ -654,38 +1094,38 @@ function vize(options = {}) {
 				scanPatterns: options.scanPatterns ?? viteConfig.scanPatterns,
 				ignorePatterns: options.ignorePatterns ?? viteConfig.ignorePatterns
 			};
-			dynamicImportAliasRules = [];
+			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}/`;
-				dynamicImportAliasRules.push({
+				state.dynamicImportAliasRules.push({
 					fromPrefix,
 					toPrefix
 				});
 			}
-			dynamicImportAliasRules.sort((a, b) => b.fromPrefix.length - a.fromPrefix.length);
-			cssAliasRules = [];
+			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;
-				cssAliasRules.push({
+				state.cssAliasRules.push({
 					find: alias.find,
 					replacement: alias.replacement
 				});
 			}
-			cssAliasRules.sort((a, b) => b.find.length - a.find.length);
-			filter = createFilter(mergedOptions.include, mergedOptions.exclude);
-			scanPatterns = mergedOptions.scanPatterns ?? ["**/*.vue"];
-			ignorePatterns = mergedOptions.ignorePatterns ?? [
+			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/**"
 			];
-			initialized = true;
+			state.initialized = true;
 		},
 		configureServer(devServer) {
-			server = devServer;
+			state.server = devServer;
 			devServer.middlewares.use((req, _res, next) => {
 				if (req.url && req.url.includes("__x00__")) {
 					const [urlPath, queryPart] = req.url.split("?");
@@ -696,7 +1136,7 @@ function vize(options = {}) {
 						if (fsPath.startsWith("/") && fs.existsSync(fsPath) && fs.statSync(fsPath).isFile() && !fsPath.endsWith(".vue.ts")) {
 							const cleaned = queryPart ? `${cleanedPath}?${queryPart}` : cleanedPath;
 							if (cleaned !== req.url) {
-								logger.log(`middleware: rewriting ${req.url} -> ${cleaned}`);
+								state.logger.log(`middleware: rewriting ${req.url} -> ${cleaned}`);
 								req.url = cleaned;
 							}
 						}
@@ -706,428 +1146,30 @@ function vize(options = {}) {
 			});
 		},
 		async buildStart() {
-			if (!scanPatterns) return;
-			await compileAll();
-			logger.log("Cache keys:", [...cache.keys()].slice(0, 3));
+			if (!state.scanPatterns) return;
+			await compileAll(state);
+			state.logger.log("Cache keys:", [...state.cache.keys()].slice(0, 3));
 		},
-		async resolveId(id, importer) {
-			const isBuild = server === null;
-			if (id.startsWith("\0")) {
-				if (isVizeVirtual(id)) return null;
-				if (id.startsWith(LEGACY_VIZE_PREFIX)) {
-					const rawPath = id.slice(LEGACY_VIZE_PREFIX.length);
-					const cleanPath$1 = rawPath.endsWith(".ts") ? rawPath.slice(0, -3) : rawPath;
-					if (!cleanPath$1.endsWith(".vue")) {
-						logger.log(`resolveId: redirecting legacy virtual ID to ${cleanPath$1}`);
-						return cleanPath$1;
-					}
-				}
-				const cleanPath = id.slice(1);
-				if (cleanPath.startsWith("/") && !cleanPath.endsWith(".vue.ts")) {
-					const [pathPart, queryPart] = cleanPath.split("?");
-					const querySuffix = queryPart ? `?${queryPart}` : "";
-					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);
-				logger.log(`resolveId: redirecting stale vize: ID to ${realPath}`);
-				const resolved = await this.resolve(realPath, importer, { skipSelf: true });
-				if (resolved && isBuild && resolved.id.startsWith("/@fs/")) return {
-					...resolved,
-					id: normalizeFsIdForBuild(resolved.id)
-				};
-				return resolved;
-			}
-			if (id === VIRTUAL_CSS_MODULE) 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(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);
-				logger.log(`resolveId from virtual: id=${id}, cleanImporter=${cleanImporter}`);
-				if (id.startsWith("#")) try {
-					return await this.resolve(id, cleanImporter, { skipSelf: true });
-				} catch {
-					return null;
-				}
-				if (!id.endsWith(".vue")) {
-					if (!id.startsWith("./") && !id.startsWith("../") && !id.startsWith("/")) {
-						const matchesAlias = cssAliasRules.some((rule) => id === rule.find || id.startsWith(rule.find + "/"));
-						if (!matchesAlias) try {
-							const resolved = await this.resolve(id, cleanImporter, { skipSelf: true });
-							if (resolved) {
-								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 {}
-						return null;
-					}
-					try {
-						const resolved = await this.resolve(id, cleanImporter, { skipSelf: true });
-						if (resolved) {
-							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;
-								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;
-								logger.log(`resolveId: resolved directory ${id} to ${finalPath}`);
-								return finalPath;
-							}
-						}
-					}
-					return null;
-				}
-			}
-			if (id.endsWith(".vue")) {
-				const handleNodeModules = initialized ? mergedOptions.handleNodeModulesVue ?? true : true;
-				if (!handleNodeModules && id.includes("node_modules")) {
-					logger.log(`resolveId: skipping node_modules import ${id}`);
-					return null;
-				}
-				const resolved = resolveVuePath(id, importer);
-				const isNodeModulesPath = resolved.includes("node_modules");
-				if (!handleNodeModules && isNodeModulesPath) {
-					logger.log(`resolveId: skipping node_modules path ${resolved}`);
-					return null;
-				}
-				if (filter && !isNodeModulesPath && !filter(resolved)) {
-					logger.log(`resolveId: skipping filtered path ${resolved}`);
-					return null;
-				}
-				const hasCache = cache.has(resolved);
-				const fileExists = fs.existsSync(resolved);
-				logger.log(`resolveId: id=${id}, resolved=${resolved}, hasCache=${hasCache}, fileExists=${fileExists}, importer=${importer ?? "none"}`);
-				if (hasCache || fileExists) return toVirtualId(resolved);
-				if (!fileExists && !path.isAbsolute(id)) {
-					const viteResolved = await this.resolve(id, importer, { skipSelf: true });
-					if (viteResolved && viteResolved.id.endsWith(".vue")) {
-						const realPath = viteResolved.id;
-						const isResolvedNodeModules = realPath.includes("node_modules");
-						if ((isResolvedNodeModules ? handleNodeModules : filter(realPath)) && (cache.has(realPath) || fs.existsSync(realPath))) {
-							logger.log(`resolveId: resolved via Vite fallback ${id} to ${realPath}`);
-							return toVirtualId(realPath);
-						}
-					}
-				}
-			}
-			return null;
+		resolveId(id, importer) {
+			return resolveIdHook(this, state, id, importer);
 		},
 		load(id, loadOptions) {
-			const currentBase = loadOptions?.ssr ? serverViteBase : clientViteBase;
-			if (id === RESOLVED_CSS_MODULE) {
-				const allCss = Array.from(collectedCss.values()).join("\n\n");
-				return allCss;
-			}
-			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");
-				const _hasModule = params.has("module");
-				const scoped = params.get("scoped");
-				const compiled = cache.get(realPath);
-				const blockIndex = indexStr !== null ? parseInt(indexStr, 10) : -1;
-				if (compiled?.styles && blockIndex >= 0 && blockIndex < compiled.styles.length) {
-					const block = compiled.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");
-						const hoistedContent = hoisted.length > 0 ? hoisted.join("\n") + "\n\n" : "";
-						styleContent = `${hoistedContent}[${scoped}] {\n${bodyContent}\n}`;
-					}
-					return {
-						code: styleContent,
-						map: null
-					};
-				}
-				if (compiled?.css) return resolveCssImports(compiled.css, realPath, cssAliasRules, 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 source = fs.readFileSync(realPath, "utf-8");
-					const setupMatch = source.match(/<script\s+setup[^>]*>([\s\S]*?)<\/script>/);
-					if (setupMatch) {
-						const scriptContent = setupMatch[1];
-						return {
-							code: `${scriptContent}\nexport default {}`,
-							map: null
-						};
-					}
-				}
-				return {
-					code: "export default {}",
-					map: null
-				};
-			}
-			if (isVizeVirtual(id)) {
-				const realPath = fromVirtualId(id);
-				if (!realPath.endsWith(".vue")) {
-					logger.log(`load: skipping non-vue virtual module ${realPath}`);
-					return null;
-				}
-				let compiled = cache.get(realPath);
-				if (!compiled && fs.existsSync(realPath)) {
-					logger.log(`load: on-demand compiling ${realPath}`);
-					compiled = compileFile(realPath, cache, {
-						sourceMap: mergedOptions?.sourceMap ?? !(isProduction ?? false),
-						ssr: mergedOptions?.ssr ?? false
-					});
-				}
-				if (compiled) {
-					const hasDelegated = compiled.styles?.some((s) => s.lang !== null && [
-						"scss",
-						"sass",
-						"less",
-						"stylus",
-						"styl"
-					].includes(s.lang) || s.module !== false);
-					if (compiled.css && !hasDelegated) compiled = {
-						...compiled,
-						css: resolveCssImports(compiled.css, realPath, cssAliasRules, server !== null, currentBase)
-					};
-					const output = rewriteStaticAssetUrls(rewriteDynamicTemplateImports(generateOutput(compiled, {
-						isProduction,
-						isDev: server !== null,
-						extractCss,
-						filePath: realPath
-					}), dynamicImportAliasRules), dynamicImportAliasRules);
-					return {
-						code: output,
-						map: null
-					};
-				}
-			}
-			if (id.startsWith("\0")) {
-				const afterPrefix = id.startsWith(LEGACY_VIZE_PREFIX) ? id.slice(LEGACY_VIZE_PREFIX.length) : 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 = server === null ? `${pathToFileURL(fsPath).href}${querySuffix}` : "/@fs" + fsPath + querySuffix;
-					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;
+			return loadHook(state, id, loadOptions);
 		},
-		async transform(code, id, options$1) {
-			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$1?.ssr ? serverViteDefine : clientViteDefine;
-					let transformed = result.code;
-					if (Object.keys(defines).length > 0) transformed = applyDefineReplacements(transformed, defines);
-					return {
-						code: transformed,
-						map: result.map
-					};
-				} catch (e) {
-					logger.error(`transformWithOxc failed for ${realPath}:`, e);
-					const dumpPath = `/tmp/vize-oxc-error-${path.basename(realPath)}.ts`;
-					fs.writeFileSync(dumpPath, code, "utf-8");
-					logger.error(`Dumped failing code to ${dumpPath}`);
-					return {
-						code: "export default {}",
-						map: null
-					};
-				}
-			}
-			return null;
+		async transform(code, id, transformOptions) {
+			return transformHook(state, code, id, transformOptions);
 		},
 		async handleHotUpdate(ctx) {
-			const { file, server: server$1, read } = ctx;
-			if (file.endsWith(".vue") && filter(file)) try {
-				const source = await read();
-				const prevCompiled = cache.get(file);
-				compileFile(file, cache, {
-					sourceMap: mergedOptions?.sourceMap ?? !isProduction,
-					ssr: mergedOptions?.ssr ?? false
-				}, source);
-				const newCompiled = cache.get(file);
-				const updateType = detectHmrUpdateType(prevCompiled, newCompiled);
-				logger.log(`Re-compiled: ${path.relative(root, file)} (${updateType})`);
-				const virtualId = toVirtualId(file);
-				const modules = server$1.moduleGraph.getModulesByFile(virtualId) ?? server$1.moduleGraph.getModulesByFile(file);
-				const hasDelegated = newCompiled.styles?.some((s) => s.lang !== null && [
-					"scss",
-					"sass",
-					"less",
-					"stylus",
-					"styl"
-				].includes(s.lang) || s.module !== false);
-				if (hasDelegated && updateType === "style-only") {
-					const affectedModules = 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$1.moduleGraph.getModulesByFile(styleId);
-						if (styleMods) for (const mod of styleMods) affectedModules.add(mod);
-					}
-					if (modules) for (const mod of modules) affectedModules.add(mod);
-					if (affectedModules.size > 0) return [...affectedModules];
-				}
-				if (updateType === "style-only" && newCompiled.css && !hasDelegated) {
-					server$1.ws.send({
-						type: "custom",
-						event: "vize:update",
-						data: {
-							id: newCompiled.scopeId,
-							type: "style-only",
-							css: resolveCssImports(newCompiled.css, file, cssAliasRules, true, clientViteBase)
-						}
-					});
-					return [];
-				}
-				if (modules) return [...modules];
-			} catch (e) {
-				logger.error(`Re-compilation failed for ${file}:`, e);
-			}
+			return handleHotUpdateHook(state, ctx);
 		},
-		generateBundle(_, _bundle) {
-			if (!extractCss || collectedCss.size === 0) return;
-			const allCss = Array.from(collectedCss.values()).join("\n\n");
-			if (allCss.trim()) {
-				this.emitFile({
-					type: "asset",
-					fileName: "assets/vize-components.css",
-					source: allCss
-				});
-				logger.log(`Extracted CSS to assets/vize-components.css (${collectedCss.size} components)`);
-			}
-		}
-	};
-	let compilerSfc = null;
-	const loadCompilerSfc = () => {
-		if (!compilerSfc) try {
-			const require = createRequire(import.meta.url);
-			compilerSfc = require("@vue/compiler-sfc");
-		} catch {
-			compilerSfc = { parse: () => ({
-				descriptor: {},
-				errors: []
-			}) };
-		}
-		return compilerSfc;
-	};
-	const vueCompatPlugin = {
-		name: "vite:vue",
-		api: { get options() {
-			return {
-				compiler: loadCompilerSfc(),
-				isProduction: isProduction ?? false,
-				root: root ?? process.cwd(),
-				template: {}
-			};
-		} }
-	};
-	const postTransformPlugin = {
-		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)) {
-				logger.log(`post-transform: compiling virtual SFC content from ${id}`);
-				try {
-					const compiled = compileFile(id, cache, {
-						sourceMap: mergedOptions?.sourceMap ?? !(isProduction ?? false),
-						ssr: mergedOptions?.ssr ?? false
-					}, code);
-					const output = generateOutput(compiled, {
-						isProduction,
-						isDev: server !== null,
-						extractCss,
-						filePath: id
-					});
-					const result = await transformWithOxc(output, id, { lang: "ts" });
-					const defines = transformOptions?.ssr ? serverViteDefine : clientViteDefine;
-					let transformed = result.code;
-					if (Object.keys(defines).length > 0) transformed = applyDefineReplacements(transformed, defines);
-					return {
-						code: transformed,
-						map: result.map
-					};
-				} catch (e) {
-					logger.error(`Virtual SFC compilation failed for ${id}:`, e);
-				}
-			}
-			return null;
+		generateBundle() {
+			handleGenerateBundleHook(state, this.emitFile.bind(this));
 		}
 	};
 	return [
-		vueCompatPlugin,
+		createVueCompatPlugin(state),
 		mainPlugin,
-		postTransformPlugin
+		createPostTransformPlugin(state)
 	];
 }