@vizejs/vite-plugin 0.302.0 → 0.303.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { registerResolvedVizeConfig, unregisterResolvedVizeConfig } from "./internal/config-bridge.mjs";
 import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
+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";
@@ -526,6 +526,83 @@ function createLogger(debug) {
 	};
 }
 //#endregion
+//#region src/plugin/precompile.ts
+const DEFAULT_PRECOMPILE_IGNORE_PATTERNS = [
+	"node_modules/**",
+	"dist/**",
+	".git/**",
+	".nuxt/**",
+	".output/**",
+	".nitro/**",
+	"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,
+		ssr,
+		vapor: !ssr && (state.mergedOptions?.vapor ?? false),
+		customRenderer: state.mergedOptions?.customRenderer ?? false,
+		templateSyntax: state.mergedOptions?.templateSyntax ?? "standard"
+	};
+	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?.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/compile-options.ts
 function buildCompileFileOptions(filePath, options) {
 	return {
@@ -742,82 +819,272 @@ function compileBatch(files, cache, options) {
 	}
 	return result;
 }
-//#endregion
-//#region src/plugin/precompile.ts
-const DEFAULT_PRECOMPILE_IGNORE_PATTERNS = [
-	"node_modules/**",
-	"dist/**",
-	".git/**",
-	".nuxt/**",
-	".output/**",
-	".nitro/**",
-	"coverage/**"
-];
-function isPrecompileSfcPath(path) {
-	return path.endsWith(".vue");
+/** SHA-256 of the exact source text handed to the compiler. */
+function hashPrecompileSource(source) {
+	return crypto.createHash("sha256").update(source, "utf8").digest("hex");
 }
-function diffPrecompileFiles(files, currentMetadata, previousMetadata) {
-	return diffVitePrecompileFiles([...files], toNativePrecompileMetadataEntries(currentMetadata), toNativePrecompileMetadataEntries(previousMetadata));
+/** 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 normalizePrecompileBatchSize(value) {
-	return normalizeVitePrecompileBatchSize(value);
+function describeBinary(binary) {
+	try {
+		const stat = fs.statSync(binary);
+		return `${path.basename(binary)}:${stat.size}:${stat.mtimeMs}`;
+	} catch {
+		return `${path.basename(binary)}:unresolved`;
+	}
 }
-function chunkPrecompileFiles(files, batchSize, options = {}) {
-	return chunkVitePrecompileFiles([...files], batchSize, {
-		maxBytes: options.maxBytes,
-		metadata: options.metadata ? toNativePrecompileMetadataEntries(options.metadata) : void 0
-	});
+/**
+* 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"]
+		};
+	}
 }
-function toNativePrecompileMetadataEntries(metadata) {
-	const entries = [];
-	for (const [path, value] of metadata) entries.push({
-		path,
-		mtimeMs: value.mtimeMs,
-		size: value.size
+/**
+* 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: 1,
+		compiler: resolveCompilerIdentity(),
+		options: compileOptions
 	});
-	return entries;
+	return crypto.createHash("sha256").update(material, "utf8").digest("hex").slice(0, 32);
 }
 //#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,
-		ssr,
-		vapor: !ssr && (state.mergedOptions?.vapor ?? false),
-		customRenderer: state.mergedOptions?.customRenderer ?? false,
-		templateSyntax: state.mergedOptions?.templateSyntax ?? "standard"
+//#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 here:
+*
+* - **Shape.** Entries are validated before use and dropped individually if
+*   they do not describe a complete `CompiledModule`. The manifest'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 `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 (typeof value !== "object" || value === null) 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);
+}
+function isCacheEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const entry = value;
+	return typeof entry.hash === "string" && entry.hash.length > 0 && isCompiledModule(entry.module);
+}
+/** 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}.json`);
+	const entries = readManifestEntries(file, key, 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;
+			if (!writeManifest(file, {
+				format: 1,
+				key,
+				entries: Object.fromEntries(entries)
+			}, onDiagnostic)) return false;
+			dirty = false;
+			return true;
+		}
 	};
-	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?.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;
+/**
+* Parse the manifest, 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, onDiagnostic) {
+	const entries = /* @__PURE__ */ new Map();
+	let raw;
+	try {
+		raw = fs.readFileSync(file, "utf-8");
+	} catch {
+		return entries;
 	}
-	if (compiled.css && !hasDelegatedStyles(compiled)) state.collectedCss.set(filePath, resolveCssImports(compiled.css, filePath, state.cssAliasRules, false));
-	else state.collectedCss.delete(filePath);
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		onDiagnostic?.(`Discarding corrupt pre-compile cache ${file}:`, error);
+		return entries;
+	}
+	const manifest = parsed;
+	if (typeof manifest !== "object" || manifest === null || manifest.format !== 1 || manifest.key !== key || typeof manifest.entries !== "object" || manifest.entries === null) {
+		onDiagnostic?.(`Ignoring pre-compile cache ${file}: unrecognized manifest`);
+		return entries;
+	}
+	for (const [filePath, entry] of Object.entries(manifest.entries)) if (isCacheEntry(entry)) entries.set(filePath, entry);
+	return entries;
 }
-function shouldExtractCssForRequest(state, ssr) {
-	return state.isProduction && !ssr;
+/** Write through a sibling temp file so a crash cannot leave a partial manifest. */
+function writeManifest(file, manifest, onDiagnostic) {
+	const temp = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+	try {
+		fs.mkdirSync(path.dirname(file), { recursive: true });
+		fs.writeFileSync(temp, JSON.stringify(manifest));
+		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;
+	}
 }
-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/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) {
+	return {
+		ssr: false,
+		vapor: state.mergedOptions.vapor ?? false,
+		mode: state.mergedOptions.mode,
+		customRenderer: state.mergedOptions.customRenderer ?? false,
+		templateSyntax: state.mergedOptions.templateSyntax ?? "standard",
+		experimentalInTagComments: state.mergedOptions.experimentalInTagComments ?? false,
+		experimentalPatternedTemplate: state.mergedOptions.experimentalPatternedTemplate ?? false,
+		experimentalServerScript: state.mergedOptions.experimentalServerScript ?? false,
+		runtimeModuleName: state.mergedOptions.runtimeModuleName,
+		runtimeGlobalName: state.mergedOptions.runtimeGlobalName,
+		vueVersion: state.mergedOptions.vueVersion
+	};
+}
+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.
@@ -858,41 +1125,50 @@ async function compileAll(state) {
 		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 = [];
-		for (const file of chunk) try {
-			const source = fs.readFileSync(file, "utf-8");
+		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, file, restored);
+				restoredCount++;
+				continue;
+			}
+			if (sourceHash !== void 0) sourceHashes.set(file, sourceHash);
 			fileContents.push({
 				path: file,
 				source
 			});
-		} catch (e) {
-			failedCount++;
-			state.cache.delete(file);
-			if (state.extractCss) state.collectedCss.delete(file);
-			state.precompileMetadata.delete(file);
-			precompileFailures.push(`[vize] Failed to read ${file}: ${formatUnknownError$2(e)}`);
-			state.logger.error(`Failed to read ${file}:`, e);
 		}
 		if (fileContents.length === 0) continue;
-		const result = compileBatch(fileContents, state.cache, {
-			ssr: false,
-			vapor: state.mergedOptions.vapor ?? false,
-			mode: state.mergedOptions.mode,
-			customRenderer: state.mergedOptions.customRenderer ?? false,
-			templateSyntax: state.mergedOptions.templateSyntax ?? "standard",
-			experimentalInTagComments: state.mergedOptions.experimentalInTagComments ?? false,
-			experimentalPatternedTemplate: state.mergedOptions.experimentalPatternedTemplate ?? false,
-			experimentalServerScript: state.mergedOptions.experimentalServerScript ?? false,
-			runtimeModuleName: state.mergedOptions.runtimeModuleName,
-			runtimeGlobalName: state.mergedOptions.runtimeGlobalName,
-			vueVersion: state.mergedOptions.vueVersion
-		});
+		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;
@@ -903,16 +1179,22 @@ async function compileAll(state) {
 				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);
-			syncCollectedCssForFile(state, fileResult.path, state.cache.get(fileResult.path));
+			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, 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, ${cachedFileCount} reused, ${failedCount} failed (${elapsed}ms, native ${batchLabel}: ${nativeTimeMs.toFixed(2)}ms)`);
+	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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.302.0",
+  "version": "0.303.0",
   "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
   "keywords": [
     "compiler",
@@ -45,10 +45,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@vizejs/native": "0.302.0",
+    "@vizejs/native": "0.303.0",
     "oxc-parser": "0.133.0",
     "tinyglobby": "0.2.16",
-    "vize": "0.302.0"
+    "vize": "0.303.0"
   },
   "devDependencies": {
     "@types/node": "25.9.2",