@vizejs/vite-plugin 0.424.10 → 0.426.0

package/dist/plugin-BSxbzkGl.mjs

@@ -0,0 +1,4111 @@
+import { a as vizeConfigStore } from "./config-PP6EAmWc.mjs";
+import { n as resolveSharedConfig } from "./shared-config-dMxrrTkb.mjs";
+import { n as registerResolvedVizeConfig, r as unregisterResolvedVizeConfig } from "./config-bridge-Dv6U7_RC.mjs";
+import { createRequire } from "node:module";
+import crypto, { createHash } from "node:crypto";
+import * as native from "@vizejs/native";
+import { applyViteDefineReplacements, buildInspectorGraph, chunkVitePrecompileFiles, classifyVitePluginRequest, createViteBareImportBases, createViteBareImportCandidates, createViteVirtualId, detectViteHmrUpdateType, diffVitePrecompileFiles, generateViteHmrCode, hasViteHmrChanges, isViteBareSpecifier, normalizeViteCssModuleFilename, normalizeViteDevMiddlewareUrl, normalizeVitePrecompileBatchSize, normalizeViteRequireBase, normalizeViteResolvedVuePath, resolveViteAliasRequest, resolveViteCssImports, resolveViteRelativeImport, resolveViteVuePath, rewriteViteDynamicTemplateImports, rewriteViteImportMetaGlobBase, rewriteViteStaticAssetUrls, scopeViteCssForPipeline, shouldApplyViteDefineInVirtualModule, splitViteIdQuery, toViteBrowserImportPrefix, transformViteCssVarsForPipeline } from "@vizejs/native";
+import { parseSync } from "oxc-parser";
+import path from "node:path";
+import fs from "node:fs";
+import { glob } from "tinyglobby";
+import zlib from "node:zlib";
+import { pathToFileURL } from "node:url";
+import * as vite from "vite";
+//#region src/hmr.ts
+function hasHmrChanges(prev, next) {
+	if (!prev) return true;
+	return hasViteHmrChanges(toHmrHashes(prev), toHmrHashes(next)) || runtimeFingerprint(prev) !== runtimeFingerprint(next) || styleFingerprint(prev) !== styleFingerprint(next);
+}
+/**
+* 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 detectViteHmrUpdateType(void 0, toHmrHashes(next));
+	if (prev.scriptHash !== next.scriptHash) return "full-reload";
+	if (prev.templateHash !== next.templateHash) return "template-only";
+	if (prev.styleHash !== next.styleHash) return "style-only";
+	if (runtimeFingerprint(prev) !== runtimeFingerprint(next)) return "full-reload";
+	if (styleFingerprint(prev) !== styleFingerprint(next)) return "style-only";
+	return "full-reload";
+}
+/**
+* Generate HMR-aware code output based on update type.
+*/
+function generateHmrCode(scopeId, updateType) {
+	return generateViteHmrCode(scopeId, updateType);
+}
+function toHmrHashes(module) {
+	return module ? {
+		scriptHash: module.scriptHash,
+		templateHash: module.templateHash,
+		styleHash: module.styleHash
+	} : void 0;
+}
+function runtimeFingerprint(module) {
+	return JSON.stringify({
+		code: module.code,
+		scopeId: module.scopeId,
+		hasScoped: module.hasScoped,
+		macroArtifacts: module.macroArtifacts?.map((artifact) => ({
+			kind: artifact.kind,
+			name: artifact.name,
+			source: artifact.source,
+			content: artifact.content,
+			moduleCode: artifact.moduleCode,
+			start: artifact.start,
+			end: artifact.end
+		})),
+		styles: module.styles?.map((style) => ({
+			lang: style.lang,
+			scoped: style.scoped,
+			module: style.module,
+			index: style.index
+		})),
+		dependencies: [...module.dependencies ?? []].sort()
+	});
+}
+function styleFingerprint(module) {
+	return JSON.stringify({
+		css: module.css,
+		styles: module.styles?.map((style) => ({
+			index: style.index,
+			content: style.content
+		}))
+	});
+}
+//#endregion
+//#region src/utils/module-output.ts
+const OUTPUT_PARSE_ID = "vize-output.tsx";
+const SFC_MAIN_NAME = "_sfc_main";
+const EXPORT_DEFAULT = "export default";
+function isNode(value) {
+	return value != null && typeof value === "object" && typeof value.type === "string";
+}
+function getNodeStart(node) {
+	return typeof node?.start === "number" ? node.start : null;
+}
+function getNodeEnd(node) {
+	return typeof node?.end === "number" ? node.end : null;
+}
+function getNodeName(node) {
+	return isNode(node) && typeof node.name === "string" ? node.name : null;
+}
+function isSfcMainDefaultExport(defaultExport) {
+	return isIdentifierNamed(isNode(defaultExport?.declaration) ? defaultExport.declaration : null, SFC_MAIN_NAME);
+}
+function parseProgram(code) {
+	try {
+		const result = parseSync(OUTPUT_PARSE_ID, code);
+		if (result != null && typeof result === "object") {
+			const errors = result.errors;
+			if (Array.isArray(errors) && errors.length > 0) return null;
+			const program = result.program;
+			if (isNode(program)) return program;
+		}
+		return isNode(result) ? result : null;
+	} catch {
+		return null;
+	}
+}
+function getProgramBody(program) {
+	if (!program || !Array.isArray(program.body)) return [];
+	return program.body.filter(isNode);
+}
+function isIdentifierNamed(node, name) {
+	return getNodeName(node) === name;
+}
+function getVariableDeclarationNames(statement) {
+	return (Array.isArray(statement.declarations) ? statement.declarations : []).filter(isNode).map((declaration) => isNode(declaration.id) ? getNodeName(declaration.id) : null).filter((name) => name != null);
+}
+function getExportedNames(statement) {
+	const declaration = isNode(statement.declaration) ? statement.declaration : null;
+	const names = [];
+	if (declaration?.type === "FunctionDeclaration" || declaration?.type === "ClassDeclaration") {
+		const name = isNode(declaration.id) ? getNodeName(declaration.id) : null;
+		if (name) names.push(name);
+	}
+	if (declaration?.type === "VariableDeclaration") names.push(...getVariableDeclarationNames(declaration));
+	const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers : [];
+	for (const specifier of specifiers) {
+		if (!isNode(specifier)) continue;
+		const exported = isNode(specifier.exported) ? specifier.exported : null;
+		const local = isNode(specifier.local) ? specifier.local : null;
+		const name = getNodeName(exported) ?? getNodeName(local);
+		if (name) names.push(name);
+	}
+	return names;
+}
+function findDefaultExport(program) {
+	return getProgramBody(program).find((statement) => statement.type === "ExportDefaultDeclaration") ?? null;
+}
+function analyzeFastDefaultOutput(code) {
+	if (code.includes(SFC_MAIN_NAME) || code.includes("export function render") || code.includes("export function ssrRender") || code.includes("export {")) return null;
+	const defaultExportStart = code.indexOf(EXPORT_DEFAULT);
+	if (defaultExportStart === -1 || defaultExportStart !== code.lastIndexOf(EXPORT_DEFAULT)) return null;
+	const before = defaultExportStart === 0 ? "\n" : code[defaultExportStart - 1];
+	if (!before || !/\s|;/.test(before)) return null;
+	return {
+		hasDefaultExport: true,
+		hasSfcMainDefined: false,
+		hasNamedRenderExport: false,
+		hasNamedSsrRenderExport: false,
+		defaultExportStart,
+		defaultExportKeywordEnd: defaultExportStart + 14,
+		defaultExportEnd: null,
+		defaultExportIsSfcMain: false
+	};
+}
+function getExportDefaultKeywordEnd(code, defaultExport) {
+	const exportStart = getNodeStart(defaultExport);
+	if (exportStart == null) return null;
+	const match = /^export\s+default\b/.exec(code.slice(exportStart));
+	return match ? exportStart + match[0].length : null;
+}
+function analyzeModuleOutput(code) {
+	const fastOutput = analyzeFastDefaultOutput(code);
+	if (fastOutput) return fastOutput;
+	const program = parseProgram(code);
+	const body = getProgramBody(program);
+	const defaultExport = findDefaultExport(program);
+	const defaultExportStart = getNodeStart(defaultExport);
+	const defaultExportKeywordEnd = defaultExport ? getExportDefaultKeywordEnd(code, defaultExport) : null;
+	const exportedNames = body.filter((statement) => statement.type === "ExportNamedDeclaration").flatMap(getExportedNames);
+	return {
+		hasDefaultExport: defaultExport != null,
+		hasSfcMainDefined: body.some((statement) => {
+			return statement.type === "VariableDeclaration" && getVariableDeclarationNames(statement).includes(SFC_MAIN_NAME);
+		}),
+		hasNamedRenderExport: exportedNames.includes("render"),
+		hasNamedSsrRenderExport: exportedNames.includes("ssrRender"),
+		defaultExportKeywordEnd,
+		defaultExportStart,
+		defaultExportEnd: getNodeEnd(defaultExport),
+		defaultExportIsSfcMain: isSfcMainDefaultExport(defaultExport)
+	};
+}
+function rewriteDefaultExportToSfcMain(code, moduleInfo = {
+	defaultExportKeywordEnd: null,
+	defaultExportStart: null
+}) {
+	let exportStart = moduleInfo.defaultExportStart;
+	let keywordEnd = moduleInfo.defaultExportKeywordEnd;
+	if (exportStart == null || keywordEnd == null) {
+		const defaultExport = findDefaultExport(parseProgram(code));
+		exportStart = getNodeStart(defaultExport);
+		keywordEnd = defaultExport ? getExportDefaultKeywordEnd(code, defaultExport) : null;
+	}
+	if (exportStart == null || keywordEnd == null) return code;
+	return `${code.slice(0, exportStart)}const ${SFC_MAIN_NAME} =${code.slice(keywordEnd)}`;
+}
+/**
+* Locate `export default _sfc_main` when the caller has no analysis to hand.
+*
+* The string test is a sound pre-filter: the AST check below only succeeds when
+* the default export's declaration *is* the `_sfc_main` identifier, which cannot
+* happen unless that name occurs in the module.
+*/
+function findSfcMainDefaultExport(code) {
+	if (!code.includes(SFC_MAIN_NAME)) return {
+		defaultExportStart: null,
+		defaultExportEnd: null,
+		defaultExportIsSfcMain: false
+	};
+	const defaultExport = findDefaultExport(parseProgram(code));
+	return {
+		defaultExportStart: getNodeStart(defaultExport),
+		defaultExportEnd: getNodeEnd(defaultExport),
+		defaultExportIsSfcMain: isSfcMainDefaultExport(defaultExport)
+	};
+}
+function insertBeforeSfcMainDefaultExport(code, insertion, options = {}) {
+	const { defaultExportStart: exportStart, defaultExportEnd: exportEnd, defaultExportIsSfcMain } = options.moduleInfo ?? findSfcMainDefaultExport(code);
+	if (!defaultExportIsSfcMain || exportStart == null) return code;
+	if (options.normalizeSemicolon && exportEnd != null) {
+		const suffixStart = code[exportEnd] === ";" ? exportEnd + 1 : exportEnd;
+		return `${code.slice(0, exportStart)}${insertion}\nexport default ${SFC_MAIN_NAME};${code.slice(suffixStart)}`;
+	}
+	return `${code.slice(0, exportStart)}${insertion}\n${code.slice(exportStart)}`;
+}
+//#endregion
+//#region src/utils/source-map.ts
+function isSourceMapV3(value) {
+	if (value === null || typeof value !== "object") return false;
+	const map = value;
+	return map.version === 3 && Array.isArray(map.sources) && Array.isArray(map.names) && typeof map.mappings === "string";
+}
+/**
+* Parse a compiler-produced map, or `null` when there is nothing usable.
+*
+* A malformed map is worse than no map — Vite would chain garbage into the
+* bundle's map — so anything that is not a v3 document is dropped.
+*/
+function parseSourceMap(json) {
+	if (!json) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		return null;
+	}
+	return isSourceMapV3(parsed) ? parsed : null;
+}
+function countNewlines(text) {
+	let total = 0;
+	for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) total++;
+	return total;
+}
+/**
+* Insert `count` unmapped generated lines at generated line `atLine`.
+*
+* Returns the map unchanged when the insertion lands past the last mapped line,
+* because nothing after it needs moving.
+*/
+function shiftMappedLines(map, atLine, count) {
+	if (count <= 0) return map;
+	const groups = map.mappings.split(";");
+	if (atLine >= groups.length) return map;
+	const shifted = [
+		...groups.slice(0, atLine),
+		...Array(count).fill(""),
+		...groups.slice(atLine)
+	];
+	return {
+		...map,
+		mappings: shifted.join(";")
+	};
+}
+/**
+* A module's code and the map that describes it, edited together.
+*
+* Every write goes through {@link edit}, so the map is corrected in the same
+* step that changes the code and the two cannot drift.
+*/
+var MappedModule = class {
+	code;
+	map;
+	constructor(code, map) {
+		this.code = code;
+		this.map = map;
+	}
+	/** Replace the module with `next`, realigning the map to the new line layout. */
+	edit(next) {
+		const previous = this.code;
+		this.code = next;
+		if (this.map === null || next === previous) return;
+		const limit = Math.min(previous.length, next.length);
+		let prefix = 0;
+		while (prefix < limit && previous.charCodeAt(prefix) === next.charCodeAt(prefix)) prefix++;
+		let suffix = 0;
+		while (suffix < limit - prefix && previous.charCodeAt(previous.length - 1 - suffix) === next.charCodeAt(next.length - 1 - suffix)) suffix++;
+		const removed = previous.slice(prefix, previous.length - suffix);
+		const addedLines = countNewlines(next.slice(prefix, next.length - suffix)) - countNewlines(removed);
+		if (addedLines === 0) return;
+		if (addedLines < 0) {
+			this.map = null;
+			return;
+		}
+		const editLine = countNewlines(previous.slice(0, prefix));
+		const startsAtLineStart = prefix === 0 || previous.charCodeAt(prefix - 1) === 10;
+		this.map = shiftMappedLines(this.map, startsAtLineStart ? editLine : editLine + 1, addedLines);
+	}
+};
+//#endregion
+//#region src/utils/css.ts
+function scopeCssForPipeline(css, scopeId) {
+	return scopeViteCssForPipeline(css, scopeId);
+}
+function transformCssVarsForPipeline(css, scopeId) {
+	return transformViteCssVarsForPipeline(css, scopeId);
+}
+/**
+* Resolve CSS @import statements by inlining the imported files,
+* then resolve @custom-media definitions within the combined CSS.
+*/
+function resolveCssImports(css, importer, aliasRules, isDev, devUrlBase) {
+	return resolveViteCssImports(css, importer, aliasRules.map(toNativeCssAliasRule), isDev, devUrlBase);
+}
+function toNativeCssAliasRule(rule) {
+	return typeof rule.find === "string" ? {
+		find: rule.find,
+		replacement: rule.replacement,
+		isRegex: false
+	} : {
+		find: rule.find.source,
+		replacement: rule.replacement,
+		isRegex: true,
+		flags: rule.find.flags.replace(/[gy]/g, "")
+	};
+}
+//#endregion
+//#region src/utils/filter.ts
+/**
+* Defaults the filter falls back to, and what the `vite:vue` shim reports
+* through `api.include` / `api.exclude` when neither is configured (#3227).
+*
+* `DEFAULT_INCLUDE_PATTERN` is `@vitejs/plugin-vue`'s own default.
+* `DEFAULT_EXCLUDE_PATTERN` has no upstream counterpart — plugin-vue leaves
+* `exclude` undefined — so the shim reports the pattern Vize actually filters
+* on rather than an upstream-shaped `undefined` it does not honor.
+*/
+const DEFAULT_INCLUDE_PATTERN = /\.vue$/;
+const DEFAULT_EXCLUDE_PATTERN = /node_modules/;
+function createFilter(include, exclude) {
+	const includePatterns = include ? Array.isArray(include) ? include : [include] : [DEFAULT_INCLUDE_PATTERN];
+	const excludePatterns = exclude ? Array.isArray(exclude) ? exclude : [exclude] : [DEFAULT_EXCLUDE_PATTERN];
+	return (id) => {
+		const matchInclude = includePatterns.some((pattern) => matchesFilterPattern(pattern, id));
+		const matchExclude = excludePatterns.some((pattern) => matchesFilterPattern(pattern, id));
+		return matchInclude && !matchExclude;
+	};
+}
+const GLOB_META = /[*?]/;
+function matchesFilterPattern(pattern, id) {
+	if (typeof pattern === "string") return matchesStringFilter(pattern, id);
+	pattern.lastIndex = 0;
+	const matched = pattern.test(id);
+	pattern.lastIndex = 0;
+	return matched;
+}
+function matchesStringFilter(pattern, id) {
+	const normalizedId = normalizeFilterPath(id);
+	const normalizedPattern = normalizeFilterPath(pattern);
+	if (!GLOB_META.test(normalizedPattern)) return normalizedId.includes(normalizedPattern);
+	return stringGlobToRegExp(normalizedPattern).test(normalizedId);
+}
+function normalizeFilterPath(value) {
+	return value.replace(/\\/g, "/");
+}
+function stringGlobToRegExp(pattern) {
+	const absolute = pattern.startsWith("/");
+	let body = absolute ? pattern : stripRelativePrefix(pattern);
+	let descendantSuffix = false;
+	if (body.endsWith("/**")) {
+		body = body.slice(0, -3);
+		descendantSuffix = true;
+	}
+	const prefix = absolute ? "^" : "(?:^|/)";
+	const suffix = descendantSuffix ? "(?:/.*)?$" : "$";
+	return new RegExp(`${prefix}${globBodyToRegExp(body)}${suffix}`);
+}
+function stripRelativePrefix(pattern) {
+	let rest = pattern;
+	while (rest.startsWith("../")) rest = rest.slice(3);
+	while (rest.startsWith("./")) rest = rest.slice(2);
+	return rest;
+}
+function globBodyToRegExp(pattern) {
+	let source = "";
+	for (let i = 0; i < pattern.length;) {
+		const char = pattern[i];
+		if (char === "*") {
+			if (pattern[i + 1] === "*") if (pattern[i + 2] === "/") {
+				source += "(?:.*\\/)?";
+				i += 3;
+			} else {
+				source += ".*";
+				i += 2;
+			}
+			else {
+				source += "[^/]*";
+				i += 1;
+			}
+			continue;
+		}
+		if (char === "?") {
+			source += "[^/]";
+			i += 1;
+			continue;
+		}
+		source += escapeRegExp(char);
+		i += 1;
+	}
+	return source;
+}
+function escapeRegExp(char) {
+	return "\\^$+?.()|[]{}".includes(char) ? `\\${char}` : char;
+}
+//#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;
+}
+function needsCssPipeline(block) {
+	return block.content.includes("@apply");
+}
+function styleVirtualSuffix(block) {
+	const lang = block.lang ?? "css";
+	return block.module !== false ? `.module.${lang}` : `.${lang}`;
+}
+function createStyleImportUrl(filePath, params, block) {
+	return `${filePath}?${params.toString()}${styleVirtualSuffix(block)}`;
+}
+/**
+* Check if any style blocks in the compiled module require delegation to
+* Vite's CSS pipeline (preprocessor, CSS Modules, or PostCSS transforms).
+*/
+function hasDelegatedStyles(compiled) {
+	if (!compiled.styles) return false;
+	return compiled.styles.some((s) => needsPreprocessor(s) || isCssModule(s) || needsCssPipeline(s));
+}
+function supportsTemplateOnlyHmr(output) {
+	return /(?:^|\n)(?:_sfc_main|__sfc__)\.render\s*=\s*render\b/m.test(output);
+}
+/**
+* Prepend a runtime `<style>` injection for plain CSS to a module's output.
+*
+* This is the same inline-CSS path plain SFC `<style>` blocks use in
+* {@link generateOutput}: a guarded `document.createElement('style')` keyed by a
+* stable id so the rule is injected once and idempotently. `styleKey` seeds the
+* element id. Used for both SFC plain CSS and JSX `<style scoped>` CSS (#1495,
+* #1533), whose content is already scope-rewritten by the compiler.
+*/
+function prependInlineStyleInjection(output, css, styleKey) {
+	return `
+export const __vize_css__ = ${JSON.stringify(css)};
+const __vize_css_id__ = ${JSON.stringify(`vize-style-${styleKey}`)};
+(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}`;
+}
+function insertAfterStaticImports(output, imports) {
+	let insertAt = 0;
+	for (const match of output.matchAll(/^import\b[^\n]*(?:\r?\n|$)/gm)) insertAt = (match.index ?? 0) + match[0].length;
+	if (insertAt === 0) return `${imports}\n${output}`;
+	return `${output.slice(0, insertAt)}${imports}\n${output.slice(insertAt)}`;
+}
+function generateScopeId(filename) {
+	return createHash("sha256").update(filename).digest("hex").slice(0, 8);
+}
+/**
+* Whether the SFC's `<style>` blocks are handed to Vite as virtual imports.
+*
+* Some blocks require Vite's CSS pipeline (preprocessor or CSS Modules), and a
+* production client build routes plain CSS through it too so nesting,
+* minification, and chunk ownership still apply. In both cases the blocks are
+* emitted as imports and `compiled.css` is not used.
+*/
+function usesStyleImports(compiled, options) {
+	return !!options.filePath && !!compiled.styles?.length && (options.customElement || hasDelegatedStyles(compiled) || !options.ssr && options.isProduction && !!options.extractCss);
+}
+/**
+* Whether `generateOutput` will embed `compiled.css` in the module.
+*
+* The only consumer of `compiled.css` is the inline `<style>` injection, so this
+* is also the only case in which resolving the CSS's `@import`s affects the
+* output. Callers that would otherwise resolve `compiled.css` eagerly consult
+* this first, which keeps the condition in one place instead of duplicating
+* `generateOutput`'s branch structure at the call site.
+*
+* That guard matters because resolving `@import`s reads and inlines files and
+* crosses the native boundary with the whole stylesheet. A production client
+* build hands plain `<style>` blocks to Vite as virtual imports and an SSR build
+* emits no CSS at all, so in both cases the resolved text was previously built
+* and discarded, once per styled SFC on every build (270 discarded calls on the
+* 300-file bench corpus).
+*/
+function embedsInlineCss(compiled, options) {
+	return !usesStyleImports(compiled, options) && !options.customElement && !options.ssr && !!compiled.css && !(options.isProduction && !!options.extractCss);
+}
+function generateOutput(compiled, options) {
+	return generateOutputWithMap(compiled, options).code;
+}
+/**
+* `generateOutput` plus the source map that describes the module it returns.
+*
+* The compiler's map (`compiled.map`) describes `compiled.code`; every rewrite
+* below goes through {@link MappedModule}, which realigns the map to the lines
+* it inserts, so the returned map describes the returned code (#3399). `map` is
+* `null` when the compiler produced none.
+*/
+function generateOutputWithMap(compiled, options) {
+	const { customElement, isProduction, isDev, ssr, hmrUpdateType, extractCss, filePath } = options;
+	const emitted = new MappedModule(compiled.code, parseSourceMap(compiled.map));
+	const moduleInfo = compiled.moduleShape ?? analyzeModuleOutput(emitted.code);
+	const hasExportDefault = moduleInfo.hasDefaultExport;
+	const hasNamedRenderExport = moduleInfo.hasNamedRenderExport;
+	const hasNamedSsrRenderExport = moduleInfo.hasNamedSsrRenderExport;
+	const hasSfcMainDefined = moduleInfo.hasSfcMainDefined;
+	if (hasExportDefault && !hasSfcMainDefined) {
+		emitted.edit(rewriteDefaultExportToSfcMain(emitted.code, moduleInfo));
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
+	} else if (hasExportDefault && hasSfcMainDefined) {
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(insertBeforeSfcMainDefaultExport(emitted.code, `_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`, { moduleInfo }));
+	} else if (!hasExportDefault && !hasSfcMainDefined && hasNamedRenderExport) {
+		emitted.edit(`${emitted.code}\nconst _sfc_main = {};`);
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\n_sfc_main.render = render;`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
+	} else if (!hasExportDefault && !hasSfcMainDefined && hasNamedSsrRenderExport) {
+		emitted.edit(`${emitted.code}\nconst _sfc_main = {};`);
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\n_sfc_main.ssrRender = ssrRender;`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
+	}
+	if (usesStyleImports(compiled, options)) {
+		const styleImports = [];
+		const cssModuleImports = [];
+		const customElementStyleBindings = [];
+		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 (customElement) {
+				if (isCssModule(block)) throw new Error("<style module> is not supported in custom element mode");
+				params.set("inline", "");
+				const bindingName = `_style_${block.index}`;
+				const importUrl = createStyleImportUrl(filePath, params, block);
+				styleImports.push(`import ${bindingName} from ${JSON.stringify(importUrl)};`);
+				customElementStyleBindings.push(bindingName);
+			} else if (isCssModule(block)) {
+				const bindingName = typeof block.module === "string" ? block.module : "$style";
+				params.set("module", typeof block.module === "string" ? block.module : "");
+				const importUrl = createStyleImportUrl(filePath, params, block);
+				cssModuleImports.push(`import ${bindingName} from ${JSON.stringify(importUrl)};`);
+			} else {
+				const importUrl = createStyleImportUrl(filePath, params, block);
+				styleImports.push(`import ${JSON.stringify(importUrl)};`);
+			}
+		}
+		const allImports = [...styleImports, ...cssModuleImports].join("\n");
+		if (allImports) emitted.edit(insertAfterStaticImports(emitted.code, allImports));
+		if (customElementStyleBindings.length > 0) emitted.edit(insertBeforeSfcMainDefaultExport(emitted.code, `_sfc_main.styles = [${customElementStyleBindings.join(", ")}];`, { normalizeSemicolon: true }));
+		else 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");
+			emitted.edit(insertBeforeSfcMainDefaultExport(emitted.code, cssModuleSetup, { normalizeSemicolon: true }));
+		}
+	} else if (!ssr && compiled.css && !(isProduction && extractCss)) emitted.edit(prependInlineStyleInjection(emitted.code, compiled.css, compiled.scopeId));
+	if (!isProduction && isDev && hasExportDefault) {
+		const effectiveHmrUpdateType = hmrUpdateType === "template-only" && !supportsTemplateOnlyHmr(emitted.code) ? "full-reload" : hmrUpdateType ?? "full-reload";
+		emitted.edit(`${emitted.code}${generateHmrCode(compiled.scopeId, effectiveHmrUpdateType)}`);
+	}
+	return {
+		code: emitted.code,
+		map: emitted.map
+	};
+}
+const RESOLVED_CSS_MODULE = "\0vize:all-styles.css";
+/** Check if a module ID is a vize-compiled virtual module */
+function isVizeVirtual(id) {
+	return classifyVitePluginRequest(id).isVizeVirtual;
+}
+function isVizeSsrVirtual(id) {
+	return classifyVitePluginRequest(id).isVizeSsrVirtual;
+}
+/** Create a virtual module ID from a real .vue file path */
+function toVirtualId(realPath, ssr = false) {
+	return createViteVirtualId(realPath, ssr);
+}
+function toPluginVisibleVirtualId(realPath, ssr = false, querySuffix = "") {
+	const params = new URLSearchParams(querySuffix.startsWith("?") ? querySuffix.slice(1) : "");
+	params.delete("vue");
+	params.delete("vize");
+	params.delete("vize-ssr");
+	const rest = params.toString();
+	return `${realPath}.ts?vue&${ssr ? "vize-ssr" : "vize"}${rest ? `&${rest}` : ""}`;
+}
+/**
+* String pre-gate for {@link fromPluginVisibleVirtualId}, so ordinary module IDs
+* never cross the native boundary (#3427).
+*
+* A non-null result requires `request.path` to end with `.vue.ts` or `.vue.tsx`
+* and `request.querySuffix` to be non-empty. `request.path` is `id` up to the
+* first `?` and `querySuffix` is non-empty exactly when that `?` exists, so both
+* conditions imply these two substring tests. The tests are strictly weaker, so
+* everything the old code accepted still reaches the classifier.
+*/
+function mayBePluginVisibleVirtualId(id) {
+	return !id.startsWith("\0") && id.includes(".vue.ts") && id.includes("?");
+}
+function fromPluginVisibleVirtualId(id) {
+	if (!mayBePluginVisibleVirtualId(id)) return null;
+	const request = classifyVitePluginRequest(id);
+	if (!isPluginVisibleVueVirtualPath(request.path) || !request.querySuffix) return null;
+	const params = new URLSearchParams(request.querySuffix.slice(1));
+	if (!params.has("vue") || !params.has("vize") && !params.has("vize-ssr")) return null;
+	return stripPluginVisibleVueVirtualSuffix(stripFsPrefix(request.path));
+}
+/**
+* The `path` a second `classifyVitePluginRequest(request.normalizedFsId ?? id)`
+* used to recompute (#3427).
+*
+* `normalizedFsId` is `Some` exactly when the pre-`?` path starts with `/@fs`,
+* and its value is that path with the four-byte prefix removed plus the original
+* query suffix. Re-splitting that at the first `?` therefore yields the path
+* without the prefix — and when `normalizedFsId` is `undefined` the second call
+* classified `id` itself and yielded `request.path` unchanged.
+*/
+function stripFsPrefix(path) {
+	return path.startsWith("/@fs") ? path.slice(4) : path;
+}
+function isPluginVisibleVueVirtualPath(path) {
+	return path.endsWith(".vue.ts") || path.endsWith(".vue.tsx");
+}
+function stripPluginVisibleVueVirtualSuffix(path) {
+	if (path.endsWith(".vue.tsx")) return path.slice(0, -4);
+	return path.endsWith(".vue.ts") ? path.slice(0, -3) : path;
+}
+function isPluginVisibleSsrVirtualId(id) {
+	const request = classifyVitePluginRequest(id);
+	return request.querySuffix ? new URLSearchParams(request.querySuffix.slice(1)).has("vize-ssr") : false;
+}
+function toBrowserImportPrefix(replacement) {
+	return toViteBrowserImportPrefix(replacement);
+}
+//#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.
+*/
+function rewriteStaticAssetUrls(code, aliasRules) {
+	if (aliasRules.length === 0 || !code.includes("src")) return code;
+	return rewriteViteStaticAssetUrls(code, aliasRules);
+}
+function rewriteDynamicTemplateImports(code, aliasRules) {
+	if (!code.includes("import(") || !code.includes("`")) return code;
+	return rewriteViteDynamicTemplateImports(code, aliasRules);
+}
+function rewriteImportMetaGlobBase(code, importer, root) {
+	if (!code.includes("import.meta.glob")) return code;
+	return rewriteViteImportMetaGlobBase(code, importer, root);
+}
+function shouldApplyDefineInVirtualModule(key) {
+	return shouldApplyViteDefineInVirtualModule(key);
+}
+/**
+* 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) {
+	return applyViteDefineReplacements(code, Object.entries(defines).map(([key, value]) => ({
+		key,
+		value
+	})));
+}
+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/plugin/plugin-vue-options.ts
+const PLUGIN_VUE_COMPAT_VERSION = "6.0.7";
+const DEFAULT_CUSTOM_ELEMENT_PATTERN = /\.ce\.vue$/;
+function booleanCompilerOption(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function resolvePluginVueCompileOptions(options) {
+	const compilerOptions = options.template?.compilerOptions;
+	const resolved = { styleTrim: options.style?.trim ?? true };
+	const templateCacheHandlers = booleanCompilerOption(compilerOptions?.cacheHandlers);
+	const templateComments = booleanCompilerOption(compilerOptions?.comments);
+	const templateHoistStatic = booleanCompilerOption(compilerOptions?.hoistStatic);
+	const templatePrefixIdentifiers = booleanCompilerOption(compilerOptions?.prefixIdentifiers);
+	if (templateCacheHandlers !== void 0) resolved.templateCacheHandlers = templateCacheHandlers;
+	if (templateComments !== void 0) resolved.templateComments = templateComments;
+	if (templateHoistStatic !== void 0) resolved.templateHoistStatic = templateHoistStatic;
+	if (templatePrefixIdentifiers !== void 0) resolved.templatePrefixIdentifiers = templatePrefixIdentifiers;
+	return resolved;
+}
+function resolveCustomElementOption(options) {
+	const featureCustomElement = options.features?.customElement;
+	if (featureCustomElement) return featureCustomElement;
+	if (options.customElement !== void 0) return options.customElement;
+	return DEFAULT_CUSTOM_ELEMENT_PATTERN;
+}
+function isPluginVueCustomElement(options, filePath) {
+	const customElement = resolveCustomElementOption(options);
+	if (typeof customElement === "boolean") return customElement;
+	return createFilter(customElement, void 0)(filePath);
+}
+//#endregion
+//#region src/plugin/precompile.ts
+const DEFAULT_PRECOMPILE_IGNORE_PATTERNS = [
+	"node_modules/**",
+	"**/node_modules/**",
+	"dist/**",
+	"**/dist/**",
+	".git/**",
+	"**/.git/**",
+	".nuxt/**",
+	"**/.nuxt/**",
+	".output/**",
+	"**/.output/**",
+	".nitro/**",
+	"**/.nitro/**",
+	"coverage/**",
+	"**/coverage/**"
+];
+function isPrecompileSfcPath(path) {
+	return path.endsWith(".vue");
+}
+function diffPrecompileFiles(files, currentMetadata, previousMetadata) {
+	return diffVitePrecompileFiles([...files], toNativePrecompileMetadataEntries(currentMetadata), toNativePrecompileMetadataEntries(previousMetadata));
+}
+function normalizePrecompileBatchSize(value) {
+	return normalizeVitePrecompileBatchSize(value);
+}
+function chunkPrecompileFiles(files, batchSize, options = {}) {
+	return chunkVitePrecompileFiles([...files], batchSize, {
+		maxBytes: options.maxBytes,
+		metadata: options.metadata ? toNativePrecompileMetadataEntries(options.metadata) : void 0
+	});
+}
+function toNativePrecompileMetadataEntries(metadata) {
+	const entries = [];
+	for (const [path, value] of metadata) entries.push({
+		path,
+		mtimeMs: value.mtimeMs,
+		size: value.size
+	});
+	return entries;
+}
+//#endregion
+//#region src/plugin/state.ts
+function getEnvironmentCache(state, ssr) {
+	return ssr ? state.ssrCache : state.cache;
+}
+function getCompileOptionsForRequest(state, ssr) {
+	const options = {
+		sourceMap: state.mergedOptions?.sourceMap ?? (!state.isProduction || !!state.viteBuildSourcemap),
+		ssr,
+		vapor: !ssr && (state.mergedOptions?.vapor ?? false),
+		customRenderer: state.mergedOptions?.customRenderer ?? false,
+		templateSyntax: state.mergedOptions?.templateSyntax ?? "standard",
+		...resolvePluginVueCompileOptions(state.mergedOptions ?? {})
+	};
+	if (state.mergedOptions?.customElements !== void 0) options.customElements = state.mergedOptions.customElements;
+	if (state.mergedOptions?.mode !== void 0) options.mode = state.mergedOptions.mode;
+	if (state.mergedOptions?.runtimeModuleName !== void 0) options.runtimeModuleName = state.mergedOptions.runtimeModuleName;
+	if (state.mergedOptions?.runtimeGlobalName !== void 0) options.runtimeGlobalName = state.mergedOptions.runtimeGlobalName;
+	if (state.mergedOptions?.vueVersion !== void 0) options.vueVersion = state.mergedOptions.vueVersion;
+	if (state.mergedOptions?.experimentalInTagComments) options.experimentalInTagComments = true;
+	if (state.mergedOptions?.experimentalPatternedTemplate) options.experimentalPatternedTemplate = true;
+	if (state.mergedOptions?.experimentalSelfComponent) options.experimentalSelfComponent = true;
+	if (state.mergedOptions?.experimentalStrictSlotChildren) options.experimentalStrictSlotChildren = true;
+	if (state.mergedOptions?.experimentalServerScript) options.experimentalServerScript = true;
+	return options;
+}
+function syncCollectedCssForFile(state, filePath, compiled) {
+	if (!compiled || !state.extractCss) return;
+	if (compiled.styles?.length) {
+		state.collectedCss.delete(filePath);
+		return;
+	}
+	if (compiled.css && !hasDelegatedStyles(compiled)) state.collectedCss.set(filePath, resolveCssImports(compiled.css, filePath, state.cssAliasRules, false));
+	else state.collectedCss.delete(filePath);
+}
+function shouldExtractCssForRequest(state, ssr) {
+	return state.isProduction && !ssr;
+}
+function clearBuildCaches(state) {
+	state.cache.clear();
+	state.ssrCache.clear();
+	state.collectedCss.clear();
+	state.precompileMetadata.clear();
+	state.pendingHmrUpdateTypes.clear();
+	state.viteResolveCache?.clear();
+}
+//#endregion
+//#region src/plugin/compiled-module-cache.ts
+/**
+* Compiled-module caches carrying a reverse index from a `src`-imported
+* dependency to the SFCs that pulled it in.
+*
+* Every hot update has to answer "which SFCs own this changed file?" before it
+* can do anything else, and that answer used to come from a full scan of both
+* caches with a `path.resolve` per dependency per cached file. HMR latency then
+* grew with the number of components in the project, on the interactive path,
+* for every save — including saves of ordinary `.vue` files, because the scan
+* runs before the `.vue` fast path.
+*
+* The index is maintained by overriding `set`/`delete`/`clear` rather than by a
+* second structure updated at each call site. `state.cache` is handed to
+* `compileFile` and `compileBatch`, and is also mutated directly from
+* `precompile-run.ts`, `hmr.ts` and `state.ts`; a structure kept in sync by hand
+* across those would drift the first time a new writer appeared. Subclassing
+* puts the bookkeeping where the mutation is.
+*
+* The keys are `path.resolve`d exactly as the previous scan resolved them, so a
+* dependency recorded as a relative path indexes and looks up identically.
+*/
+var CompiledModuleCache = class extends Map {
+	#ownersByDependency = /* @__PURE__ */ new Map();
+	#dependenciesByOwner = /* @__PURE__ */ new Map();
+	/**
+	* Deliberately takes no entries: `Map`'s constructor would call the
+	* overridden `set` from inside `super()`, before `#ownersByDependency` exists.
+	*/
+	constructor() {
+		super();
+	}
+	set(file, compiled) {
+		this.#unindex(file);
+		super.set(file, compiled);
+		const dependencies = /* @__PURE__ */ new Set();
+		for (const dependency of compiled.dependencies ?? []) {
+			const key = path.resolve(dependency);
+			dependencies.add(key);
+			const owners = this.#ownersByDependency.get(key);
+			if (owners) owners.add(file);
+			else this.#ownersByDependency.set(key, new Set([file]));
+		}
+		this.#dependenciesByOwner.set(file, dependencies);
+		return this;
+	}
+	delete(file) {
+		this.#unindex(file);
+		return super.delete(file);
+	}
+	clear() {
+		this.#ownersByDependency.clear();
+		this.#dependenciesByOwner.clear();
+		super.clear();
+	}
+	/**
+	* Evict a compiled value while retaining the dependency ownership that is
+	* required to route another hot update before Vite reloads the owner module.
+	* The next `set` reconciles that retained snapshot with the new compilation.
+	*/
+	evict(file) {
+		return super.delete(file);
+	}
+	/** The cached SFCs that `src`-import `resolvedDependency`. */
+	ownersOf(resolvedDependency) {
+		const owners = this.#ownersByDependency.get(resolvedDependency);
+		return owners ? [...owners] : [];
+	}
+	#unindex(file) {
+		for (const dependency of this.#dependenciesByOwner.get(file) ?? []) {
+			const owners = this.#ownersByDependency.get(dependency);
+			if (!owners) continue;
+			owners.delete(file);
+			if (owners.size === 0) this.#ownersByDependency.delete(dependency);
+		}
+		this.#dependenciesByOwner.delete(file);
+	}
+};
+/**
+* Invalidate a compiled module without dropping its HMR dependency routing.
+* Hand-built plain Maps retain their historical delete behaviour.
+*/
+function evictCompiledModule(cache, file) {
+	return cache instanceof CompiledModuleCache ? cache.evict(file) : cache.delete(file);
+}
+/**
+* Owners of `resolvedDependency` in one cache.
+*
+* Plain `Map`s — the hand-built states in unit tests — keep the original linear
+* scan, so an unindexed cache answers exactly what the indexed one does.
+*/
+function ownersOfDependency(cache, resolvedDependency) {
+	if (cache instanceof CompiledModuleCache) return cache.ownersOf(resolvedDependency);
+	const owners = [];
+	for (const [file, compiled] of cache) if (compiled.dependencies?.some((dependency) => path.resolve(dependency) === resolvedDependency)) owners.push(file);
+	return owners;
+}
+//#endregion
+//#region src/compile-options.ts
+function buildCompileFileOptions(filePath, options) {
+	return {
+		filename: filePath,
+		sourceMap: options.sourceMap,
+		ssr: options.ssr,
+		vapor: options.vapor,
+		customRenderer: options.customRenderer ?? false,
+		...options.customElements === void 0 ? {} : { customElements: options.customElements },
+		experimentalInTagComments: options.experimentalInTagComments ?? false,
+		experimentalPatternedTemplate: options.experimentalPatternedTemplate ?? false,
+		experimentalSelfComponent: options.experimentalSelfComponent ?? false,
+		experimentalStrictSlotChildren: options.experimentalStrictSlotChildren ?? false,
+		experimentalServerScript: options.experimentalServerScript ?? false,
+		scopeId: `data-v-${generateScopeId(filePath)}`,
+		styleTrim: options.styleTrim,
+		...options.templateCacheHandlers === void 0 ? {} : { templateCacheHandlers: options.templateCacheHandlers },
+		...options.templateComments === void 0 ? {} : { templateComments: options.templateComments },
+		...options.templateHoistStatic === void 0 ? {} : { templateHoistStatic: options.templateHoistStatic },
+		...options.templatePrefixIdentifiers === void 0 ? {} : { templatePrefixIdentifiers: options.templatePrefixIdentifiers },
+		...options.mode === void 0 ? {} : { mode: options.mode },
+		...options.templateSyntax === void 0 ? {} : { templateSyntax: options.templateSyntax },
+		...options.runtimeModuleName === void 0 ? {} : { runtimeModuleName: options.runtimeModuleName },
+		...options.runtimeGlobalName === void 0 ? {} : { runtimeGlobalName: options.runtimeGlobalName },
+		...options.vueVersion == null ? {} : { vueVersion: String(options.vueVersion) }
+	};
+}
+function buildCompileBatchOptions(options) {
+	return {
+		ssr: options.ssr,
+		vapor: options.vapor,
+		customRenderer: options.customRenderer ?? false,
+		...options.customElements === void 0 ? {} : { customElements: options.customElements },
+		experimentalInTagComments: options.experimentalInTagComments ?? false,
+		experimentalPatternedTemplate: options.experimentalPatternedTemplate ?? false,
+		experimentalSelfComponent: options.experimentalSelfComponent ?? false,
+		experimentalStrictSlotChildren: options.experimentalStrictSlotChildren ?? false,
+		experimentalServerScript: options.experimentalServerScript ?? false,
+		includeStyles: true,
+		includeMacroArtifacts: true,
+		includeHashes: true,
+		includeSourceMap: options.sourceMap,
+		styleTrim: options.styleTrim,
+		...options.templateCacheHandlers === void 0 ? {} : { templateCacheHandlers: options.templateCacheHandlers },
+		...options.templateComments === void 0 ? {} : { templateComments: options.templateComments },
+		...options.templateHoistStatic === void 0 ? {} : { templateHoistStatic: options.templateHoistStatic },
+		...options.templatePrefixIdentifiers === void 0 ? {} : { templatePrefixIdentifiers: options.templatePrefixIdentifiers },
+		...options.mode === void 0 ? {} : { mode: options.mode },
+		...options.templateSyntax === void 0 ? {} : { templateSyntax: options.templateSyntax },
+		...options.runtimeModuleName === void 0 ? {} : { runtimeModuleName: options.runtimeModuleName },
+		...options.runtimeGlobalName === void 0 ? {} : { runtimeGlobalName: options.runtimeGlobalName },
+		...options.vueVersion == null ? {} : { vueVersion: String(options.vueVersion) }
+	};
+}
+//#endregion
+//#region src/compiler.ts
+const { compileSfc, compileSfcBatchWithResults } = native;
+const compileJsx = native.compileJsx;
+var VizeSfcCompileError = class extends Error {
+	filePath;
+	diagnostics;
+	constructor(filePath, diagnostics) {
+		super(formatCompileErrorMessage(filePath, diagnostics));
+		this.name = "VizeSfcCompileError";
+		this.filePath = filePath;
+		this.diagnostics = diagnostics;
+	}
+};
+function formatCompileErrorMessage(filePath, diagnostics) {
+	return `[vize] Compilation failed in ${filePath}:\n${diagnostics.map((diagnostic) => `  - ${diagnostic}`).join("\n")}`;
+}
+function normalizeStyleBlocks(styles) {
+	if (!styles) return [];
+	return styles.map((block) => ({
+		content: block.content,
+		src: block.src ?? null,
+		lang: block.lang ?? null,
+		scoped: block.scoped,
+		module: block.module ? block.moduleName ?? true : false,
+		index: block.index
+	}));
+}
+function resolveRelativeSrc(filePath, src) {
+	return path.isAbsolute(src) ? src : path.resolve(path.dirname(filePath), src);
+}
+function readSrcImport(filePath, tag, src) {
+	const resolvedPath = resolveRelativeSrc(filePath, src);
+	try {
+		return {
+			path: resolvedPath,
+			content: fs.readFileSync(resolvedPath, "utf-8")
+		};
+	} catch {
+		throw new Error(`[vize] <${tag} src="${src}"> not found (resolved: ${resolvedPath}) in ${filePath}`);
+	}
+}
+function stripSrcAttribute(attrs) {
+	return attrs.replace(/\s*\bsrc\s*=\s*(?:"[^"]*"|'[^']*')/i, "");
+}
+function inlineSingleSrcBlock(source, filePath, tag, src, dependencies) {
+	if (!src) return source;
+	const imported = readSrcImport(filePath, tag, src);
+	dependencies.push(imported.path);
+	const pattern = new RegExp(`<${tag}\\b([^>]*)\\bsrc\\s*=\\s*(['"])[^'"]+\\2([^>]*)>[\\s\\S]*?<\\/${tag}>`, "i");
+	return source.replace(pattern, (_match, beforeSrc, _quote, afterSrc) => {
+		return `<${tag}${stripSrcAttribute(`${beforeSrc}${afterSrc}`)}>\n${imported.content}\n</${tag}>`;
+	});
+}
+function inlineStyleSrcBlocks(source, filePath, dependencies) {
+	return source.replace(/<style\b([^>]*)\bsrc\s*=\s*(['"])([^'"]+)\2([^>]*)>[\s\S]*?<\/style>/gi, (_match, beforeSrc, _quote, src, afterSrc) => {
+		const imported = readSrcImport(filePath, "style", src);
+		dependencies.push(imported.path);
+		return `<style${stripSrcAttribute(`${beforeSrc}${afterSrc}`)}>\n${imported.content}\n</style>`;
+	});
+}
+/**
+* Cheap necessary condition for an SFC block carrying a `src` attribute.
+*
+* `extractSfcSrcInfo` parses a full SFC descriptor, so calling it for every file
+* costs a second whole-source parse per compile on top of the one the compiler
+* itself performs -- and block `src` attributes are rare (roughly 4% of files in
+* a real app). Any `<script src>`/`<template src>`/`<style src>` necessarily
+* contains `src` followed by `=`, so a source without this substring provably
+* has nothing to inline and can skip the descriptor parse entirely. False
+* positives (e.g. `<img src=...>` in a template) simply take the original path.
+*/
+const SFC_SRC_ATTRIBUTE_HINT = /\bsrc\s*=/i;
+function resolveSfcSrcImports(filePath, source) {
+	if (!SFC_SRC_ATTRIBUTE_HINT.test(source)) return {
+		source,
+		dependencies: []
+	};
+	const dependencies = [];
+	const srcInfo = native.extractSfcSrcInfo(source, filePath);
+	let resolvedSource = source;
+	resolvedSource = inlineSingleSrcBlock(resolvedSource, filePath, "script", srcInfo.scriptSrc, dependencies);
+	resolvedSource = inlineSingleSrcBlock(resolvedSource, filePath, "template", srcInfo.templateSrc, dependencies);
+	resolvedSource = inlineStyleSrcBlocks(resolvedSource, filePath, dependencies);
+	return {
+		source: resolvedSource,
+		dependencies
+	};
+}
+function compileFile(filePath, cache, options, source, diagnostics) {
+	const resolved = resolveSfcSrcImports(filePath, source ?? fs.readFileSync(filePath, "utf-8"));
+	const scopeId = generateScopeId(filePath);
+	const result = compileSfc(resolved.source, buildCompileFileOptions(filePath, options));
+	if (result.errors.length > 0) throw new VizeSfcCompileError(filePath, result.errors);
+	if (result.warnings.length > 0 && (diagnostics?.logWarnings ?? true)) result.warnings.forEach((warning) => {
+		console.warn(`[vize] Warning in ${filePath}: ${warning}`);
+	});
+	const compiled = {
+		code: result.code,
+		...result.map ? { map: result.map } : {},
+		css: result.css,
+		scopeId,
+		hasScoped: result.hasScoped,
+		templateHash: result.templateHash,
+		styleHash: result.styleHash,
+		scriptHash: result.scriptHash,
+		macroArtifacts: result.macroArtifacts ?? [],
+		styles: normalizeStyleBlocks(result.styles),
+		dependencies: resolved.dependencies
+	};
+	cache.set(filePath, compiled);
+	return compiled;
+}
+/**
+* Compile a `.jsx`/`.tsx` Vue component module to render code through Vize.
+*
+* Mirrors `compileFile` for SFCs but routes through the native `compileJsx`
+* binding. The returned `code` is a self-contained module (the runtime-helper
+* preamble is included, #1533), and `map` carries a v3 source map when
+* `sourceMap` is requested. A component's `<style scoped>` CSS is surfaced
+* (already scope-rewritten) and emitted through the same inline-injection path
+* plain SFC `<style>` blocks use (#1495, #1533).
+*/
+function compileJsxModule(filePath, source, options = {}) {
+	const result = compileJsx(source, {
+		filename: filePath,
+		lang: filePath.endsWith(".tsx") ? "tsx" : "jsx",
+		jsxMode: options.jsxMode,
+		jsxCompat: options.jsxCompat,
+		vapor: options.vapor ?? false,
+		sourceMap: options.sourceMap ?? false
+	});
+	if (result.errors.length > 0) throw new VizeSfcCompileError(filePath, result.errors);
+	const css = (result.scopedStyles ?? []).map((style) => style.css).join("\n");
+	let code = result.code;
+	let map = result.map ?? null;
+	if (css && !options.ssr) {
+		const styleKey = result.scopedStyles[0].scopeId.replace(/^data-v-/, "");
+		code = prependInlineStyleInjection(code, css, styleKey);
+		map = null;
+	}
+	return {
+		code,
+		map,
+		warnings: result.warnings
+	};
+}
+/**
+* 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 dependenciesByPath = /* @__PURE__ */ new Map();
+	const result = compileSfcBatchWithResults(files.map((file) => {
+		const resolved = resolveSfcSrcImports(file.path, file.source);
+		dependenciesByPath.set(file.path, resolved.dependencies);
+		return {
+			path: file.path,
+			source: resolved.source
+		};
+	}), buildCompileBatchOptions(options));
+	for (const fileResult of result.results) {
+		if (fileResult.errors.length === 0) cache.set(fileResult.path, {
+			code: fileResult.code,
+			...fileResult.map ? { map: fileResult.map } : {},
+			css: fileResult.css,
+			scopeId: fileResult.scopeId,
+			hasScoped: fileResult.hasScoped,
+			templateHash: fileResult.templateHash,
+			styleHash: fileResult.styleHash,
+			scriptHash: fileResult.scriptHash,
+			macroArtifacts: fileResult.macroArtifacts ?? [],
+			styles: normalizeStyleBlocks(fileResult.styles),
+			dependencies: dependenciesByPath.get(fileResult.path) ?? []
+		});
+		if (fileResult.errors.length > 0) console.error(formatCompileErrorMessage(fileResult.path, fileResult.errors));
+		if (fileResult.warnings.length > 0) fileResult.warnings.forEach((warning) => {
+			console.warn(`[vize] Warning in ${fileResult.path}: ${warning}`);
+		});
+	}
+	return result;
+}
+/**
+* SHA-256 of the exact source text handed to the compiler.
+*
+* `base64url` rather than hex: the same 256 bits in 43 characters instead of 64,
+* and the index carries one of these per entry.
+*/
+function hashPrecompileSource(source) {
+	return crypto.createHash("sha256").update(source, "utf8").digest("base64url");
+}
+/** Key-independent JSON: object key order must not change the hash. */
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (typeof value === "object" && value !== null) return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+function describeBinary(binary) {
+	try {
+		const stat = fs.statSync(binary);
+		return `${path.basename(binary)}:${stat.size}:${stat.mtimeMs}`;
+	} catch {
+		return `${path.basename(binary)}:unresolved`;
+	}
+}
+/**
+* Identity of the native compiler that produced (or would produce) the output.
+*
+* The package version covers releases; the binary's size and mtime cover local
+* `pnpm --dir npm/native build:debug` rebuilds, which change codegen without
+* changing any version. Hashing the binary itself would be airtight but costs
+* hundreds of milliseconds for a >30 MB artifact, so a rebuild is treated as a
+* new identity — a miss, never a stale hit.
+*/
+function resolveCompilerIdentity() {
+	const configured = process.env.NAPI_RS_NATIVE_LIBRARY_PATH;
+	try {
+		const manifestPath = createRequire(import.meta.url).resolve("@vizejs/native/package.json");
+		const packageDir = path.dirname(manifestPath);
+		const version = JSON.parse(fs.readFileSync(manifestPath, "utf-8")).version;
+		const binaries = configured ? [configured] : fs.readdirSync(packageDir).filter((name) => name.endsWith(".node")).sort().map((name) => path.join(packageDir, name));
+		return {
+			version: typeof version === "string" ? version : "unknown",
+			binaries: binaries.map(describeBinary)
+		};
+	} catch {
+		return {
+			version: "unresolved",
+			binaries: [configured ?? "unresolved"]
+		};
+	}
+}
+/**
+* Hash of everything outside the source text that changes compiled output.
+*
+* `compileOptions` must be the object actually handed to the native batch
+* compiler, so a newly added compile option cannot be forgotten here.
+*/
+function computePrecompileCacheKey(compileOptions) {
+	const material = stableStringify({
+		format: 3,
+		compiler: resolveCompilerIdentity(),
+		options: compileOptions
+	});
+	return crypto.createHash("sha256").update(material, "utf8").digest("hex").slice(0, 32);
+}
+//#endregion
+//#region src/plugin/precompile-cache-store.ts
+/**
+* On-disk container for the persistent pre-compile cache.
+*
+* The first format stored the whole manifest as one JSON document, which meant
+* every compiled module's `code` went to disk as a JSON-escaped string: ~87% of
+* the bytes were that one field, and a cold build paid `JSON.stringify` over all
+* of it while a warm build paid `JSON.parse` back. This container splits the
+* two concerns instead:
+*
+* ```text
+* <header JSON>\n<compressed index><compressed payload>
+* ```
+*
+* - The **header** is one line of plain JSON naming the format, the cache key,
+*   the codec, and the exact byte length of the two bodies.
+* - The **index** is a compressed JSON array of `[relativePath, sourceHash,
+*   recordLength]`. Record offsets are *not* stored: they are the running sum of
+*   the lengths, so there is no offset that can point somewhere else.
+* - The **payload** is the records back to back, each one
+*   `<meta JSON>\n<code utf8><css utf8>\n`. `code` and `css` are raw UTF-8, so
+*   the 90% of the manifest that is compiled output is never escaped, parsed, or
+*   re-quoted -- only sliced out.
+*
+* `meta` is `[codeLength, cssLength, everythingElse]`, where `everythingElse` is
+* the compiled module minus `code`/`css` **by rest destructuring**, not by a
+* hand-copied field list. A field added to `CompiledModule` later is therefore
+* carried through automatically instead of being silently dropped.
+*
+* Every structural expectation above is re-checked on read and any failure
+* returns `null`, which the caller treats as "no cache" -- a full recompile.
+* See `decodePrecompileManifest`.
+*/
+/** File extension of the container. Not `.json`: it is a header plus two blobs. */
+const PRECOMPILE_CACHE_EXTENSION = ".vpc";
+const LF = 10;
+const NEWLINE = Buffer.from("\n");
+const EMPTY = Buffer.alloc(0);
+/**
+* Whether `module` may be persisted.
+*
+* Modules assembled from `src` imports depend on sibling files that this cache
+* does not hash, so they are recompiled on every cold start instead.
+*/
+function isPersistablePrecompileModule(module) {
+	return !module.dependencies || module.dependencies.length === 0;
+}
+function isCompiledModule(value) {
+	if (value === null || typeof value !== "object") return false;
+	const module = value;
+	if (typeof module.code !== "string" || typeof module.scopeId !== "string") return false;
+	if (typeof module.hasScoped !== "boolean") return false;
+	if (module.css !== void 0 && typeof module.css !== "string") return false;
+	if (module.styles !== void 0 && !Array.isArray(module.styles)) return false;
+	if (module.macroArtifacts !== void 0 && !Array.isArray(module.macroArtifacts)) return false;
+	return isPersistablePrecompileModule(module);
+}
+/**
+* `zstd` when this Node has it, `gzip` otherwise.
+*
+* The sync zstd bindings arrived in Node 22.15 / 23.8 and this package supports
+* Node >= 22, so the codec is detected rather than assumed. Both codecs carry
+* an integrity check of their own -- zstd with `checksumFlag`, gzip with its
+* trailing CRC32 -- so bit rot inside either body fails decompression instead of
+* being decoded into a plausible-looking module.
+*/
+const hasZstd = typeof zlib.zstdCompressSync === "function" && typeof zlib.zstdDecompressSync === "function";
+const ZSTD_PARAMS = hasZstd ? { params: { [zlib.constants.ZSTD_c_checksumFlag]: 1 } } : void 0;
+function compressBody(body) {
+	return hasZstd ? zlib.zstdCompressSync(body, ZSTD_PARAMS) : zlib.gzipSync(body, { level: 1 });
+}
+/** `null` for an unknown codec, or one this Node cannot read. */
+function decompressBody(codec, body) {
+	if (codec === "zstd") return hasZstd ? zlib.zstdDecompressSync(body) : null;
+	if (codec === "gzip") return zlib.gunzipSync(body);
+	return null;
+}
+/** `<meta JSON>\n<code><css>\n` -- the trailing LF marks the record boundary. */
+function encodeRecord(module) {
+	const { code, css, ...rest } = module;
+	const codeBytes = Buffer.from(code, "utf8");
+	const cssBytes = css === void 0 ? null : Buffer.from(css, "utf8");
+	const meta = Buffer.from(JSON.stringify([
+		codeBytes.length,
+		cssBytes === null ? -1 : cssBytes.length,
+		rest
+	]), "utf8");
+	return Buffer.concat([
+		meta,
+		NEWLINE,
+		codeBytes,
+		cssBytes ?? EMPTY,
+		NEWLINE
+	]);
+}
+/** Serialize the container. Never throws for well-typed entries. */
+function encodePrecompileManifest(options) {
+	const { key, root, entries } = options;
+	const index = [];
+	const records = [];
+	for (const [file, entry] of entries) {
+		const record = encodeRecord(entry.module);
+		index.push([
+			path.relative(root, file),
+			entry.hash,
+			record.length
+		]);
+		records.push(record);
+	}
+	const indexBody = compressBody(Buffer.from(JSON.stringify(index), "utf8"));
+	const payloadBody = compressBody(Buffer.concat(records));
+	const header = Buffer.from(JSON.stringify({
+		format: 3,
+		key,
+		codec: hasZstd ? "zstd" : "gzip",
+		index: indexBody.length,
+		payload: payloadBody.length
+	}), "utf8");
+	return Buffer.concat([
+		header,
+		NEWLINE,
+		indexBody,
+		payloadBody
+	]);
+}
+function isByteLength(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isIndexRow(value) {
+	return Array.isArray(value) && value.length === 3 && typeof value[0] === "string" && value[0].length > 0 && typeof value[1] === "string" && value[1].length > 0 && isByteLength(value[2]) && value[2] > 0;
+}
+/** Rebuild one module from its payload record, or `null` if the record is not one. */
+function decodeRecord(record) {
+	if (record.at(-1) !== LF) return null;
+	const metaEnd = record.indexOf(LF);
+	if (metaEnd < 0 || metaEnd >= record.length - 1) return null;
+	let meta;
+	try {
+		meta = JSON.parse(record.toString("utf8", 0, metaEnd));
+	} catch {
+		return null;
+	}
+	if (!Array.isArray(meta) || meta.length !== 3) return null;
+	const [codeLength, cssLength, rest] = meta;
+	if (!isByteLength(codeLength) || typeof cssLength !== "number") return null;
+	if (!isByteLength(cssLength) && cssLength !== -1) return null;
+	const cssBytes = cssLength === -1 ? 0 : cssLength;
+	if (metaEnd + 1 + codeLength + cssBytes + 1 !== record.length) return null;
+	if (typeof rest !== "object" || rest === null || Array.isArray(rest)) return null;
+	if ("code" in rest || "css" in rest) return null;
+	const codeStart = metaEnd + 1;
+	const cssStart = codeStart + codeLength;
+	const module = {
+		...rest,
+		code: record.toString("utf8", codeStart, cssStart)
+	};
+	if (cssLength !== -1) module.css = record.toString("utf8", cssStart, cssStart + cssLength);
+	return isCompiledModule(module) ? module : null;
+}
+/**
+* Parse the container, or return `null`.
+*
+* `null` is indistinguishable from having no cache at all, which is exactly the
+* safe outcome: recompile everything. Every gate below fails that way --
+* a missing or unparsable header, a foreign `format` or `key`, a codec this Node
+* cannot read, body lengths that do not account for the file exactly (a
+* truncated or partially written container), a body that fails its own
+* decompression checksum, an index that is not the expected shape, and record
+* lengths that do not sum to the payload. An individual entry whose record does
+* not decode into a valid `CompiledModule` is dropped on its own, as in format 1;
+* because offsets come from the index alone, one bad record cannot shift the
+* others.
+*/
+function decodePrecompileManifest(bytes, options) {
+	const { key, root, onReject } = options;
+	const reject = (reason) => {
+		onReject?.(reason);
+		return null;
+	};
+	const headerEnd = bytes.indexOf(LF);
+	if (headerEnd < 0) return reject("no header");
+	let header;
+	try {
+		header = JSON.parse(bytes.toString("utf8", 0, headerEnd));
+	} catch {
+		return reject("unparsable header");
+	}
+	if (typeof header !== "object" || header === null || Array.isArray(header)) return reject("unrecognized header");
+	if (header.format !== 3 || header.key !== key) return reject("foreign format or key");
+	if (!isByteLength(header.index) || !isByteLength(header.payload)) return reject("unrecognized body lengths");
+	const indexStart = headerEnd + 1;
+	const payloadStart = indexStart + header.index;
+	if (payloadStart + header.payload !== bytes.length) return reject("truncated container");
+	let bodies;
+	try {
+		const indexText = decompressBody(header.codec, bytes.subarray(indexStart, payloadStart));
+		const payloadText = decompressBody(header.codec, bytes.subarray(payloadStart));
+		bodies = indexText === null || payloadText === null ? null : [indexText, payloadText];
+	} catch {
+		return reject("corrupt body");
+	}
+	if (bodies === null) return reject(`unsupported codec ${JSON.stringify(header.codec)}`);
+	const [indexText, payload] = bodies;
+	let index;
+	try {
+		index = JSON.parse(indexText.toString("utf8"));
+	} catch {
+		return reject("unparsable index");
+	}
+	if (!Array.isArray(index)) return reject("unrecognized index");
+	const entries = /* @__PURE__ */ new Map();
+	let offset = 0;
+	for (const row of index) {
+		if (!isIndexRow(row)) return reject("unrecognized index row");
+		const [relative, hash, length] = row;
+		const end = offset + length;
+		if (end > payload.length) return reject("index overruns payload");
+		const module = decodeRecord(payload.subarray(offset, end));
+		offset = end;
+		if (module !== null) entries.set(path.resolve(root, relative), {
+			hash,
+			module
+		});
+	}
+	if (offset !== payload.length) return reject("payload not fully described by the index");
+	return entries;
+}
+//#endregion
+//#region src/plugin/precompile-cache.ts
+/**
+* Persistent (on-disk) pre-compile cache.
+*
+* `state.precompileMetadata` plus `state.cache` already skip recompilation
+* inside one process, but both are empty on every process start, so `vite
+* build`, CI, and each dev-server start recompile the whole scan from scratch.
+* This module backs them with a manifest under
+* `node_modules/.vize/vite-precompile/` so a cold process can restore the
+* previous run's output.
+*
+* The two invalidation gates -- manifest identity and per-entry source hash --
+* live in `./precompile-cache-key.ts`, which documents why each one is safe.
+* Two more gates live in `./precompile-cache-store.ts`, which owns the on-disk
+* container:
+*
+* - **Shape.** Entries are validated before use and dropped individually if
+*   they do not describe a complete `CompiledModule`. The container's own
+*   `format`/`key` are re-checked after parsing, so a manifest reached by any
+*   route other than its key still gets rejected.
+* - **`src` imports.** SFCs that pull blocks in through `<script src>` /
+*   `<template src>` / `<style src>` are never persisted: their output depends
+*   on files whose content this cache does not hash.
+*
+* A missing, truncated, or corrupt manifest degrades to a full recompile: every
+* read is guarded and any failure yields an empty cache. Writes go through a
+* sibling temp file and a rename, so an interrupted write cannot be read back.
+*
+* Set `VIZE_PRECOMPILE_CACHE=0` to force a full recompile without editing any
+* config.
+*/
+/** Manifest location, relative to the Vite root. */
+const PRECOMPILE_CACHE_DIR = path.join("node_modules", ".vize", "vite-precompile");
+/** Set to `0`/`false` to force a full recompile without editing the config. */
+const PRECOMPILE_CACHE_ENV = "VIZE_PRECOMPILE_CACHE";
+/** Whether the environment forces the cache off. */
+function isPrecompileCacheDisabledByEnv(env = process.env) {
+	const value = env[PRECOMPILE_CACHE_ENV];
+	return value === "0" || value === "false";
+}
+const disabledCache = {
+	file: null,
+	get: () => void 0,
+	set: () => {},
+	delete: () => {},
+	retain: () => {},
+	flush: () => false
+};
+/** A cache that never hits and never writes. */
+function createDisabledPrecompileCache() {
+	return disabledCache;
+}
+function openPrecompileCache(options) {
+	const { root, compileOptions, onDiagnostic, env = process.env } = options;
+	if (!root || isPrecompileCacheDisabledByEnv(env)) return createDisabledPrecompileCache();
+	const key = computePrecompileCacheKey(compileOptions);
+	const file = path.join(root, PRECOMPILE_CACHE_DIR, `${key}${PRECOMPILE_CACHE_EXTENSION}`);
+	const entries = readManifestEntries(file, key, root, onDiagnostic);
+	let dirty = false;
+	return {
+		file,
+		get(filePath, sourceHash) {
+			const entry = entries.get(filePath);
+			return entry && entry.hash === sourceHash ? entry.module : void 0;
+		},
+		set(filePath, sourceHash, module) {
+			if (!isPersistablePrecompileModule(module)) {
+				if (entries.delete(filePath)) dirty = true;
+				return;
+			}
+			const existing = entries.get(filePath);
+			if (existing?.hash === sourceHash && existing.module === module) return;
+			entries.set(filePath, {
+				hash: sourceHash,
+				module
+			});
+			dirty = true;
+		},
+		delete(filePath) {
+			if (entries.delete(filePath)) dirty = true;
+		},
+		retain(files) {
+			const keep = files instanceof Set ? files : new Set(files);
+			for (const filePath of entries.keys()) if (!keep.has(filePath)) {
+				entries.delete(filePath);
+				dirty = true;
+			}
+		},
+		flush() {
+			if (!dirty) return false;
+			let container;
+			try {
+				container = encodePrecompileManifest({
+					key,
+					root,
+					entries
+				});
+			} catch (error) {
+				onDiagnostic?.(`Failed to encode pre-compile cache ${file}:`, error);
+				return false;
+			}
+			if (!writeManifest(file, container, onDiagnostic)) return false;
+			removeFormat1Manifests(path.dirname(file));
+			dirty = false;
+			return true;
+		}
+	};
+}
+/**
+* Drop the `.json` manifests format 1 left behind.
+*
+* Nothing can read them any more, and they are the reason this change exists:
+* ~9 KB per SFC, so ~27 MB for a 3000-SFC project sitting in `node_modules`
+* forever after an upgrade. Only `.json` is removed, which is exactly the set
+* format 1 wrote; every live manifest is a `.vpc`, and a project legitimately
+* keeps one per compile-option set. Best effort -- a failure here is not worth
+* a diagnostic, let alone a failed build.
+*/
+function removeFormat1Manifests(dir) {
+	try {
+		for (const name of fs.readdirSync(dir)) if (name.endsWith(".json")) fs.rmSync(path.join(dir, name), { force: true });
+	} catch {}
+}
+/**
+* Read the container, or return an empty map.
+*
+* A missing, truncated, corrupt, or foreign manifest is indistinguishable from
+* no cache at all, which is exactly the safe outcome: recompile everything.
+*/
+function readManifestEntries(file, key, root, onDiagnostic) {
+	let bytes;
+	try {
+		bytes = fs.readFileSync(file);
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+	return decodePrecompileManifest(bytes, {
+		key,
+		root,
+		onReject: (reason) => onDiagnostic?.(`Ignoring pre-compile cache ${file}: ${reason}`)
+	}) ?? /* @__PURE__ */ new Map();
+}
+/** Write through a sibling temp file so a crash cannot leave a partial manifest. */
+function writeManifest(file, container, onDiagnostic) {
+	const temp = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+	try {
+		fs.mkdirSync(path.dirname(file), { recursive: true });
+		fs.writeFileSync(temp, container);
+		fs.renameSync(temp, file);
+		return true;
+	} catch (error) {
+		try {
+			fs.rmSync(temp, { force: true });
+		} catch {}
+		onDiagnostic?.(`Failed to write pre-compile cache ${file}:`, error);
+		return false;
+	}
+}
+//#endregion
+//#region src/plugin/precompile-run.ts
+/**
+* The pre-compilation pass.
+*
+* Scans the configured patterns, diffs them against the previous in-process
+* run, restores whatever the persistent cache can prove is still valid, and
+* batch-compiles the rest. Extracted from `state.ts` so the state module stays
+* a state module.
+*/
+/**
+* The options the pre-compile batch actually compiles with.
+*
+* Also the input to the cache key, so the two can never drift: a new option
+* that reaches the native compiler reaches the key with it.
+*/
+function resolvePrecompileBatchOptions(state) {
+	const requestOptions = getCompileOptionsForRequest(state, false);
+	return {
+		sourceMap: requestOptions.sourceMap,
+		ssr: false,
+		vapor: state.mergedOptions.vapor ?? false,
+		mode: state.mergedOptions.mode,
+		customRenderer: state.mergedOptions.customRenderer ?? false,
+		customElements: state.mergedOptions.customElements,
+		templateSyntax: state.mergedOptions.templateSyntax ?? "standard",
+		experimentalInTagComments: state.mergedOptions.experimentalInTagComments ?? false,
+		experimentalPatternedTemplate: state.mergedOptions.experimentalPatternedTemplate ?? false,
+		experimentalSelfComponent: state.mergedOptions.experimentalSelfComponent ?? false,
+		experimentalStrictSlotChildren: state.mergedOptions.experimentalStrictSlotChildren ?? false,
+		experimentalServerScript: state.mergedOptions.experimentalServerScript ?? false,
+		runtimeModuleName: state.mergedOptions.runtimeModuleName,
+		runtimeGlobalName: state.mergedOptions.runtimeGlobalName,
+		vueVersion: state.mergedOptions.vueVersion,
+		styleTrim: requestOptions.styleTrim,
+		templateCacheHandlers: requestOptions.templateCacheHandlers,
+		templateComments: requestOptions.templateComments,
+		templateHoistStatic: requestOptions.templateHoistStatic,
+		templatePrefixIdentifiers: requestOptions.templatePrefixIdentifiers
+	};
+}
+function openCacheForRun(state, batchOptions) {
+	if (!state.root) return createDisabledPrecompileCache();
+	return openPrecompileCache({
+		root: state.root,
+		compileOptions: buildCompileBatchOptions(batchOptions),
+		onDiagnostic: (message, error) => error === void 0 ? state.logger.warn(message) : state.logger.warn(message, error)
+	});
+}
+/**
+* Pre-compile all Vue files matching scan patterns.
+*/
+async function compileAll(state) {
+	const startTime = performance.now();
+	const sfcFiles = (await glob(state.scanPatterns, {
+		cwd: state.root,
+		ignore: state.ignorePatterns,
+		absolute: true,
+		followSymbolicLinks: false
+	})).filter(isPrecompileSfcPath);
+	const currentMetadata = /* @__PURE__ */ new Map();
+	for (const file of sfcFiles) 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(sfcFiles, currentMetadata, state.precompileMetadata);
+	const cachedFileCount = sfcFiles.length - changedFiles.length;
+	for (const file of deletedFiles) {
+		state.cache.delete(file);
+		state.ssrCache.delete(file);
+		if (state.extractCss) state.collectedCss.delete(file);
+		state.precompileMetadata.delete(file);
+		state.pendingHmrUpdateTypes.delete(file);
+	}
+	state.logger.info(`Pre-compiling ${sfcFiles.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;
+	}
+	for (const file of changedFiles) {
+		if (state.extractCss) state.collectedCss.delete(file);
+		state.pendingHmrUpdateTypes.delete(file);
+	}
+	const batchOptions = resolvePrecompileBatchOptions(state);
+	const cache = openCacheForRun(state, batchOptions);
+	const cacheEnabled = cache.file !== null;
+	let successCount = 0;
+	let restoredCount = 0;
+	let failedCount = 0;
+	let nativeTimeMs = 0;
+	const precompileFailures = [];
+	const chunks = chunkPrecompileFiles(changedFiles, state.precompileBatchSize, { metadata: currentMetadata });
+	for (const chunk of chunks) {
+		const fileContents = [];
+		const sourceHashes = /* @__PURE__ */ new Map();
+		for (const file of chunk) {
+			let source;
+			try {
+				source = fs.readFileSync(file, "utf-8");
+			} catch (e) {
+				failedCount++;
+				state.cache.delete(file);
+				if (state.extractCss) state.collectedCss.delete(file);
+				state.precompileMetadata.delete(file);
+				cache.delete(file);
+				precompileFailures.push(`[vize] Failed to read ${file}: ${formatUnknownError$2(e)}`);
+				state.logger.error(`Failed to read ${file}:`, e);
+				continue;
+			}
+			const sourceHash = cacheEnabled ? hashPrecompileSource(source) : void 0;
+			const restored = sourceHash === void 0 ? void 0 : cache.get(file, sourceHash);
+			if (restored) {
+				state.cache.set(file, restored);
+				const metadata = currentMetadata.get(file);
+				if (metadata) state.precompileMetadata.set(file, metadata);
+				syncCollectedCssForFile({
+					...state,
+					extractCss: state.extractCss && !isPluginVueCustomElement(state.mergedOptions, file)
+				}, file, restored);
+				restoredCount++;
+				continue;
+			}
+			if (sourceHash !== void 0) sourceHashes.set(file, sourceHash);
+			fileContents.push({
+				path: file,
+				source
+			});
+		}
+		if (fileContents.length === 0) continue;
+		const result = compileBatch(fileContents, state.cache, batchOptions);
+		const chunkFailedCount = result.results.filter((fileResult) => fileResult.errors.length > 0).length;
+		failedCount += chunkFailedCount;
+		successCount += result.results.length - chunkFailedCount;
+		nativeTimeMs += result.timeMs;
+		for (const fileResult of result.results) {
+			const metadata = currentMetadata.get(fileResult.path);
+			if (fileResult.errors.length > 0) {
+				state.cache.delete(fileResult.path);
+				if (state.extractCss) state.collectedCss.delete(fileResult.path);
+				state.precompileMetadata.delete(fileResult.path);
+				cache.delete(fileResult.path);
+				precompileFailures.push(formatCompileErrorMessage(fileResult.path, fileResult.errors));
+				continue;
+			}
+			if (metadata) state.precompileMetadata.set(fileResult.path, metadata);
+			const compiled = state.cache.get(fileResult.path);
+			const sourceHash = sourceHashes.get(fileResult.path);
+			if (compiled && sourceHash !== void 0) cache.set(fileResult.path, sourceHash, compiled);
+			syncCollectedCssForFile({
+				...state,
+				extractCss: state.extractCss && !isPluginVueCustomElement(state.mergedOptions, fileResult.path)
+			}, fileResult.path, compiled);
+		}
+	}
+	cache.retain(new Set(sfcFiles));
+	cache.flush();
+	const elapsed = (performance.now() - startTime).toFixed(2);
+	const batchLabel = chunks.length === 1 ? "batch" : "batches";
+	state.logger.info(`Pre-compilation complete: ${successCount} recompiled, ${restoredCount} restored from disk, ${cachedFileCount} reused, ${failedCount} failed (${elapsed}ms, native ${batchLabel}: ${nativeTimeMs.toFixed(2)}ms)`);
+	if (failedCount > 0) {
+		const details = precompileFailures.length > 0 ? `\n\n${precompileFailures.join("\n\n")}` : "";
+		throw new Error(`[vize] Pre-compilation failed for ${failedCount} file(s).${details}`);
+	}
+}
+function formatUnknownError$2(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/plugin/importer.ts
+function isInsidePath(parent, child) {
+	const relative = path.relative(parent, child);
+	return relative === "" || !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function normalizeNuxtVirtualImporterPath(importer) {
+	const { request } = splitViteIdQuery(importer);
+	for (const prefix of ["/@id/virtual:nuxt:", "virtual:nuxt:"]) {
+		if (!request.startsWith(prefix)) continue;
+		const encodedPath = request.slice(prefix.length);
+		try {
+			return decodeURIComponent(encodedPath);
+		} catch {
+			return encodedPath;
+		}
+	}
+	return null;
+}
+function normalizeImporterFilePath(importer) {
+	const nuxtVirtualPath = normalizeNuxtVirtualImporterPath(importer);
+	if (nuxtVirtualPath) return nuxtVirtualPath;
+	const request = classifyVitePluginRequest(importer);
+	return request.normalizedFsId ?? request.strippedVirtualPath ?? request.vizeVirtualPath ?? request.normalizedVuePath ?? splitViteIdQuery(importer).request;
+}
+function isProjectSourceImporter(root, importer) {
+	if (!importer) return false;
+	const importerPath = normalizeImporterFilePath(importer);
+	if (!path.isAbsolute(importerPath)) return false;
+	if (importerPath.split(path.sep).join("/").includes("/node_modules/")) return false;
+	if (isInsidePath(root, importerPath)) return true;
+	try {
+		return isInsidePath(fs.realpathSync(root), fs.realpathSync(importerPath));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/plugin/package-imports.ts
+const PACKAGE_IMPORT_CONDITIONS = [
+	"browser",
+	"import",
+	"module",
+	"default",
+	"node",
+	"require",
+	"types"
+];
+function resolvePackageJsonImportFromVizeImporter(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	if (!request.startsWith("#")) return null;
+	const seen = /* @__PURE__ */ new Set();
+	for (const base of createViteBareImportBases(state.root, importer)) {
+		const packageRoot = findPackageScope(base);
+		if (!packageRoot || seen.has(packageRoot)) continue;
+		seen.add(packageRoot);
+		const direct = tryRequireResolve(path.join(packageRoot, "package.json"), request, querySuffix);
+		if (direct) return direct;
+		const imports = readPackageImports(packageRoot);
+		const target = imports ? resolvePackageImportTarget(imports, request) : null;
+		const resolved = target ? resolvePackageImportTargetPath(packageRoot, target, importer, querySuffix) : null;
+		if (resolved) return resolved;
+	}
+	return null;
+}
+function findPackageScope(base) {
+	let current = fs.existsSync(base) && fs.statSync(base).isDirectory() ? base : path.dirname(base);
+	while (current !== path.dirname(current)) {
+		if (fs.existsSync(path.join(current, "package.json"))) return current;
+		current = path.dirname(current);
+	}
+	return null;
+}
+function tryRequireResolve(base, request, querySuffix) {
+	try {
+		return `${createRequire(base).resolve(request)}${querySuffix}`;
+	} catch {
+		return null;
+	}
+}
+function readPackageImports(packageRoot) {
+	try {
+		const json = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+		return isPlainObject(json.imports) ? json.imports : null;
+	} catch {
+		return null;
+	}
+}
+function resolvePackageImportTarget(imports, request) {
+	const exact = resolveConditionalTarget(imports[request]);
+	if (exact) return exact;
+	let best = null;
+	for (const [key, value] of Object.entries(imports)) {
+		const starIndex = key.indexOf("*");
+		if (starIndex === -1) continue;
+		const prefix = key.slice(0, starIndex);
+		const suffix = key.slice(starIndex + 1);
+		if (!request.startsWith(prefix) || !request.endsWith(suffix)) continue;
+		const target = resolveConditionalTarget(value);
+		if (!target || best && key.length <= best.keyLength) continue;
+		const matched = request.slice(prefix.length, request.length - suffix.length);
+		best = {
+			keyLength: key.length,
+			target: target.replaceAll("*", matched)
+		};
+	}
+	return best?.target ?? null;
+}
+function resolveConditionalTarget(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const target = resolveConditionalTarget(item);
+			if (target) return target;
+		}
+		return null;
+	}
+	if (!isPlainObject(value)) return null;
+	for (const condition of PACKAGE_IMPORT_CONDITIONS) {
+		const target = resolveConditionalTarget(value[condition]);
+		if (target) return target;
+	}
+	return null;
+}
+function resolvePackageImportTargetPath(packageRoot, target, importer, querySuffix) {
+	const { request } = splitViteIdQuery(target);
+	if (request.startsWith("./")) {
+		const resolved = resolveViteRelativeImport(request, path.join(packageRoot, "package.json"));
+		return resolved && isInsidePackage(packageRoot, resolved) ? `${resolved}${querySuffix}` : null;
+	}
+	if (request.startsWith("../")) return null;
+	if (path.isAbsolute(request)) return fs.existsSync(request) ? `${request}${querySuffix}` : null;
+	return tryRequireResolve(importer, request, querySuffix);
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isInsidePackage(packageRoot, resolved) {
+	const relative = path.relative(packageRoot, splitViteIdQuery(resolved).request);
+	return relative === "" || !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+//#endregion
+//#region src/plugin/resolve-relative-vue.ts
+function cleanVueSfcImporter(importer, request) {
+	let cleanImporter = request?.normalizedFsId ?? request?.normalizedVuePath ?? importer;
+	if (cleanImporter.startsWith("/@id/__x00__")) cleanImporter = cleanImporter.slice(12);
+	else if (cleanImporter.startsWith("__x00__")) cleanImporter = cleanImporter.slice(7);
+	return classifyVitePluginRequest(cleanImporter).normalizedVuePath;
+}
+async function resolveRelativeVueSfcImport(ctx, state, id, cleanImporter, isSsrRequest, isDependencyScan, resolveWithVite) {
+	if (!id.startsWith("./") && !id.startsWith("../")) return null;
+	const { request, querySuffix } = splitViteIdQuery(id);
+	if (!request.endsWith(".vue")) return null;
+	const resolved = await resolveWithVite(ctx, state, id, cleanImporter, { skipSelf: true });
+	if (!resolved) return null;
+	const resolvedRequest = classifyVitePluginRequest(resolved.id);
+	const resolvedPath = resolvedRequest.normalizedFsId ?? resolvedRequest.normalizedVuePath;
+	if (!resolvedPath || !resolvedPath.endsWith(".vue")) return resolved;
+	const effectiveQuery = resolvedRequest.querySuffix || querySuffix;
+	return isDependencyScan ? toVirtualId(resolvedPath, isSsrRequest) : toPluginVisibleVirtualId(resolvedPath, isSsrRequest, effectiveQuery);
+}
+//#endregion
+//#region src/plugin/resolve.ts
+function resolveVuePath(state, id, importer) {
+	return resolveViteVuePath(state.root, id, importer);
+}
+const EMPTY_NATIVE_ALIAS_RULES = [];
+const VUE_PEER_RUNTIME_PACKAGES = new Set(["vue-router"]);
+const VUE_PEER_RUNTIME_ESM_ENTRIES = new Map([["vue-router", [
+	"dist/vue-router.mjs",
+	"dist/vue-router.js",
+	"index.mjs",
+	"index.js"
+]]]);
+function getViteResolveCache(state) {
+	return state.viteResolveCache ??= /* @__PURE__ */ new Map();
+}
+function createViteResolveCacheKey(id, importer, options, environmentName) {
+	return JSON.stringify([
+		environmentName ?? null,
+		id,
+		importer ?? null,
+		options?.skipSelf ?? false
+	]);
+}
+function resolveWithVite(ctx, state, id, importer, options) {
+	if (state.server !== null) return ctx.resolve(id, importer, options);
+	const cache = getViteResolveCache(state);
+	const key = createViteResolveCacheKey(id, importer, options, ctx.environment?.name);
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const pending = ctx.resolve(id, importer, options).catch((error) => {
+		cache.delete(key);
+		throw error;
+	});
+	cache.set(key, pending);
+	return pending;
+}
+function resolveAliasRequest(state, id) {
+	return resolveViteAliasRequest(id, nativeCssAliasRules(state));
+}
+function getBarePackageName(id) {
+	if (!isViteBareSpecifier(id)) return null;
+	const segments = id.split("/");
+	if (id.startsWith("@")) return segments.length >= 2 ? `${segments[0]}/${segments[1]}` : null;
+	return segments[0] || null;
+}
+function resolveBareImportFromPnpmHoist(request, base) {
+	const packageName = getBarePackageName(request);
+	if (!packageName) return null;
+	let current = path.dirname(base);
+	while (current !== path.dirname(current)) {
+		const directPackage = path.join(current, "node_modules", packageName);
+		if (fs.existsSync(directPackage)) return null;
+		const hoistRoot = path.join(current, "node_modules", ".pnpm", "node_modules");
+		const hoistedPackage = path.join(hoistRoot, packageName);
+		if (fs.existsSync(hoistedPackage)) try {
+			return createRequire(path.join(hoistRoot, "__vize_probe__.js")).resolve(request);
+		} catch {}
+		current = path.dirname(current);
+	}
+	return null;
+}
+function resolveBareImportWithNode(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	for (const candidate of createViteBareImportBases(state.root, importer)) {
+		const hoisted = resolveBareImportFromPnpmHoist(request, candidate);
+		if (hoisted) return `${hoisted}${querySuffix}`;
+		try {
+			return `${createRequire(candidate).resolve(request)}${querySuffix}`;
+		} catch {}
+	}
+	return null;
+}
+function resolveBareImportFromPnpmHoistWithNode(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	for (const candidate of createViteBareImportBases(state.root, importer)) {
+		const hoisted = resolveBareImportFromPnpmHoist(request, candidate);
+		if (hoisted) return `${hoisted}${querySuffix}`;
+	}
+	return null;
+}
+function resolveBareImportCandidatesWithNode(state, id, importer, resolvedId) {
+	for (const candidate of createViteBareImportCandidates(id, nativeCssAliasRules(state), resolvedId)) {
+		const resolved = resolveBareImportWithNode(state, candidate, importer);
+		if (resolved) return resolved;
+	}
+	return null;
+}
+function findPackageRoot(resolvedFile) {
+	let current = path.dirname(resolvedFile);
+	while (current !== path.dirname(current)) {
+		if (fs.existsSync(path.join(current, "package.json"))) return current;
+		current = path.dirname(current);
+	}
+	return null;
+}
+function resolvePackageRootWithNode(state, packageName, importer) {
+	const packageJson = resolveBareImportWithNode(state, `${packageName}/package.json`, importer);
+	if (packageJson) return path.dirname(packageJson);
+	const resolvedEntry = resolveBareImportWithNode(state, packageName, importer);
+	return resolvedEntry ? findPackageRoot(resolvedEntry) : null;
+}
+function resolveVueBundlerEntryWithNode(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	let relativeEntries;
+	if (request === "vue") relativeEntries = [
+		"dist/vue.runtime.esm-bundler.js",
+		"dist/vue.esm-bundler.js",
+		"index.mjs"
+	];
+	else if (request.startsWith("vue/dist/") && request.endsWith(".js")) relativeEntries = [request.slice(4)];
+	else return null;
+	const packageRoot = resolvePackageRootWithNode(state, "vue", importer);
+	if (!packageRoot) return null;
+	for (const relativeEntry of relativeEntries) {
+		const entry = path.join(packageRoot, relativeEntry);
+		if (fs.existsSync(entry)) return `${entry}${querySuffix}`;
+	}
+	return null;
+}
+function resolveVueBundlerEntryFromPnpmHoist(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	let relativeEntries;
+	if (request === "vue") relativeEntries = [
+		"dist/vue.runtime.esm-bundler.js",
+		"dist/vue.esm-bundler.js",
+		"index.mjs"
+	];
+	else if (request.startsWith("vue/dist/") && request.endsWith(".js")) relativeEntries = [request.slice(4)];
+	else return null;
+	const packageJson = resolveBareImportFromPnpmHoistWithNode(state, "vue/package.json", importer);
+	if (!packageJson) return null;
+	const packageRoot = path.dirname(splitViteIdQuery(packageJson).request);
+	for (const relativeEntry of relativeEntries) {
+		const entry = path.join(packageRoot, relativeEntry);
+		if (fs.existsSync(entry)) return `${entry}${querySuffix}`;
+	}
+	return null;
+}
+function isVueRuntimeRequest(id) {
+	const request = splitViteIdQuery(id).request;
+	return request === "vue" || request.startsWith("vue/dist/") && request.endsWith(".js");
+}
+function isVuePeerRuntimeRequest(id) {
+	const request = splitViteIdQuery(id).request;
+	const packageName = getBarePackageName(request);
+	return packageName ? VUE_PEER_RUNTIME_PACKAGES.has(packageName) : false;
+}
+function isProjectVueRuntimeRequest(id) {
+	return isVueRuntimeRequest(id) || isVuePeerRuntimeRequest(id);
+}
+function isVueServerRendererRequest(request) {
+	return request === "@vue/server-renderer" || request === "vue/server-renderer" || request.startsWith("vue/dist/") && request.endsWith("/server-renderer");
+}
+function resolveVueServerRendererPackageRootWithNode(state, importer) {
+	const packageRoot = resolvePackageRootWithNode(state, "@vue/server-renderer", importer);
+	if (packageRoot) return packageRoot;
+	const vuePackageRoot = resolvePackageRootWithNode(state, "vue", importer);
+	return vuePackageRoot ? resolvePackageRootWithNode(state, "@vue/server-renderer", path.join(vuePackageRoot, "package.json")) : null;
+}
+function resolveVueServerRendererBundlerEntryWithNode(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	if (querySuffix || !isVueServerRendererRequest(request)) return null;
+	const packageRoot = resolveVueServerRendererPackageRootWithNode(state, importer);
+	if (!packageRoot) return null;
+	for (const relativeEntry of [
+		"dist/server-renderer.esm-bundler.js",
+		"index.mjs",
+		"index.js"
+	]) {
+		const entry = path.join(packageRoot, relativeEntry);
+		if (fs.existsSync(entry)) return entry;
+	}
+	return null;
+}
+function resolveSsrExternalVueRequest(id) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	if (querySuffix) return null;
+	if (isVueServerRendererRequest(request)) return "vue/server-renderer";
+	if (request === "vue" || request.startsWith("vue/dist/")) return "vue";
+	if (request.startsWith("@vue/")) return request;
+	return null;
+}
+function isVuePackageEntry(id) {
+	const { request } = splitViteIdQuery(id);
+	const normalized = request.split(path.sep).join("/");
+	return normalized.endsWith("/node_modules/vue/index.js") || normalized.endsWith("/node_modules/vue/dist/vue.runtime.esm-bundler.js") || normalized.endsWith("/node_modules/vue/dist/vue.esm-bundler.js") || normalized.includes("/node_modules/.pnpm/vue@") || normalized.includes("/node_modules/.pnpm/@vue+");
+}
+function isProjectLocalImporter(state, importer) {
+	if (!importer) return false;
+	const importerPath = normalizeImporterFilePath(importer);
+	if (!path.isAbsolute(importerPath)) return false;
+	if (isInsidePath(state.root, importerPath)) return true;
+	try {
+		return isInsidePath(fs.realpathSync(state.root), fs.realpathSync(importerPath));
+	} catch {
+		return false;
+	}
+}
+function resolveProjectLocalPnpmVueRuntime(state, resolvedId) {
+	const normalizedResolvedId = normalizeResolvedVuePath(resolvedId) ?? resolvedId;
+	if (!isVuePackageEntry(normalizedResolvedId)) return null;
+	const { request, querySuffix } = splitViteIdQuery(normalizedResolvedId);
+	if (!request.split(path.sep).join("/").includes("/node_modules/.pnpm/")) return null;
+	let realPath = request;
+	try {
+		realPath = fs.realpathSync(request);
+	} catch {}
+	return isInsidePath(state.root, realPath) ? `${realPath}${querySuffix}` : null;
+}
+function resolveProjectLocalResolvedPath(state, resolvedId) {
+	const { request, querySuffix } = splitViteIdQuery(resolvedId);
+	if (!path.isAbsolute(request)) return null;
+	let realPath = request;
+	try {
+		realPath = fs.realpathSync(request);
+	} catch {}
+	return isInsidePath(state.root, realPath) ? `${realPath}${querySuffix}` : null;
+}
+function resolveVuePeerRuntimeEntryWithNode(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	const packageName = getBarePackageName(request);
+	if (!packageName || !VUE_PEER_RUNTIME_PACKAGES.has(packageName)) return null;
+	const packageRoot = resolvePackageRootWithNode(state, packageName, importer);
+	if (!packageRoot || !resolveProjectLocalResolvedPath(state, packageRoot)) return null;
+	if (request === packageName) for (const relativeEntry of VUE_PEER_RUNTIME_ESM_ENTRIES.get(packageName) ?? ["index.mjs"]) {
+		const entry = path.join(packageRoot, relativeEntry);
+		if (fs.existsSync(entry)) return `${entry}${querySuffix}`;
+	}
+	const nodeResolved = resolveBareImportWithNode(state, id, importer);
+	return nodeResolved ? resolveProjectLocalResolvedPath(state, nodeResolved) : null;
+}
+function resolveVuePeerRuntimeEntryFromBaseWithNode(state, id, base) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	const packageName = getBarePackageName(request);
+	if (!packageName || !VUE_PEER_RUNTIME_PACKAGES.has(packageName)) return null;
+	let packageJson;
+	try {
+		packageJson = createRequire(base).resolve(`${packageName}/package.json`);
+	} catch {
+		return null;
+	}
+	const packageRoot = path.dirname(packageJson);
+	if (!resolveProjectLocalResolvedPath(state, packageRoot)) return null;
+	if (request === packageName) for (const relativeEntry of VUE_PEER_RUNTIME_ESM_ENTRIES.get(packageName) ?? ["index.mjs"]) {
+		const entry = path.join(packageRoot, relativeEntry);
+		if (fs.existsSync(entry)) return `${entry}${querySuffix}`;
+	}
+	try {
+		return resolveProjectLocalResolvedPath(state, `${createRequire(base).resolve(request)}${querySuffix}`);
+	} catch {
+		return null;
+	}
+}
+function resolveProjectNuxtVuePeerRuntimeEntryWithNode(state, id) {
+	const { request } = splitViteIdQuery(id);
+	if (getBarePackageName(request) !== "vue-router") return null;
+	const nuxtPackageJson = resolveBareImportWithNode(state, "nuxt/package.json", path.join(state.root, "package.json"));
+	if (!nuxtPackageJson) return null;
+	const nuxtPackageRoot = path.dirname(splitViteIdQuery(nuxtPackageJson).request);
+	if (!resolveProjectLocalResolvedPath(state, nuxtPackageRoot)) return null;
+	return resolveVuePeerRuntimeEntryFromBaseWithNode(state, id, path.join(nuxtPackageRoot, "package.json"));
+}
+function isOptimizedVueDependency(id) {
+	const { request } = splitViteIdQuery(id);
+	return request.split(path.sep).join("/").includes("/node_modules/.vite/deps/vue.");
+}
+const vueResolvableFromRootCache = /* @__PURE__ */ new Map();
+function isVueResolvableFromRoot(root) {
+	let cached = vueResolvableFromRootCache.get(root);
+	if (cached === void 0) {
+		const rootNodeModules = path.join(root, "node_modules");
+		const directPackageJson = path.join(rootNodeModules, "vue", "package.json");
+		cached = fs.existsSync(directPackageJson);
+		if (!cached) try {
+			createRequire(path.join(root, "__vize_probe__.js")).resolve("vue/package.json");
+			cached = true;
+		} catch {}
+		vueResolvableFromRootCache.set(root, cached);
+	}
+	return cached;
+}
+function normalizeResolvedVuePath(id) {
+	return normalizeViteResolvedVuePath(id);
+}
+async function resolveProjectVueRuntime(ctx, state, id, importer, isSsrRequest) {
+	if (isSsrRequest || !isProjectVueRuntimeRequest(id) || !isProjectLocalImporter(state, importer)) return null;
+	const isBuild = state.server === null;
+	const viteImporter = normalizeViteRequireBase(importer) ?? importer;
+	if (isVuePeerRuntimeRequest(id)) {
+		const nuxtPeerEntry = resolveProjectNuxtVuePeerRuntimeEntryWithNode(state, id);
+		if (nuxtPeerEntry) {
+			state.logger.log(`resolveId: resolved Nuxt Vue peer runtime ${id} to ${nuxtPeerEntry}`);
+			return nuxtPeerEntry;
+		}
+		if (!isBuild && isProjectSourceImporter(state.root, importer)) {
+			state.logger.log(`resolveId: deferring source Vue peer runtime ${id} to Vite optimizer`);
+			return null;
+		}
+		const projectLocalEntry = resolveVuePeerRuntimeEntryWithNode(state, id, viteImporter);
+		if (projectLocalEntry) {
+			state.logger.log(`resolveId: resolved project-local Vue peer runtime ${id} to ${projectLocalEntry}`);
+			return projectLocalEntry;
+		}
+		return null;
+	}
+	try {
+		const resolved = await resolveWithVite(ctx, state, id, viteImporter, { skipSelf: true });
+		if (resolved && isOptimizedVueDependency(resolved.id)) return null;
+		if (resolved) {
+			const projectLocalEntry = resolveProjectLocalPnpmVueRuntime(state, resolved.id);
+			if (projectLocalEntry) {
+				state.logger.log(`resolveId: resolved project-local Vue runtime to ${projectLocalEntry}`);
+				return projectLocalEntry;
+			}
+		}
+	} catch {}
+	const pnpmHoistedEntry = resolveVueBundlerEntryFromPnpmHoist(state, id, viteImporter);
+	if (pnpmHoistedEntry) {
+		state.logger.log(`resolveId: resolved project pnpm-hoisted Vue runtime to ${pnpmHoistedEntry}`);
+		return pnpmHoistedEntry;
+	}
+	const importerLocalEntry = resolveVueBundlerEntryWithNode(state, id, viteImporter);
+	const projectLocalEntry = importerLocalEntry ? resolveProjectLocalPnpmVueRuntime(state, importerLocalEntry) : null;
+	if (projectLocalEntry) {
+		state.logger.log(`resolveId: resolved importer-local Vue runtime to ${projectLocalEntry}`);
+		return projectLocalEntry;
+	}
+	return null;
+}
+function nativeCssAliasRules(state) {
+	return state.cssAliasRules.length === 0 ? EMPTY_NATIVE_ALIAS_RULES : state.cssAliasRules.map(toNativeCssAliasRule);
+}
+function isPotentialVizeResolveId(id) {
+	return id.startsWith("\0") || id.startsWith("vize:") || id.startsWith("/@fs") || isProjectVueRuntimeRequest(id) || id === "virtual:vize-styles" || id.endsWith(".vue") || id.includes(".vue?") || /\.vue\.tsx?\?/.test(id) || id.includes("?macro=true") || id.includes("?definePage");
+}
+function classifyImporterRequest(importer) {
+	return importer ? classifyVitePluginRequest(importer) : null;
+}
+function isPotentialVizeImporter(importer) {
+	if (importer === void 0) return false;
+	if (importer.startsWith("\0") || importer.startsWith("vize:")) return true;
+	return importer.includes(".vue");
+}
+function shouldCompileVueSfcRequest(request) {
+	if (!request.isVueSfcPath || request.isVueStyleQuery || request.hasMacroQuery || request.hasDefinePageQuery) return false;
+	if (!request.querySuffix) return true;
+	const params = new URLSearchParams(request.querySuffix.slice(1));
+	if (params.has("raw") || params.has("url") || params.has("worker") || params.has("sharedworker")) return false;
+	return params.has("nuxt_component");
+}
+function hasNuxtComponentQuery(request) {
+	if (!request.querySuffix) return false;
+	return new URLSearchParams(request.querySuffix.slice(1)).has("nuxt_component");
+}
+async function resolveAliasedVueImport(ctx, state, id, importer, isSsrRequest, handleNodeModules, querySuffix, preserveQueryAsPath, isDependencyScan) {
+	if (path.isAbsolute(id)) return null;
+	const viteResolved = await resolveWithVite(ctx, state, id, normalizeViteRequireBase(importer) ?? importer, { skipSelf: true });
+	const realPath = viteResolved ? normalizeResolvedVuePath(viteResolved.id) : null;
+	if (!realPath) return null;
+	const isResolvedNodeModules = realPath.includes("node_modules");
+	if (!handleNodeModules && preserveQueryAsPath && isResolvedNodeModules) {
+		state.logger.log(`resolveId: skipping resolved node_modules path ${realPath}`);
+		return null;
+	}
+	if (!isResolvedNodeModules && state.filter && !state.filter(realPath)) {
+		state.logger.log(`resolveId: skipping filtered resolved path ${realPath}`);
+		return null;
+	}
+	if (state.cache.has(realPath) || fs.existsSync(realPath)) {
+		state.logger.log(`resolveId: resolved via Vite fallback ${id} to ${realPath}`);
+		return preserveQueryAsPath ? `${realPath}${querySuffix}` : isDependencyScan ? toVirtualId(realPath, isSsrRequest) : toPluginVisibleVirtualId(realPath, isSsrRequest, querySuffix);
+	}
+	return null;
+}
+async function resolveIdHook(ctx, state, id, importer, options) {
+	if (!isPotentialVizeResolveId(id) && !isPotentialVizeImporter(importer)) return null;
+	const importerRequest = classifyImporterRequest(importer);
+	const isBuild = state.server === null;
+	const isDependencyScan = !!options?.scan;
+	const isSsrRequest = !!options?.ssr || (importerRequest?.isVizeSsrVirtual ?? false) || (importer ? isPluginVisibleSsrVirtualId(importer) : false);
+	const request = classifyVitePluginRequest(id);
+	const pluginVisibleVirtualPath = fromPluginVisibleVirtualId(id);
+	const projectVueRuntime = await resolveProjectVueRuntime(ctx, state, id, importer, isSsrRequest);
+	if (projectVueRuntime) return projectVueRuntime;
+	if (pluginVisibleVirtualPath) {
+		if (isDependencyScan) return toVirtualId(pluginVisibleVirtualPath, isSsrRequest);
+		return isSsrRequest ? toPluginVisibleVirtualId(pluginVisibleVirtualPath, true, request.querySuffix) : id;
+	}
+	if (id.startsWith("\0")) {
+		if (request.isVizeVirtual) {
+			if (isSsrRequest && !request.isVizeSsrVirtual && request.vizeVirtualPath) return isDependencyScan ? toVirtualId(request.vizeVirtualPath, true) : toPluginVisibleVirtualId(request.vizeVirtualPath, true, request.querySuffix);
+			return id;
+		}
+		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 { request: pathPart, querySuffix } = splitViteIdQuery(cleanPath);
+			state.logger.log(`resolveId: redirecting \0-prefixed non-vue ID to ${pathPart}${querySuffix}`);
+			const redirected = pathPart + querySuffix;
+			return isBuild ? classifyVitePluginRequest(redirected).normalizedFsId ?? 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 resolveWithVite(ctx, state, realPath, importer, { skipSelf: true });
+		const normalizedFsId = resolved ? classifyVitePluginRequest(resolved.id).normalizedFsId : null;
+		if (resolved && isBuild && normalizedFsId) return {
+			...resolved,
+			id: normalizedFsId
+		};
+		return resolved;
+	}
+	if (id === "virtual:vize-styles") return RESOLVED_CSS_MODULE;
+	if ((request.hasMacroQuery || request.hasDefinePageQuery) && request.isVueSfcPath) {
+		const resolved = resolveVuePath(state, request.path, importer);
+		if (resolved && fs.existsSync(resolved)) return `\0${resolved}${request.querySuffix}`;
+	}
+	if (request.isVueStyleQuery && request.styleVirtualSuffix) {
+		if (id.includes("vitepress-plugin-llms")) {
+			state.logger.log(`resolveId: skipping vitepress-plugin-llms style import ${id}`);
+			return null;
+		}
+		return `${request.normalizedFsId ?? id}${request.styleVirtualSuffix}`;
+	}
+	if (isBuild && request.normalizedFsId) return request.normalizedFsId;
+	const isMacroImporter = importerRequest?.isMacroVirtualId ?? false;
+	const isVizeVirtualImporter = importerRequest?.isVizeVirtual ?? false;
+	const isVueSfcImporter = importerRequest?.isVueSfcPath ?? false;
+	if (importer && (isVizeVirtualImporter || isMacroImporter || isVueSfcImporter)) {
+		const cleanImporter = isMacroImporter ? importerRequest?.strippedVirtualPath ?? "" : isVizeVirtualImporter ? importerRequest?.vizeVirtualPath ?? "" : cleanVueSfcImporter(importer, importerRequest);
+		state.logger.log(`resolveId from virtual: id=${id}, cleanImporter=${cleanImporter}`);
+		const relativeVueResolved = await resolveRelativeVueSfcImport(ctx, state, id, cleanImporter, isSsrRequest, isDependencyScan, resolveWithVite);
+		if (relativeVueResolved) return relativeVueResolved;
+		if (id.startsWith("#")) {
+			try {
+				const resolved = await resolveWithVite(ctx, state, id, cleanImporter, { skipSelf: true });
+				if (resolved) return resolved;
+			} catch {}
+			return resolvePackageJsonImportFromVizeImporter(state, id, cleanImporter);
+		}
+		if (!id.endsWith(".vue")) {
+			const ssrExternalVueRequest = isSsrRequest ? resolveSsrExternalVueRequest(id) : null;
+			if (ssrExternalVueRequest) {
+				if (!isBuild) {
+					const devSsrVueEntry = ssrExternalVueRequest === "vue/server-renderer" ? resolveVueServerRendererBundlerEntryWithNode(state, id, cleanImporter) : resolveVueBundlerEntryWithNode(state, id, cleanImporter);
+					if (devSsrVueEntry) {
+						state.logger.log(`resolveId: resolved SSR Vue request ${id} to ${devSsrVueEntry}`);
+						return devSsrVueEntry;
+					}
+				}
+				return {
+					id: ssrExternalVueRequest,
+					external: true
+				};
+			}
+			if (!id.startsWith("./") && !id.startsWith("../") && !id.startsWith("/")) {
+				const isVueRuntime = isVueRuntimeRequest(id);
+				const isVuePeerRuntime = isVuePeerRuntimeRequest(id);
+				if (!isBuild && isVuePeerRuntime && isProjectSourceImporter(state.root, importer)) {
+					state.logger.log(`resolveId: deferring source Vue peer runtime ${id} to Vite optimizer`);
+					return null;
+				}
+				if (isVueRuntime && isBuild) {
+					const vueBundlerEntry = resolveVueBundlerEntryWithNode(state, id, cleanImporter);
+					if (vueBundlerEntry) {
+						state.logger.log(`resolveId: resolved Vue runtime to ${vueBundlerEntry}`);
+						return vueBundlerEntry;
+					}
+				}
+				const aliasRequest = resolveAliasRequest(state, id);
+				if (!isVueRuntime && aliasRequest && isViteBareSpecifier(aliasRequest)) {
+					const nodeResolved = resolveBareImportCandidatesWithNode(state, id, cleanImporter);
+					if (nodeResolved) {
+						state.logger.log(`resolveId: resolved aliased bare ${id} to ${nodeResolved} via Node fallback`);
+						return nodeResolved;
+					}
+				}
+				try {
+					const resolved = await resolveWithVite(ctx, state, id, cleanImporter, { skipSelf: true });
+					if (resolved) {
+						state.logger.log(`resolveId: resolved bare ${id} to ${resolved.id} via Vite resolver`);
+						const normalizedFsId = classifyVitePluginRequest(resolved.id).normalizedFsId;
+						if (isBuild && normalizedFsId) return {
+							...resolved,
+							id: normalizedFsId
+						};
+						if (isVueRuntime && state.server !== null && !isOptimizedVueDependency(resolved.id)) {
+							const pnpmHoistedEntry = resolveVueBundlerEntryFromPnpmHoist(state, id, cleanImporter);
+							if (pnpmHoistedEntry) {
+								state.logger.log(`resolveId: resolved pnpm-hoisted Vue runtime to ${pnpmHoistedEntry}`);
+								return pnpmHoistedEntry;
+							}
+							const projectLocalEntry = resolveProjectLocalPnpmVueRuntime(state, resolved.id);
+							if (projectLocalEntry) {
+								state.logger.log(`resolveId: resolved project-local Vue runtime to ${projectLocalEntry}`);
+								return projectLocalEntry;
+							}
+							if (isVueResolvableFromRoot(state.root)) {
+								state.logger.log(`resolveId: deferring Vue runtime ${resolved.id} to Vite optimizer`);
+								return null;
+							}
+							const isolatedEntry = resolveVueBundlerEntryWithNode(state, id, cleanImporter) ?? resolved.id;
+							state.logger.log(`resolveId: isolated install — resolved Vue runtime to ${isolatedEntry}`);
+							return isolatedEntry;
+						}
+						if (isVueRuntime && isVuePackageEntry(resolved.id)) {
+							const vueBundlerEntry = resolveVueBundlerEntryWithNode(state, id, cleanImporter);
+							if (vueBundlerEntry) {
+								state.logger.log(`resolveId: resolved Vue runtime to ${vueBundlerEntry}`);
+								return vueBundlerEntry;
+							}
+							return null;
+						}
+						if (isViteBareSpecifier(resolved.id)) {
+							if (isVueRuntime) {
+								const vueBundlerEntry = isBuild || !isVueResolvableFromRoot(state.root) ? resolveVueBundlerEntryWithNode(state, id, cleanImporter) : null;
+								if (vueBundlerEntry) {
+									state.logger.log(`resolveId: resolved Vue runtime to ${vueBundlerEntry}`);
+									return vueBundlerEntry;
+								}
+								state.logger.log(`resolveId: deferring bare Vue runtime ${id} to Vite`);
+								return null;
+							}
+							const nodeResolved = resolveBareImportCandidatesWithNode(state, id, cleanImporter, resolved.id);
+							if (nodeResolved) {
+								state.logger.log(`resolveId: normalized bare ${id} to ${nodeResolved} via Node fallback`);
+								return nodeResolved;
+							}
+							return null;
+						}
+						return resolved;
+					}
+				} catch {}
+				if (isVueRuntime) {
+					const importerLocalEntry = resolveVueBundlerEntryWithNode(state, id, cleanImporter);
+					const projectLocalEntry = importerLocalEntry ? resolveProjectLocalPnpmVueRuntime(state, importerLocalEntry) : null;
+					if (projectLocalEntry) {
+						state.logger.log(`resolveId: resolved project-local Vue runtime to ${projectLocalEntry}`);
+						return projectLocalEntry;
+					}
+					const vueBundlerEntry = isBuild || !isVueResolvableFromRoot(state.root) ? importerLocalEntry : null;
+					if (vueBundlerEntry) {
+						state.logger.log(`resolveId: resolved Vue runtime to ${vueBundlerEntry}`);
+						return vueBundlerEntry;
+					}
+					state.logger.log(`resolveId: deferring Vue runtime ${id} to Vite`);
+					return null;
+				}
+				const nodeResolved = resolveBareImportCandidatesWithNode(state, id, cleanImporter);
+				if (nodeResolved) {
+					state.logger.log(`resolveId: resolved bare ${id} to ${nodeResolved} via Node fallback`);
+					return nodeResolved;
+				}
+				if (aliasRequest && aliasRequest !== id && !isViteBareSpecifier(aliasRequest)) {
+					try {
+						const resolved = await resolveWithVite(ctx, state, aliasRequest, cleanImporter, { skipSelf: true });
+						if (resolved) {
+							state.logger.log(`resolveId: resolved aliased bare ${id} to ${resolved.id} via Vite resolver`);
+							const normalizedFsId = classifyVitePluginRequest(resolved.id).normalizedFsId;
+							if (isBuild && normalizedFsId) return {
+								...resolved,
+								id: normalizedFsId
+							};
+							if (isViteBareSpecifier(resolved.id)) {
+								const nodeResolved = resolveBareImportCandidatesWithNode(state, id, cleanImporter, resolved.id);
+								if (nodeResolved) {
+									state.logger.log(`resolveId: normalized aliased bare ${id} to ${nodeResolved} via Node fallback`);
+									return nodeResolved;
+								}
+								return null;
+							}
+							return resolved;
+						}
+					} catch {}
+					const nodeResolved = resolveBareImportCandidatesWithNode(state, aliasRequest, cleanImporter);
+					if (nodeResolved) {
+						state.logger.log(`resolveId: resolved aliased bare ${id} to ${nodeResolved} via Node fallback`);
+						return nodeResolved;
+					}
+				}
+				return null;
+			}
+			try {
+				const resolved = await resolveWithVite(ctx, state, id, cleanImporter, { skipSelf: true });
+				if (resolved) {
+					state.logger.log(`resolveId: resolved ${id} to ${resolved.id} via Vite resolver`);
+					const normalizedFsId = classifyVitePluginRequest(resolved.id).normalizedFsId;
+					if (isBuild && normalizedFsId) return {
+						...resolved,
+						id: normalizedFsId
+					};
+					return resolved;
+				}
+			} catch {}
+			if (id.startsWith("./") || id.startsWith("../")) {
+				const resolved = resolveViteRelativeImport(id, cleanImporter);
+				if (resolved) {
+					state.logger.log(`resolveId: resolved relative ${id} to ${resolved}`);
+					return resolved;
+				}
+			}
+			return null;
+		}
+	}
+	if (shouldCompileVueSfcRequest(request)) {
+		const handleNodeModules = state.mergedOptions.handleNodeModulesVue ?? true;
+		const preserveQueryAsPath = hasNuxtComponentQuery(request);
+		const vueRequestPath = request.path;
+		if (!handleNodeModules && preserveQueryAsPath && vueRequestPath.includes("node_modules")) {
+			state.logger.log(`resolveId: skipping node_modules import ${id}`);
+			return null;
+		}
+		const resolved = resolveVuePath(state, vueRequestPath, importer);
+		const fileExists = fs.existsSync(resolved);
+		if (!fileExists) {
+			const aliased = await resolveAliasedVueImport(ctx, state, id, importer, isSsrRequest, handleNodeModules, request.querySuffix, preserveQueryAsPath, isDependencyScan);
+			if (aliased) return aliased;
+		}
+		const isNodeModulesPath = resolved.includes("node_modules");
+		if (!handleNodeModules && preserveQueryAsPath && 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);
+		state.logger.log(`resolveId: id=${id}, resolved=${resolved}, hasCache=${hasCache}, fileExists=${fileExists}, importer=${importer ?? "none"}`);
+		if (hasCache || fileExists) {
+			if (preserveQueryAsPath) return `${resolved}${request.querySuffix}`;
+			return isDependencyScan ? toVirtualId(resolved, isSsrRequest) : toPluginVisibleVirtualId(resolved, isSsrRequest, request.querySuffix);
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/plugin/load-sfc.ts
+function shouldLoadVueSfcRequest(request) {
+	if (!request.isVueSfcPath || request.isVueStyleQuery || request.hasMacroQuery || request.hasDefinePageQuery) return false;
+	if (!request.querySuffix) return true;
+	const params = new URLSearchParams(request.querySuffix.slice(1));
+	if (params.has("raw") || params.has("url") || params.has("worker") || params.has("sharedworker")) return false;
+	return params.has("nuxt_component");
+}
+function getLoadableVueSfcPath(request) {
+	if (!shouldLoadVueSfcRequest(request)) return null;
+	return classifyVitePluginRequest(request.normalizedFsId ?? request.path).normalizedVuePath;
+}
+function shouldLoadCompiledVueSfcPath(state, realPath, hasNuxtComponentQuery = false) {
+	const isNodeModulesPath = realPath.includes("node_modules");
+	if (!(state.mergedOptions.handleNodeModulesVue ?? true) && isNodeModulesPath && hasNuxtComponentQuery) {
+		state.logger.log(`load: skipping node_modules Vue SFC ${realPath}`);
+		return false;
+	}
+	if (!isNodeModulesPath && !state.filter(realPath)) {
+		state.logger.log(`load: skipping filtered Vue SFC ${realPath}`);
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/plugin/ssr-modules.ts
+/**
+* Point a compiled SSR module at the `vue/server-renderer` subpath.
+*
+* The compiler emits `@vue/server-renderer`, which is not a dependency every
+* app declares; the subpath re-export always resolves alongside `vue` itself.
+*/
+function normalizeVueServerRendererImport(code) {
+	return code.replace(/\bfrom\s+(['"])@vue\/server-renderer\1/g, "from \"vue/server-renderer\"");
+}
+/**
+* Marks a module whose registration has already been appended.
+*
+* Idempotency cannot key on the helper identifiers: an SFC is free to declare
+* `__vize_useSSRContext` itself, and skipping registration for it would cost it
+* its initial stylesheet.
+*/
+const REGISTRATION_MARKER = "/* @vize-ssr-modules-registered */";
+/**
+* Matches the `_sfc_main` component declaration the emitted module carries.
+*
+* A bare `\b_sfc_main\b` also matches the identifier inside a string literal or
+* a comment, and wrapping a component that was never declared is a
+* `ReferenceError` at render time.
+*/
+const SFC_MAIN_DECLARATION = /\b(?:const|let|var)\s+_sfc_main\s*=/;
+/**
+* Register an SFC in `ssrContext.modules` during SSR, the way
+* `@vitejs/plugin-vue` does.
+*
+* After rendering, `vue-bundle-renderer` intersects `ssrContext.modules` with
+* the client manifest to decide which stylesheets belong in the document head.
+* A component that never registers itself contributes no `<link>`, so the
+* server-rendered markup arrives unstyled and only gains its styles once the
+* route chunk loads on the client — a flash of unstyled content that never
+* recovers when JavaScript is disabled (#3868).
+*
+* The key must be the module's path relative to the Vite root with POSIX
+* separators, because that is what the client manifest is keyed on.
+*/
+function ssrModuleRegistrationCode(filePath, root, helpers = {}) {
+	const moduleId = JSON.stringify(toManifestModuleId(filePath, root));
+	const useSSRContext = helpers.useSSRContext ?? "__vize_useSSRContext";
+	const sfcSetup = helpers.sfcSetup ?? "__vize_sfc_setup";
+	return {
+		prologue: `${REGISTRATION_MARKER}\nimport { useSSRContext as ${useSSRContext} } from "vue";`,
+		epilogue: [
+			`const ${sfcSetup} = _sfc_main.setup;`,
+			`_sfc_main.setup = (props, ctx) => {`,
+			`  const ssrContext = ${useSSRContext}();`,
+			`  (ssrContext.modules || (ssrContext.modules = new Set())).add(${moduleId});`,
+			`  return ${sfcSetup} ? ${sfcSetup}(props, ctx) : undefined;`,
+			`};`
+		].join("\n")
+	};
+}
+/**
+* The client-manifest key for `filePath`: relative to `root`, POSIX separators.
+*
+* A path outside the root keeps its absolute form rather than becoming a `../`
+* chain, matching how Vite keys modules it cannot root-relativize. Only a real
+* parent-directory step counts as outside: a filename that merely begins with
+* `..` still lives in the root and is keyed relative to it.
+*/
+function toManifestModuleId(filePath, root) {
+	const relative = path.relative(root, filePath).replace(/\\/g, "/");
+	if (!relative || relative === ".." || relative.startsWith("../") || path.isAbsolute(relative)) return filePath.replace(/\\/g, "/");
+	return relative;
+}
+/**
+* Wrap an emitted module with the registration.
+*
+* The wrapper is appended, so it closes over whatever `setup` the emitter's own
+* rewrites left in place, but its `import` is *prepended*. A trailing `import`
+* is legal ESM, yet it makes the module's last import statement its last line,
+* and Nuxt's auto-import injection then inserts nothing — a component relying on
+* an auto-imported composable loses that binding and throws `ReferenceError` at
+* render time (#3868). Leading the module with the import keeps the import
+* section where every downstream transform expects to find it.
+*
+* `useSSRContext()` throws outside a render, so this is a no-op unless `isSsr`.
+* Modules without an `_sfc_main` declaration — a render-function-only output, or
+* a boundary placeholder — have no component object to wrap and are returned
+* untouched.
+*/
+function appendSsrModuleRegistration(code, filePath, root, isSsr) {
+	if (!isSsr || !SFC_MAIN_DECLARATION.test(code)) return code;
+	if (code.includes(REGISTRATION_MARKER)) return code;
+	const { prologue, epilogue } = ssrModuleRegistrationCode(filePath, root, {
+		useSSRContext: freeIdentifier("__vize_useSSRContext", code),
+		sfcSetup: freeIdentifier("__vize_sfc_setup", code)
+	});
+	return `${prologue}\n${code}\n${epilogue}`;
+}
+/**
+* `base`, or `base` plus the smallest numeric suffix the module does not use.
+*
+* Re-declaring an identifier the SFC already bound is a `SyntaxError`, which
+* would take down the whole module rather than just its stylesheet.
+*/
+function freeIdentifier(base, code) {
+	if (!new RegExp(`\\b${base}\\b`).test(code)) return base;
+	for (let suffix = 2;; suffix++) {
+		const candidate = `${base}${suffix}`;
+		if (!new RegExp(`\\b${candidate}\\b`).test(code)) return candidate;
+	}
+}
+//#endregion
+//#region src/plugin/vite-transform.ts
+function createVirtualTypeScriptTransformer(viteApi) {
+	return async (code, id) => {
+		if (typeof viteApi.transformWithOxc === "function") return viteApi.transformWithOxc(code, id, {
+			lang: "ts",
+			sourcemap: false,
+			target: "esnext"
+		});
+		if (typeof viteApi.transformWithEsbuild === "function") return viteApi.transformWithEsbuild(code, id, {
+			loader: "ts",
+			sourcemap: false,
+			target: "esnext"
+		});
+		throw new Error("Installed Vite does not expose transformWithOxc or transformWithEsbuild");
+	};
+}
+/**
+* Report whether `realPath` names a module Vize's own compiler emitted.
+*
+* Vize's Rust emitter guarantees plain JavaScript for every module it produces
+* (`ensure_javascript_output` at the napi boundary), so re-running Vite's
+* TypeScript strip over emitter output is a pure re-print. Every emitted module
+* is recorded in one of the two environment caches, so cache membership is the
+* cheap, allocation-free proof that the code came from the emitter.
+*
+* The probe fails safe: a module the caches do not know about still gets the
+* strip, which keeps hand-written and malformed virtual modules behaving
+* exactly as they did before.
+*/
+function isVizeEmitterOutput(state, realPath) {
+	return state.cache.has(realPath) || state.ssrCache.has(realPath);
+}
+const transformVirtualTypeScript = createVirtualTypeScriptTransformer(vite);
+function getOxcDumpPath(root, realPath) {
+	const dumpDir = path.resolve(root || process.cwd(), "node_modules", ".vize", "oxc-dumps");
+	fs.mkdirSync(dumpDir, { recursive: true });
+	return path.join(dumpDir, `vize-oxc-error-${path.basename(realPath)}.ts`);
+}
+function getVirtualModuleDefines(state, ssr) {
+	return {
+		"import.meta.client": ssr ? "false" : "true",
+		"import.meta.server": ssr ? "true" : "false",
+		"import.meta.dev": state.isProduction ? "false" : "true",
+		"import.meta.test": "false",
+		"import.meta.prerender": "false",
+		...ssr ? state.serverViteDefine : state.clientViteDefine
+	};
+}
+function formatUnknownError$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function transformVizeVirtualModule(state, code, realPath, ssr, forceTypeScriptTransform = false) {
+	const needsTsTransform = forceTypeScriptTransform || !isVizeEmitterOutput(state, realPath);
+	try {
+		let transformed = (needsTsTransform ? await transformVirtualTypeScript(code, realPath) : { code }).code;
+		if (transformed.includes("import.meta.")) transformed = applyDefineReplacements(transformed, getVirtualModuleDefines(state, ssr));
+		return transformed === code ? null : {
+			code: transformed,
+			map: null
+		};
+	} catch (e) {
+		state.logger.error(`transformWithOxc failed for ${realPath}:`, e);
+		let dumpPath = null;
+		try {
+			dumpPath = getOxcDumpPath(state.root, realPath);
+			fs.writeFileSync(dumpPath, code, "utf-8");
+			state.logger.error(`Dumped failing code to ${dumpPath}`);
+		} catch (dumpError) {
+			state.logger.error(`Failed to dump failing virtual module for ${realPath}:`, dumpError);
+		}
+		const message = [`[vize] Virtual module transform failed for ${realPath}: ${formatUnknownError$1(e)}`, dumpPath ? `Dumped failing code to ${dumpPath}` : null].filter(Boolean).join("\n");
+		throw new Error(message);
+	}
+}
+//#endregion
+//#region src/plugin/load-style.ts
+function normalizeStyleVirtualId(id) {
+	const withoutPrefix = id.startsWith("\0") ? id.slice(1) : id;
+	if (!withoutPrefix.includes("?vue")) return id;
+	return withoutPrefix.replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
+}
+//#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) {
+	const boundaryKind = classifyVitePluginRequest(realPath).boundaryKind;
+	if (ssr && boundaryKind === "client") return SERVER_PLACEHOLDER_CODE;
+	if (!ssr && boundaryKind === "server") return SERVER_PLACEHOLDER_CODE;
+	return null;
+}
+function findMacroArtifactModule(state, realPath, ssr, kind) {
+	const cache = getEnvironmentCache(state, ssr);
+	const extractCss = shouldExtractCssForRequest(state, ssr);
+	realPath = classifyVitePluginRequest(realPath).normalizedVuePath;
+	let compiled = cache.get(realPath) ?? state.cache.get(realPath) ?? state.ssrCache.get(realPath);
+	if (!compiled && fs.existsSync(realPath)) {
+		const source = fs.readFileSync(realPath, "utf-8");
+		compiled = compileFile(realPath, cache, getCompileOptionsForRequest(state, ssr), source);
+	}
+	syncCollectedCssForFile({
+		...state,
+		extractCss
+	}, realPath, compiled);
+	return compiled?.macroArtifacts?.find((artifact) => artifact.kind === kind)?.moduleCode ?? null;
+}
+function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions) {
+	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);
+	const customElement = isPluginVueCustomElement(state.mergedOptions, realPath);
+	const extractCss = shouldExtractCssForRequest(state, isSsr) && !customElement;
+	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), void 0, { logWarnings: shouldLogSfcWarnings(state, realPath) });
+	}
+	syncCollectedCssForFile({
+		...state,
+		extractCss
+	}, realPath, compiled);
+	if (!compiled) return null;
+	for (const watchFile of new Set([realPath, ...compiled.dependencies ?? []])) loadOptions?.addWatchFile?.(watchFile);
+	const hasDelegated = hasDelegatedStyles(compiled);
+	const outputOptions = {
+		isProduction: state.isProduction,
+		isDev: state.server !== null && !isSsr,
+		ssr: isSsr,
+		hmrUpdateType: loadOptions?.ssr ? void 0 : state.pendingHmrUpdateTypes.get(realPath),
+		extractCss,
+		customElement,
+		filePath: realPath
+	};
+	if (compiled.css && !hasDelegated && embedsInlineCss(compiled, outputOptions)) compiled = {
+		...compiled,
+		css: resolveCssImports(compiled.css, realPath, state.cssAliasRules, state.server !== null, currentBase)
+	};
+	const emitted = generateOutputWithMap(compiled, outputOptions);
+	const rewritten = new MappedModule(isSsr ? normalizeVueServerRendererImport(emitted.code) : emitted.code, emitted.map);
+	rewritten.edit(rewriteDynamicTemplateImports(rewritten.code, state.dynamicImportAliasRules));
+	rewritten.edit(rewriteStaticAssetUrls(rewritten.code, state.dynamicImportAliasRules));
+	rewritten.edit(rewriteImportMetaGlobBase(rewritten.code, realPath, state.root));
+	rewritten.edit(appendSsrModuleRegistration(rewritten.code, realPath, state.root, isSsr));
+	return {
+		code: rewritten.code,
+		map: rewritten.map
+	};
+}
+function loadDefinePageArtifact(state, realPath, ssr) {
+	return {
+		code: findMacroArtifactModule(state, realPath, ssr, "vue-router.definePage") ?? "export default {}",
+		map: null
+	};
+}
+function loadDefinePageMetaArtifact(state, realPath, ssr) {
+	const code = findMacroArtifactModule(state, realPath, ssr, "nuxt.definePageMeta");
+	return code ? {
+		code,
+		map: null
+	} : null;
+}
+function loadHook(state, id, loadOptions) {
+	if (id !== "\0vize:all-styles.css" && !id.startsWith("\0") && !id.includes(".vue")) return null;
+	const request = classifyVitePluginRequest(id);
+	const pluginVisibleVirtualPath = fromPluginVisibleVirtualId(id);
+	const loadableVueSfcPath = getLoadableVueSfcPath(request);
+	const currentBase = loadOptions?.ssr ? state.serverViteBase : state.clientViteBase;
+	if (id === "\0vize:all-styles.css") {
+		let allCss = "";
+		for (const css of state.collectedCss.values()) allCss += allCss ? `\n\n${css}` : css;
+		return allCss;
+	}
+	const styleRequest = classifyVitePluginRequest(normalizeStyleVirtualId(id));
+	if (styleRequest.isVueStyleQuery) {
+		const sourceRequest = classifyVitePluginRequest(styleRequest.path);
+		const realPath = sourceRequest.vizeVirtualPath ?? sourceRequest.normalizedFsId ?? sourceRequest.normalizedVuePath ?? styleRequest.path;
+		const lang = styleRequest.styleLang ?? null;
+		const scoped = styleRequest.styleScoped ?? null;
+		const fallbackCompiled = loadOptions?.ssr ? state.ssrCache.get(realPath) ?? state.cache.get(realPath) : state.cache.get(realPath) ?? state.ssrCache.get(realPath);
+		const blockIndex = styleRequest.styleIndex ?? -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")) styleContent = scopeCssForPipeline(styleContent, scoped);
+			styleContent = transformCssVarsForPipeline(styleContent, fallbackCompiled.scopeId);
+			return {
+				code: styleContent,
+				map: null
+			};
+		}
+		if (fallbackCompiled?.css) return resolveCssImports(fallbackCompiled.css, realPath, state.cssAliasRules, state.server !== null, currentBase);
+		return null;
+	}
+	if (id !== "\0vize:all-styles.css" && !id.startsWith("\0") && !pluginVisibleVirtualPath && !loadableVueSfcPath) return null;
+	if (id.startsWith("\0") && request.hasDefinePageQuery) {
+		const realPath = request.strippedVirtualPath ?? "";
+		if (request.isVueSfcPath) return loadDefinePageArtifact(state, realPath, !!loadOptions?.ssr);
+	}
+	if (id.startsWith("\0") && request.hasMacroQuery) {
+		const realPath = request.strippedVirtualPath ?? "";
+		if (request.isVueSfcPath) {
+			const artifactLoad = loadDefinePageMetaArtifact(state, realPath, !!loadOptions?.ssr);
+			if (artifactLoad) return artifactLoad;
+			return {
+				code: "export default {}",
+				map: null
+			};
+		}
+	}
+	if (request.isVizeVirtual || pluginVisibleVirtualPath) {
+		const realPath = request.vizeVirtualPath ?? pluginVisibleVirtualPath ?? "";
+		const isSsr = request.isVizeSsrVirtual || isPluginVisibleSsrVirtualId(id) || !!loadOptions?.ssr;
+		if (!realPath.endsWith(".vue")) {
+			state.logger.log(`load: skipping non-vue virtual module ${realPath}`);
+			return null;
+		}
+		if (!shouldLoadCompiledVueSfcPath(state, realPath)) return null;
+		return loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions);
+	}
+	if (loadableVueSfcPath) {
+		if (!shouldLoadCompiledVueSfcPath(state, loadableVueSfcPath, !!request.querySuffix && new URLSearchParams(request.querySuffix.slice(1)).has("nuxt_component"))) return null;
+		return loadCompiledSfcModule(state, loadableVueSfcPath, !!loadOptions?.ssr, currentBase, loadOptions);
+	}
+	if (id.startsWith("\0")) {
+		const afterPrefix = id.startsWith("\0vize:") ? id.slice(6) : id.slice(1);
+		if (afterPrefix.includes("?commonjs-")) return null;
+		const leakedRequest = classifyVitePluginRequest(afterPrefix);
+		const fsPath = leakedRequest.normalizedFsId ? classifyVitePluginRequest(leakedRequest.normalizedFsId).path : leakedRequest.path;
+		const querySuffix = leakedRequest.querySuffix;
+		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;
+}
+function shouldLogSfcWarnings(state, realPath) {
+	if (!realPath.includes("node_modules")) return true;
+	if ((state.mergedOptions.handleNodeModulesVue ?? true) === false) return false;
+	return state.filter(realPath);
+}
+function isJsxComponentPath(path) {
+	return /\.[jt]sx$/.test(path) && !/\.(?:stories|story)\.[jt]sx$/.test(path);
+}
+function shouldTransformJsxRequest(state, request) {
+	if (!isJsxComponentPath(request.path)) return false;
+	if (request.querySuffix) {
+		const params = new URLSearchParams(request.querySuffix.slice(1));
+		if (params.has("raw") || params.has("url") || params.has("worker") || params.has("sharedworker")) return false;
+	}
+	if (!state.mergedOptions.include || !state.filter(request.path)) return false;
+	return true;
+}
+/**
+* Route a raw `.jsx`/`.tsx` request through Vize's JSX compiler.
+*
+* Returns `undefined` when the request is not a JSX/TSX component (so the
+* caller falls through to the virtual-module pipeline), or a transform result
+* otherwise.
+*/
+function transformJsxRequest(state, code, id, options) {
+	const request = classifyVitePluginRequest(id);
+	if (!shouldTransformJsxRequest(state, request)) return;
+	const realPath = request.normalizedFsId ? classifyVitePluginRequest(request.normalizedFsId).path : request.path;
+	const ssr = options?.ssr ?? false;
+	const sourceMap = getCompileOptionsForRequest(state, ssr).sourceMap;
+	const { code: compiled, map, warnings } = compileJsxModule(realPath, code, {
+		jsxMode: state.mergedOptions.jsxMode,
+		jsxCompat: state.mergedOptions.jsxCompat,
+		vapor: state.mergedOptions.vapor ?? false,
+		ssr,
+		sourceMap
+	});
+	for (const warning of warnings) state.logger.warn(`Warning in ${realPath}: ${warning}`);
+	return {
+		code: compiled,
+		map: map ? JSON.parse(map) : null
+	};
+}
+async function transformHook(state, code, id, options) {
+	if (!id.startsWith("\0") && !id.includes(".vue.ts") && !isJsxComponentPath(id)) return null;
+	const pluginVisibleVirtualPath = fromPluginVisibleVirtualId(id);
+	const jsxResult = transformJsxRequest(state, code, id, { ssr: options?.ssr });
+	if (jsxResult !== void 0) return jsxResult;
+	if (!id.startsWith("\0") && !pluginVisibleVirtualPath) return null;
+	const request = classifyVitePluginRequest(id);
+	if (request.isVizeVirtual || request.isMacroVirtualId || pluginVisibleVirtualPath) return transformVizeVirtualModule(state, code, request.isMacroVirtualId ? request.strippedVirtualPath ?? "" : request.vizeVirtualPath ?? pluginVisibleVirtualPath ?? "", options?.ssr ?? false, request.isMacroVirtualId);
+	return null;
+}
+//#endregion
+//#region src/plugin/hmr-module-graph.ts
+function unique(values) {
+	return [...new Set(values)];
+}
+function toViteFsFileId(fileId) {
+	if (!path.isAbsolute(fileId)) return null;
+	const normalized = fileId.replace(/\\/g, "/");
+	return normalized.startsWith("/") ? `/@fs${normalized}` : `/@fs/${normalized}`;
+}
+function getVueModuleFileCandidates(vueFile) {
+	const candidates = [
+		toVirtualId(vueFile),
+		toPluginVisibleVirtualId(vueFile),
+		toVirtualId(vueFile, true),
+		toPluginVisibleVirtualId(vueFile, true),
+		toPluginVisibleVirtualId(vueFile).split("?")[0],
+		vueFile
+	];
+	const viteFsCandidates = candidates.flatMap((candidate) => {
+		const viteFsId = toViteFsFileId(candidate);
+		return viteFsId ? [viteFsId] : [];
+	});
+	return unique([...candidates, ...viteFsCandidates]);
+}
+function getStyleModuleFileCandidates(styleId) {
+	return unique([styleId, `${styleId}.css`]);
+}
+async function collectModulesByFile(server, fileIds) {
+	const modules = /* @__PURE__ */ new Set();
+	for (const fileId of fileIds) {
+		const add = (module) => {
+			if (module) modules.add(module);
+		};
+		add(server.moduleGraph.getModuleById?.(fileId));
+		if (!fileId.startsWith("\0")) try {
+			add(await server.moduleGraph.getModuleByUrl?.(fileId));
+		} catch {}
+		for (const module of server.moduleGraph.getModulesByFile(fileId) ?? []) add(module);
+	}
+	return modules;
+}
+function preferAcceptingClientModules(modules, requireAcceptingClientModule = false) {
+	const accepting = [...modules].filter((module) => {
+		if (isVizeVirtual(module.url)) return !isVizeSsrVirtual(module.url);
+		return fromPluginVisibleVirtualId(module.url) !== null && !isPluginVisibleSsrVirtualId(module.url);
+	});
+	if (accepting.length > 0) return new Set(accepting);
+	return requireAcceptingClientModule ? /* @__PURE__ */ new Set() : modules;
+}
+function invalidateModules(server, modules) {
+	for (const module of modules) server.moduleGraph.invalidateModule(module);
+}
+//#endregion
+//#region src/plugin/hmr.ts
+const VIZE_COMPONENTS_CSS_BASENAME = "vize-components.css";
+const VIZE_COMPONENTS_CSS_FILE = `assets/${VIZE_COMPONENTS_CSS_BASENAME}`;
+/**
+* The cached SFCs that pulled `dependencyFile` in through
+* `<script src>` / `<template src>` / `<style src>`.
+*
+* This runs as the first statement of every hot update, before the `.vue` fast
+* path, so editing an ordinary SFC pays for it too. It used to walk both caches
+* end to end with a `path.resolve` per dependency, which made HMR latency grow
+* with the number of components in the project; the caches now carry a reverse
+* index that answers it in constant time. See `compiled-module-cache.ts`.
+*/
+function getVueFilesDependingOn(state, dependencyFile) {
+	const normalizedDependency = path.resolve(dependencyFile);
+	const owners = /* @__PURE__ */ new Set();
+	for (const cache of [state.cache, state.ssrCache]) for (const vueFile of ownersOfDependency(cache, normalizedDependency)) owners.add(vueFile);
+	return [...owners];
+}
+async function handleHotUpdateHook(state, ctx, options = {}) {
+	const { file, server, read } = ctx;
+	const clientDependencyOwners = new Set(ownersOfDependency(state.cache, path.resolve(file)));
+	const dependencyOwners = getVueFilesDependingOn(state, file);
+	if (dependencyOwners.length > 0) {
+		const affectedModules = /* @__PURE__ */ new Set();
+		for (const vueFile of dependencyOwners) {
+			const collectedModules = await collectModulesByFile(server, getVueModuleFileCandidates(vueFile));
+			const modules = options.requireAcceptingClientModule ? preferAcceptingClientModules(collectedModules, true) : collectedModules;
+			if (options.requireAcceptingClientModule && modules.size === 0) {
+				if (!options.ensureAcceptingClientModule || !clientDependencyOwners.has(vueFile)) continue;
+				try {
+					const ensured = await options.ensureAcceptingClientModule(vueFile);
+					modules.add(ensured);
+				} catch (error) {
+					state.logger.error(`Failed to restore the client HMR owner for ${vueFile}:`, error);
+					options.onRecompileError?.(error);
+					return;
+				}
+			}
+			evictCompiledModule(state.cache, vueFile);
+			evictCompiledModule(state.ssrCache, vueFile);
+			state.collectedCss.delete(vueFile);
+			state.precompileMetadata.delete(vueFile);
+			state.pendingHmrUpdateTypes.set(vueFile, "full-reload");
+			for (const module of modules) {
+				server.moduleGraph.invalidateModule(module);
+				affectedModules.add(module);
+			}
+			state.logger.log(`Invalidated ${path.relative(state.root, vueFile)} because ${path.relative(state.root, file)} changed`);
+		}
+		return [...affectedModules];
+	}
+	if (file.endsWith(".vue") && state.filter(file)) try {
+		const initialModules = options.requireAcceptingClientModule ? preferAcceptingClientModules(await collectModulesByFile(server, getVueModuleFileCandidates(file)), true) : void 0;
+		if (initialModules?.size === 0) return [];
+		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 modules = preferAcceptingClientModules(initialModules ?? await collectModulesByFile(server, getVueModuleFileCandidates(file)), options.requireAcceptingClientModule);
+		const hasDelegated = hasDelegatedStyles(newCompiled);
+		if (isPluginVueCustomElement(state.mergedOptions, file) && updateType === "style-only") {
+			if (modules.size > 0) {
+				state.pendingHmrUpdateTypes.set(file, "full-reload");
+				invalidateModules(server, modules);
+				return [...modules];
+			}
+			state.pendingHmrUpdateTypes.delete(file);
+			return [];
+		}
+		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 styleMods = await collectModulesByFile(server, getStyleModuleFileCandidates(`${file}?${params.toString()}`));
+				for (const mod of styleMods) affectedModules.add(mod);
+			}
+			if (affectedModules.size > 0) return [...affectedModules];
+			if (modules.size > 0) 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.size > 0) {
+			state.pendingHmrUpdateTypes.set(file, updateType);
+			invalidateModules(server, modules);
+			return [...modules];
+		}
+		state.pendingHmrUpdateTypes.delete(file);
+	} catch (e) {
+		state.logger.error(`Re-compilation failed for ${file}:`, e);
+		options.onRecompileError?.(e);
+	}
+}
+function handleGenerateBundleHook(state, emitFile, bundle) {
+	if (!state.extractCss || state.collectedCss.size === 0) return;
+	let allCss = "";
+	for (const css of state.collectedCss.values()) allCss += allCss ? `\n\n${css}` : css;
+	if (allCss.trim()) {
+		const cssFileName = state.componentsCssFileName || VIZE_COMPONENTS_CSS_FILE;
+		emitFile({
+			type: "asset",
+			fileName: cssFileName,
+			source: allCss
+		});
+		attachComponentsCssToEntryChunks(bundle, cssFileName);
+		state.logger.log(`Extracted CSS to ${cssFileName} (${state.collectedCss.size} components)`);
+	}
+}
+function resolveComponentsCssFileName(assetsDir) {
+	const normalizedAssetsDir = (assetsDir || "assets").replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+	if (!normalizedAssetsDir || normalizedAssetsDir === ".") return VIZE_COMPONENTS_CSS_BASENAME;
+	return `${normalizedAssetsDir}/${VIZE_COMPONENTS_CSS_BASENAME}`;
+}
+function attachComponentsCssToEntryChunks(bundle, cssFileName) {
+	for (const item of Object.values(bundle)) {
+		if (item.type !== "chunk" || !item.isEntry && !item.isDynamicEntry) continue;
+		item.viteMetadata ??= {};
+		item.viteMetadata.importedCss ??= /* @__PURE__ */ new Set();
+		item.viteMetadata.importedCss.add(cssFileName);
+	}
+}
+//#endregion
+//#region src/plugin/hot-update-environment.ts
+async function handleHotUpdateEnvironmentHook(state, environment, options) {
+	if (environment.name !== "client" && environment.name !== "browser") return options.modules;
+	const server = {
+		moduleGraph: environment.moduleGraph,
+		ws: { send: environment.hot.send.bind(environment.hot) }
+	};
+	let recompileFailed = false;
+	const modules = await handleHotUpdateHook(state, {
+		...options,
+		server
+	}, {
+		ensureAcceptingClientModule: (vueFile) => environment.moduleGraph.ensureEntryFromUrl(toPluginVisibleVirtualId(vueFile), false),
+		requireAcceptingClientModule: true,
+		onRecompileError: () => {
+			recompileFailed = true;
+		}
+	});
+	if (recompileFailed) return;
+	if (modules === void 0 && options.file.endsWith(".vue") && state.filter(options.file)) return [];
+	return modules;
+}
+//#endregion
+//#region src/plugin/compat.ts
+/**
+* The `vite:vue` shim a host framework probes for a Vue plugin.
+*
+* `api.include` / `api.exclude` report the patterns behind `state.filter`, and
+* assigning them rewrites the plugin's own options — the only window where that
+* is meaningful is before `configResolved` builds the filter, so a later write
+* throws rather than silently doing nothing (#3227). Upstream guards the same
+* way, keyed on its `options` hook instead.
+*/
+function createVueCompatPlugin(state, options) {
+	let compilerSfc = null;
+	const templateOptions = { compilerOptions: {
+		directiveTransforms: {},
+		nodeTransforms: []
+	} };
+	const loadCompilerSfc = () => {
+		if (!compilerSfc) try {
+			compilerSfc = createRequire(import.meta.url)("@vue/compiler-sfc");
+		} catch {
+			compilerSfc = { parse: () => ({
+				descriptor: {},
+				errors: []
+			}) };
+		}
+		return compilerSfc;
+	};
+	const configured = () => state.initialized ? state.mergedOptions : options;
+	const assertUnresolved = (name) => {
+		if (state.initialized) throw new Error(`${name} cannot be updated after the filter is resolved`);
+	};
+	return {
+		name: "vite:vue",
+		api: {
+			get options() {
+				return {
+					compiler: loadCompilerSfc(),
+					isProduction: state.isProduction ?? false,
+					root: state.root ?? process.cwd(),
+					template: templateOptions
+				};
+			},
+			get include() {
+				return configured().include ?? DEFAULT_INCLUDE_PATTERN;
+			},
+			set include(value) {
+				assertUnresolved("include");
+				options.include = value;
+			},
+			get exclude() {
+				return configured().exclude ?? DEFAULT_EXCLUDE_PATTERN;
+			},
+			set exclude(value) {
+				assertUnresolved("exclude");
+				options.exclude = value;
+			},
+			version: PLUGIN_VUE_COMPAT_VERSION
+		}
+	};
+}
+function normalizeVirtualStyleId(id) {
+	const withoutPrefix = id.startsWith("\0") ? id.slice(1) : id;
+	if (!withoutPrefix.includes("?vue")) return id;
+	return withoutPrefix.replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
+}
+/**
+* String pre-gate for {@link transformScopedPreprocessorCss} (#3427).
+*
+* The post-transform plugin's `transform` hook sees every module in the graph,
+* and without this every one of them crossed the NAPI boundary to be told it is
+* not a style query. The native `isVueStyleQuery` is
+* `query.contains("vue&type=style") || query.contains("vue=&type=style")`, both
+* of which contain `type=style`; the query is a substring of the id, and
+* `normalizeVirtualStyleId` only ever deletes characters, so a normalized id
+* that classifies as a style query implies `type=style` in the raw id.
+*/
+function mayBeVueStyleQuery(id) {
+	return id.includes("type=style");
+}
+function transformScopedPreprocessorCss(code, id) {
+	if (!mayBeVueStyleQuery(id)) return null;
+	const request = classifyVitePluginRequest(normalizeVirtualStyleId(id));
+	if (!request.isVueStyleQuery || !request.styleScoped || !request.styleLang || request.styleLang === "css") return null;
+	return scopeCssForPipeline(code, request.styleScoped);
+}
+function createStylePostTransformPlugin() {
+	return {
+		name: "vize:style-post-transform",
+		transform(code, id) {
+			const scoped = transformScopedPreprocessorCss(code, id);
+			return scoped === null ? null : {
+				code: scoped,
+				map: null
+			};
+		}
+	};
+}
+function stripQuery(id) {
+	const queryStart = id.search(/[?#]/);
+	return queryStart === -1 ? id : id.slice(0, queryStart);
+}
+function isSfcLikeSource(code) {
+	return /^<(?:template|script|style)(?:\s|>|\/)/.test(code.trimStart());
+}
+function shouldPostTransformSfcLikeModule(state, id) {
+	const filename = stripQuery(id);
+	if (filename.endsWith(".vue") || filename.endsWith(".vue.ts") || filename.endsWith(".vue.tsx") || filename.includes("node_modules")) return false;
+	if (filename.endsWith(".setup.ts")) return true;
+	if (state.filter(filename) || state.filter(id)) return true;
+	return /\.(?:md|markdown)$/i.test(filename);
+}
+function createPostTransformPlugin(state) {
+	return {
+		name: "vize:post-transform",
+		enforce: "post",
+		async transform(code, id, transformOptions) {
+			if (shouldPostTransformSfcLikeModule(state, id) && isSfcLikeSource(code)) {
+				state.logger.log(`post-transform: compiling virtual SFC content from ${id}`);
+				try {
+					const isSsr = !!transformOptions?.ssr;
+					const extractCss = shouldExtractCssForRequest(state, isSsr);
+					const compiled = compileFile(id, getEnvironmentCache(state, isSsr), getCompileOptionsForRequest(state, isSsr), code);
+					syncCollectedCssForFile({
+						...state,
+						extractCss
+					}, id, compiled);
+					const result = await transformVirtualTypeScript(generateOutput(compiled, {
+						isProduction: state.isProduction,
+						isDev: state.server !== null,
+						ssr: isSsr,
+						extractCss,
+						filePath: id
+					}), id);
+					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: null
+					};
+				} catch (e) {
+					state.logger.error(`Virtual SFC compilation failed for ${id}:`, e);
+				}
+			}
+			return null;
+		}
+	};
+}
+//#endregion
+//#region src/plugin/unocss.ts
+const bridgePatched$1 = Symbol("vize.unocssBridgePatched");
+const VIZE_SSR_PREFIX$1 = "\0vize-ssr:";
+const plainSsrPrefix$1 = VIZE_SSR_PREFIX$1.slice(1);
+function stripBridgePrefix$1(id) {
+	if (id.startsWith(VIZE_SSR_PREFIX$1)) return id.slice(10);
+	if (id.startsWith(plainSsrPrefix$1)) return id.slice(plainSsrPrefix$1.length);
+	if (id.startsWith("\0")) return id.slice(1);
+	return id;
+}
+function isUnoCssBridgeModuleId(id) {
+	return /\.vue\.tsx?(?:\?|$)/.test(stripBridgePrefix$1(id));
+}
+function normalizeUnoCssBridgeModuleId(id) {
+	return stripBridgePrefix$1(id).replace(/\.tsx?(?=\?|$)/, "");
+}
+function appendOriginalVueSourceForUnoCss(code, normalizedId) {
+	const sourcePath = normalizedId.split("?")[0];
+	if (!sourcePath) return code;
+	try {
+		if (fs.statSync(sourcePath).size > 2097152) return code;
+	} catch {
+		return code;
+	}
+	try {
+		return `${code}\n${fs.readFileSync(sourcePath, "utf-8")}`;
+	} catch {
+		return code;
+	}
+}
+function patchUnoCssBridge(plugins) {
+	for (const plugin of plugins) {
+		if (!plugin.name?.startsWith("unocss:") || typeof plugin.transform !== "function" || plugin[bridgePatched$1]) continue;
+		const originalTransform = plugin.transform;
+		const isExtractionOnly = plugin.name.startsWith("unocss:global");
+		plugin.transform = function(code, id, ...args) {
+			if (!isUnoCssBridgeModuleId(id)) return originalTransform.call(this, code, id, ...args);
+			const normalizedId = normalizeUnoCssBridgeModuleId(id);
+			let effectiveCode = code;
+			if (isExtractionOnly) effectiveCode = appendOriginalVueSourceForUnoCss(code, normalizedId);
+			return originalTransform.call(this, effectiveCode, normalizedId, ...args);
+		};
+		plugin[bridgePatched$1] = true;
+	}
+}
+//#endregion
+//#region src/plugin/quasar.ts
+const bridgePatched = Symbol("vize.quasarBridgePatched");
+const VIZE_SSR_PREFIX = "\0vize-ssr:";
+const LEGACY_VIZE_PREFIX = "\0vize:";
+const plainSsrPrefix = VIZE_SSR_PREFIX.slice(1);
+const plainLegacyPrefix = LEGACY_VIZE_PREFIX.slice(1);
+function stripBridgePrefix(id) {
+	if (id.startsWith(VIZE_SSR_PREFIX)) return id.slice(10);
+	if (id.startsWith(LEGACY_VIZE_PREFIX)) return id.slice(6);
+	if (id.startsWith(plainSsrPrefix)) return id.slice(plainSsrPrefix.length);
+	if (id.startsWith(plainLegacyPrefix)) return id.slice(plainLegacyPrefix.length);
+	if (id.startsWith("\0")) return id.slice(1);
+	return id;
+}
+function isQuasarBridgeModuleId(id) {
+	return /\.vue\.tsx?(?:[?#]|$)/.test(stripBridgePrefix(id));
+}
+function normalizeQuasarBridgeModuleId(id) {
+	return stripBridgePrefix(id).replace(/\.vue\.tsx?(?=[?#]|$)/, ".vue");
+}
+function patchQuasarBridge(plugins) {
+	for (const plugin of plugins) {
+		if (plugin.name !== "vite:quasar:script" || typeof plugin.transform !== "function" || plugin[bridgePatched]) continue;
+		const originalTransform = plugin.transform;
+		plugin.transform = function(code, id, ...args) {
+			if (!isQuasarBridgeModuleId(id)) return originalTransform.call(this, code, id, ...args);
+			return originalTransform.call(this, code, normalizeQuasarBridgeModuleId(id), ...args);
+		};
+		plugin[bridgePatched] = true;
+	}
+}
+//#endregion
+//#region src/plugin/css-modules.ts
+function patchCssModuleGenerateScopedName(userConfig) {
+	const cssModules = userConfig.css?.modules;
+	if (!cssModules || typeof cssModules.generateScopedName !== "function") return;
+	const origFn = cssModules.generateScopedName;
+	cssModules.generateScopedName = function(name, filename, css) {
+		return origFn.call(this, name, normalizeCssModuleFilename(filename), css);
+	};
+}
+function normalizeCssModuleFilename(filename) {
+	const normalized = normalizeViteCssModuleFilename(filename);
+	if (normalized.startsWith("/@fs/")) return normalized.slice(4);
+	return normalized;
+}
+//#endregion
+//#region src/plugin/inspector-lint-plan.ts
+const VIZE_INSPECTOR_LINT_PLAN_ENDPOINT = "/__vize/inspector/lint-plan";
+const MAX_REQUEST_URL_BYTES = 8 * 1024;
+const MAX_FILE_COUNT = 128;
+const MAX_FILE_BYTES = 4 * 1024;
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+const ALLOWED_QUERY_KEYS = new Set(["file", "fresh"]);
+function installInspectorLintPlanMiddleware(devServer, state) {
+	const provider = state.mergedOptions.inspector?.lintPlan;
+	if (!provider) return;
+	devServer.middlewares.use((req, res, next) => {
+		if (!isInspectorLintPlanRequest(req.url, state.clientViteBase)) {
+			next();
+			return;
+		}
+		handleInspectorLintPlanRequest(req, res, provider, state.logger, state.clientViteBase);
+	});
+}
+function isInspectorLintPlanRequest(reqUrl, base = "/") {
+	if (!reqUrl) return false;
+	try {
+		return new URL(reqUrl, "http://localhost").pathname === resolveInspectorEndpoint(base);
+	} catch {
+		return false;
+	}
+}
+function parseInspectorLintPlanRequest(reqUrl, base = "/") {
+	if (!reqUrl || !isInspectorLintPlanRequest(reqUrl, base)) return null;
+	if (Buffer.byteLength(reqUrl) > MAX_REQUEST_URL_BYTES) return {
+		statusCode: 414,
+		error: "request_uri_too_long"
+	};
+	const url = new URL(reqUrl, "http://localhost");
+	for (const key of url.searchParams.keys()) if (!ALLOWED_QUERY_KEYS.has(key)) return {
+		statusCode: 400,
+		error: "invalid_query"
+	};
+	const freshValues = url.searchParams.getAll("fresh");
+	if (freshValues.length > 1 || freshValues[0] !== void 0 && freshValues[0] !== "1") return {
+		statusCode: 400,
+		error: "invalid_fresh"
+	};
+	const rawFiles = url.searchParams.getAll("file");
+	if (rawFiles.length > MAX_FILE_COUNT) return {
+		statusCode: 413,
+		error: "too_many_files"
+	};
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const file of rawFiles) {
+		if (!isSafeInspectorFile(file)) return {
+			statusCode: 400,
+			error: "invalid_file"
+		};
+		if (!seen.has(file)) {
+			seen.add(file);
+			files.push(file);
+		}
+	}
+	return { request: {
+		files,
+		fresh: freshValues[0] === "1"
+	} };
+}
+async function handleInspectorLintPlanRequest(req, res, provider, logger, base = "/") {
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		res.setHeader("allow", "GET, HEAD");
+		sendJson$1(res, 405, { error: "method_not_allowed" });
+		return;
+	}
+	const parsed = parseInspectorLintPlanRequest(req.url, base);
+	if (!parsed) {
+		sendJson$1(res, 404, { error: "not_found" });
+		return;
+	}
+	if ("error" in parsed) {
+		sendJson$1(res, parsed.statusCode, { error: parsed.error }, req.method === "HEAD");
+		return;
+	}
+	try {
+		sendJson$1(res, 200, await provider(parsed.request), req.method === "HEAD");
+	} catch (error) {
+		logger.error("Failed to build inspector lint plan:", error);
+		sendJson$1(res, 500, { error: "inspector_lint_plan_failed" }, req.method === "HEAD");
+	}
+}
+function resolveInspectorEndpoint(base) {
+	return `${new URL(base, "http://localhost").pathname.replace(/\/+$/, "")}${VIZE_INSPECTOR_LINT_PLAN_ENDPOINT}`;
+}
+function isSafeInspectorFile(file) {
+	if (file.length === 0 || Buffer.byteLength(file) > MAX_FILE_BYTES || file.includes("\0") || file.includes("\\") || path.posix.isAbsolute(file)) return false;
+	return !file.split("/").some((segment) => segment === ".." || segment.length === 0);
+}
+function sendJson$1(res, statusCode, payload, headOnly = false) {
+	let body = JSON.stringify(payload);
+	if (body === void 0) throw new TypeError("Inspector payload is not JSON serializable");
+	if (Buffer.byteLength(body) > MAX_RESPONSE_BYTES) {
+		statusCode = 413;
+		body = JSON.stringify({ error: "inspector_response_too_large" });
+	}
+	res.statusCode = statusCode;
+	res.setHeader("cache-control", "no-store");
+	res.setHeader("content-type", "application/json; charset=utf-8");
+	res.setHeader("content-length", Buffer.byteLength(body));
+	res.setHeader("x-content-type-options", "nosniff");
+	res.end(headOnly ? void 0 : body);
+}
+//#endregion
+//#region src/plugin/dev-middleware.ts
+const VIZE_INSPECTOR_GRAPH_ENDPOINT = "/__vize/inspector/graph";
+const INSPECTOR_SCRIPT_PATTERNS = ["**/*.{js,jsx,ts,tsx}"];
+const INSPECTOR_EXTRA_IGNORE_PATTERNS = ["**/*.d.ts"];
+const INSPECTOR_FILE_EXTENSION_RE = /\.(?:vue|[jt]sx?)$/;
+function installDevMiddleware(devServer, state) {
+	installVirtualAssetMiddleware(devServer, state);
+	installInspectorGraphMiddleware(devServer, state);
+	installInspectorLintPlanMiddleware(devServer, state);
+}
+function installVirtualAssetMiddleware(devServer, state) {
+	devServer.middlewares.use((req, _res, next) => {
+		const rewrite = req.url ? normalizeViteDevMiddlewareUrl(req.url) : null;
+		if (rewrite && fs.existsSync(rewrite.fsPath) && fs.statSync(rewrite.fsPath).isFile()) {
+			state.logger.log(`middleware: rewriting ${req.url} -> ${rewrite.cleanedUrl}`);
+			req.url = rewrite.cleanedUrl;
+		}
+		next();
+	});
+}
+function installInspectorGraphMiddleware(devServer, state) {
+	devServer.middlewares.use((req, res, next) => {
+		if (!isInspectorGraphRequest(req.url)) {
+			next();
+			return;
+		}
+		handleInspectorGraphRequest(req, res, state);
+	});
+}
+async function createInspectorGraphPayload(state) {
+	const files = await collectInspectorSourceFiles(state);
+	return {
+		schema: "vize.inspector.graph",
+		version: 1,
+		root: state.root,
+		fileCount: files.length,
+		graph: buildInspectorGraph(files)
+	};
+}
+async function collectInspectorSourceFiles(state) {
+	const paths = await glob(resolveInspectorScanPatterns(state.scanPatterns), {
+		cwd: state.root,
+		absolute: true,
+		followSymbolicLinks: false,
+		ignore: [...state.ignorePatterns, ...INSPECTOR_EXTRA_IGNORE_PATTERNS]
+	});
+	const files = [];
+	for (const filePath of [...new Set(paths)].sort()) {
+		if (!INSPECTOR_FILE_EXTENSION_RE.test(filePath)) continue;
+		const stat = statFile(filePath);
+		if (!stat) continue;
+		if (!stat.isFile() || stat.isSymbolicLink()) continue;
+		if (!isPathInsideRoot(state.root, filePath)) continue;
+		files.push({
+			path: normalizeInspectorPath(state.root, filePath),
+			source: fs.readFileSync(filePath, "utf-8")
+		});
+	}
+	return files;
+}
+function isInspectorGraphRequest(reqUrl) {
+	if (!reqUrl) return false;
+	try {
+		return new URL(reqUrl, "http://localhost").pathname === VIZE_INSPECTOR_GRAPH_ENDPOINT;
+	} catch {
+		return false;
+	}
+}
+function resolveInspectorScanPatterns(scanPatterns) {
+	return [...scanPatterns && scanPatterns.length > 0 ? scanPatterns : ["**/*.vue"], ...INSPECTOR_SCRIPT_PATTERNS];
+}
+function normalizeInspectorPath(root, filePath) {
+	return path.relative(root, filePath).split(path.sep).join("/");
+}
+function isPathInsideRoot(root, filePath) {
+	try {
+		const realRoot = fs.realpathSync.native(root);
+		const realFile = fs.realpathSync.native(filePath);
+		const relative = path.relative(realRoot, realFile);
+		return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+	} catch {
+		return false;
+	}
+}
+function statFile(filePath) {
+	try {
+		return fs.lstatSync(filePath);
+	} catch {
+		return null;
+	}
+}
+async function handleInspectorGraphRequest(req, res, state) {
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		sendJson(res, 405, { error: "method_not_allowed" });
+		return;
+	}
+	try {
+		sendJson(res, 200, await createInspectorGraphPayload(state), req.method === "HEAD");
+	} catch (error) {
+		state.logger.error("Failed to build inspector graph:", error);
+		sendJson(res, 500, {
+			error: "inspector_graph_failed",
+			message: formatUnknownError(error)
+		});
+	}
+}
+function sendJson(res, statusCode, payload, headOnly = false) {
+	const body = JSON.stringify(payload);
+	res.statusCode = statusCode;
+	res.setHeader("content-type", "application/json; charset=utf-8");
+	res.setHeader("content-length", Buffer.byteLength(body));
+	res.end(headOnly ? void 0 : body);
+}
+function formatUnknownError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/plugin/experimentals.ts
+function isExperimentalEnabled(value) {
+	return value !== void 0 && value !== null && value !== false;
+}
+function resolveExperimentalOptions(options, config) {
+	const pick = (...values) => values.find((value) => value !== void 0);
+	const enabled = (...values) => isExperimentalEnabled(pick(...values));
+	return {
+		vapor: enabled(options?.vapor, config?.vapor),
+		jsxVapor: enabled(options?.jsxVapor, config?.jsxVapor),
+		inTagComments: enabled(options?.intagComment, options?.inTagComment, config?.intagComment, config?.inTagComment),
+		patternedTemplate: enabled(options?.pattenedTemplate, options?.patternedTemplate, config?.pattenedTemplate, config?.patternedTemplate),
+		selfComponent: enabled(options?.selfComponent, config?.selfComponent),
+		strictSlotChildren: enabled(options?.strictSlotChildren, config?.strictSlotChildren),
+		serverScript: enabled(options?.serverScript, options?.["server script"], config?.serverScript, config?.["server script"])
+	};
+}
+function resolveExperimentalCompilerOptions(options, compilerConfig, config) {
+	const experimentals = resolveExperimentalOptions(options.experimentals, config);
+	return {
+		vapor: options.vapor ?? compilerConfig?.vapor ?? experimentals.vapor,
+		jsxMode: options.jsxMode ?? compilerConfig?.jsxMode ?? (experimentals.jsxVapor ? "vapor" : void 0),
+		jsxCompat: options.jsxCompat ?? compilerConfig?.jsxCompat,
+		experimentalInTagComments: experimentals.inTagComments,
+		experimentalPatternedTemplate: experimentals.patternedTemplate,
+		experimentalSelfComponent: experimentals.selfComponent,
+		experimentalStrictSlotChildren: experimentals.strictSlotChildren,
+		experimentalServerScript: experimentals.serverScript
+	};
+}
+//#endregion
+//#region src/plugin/vue-version.ts
+function isLegacyVueVersion(version) {
+	return version === "legacy" || version === .11 || version === 1 || version === 2 || version === "2.7";
+}
+function isLegacyVueCompatibilityMode(options) {
+	const vueVersion = options.vueVersion ?? options.compatibility?.vueVersion;
+	return (options.compatibility?.hostCompiler ?? isLegacyVueVersion(vueVersion)) && isLegacyVueVersion(vueVersion);
+}
+function hasHostVueSfcCompilerPlugin(plugins) {
+	return plugins.some((plugin) => {
+		const name = plugin.name;
+		return name === "vite:vue" || name === "vite:vue2" || name.includes("plugin-vue") || name.includes("vue2");
+	});
+}
+function createLegacyVueCompatibilityPlugin(options) {
+	return {
+		name: "vite-plugin-vize:legacy-vue-compat",
+		configResolved(resolvedConfig) {
+			if (!hasHostVueSfcCompilerPlugin(resolvedConfig.plugins)) throw new Error("vite-plugin-vize: legacy Vue host-compiler mode requires a host Vue SFC compiler plugin. Add @vitejs/plugin-vue2 (or your framework's Vue 2 Vite SFC plugin), or set compatibility.hostCompiler=false if this project can use Vize's compiler pipeline.");
+			createLogger(options.debug ?? false).log(`Legacy Vue compatibility mode is active for ${resolvedConfig.root}; Vize will not compile .vue files.`);
+		}
+	};
+}
+//#endregion
+//#region src/plugin/config-lifecycle.ts
+const compatibilityOwners = /* @__PURE__ */ new Map();
+const compatibilityRegistrations = /* @__PURE__ */ new WeakMap();
+function releaseCompatibilityRegistration(resolvedConfig) {
+	const registration = compatibilityRegistrations.get(resolvedConfig);
+	compatibilityRegistrations.delete(resolvedConfig);
+	if (!registration || compatibilityOwners.get(registration.root) !== registration.token) return;
+	compatibilityOwners.delete(registration.root);
+	if (vizeConfigStore.get(registration.root) === registration.config) vizeConfigStore.delete(registration.root);
+}
+function unregisterConfig(resolvedConfig) {
+	unregisterResolvedVizeConfig(resolvedConfig);
+	releaseCompatibilityRegistration(resolvedConfig);
+}
+async function register(resolvedConfig, root, sharedConfigPromise) {
+	releaseCompatibilityRegistration(resolvedConfig);
+	const token = Symbol(root);
+	compatibilityOwners.set(root, token);
+	vizeConfigStore.delete(root);
+	registerResolvedVizeConfig(resolvedConfig, sharedConfigPromise);
+	let sharedConfig;
+	try {
+		sharedConfig = await sharedConfigPromise;
+	} catch (error) {
+		unregisterResolvedVizeConfig(resolvedConfig);
+		if (compatibilityOwners.get(root) === token) {
+			compatibilityOwners.delete(root);
+			vizeConfigStore.delete(root);
+		}
+		throw error;
+	}
+	if (compatibilityOwners.get(root) !== token) return sharedConfig;
+	if (sharedConfig) {
+		compatibilityRegistrations.set(resolvedConfig, {
+			config: sharedConfig,
+			root,
+			token
+		});
+		vizeConfigStore.set(root, sharedConfig);
+	} else {
+		compatibilityOwners.delete(root);
+		vizeConfigStore.delete(root);
+	}
+	return sharedConfig;
+}
+function configureServerCleanup(devServer) {
+	const resolvedConfig = devServer.config;
+	let unregistered = false;
+	const unregister = () => {
+		if (unregistered) return;
+		unregistered = true;
+		devServer.httpServer?.off("close", unregister);
+		devServer.watcher.off("close", unregister);
+		unregisterConfig(resolvedConfig);
+	};
+	devServer.httpServer?.once("close", unregister);
+	devServer.watcher.once("close", unregister);
+}
+function unregisterBuild(context) {
+	const resolvedConfig = context.environment?.getTopLevelConfig?.();
+	if (resolvedConfig) unregisterConfig(resolvedConfig);
+}
+//#endregion
+//#region src/plugin/vue-feature-defines.ts
+function parseDefine(value) {
+	try {
+		return typeof value === "string" ? JSON.parse(value) : value;
+	} catch {
+		return value;
+	}
+}
+/**
+* Resolve Vue runtime defines with plugin-vue's precedence and defaults.
+*
+* `__VUE_PROD_DEVTOOLS__` used to be `command === "serve"`, which left no way to
+* enable devtools for a production build (#3227). It now follows plugin-vue's
+* OR semantics, and defaults to `false` in dev as upstream does: a development
+* build enables devtools through Vue's own `__DEV__`, not through this flag.
+*/
+function resolveVueFeatureDefines(features, define) {
+	return {
+		__VUE_OPTIONS_API__: features?.optionsAPI ?? parseDefine(define?.__VUE_OPTIONS_API__) ?? true,
+		__VUE_PROD_DEVTOOLS__: (features?.prodDevtools || parseDefine(define?.__VUE_PROD_DEVTOOLS__)) ?? false,
+		__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: (features?.prodHydrationMismatchDetails || parseDefine(define?.__VUE_PROD_HYDRATION_MISMATCH_DETAILS__)) ?? false
+	};
+}
+//#endregion
+//#region src/plugin/index-helpers.ts
+function shouldExtractCssForBuild(state, context) {
+	if (!state.isProduction) return false;
+	const environmentName = context.environment?.name;
+	if (environmentName === "client" || environmentName === "browser") return true;
+	if (environmentName === "ssr" || environmentName === "server") return false;
+	return state.extractCss;
+}
+function resolveCompatibilityOptions(options, compilerConfig = {}) {
+	const compatibility = {
+		...compilerConfig.compatibility,
+		...options.compatibility
+	};
+	const vueVersion = options.vueVersion ?? compatibility.vueVersion ?? 3;
+	if (compatibility.hostCompiler === void 0 && isLegacyVueVersion(vueVersion)) compatibility.hostCompiler = true;
+	return compatibility;
+}
+function aliasSortKey(find) {
+	return typeof find === "string" ? find.length : find.source.length;
+}
+//#endregion
+//#region src/plugin/index.ts
+function vize(options = {}) {
+	if (isLegacyVueCompatibilityMode(options)) return [createLegacyVueCompatibilityPlugin(options)];
+	const state = {
+		cache: new CompiledModuleCache(),
+		ssrCache: new CompiledModuleCache(),
+		collectedCss: /* @__PURE__ */ new Map(),
+		precompileMetadata: /* @__PURE__ */ new Map(),
+		pendingHmrUpdateTypes: /* @__PURE__ */ new Map(),
+		viteResolveCache: /* @__PURE__ */ new Map(),
+		isProduction: false,
+		viteBuildSourcemap: false,
+		root: "",
+		clientViteBase: "/",
+		serverViteBase: "/",
+		server: null,
+		filter: () => true,
+		scanPatterns: null,
+		precompileBatchSize: 128,
+		ignorePatterns: [],
+		mergedOptions: options,
+		initialized: false,
+		dynamicImportAliasRules: [],
+		cssAliasRules: [],
+		extractCss: false,
+		componentsCssFileName: "assets/vize-components.css",
+		clientViteDefine: {},
+		serverViteDefine: {},
+		logger: createLogger(options.debug ?? false)
+	};
+	return [
+		createVueCompatPlugin(state, options),
+		{
+			name: "vite-plugin-vize",
+			enforce: "pre",
+			config(userConfig) {
+				patchCssModuleGenerateScopedName(userConfig);
+				return {
+					define: resolveVueFeatureDefines(options.features, userConfig.define),
+					optimizeDeps: { exclude: ["virtual:vize-styles"] }
+				};
+			},
+			async configResolved(resolvedConfig) {
+				state.root = options.root ?? resolvedConfig.root;
+				state.isProduction = options.isProduction ?? resolvedConfig.isProduction;
+				state.viteBuildSourcemap = !!resolvedConfig.build?.sourcemap;
+				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 && !isSsrBuild;
+				state.componentsCssFileName = resolveComponentsCssFileName(resolvedConfig.build.assetsDir);
+				const isSsr = !!resolvedConfig.build?.ssr;
+				const envDefine = {};
+				if (resolvedConfig.define) for (const [key, value] of Object.entries(resolvedConfig.define)) {
+					if (!shouldApplyDefineInVirtualModule(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
+				};
+				const sharedConfigPromise = resolveSharedConfig(options, state.root, configEnv, state.logger);
+				const sharedConfig = await register(resolvedConfig, state.root, sharedConfigPromise);
+				const viteConfig = sharedConfig?.vite ?? {};
+				const compilerConfig = sharedConfig?.compiler ?? {};
+				const compatibility = resolveCompatibilityOptions(options, compilerConfig);
+				const vueVersion = options.vueVersion ?? compatibility.vueVersion ?? 3;
+				const mode = options.mode ?? compilerConfig.mode ?? (compatibility.scriptSetupInStandalone === true ? "function" : "module");
+				const templateSyntax = options.templateSyntax ?? compilerConfig.templateSyntax ?? "standard";
+				state.mergedOptions = {
+					...options,
+					ssr: options.ssr ?? compilerConfig.ssr ?? false,
+					sourceMap: options.sourceMap ?? compilerConfig.sourceMap,
+					...resolveExperimentalCompilerOptions(options, compilerConfig, sharedConfig?.experimentals),
+					customRenderer: options.customRenderer ?? compilerConfig.customRenderer ?? false,
+					customElements: options.customElements ?? compilerConfig.customElements,
+					templateSyntax,
+					compatibility,
+					vueVersion,
+					mode,
+					runtimeModuleName: options.runtimeModuleName ?? compilerConfig.runtimeModuleName ?? "vue",
+					runtimeGlobalName: options.runtimeGlobalName ?? compilerConfig.runtimeGlobalName ?? "Vue",
+					include: options.include ?? viteConfig.include,
+					exclude: options.exclude ?? viteConfig.exclude,
+					scanPatterns: options.scanPatterns ?? viteConfig.scanPatterns,
+					precompileBatchSize: options.precompileBatchSize ?? viteConfig.precompileBatchSize,
+					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" || alias.find instanceof RegExp) || typeof alias.replacement !== "string") continue;
+					state.cssAliasRules.push({
+						find: alias.find,
+						replacement: alias.replacement
+					});
+				}
+				state.cssAliasRules.sort((a, b) => aliasSortKey(b.find) - aliasSortKey(a.find));
+				if (isLegacyVueCompatibilityMode(state.mergedOptions)) {
+					state.filter = () => false;
+					state.scanPatterns = [];
+				} else {
+					state.filter = createFilter(state.mergedOptions.include, state.mergedOptions.exclude);
+					state.scanPatterns = state.mergedOptions.scanPatterns ?? ["**/*.vue"];
+				}
+				state.precompileBatchSize = normalizePrecompileBatchSize(state.mergedOptions.precompileBatchSize);
+				state.ignorePatterns = state.mergedOptions.ignorePatterns ?? [...DEFAULT_PRECOMPILE_IGNORE_PATTERNS];
+				patchUnoCssBridge(resolvedConfig.plugins);
+				patchQuasarBridge(resolvedConfig.plugins);
+				state.initialized = true;
+			},
+			configureServer(devServer) {
+				state.server = devServer;
+				configureServerCleanup(devServer);
+				installDevMiddleware(devServer, state);
+			},
+			async buildStart() {
+				state.viteResolveCache?.clear();
+				if (!state.scanPatterns || state.scanPatterns.length === 0) return;
+				await compileAll({
+					...state,
+					extractCss: shouldExtractCssForBuild(state, this)
+				});
+				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,
+					addWatchFile: this.addWatchFile.bind(this)
+				});
+			},
+			async transform(code, id, transformOptions) {
+				return transformHook(state, code, id, transformOptions);
+			},
+			async hotUpdate(options) {
+				return handleHotUpdateEnvironmentHook(state, this.environment, options);
+			},
+			shouldTransformCachedModule({ id }) {
+				return id?.includes(".vue") ? true : void 0;
+			},
+			async handleHotUpdate(ctx) {
+				return handleHotUpdateHook(state, ctx);
+			},
+			generateBundle(_, bundle) {
+				handleGenerateBundleHook({
+					...state,
+					extractCss: shouldExtractCssForBuild(state, this)
+				}, this.emitFile.bind(this), bundle);
+			},
+			closeBundle() {
+				if (state.server === null) {
+					unregisterBuild(this);
+					clearBuildCaches(state);
+				}
+			}
+		},
+		createStylePostTransformPlugin(),
+		createPostTransformPlugin(state)
+	];
+}
+//#endregion
+export { rewriteStaticAssetUrls as n, vize as t };