@vizejs/vite-plugin 0.291.0 → 0.303.0

package/dist/index.mjs

@@ -1,14 +1,14 @@
 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 * as vite from "vite";
-import { parseSync } from "vite";
+import { parseSync } from "oxc-parser";
 import fs from "node:fs";
 import { glob } from "tinyglobby";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import * as vite from "vite";
 //#region src/hmr.ts
 function hasHmrChanges(prev, next) {
 	if (!prev) return true;
@@ -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 {
@@ -624,7 +701,23 @@ function inlineStyleSrcBlocks(source, filePath, dependencies) {
 		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;
@@ -726,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.
@@ -842,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;
@@ -887,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}`);
@@ -1649,67 +1947,21 @@ function createVirtualTypeScriptTransformer(viteApi) {
 		throw new Error("Installed Vite does not expose transformWithOxc or transformWithEsbuild");
 	};
 }
-const TYPE_DECLARATION_RE = /\b(?:interface|type|enum|namespace|declare)\s+[A-Za-z_$]/;
-const TYPE_ASSERTION_RE = /\bas\s+(?:const|unknown|never|any|string|number|boolean|readonly\b|[A-Z][A-Za-z0-9_$]*(?:\s*[<[{&|),;=]|$))/;
-const TYPED_BINDING_RE = /\b(?:const|let|var)\s+[A-Za-z_$][\w$]*\s*:/;
-const GENERIC_FUNCTION_RE = /\bfunction\s+[A-Za-z_$][\w$]*\s*<[^>{}]*>\s*\(/;
-const TYPED_PARAMETER_RE = /[(,]\s*(?:\.\.\.)?[A-Za-z_$][\w$]*\??\s*:\s*[^,)=]+/;
-const RETURN_TYPE_RE = /\)\s*:\s*[^=<{;]+[{=>]/;
-const ACCESS_MODIFIER_RE = /\b(?:public|private|protected|readonly|abstract|implements)\b/;
-const SATISFIES_RE = /\bsatisfies\s+[A-Za-z_$]/;
-function hasUnbalancedDelimiters(code) {
-	const stack = [];
-	let quote = null;
-	let escaped = false;
-	let lineComment = false;
-	let blockComment = false;
-	for (let index = 0; index < code.length; index += 1) {
-		const char = code[index];
-		const next = code[index + 1];
-		if (lineComment) {
-			if (char === "\n" || char === "\r") lineComment = false;
-			continue;
-		}
-		if (blockComment) {
-			if (char === "*" && next === "/") {
-				blockComment = false;
-				index += 1;
-			}
-			continue;
-		}
-		if (quote) {
-			if (escaped) escaped = false;
-			else if (char === "\\") escaped = true;
-			else if (char === quote) quote = null;
-			continue;
-		}
-		if (char === "/" && next === "/") {
-			lineComment = true;
-			index += 1;
-			continue;
-		}
-		if (char === "/" && next === "*") {
-			blockComment = true;
-			index += 1;
-			continue;
-		}
-		if (char === "'" || char === "\"" || char === "`") {
-			quote = char;
-			continue;
-		}
-		if (char === "{" || char === "(" || char === "[") {
-			stack.push(char);
-			continue;
-		}
-		if (char === "}" || char === ")" || char === "]") {
-			const open = stack.pop();
-			if (char === "}" && open !== "{" || char === ")" && open !== "(" || char === "]" && open !== "[") return true;
-		}
-	}
-	return quote !== null || blockComment || stack.length > 0;
-}
-function needsVirtualTypeScriptTransform(code) {
-	return TYPE_DECLARATION_RE.test(code) || TYPE_ASSERTION_RE.test(code) || TYPED_BINDING_RE.test(code) || GENERIC_FUNCTION_RE.test(code) || TYPED_PARAMETER_RE.test(code) || RETURN_TYPE_RE.test(code) || ACCESS_MODIFIER_RE.test(code) || SATISFIES_RE.test(code) || hasUnbalancedDelimiters(code);
+/**
+* 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) {
@@ -1731,7 +1983,7 @@ function formatUnknownError$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 async function transformVizeVirtualModule(state, code, realPath, ssr, forceTypeScriptTransform = false) {
-	const needsTsTransform = forceTypeScriptTransform || needsVirtualTypeScriptTransform(code);
+	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));

package/package.json

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