@vizejs/vite-plugin 0.302.0 → 0.306.0

package/dist/index.mjs

@@ -1,12 +1,13 @@
 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";
 import fs from "node:fs";
 import { glob } from "tinyglobby";
 import path from "node:path";
+import zlib from "node:zlib";
 import { pathToFileURL } from "node:url";
 import * as vite from "vite";
 //#region src/hmr.ts
@@ -86,9 +87,15 @@ function isNode(value) {
 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);
@@ -146,7 +153,9 @@ function analyzeFastDefaultOutput(code) {
 		hasNamedRenderExport: false,
 		hasNamedSsrRenderExport: false,
 		defaultExportStart,
-		defaultExportKeywordEnd: defaultExportStart + 14
+		defaultExportKeywordEnd: defaultExportStart + 14,
+		defaultExportEnd: null,
+		defaultExportIsSfcMain: false
 	};
 }
 function getExportDefaultKeywordEnd(code, defaultExport) {
@@ -172,7 +181,9 @@ function analyzeModuleOutput(code) {
 		hasNamedRenderExport: exportedNames.includes("render"),
 		hasNamedSsrRenderExport: exportedNames.includes("ssrRender"),
 		defaultExportKeywordEnd,
-		defaultExportStart
+		defaultExportStart,
+		defaultExportEnd: getNodeEnd(defaultExport),
+		defaultExportIsSfcMain: isSfcMainDefaultExport(defaultExport)
 	};
 }
 function rewriteDefaultExportToSfcMain(code, moduleInfo = {
@@ -189,12 +200,29 @@ function rewriteDefaultExportToSfcMain(code, moduleInfo = {
 	if (exportStart == null || keywordEnd == null) return code;
 	return `${code.slice(0, exportStart)}const ${SFC_MAIN_NAME} =${code.slice(keywordEnd)}`;
 }
-function insertBeforeSfcMainDefaultExport(code, insertion, options = {}) {
+/**
+* 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));
-	const declaration = isNode(defaultExport?.declaration) ? defaultExport.declaration : null;
-	const exportStart = getNodeStart(defaultExport);
-	const exportEnd = typeof defaultExport?.end === "number" ? defaultExport.end : null;
-	if (!isIdentifierNamed(declaration, SFC_MAIN_NAME) || exportStart == null) return 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)}`;
@@ -374,6 +402,36 @@ function insertAfterStaticImports(output, imports) {
 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 && (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.ssr && !!compiled.css && !(options.isProduction && !!options.extractCss);
+}
 function generateOutput(compiled, options) {
 	const { isProduction, isDev, ssr, hmrUpdateType, extractCss, filePath } = options;
 	let output = compiled.code;
@@ -387,7 +445,7 @@ function generateOutput(compiled, options) {
 		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
 		output += "\nexport default _sfc_main;";
 	} else if (hasExportDefault && hasSfcMainDefined) {
-		if (compiled.hasScoped && compiled.scopeId) output = insertBeforeSfcMainDefaultExport(output, `_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		if (compiled.hasScoped && compiled.scopeId) output = insertBeforeSfcMainDefaultExport(output, `_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`, { moduleInfo });
 	} else if (!hasExportDefault && !hasSfcMainDefined && hasNamedRenderExport) {
 		output += "\nconst _sfc_main = {};";
 		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
@@ -399,7 +457,7 @@ function generateOutput(compiled, options) {
 		output += "\n_sfc_main.ssrRender = ssrRender;";
 		output += "\nexport default _sfc_main;";
 	}
-	if (!!filePath && !!compiled.styles?.length && (hasDelegatedStyles(compiled) || !ssr && isProduction && extractCss)) {
+	if (usesStyleImports(compiled, options)) {
 		const styleImports = [];
 		const cssModuleImports = [];
 		for (const block of compiled.styles) {
@@ -454,13 +512,39 @@ function toPluginVisibleVirtualId(realPath, ssr = false, querySuffix = "") {
 	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 (id.startsWith("\0")) return null;
+	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(classifyVitePluginRequest(request.normalizedFsId ?? id).path);
+	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");
@@ -526,6 +610,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 +903,495 @@ 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.
+*
+* `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");
 }
-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: 2,
+		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;
+//#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);
 }
-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"
+/**
+* `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: 2,
+		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 (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;
+	if (cssLength !== -1) module.css = record.toString("utf8", cssStart, cssStart + cssLength);
+	return isCompiledModule(module) ? module : null;
 }
-function syncCollectedCssForFile(state, filePath, compiled) {
-	if (!compiled || !state.extractCss) return;
-	if (compiled.styles?.length) {
-		state.collectedCss.delete(filePath);
-		return;
+/**
+* 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 !== 2 || 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 (compiled.css && !hasDelegatedStyles(compiled)) state.collectedCss.set(filePath, resolveCssImports(compiled.css, filePath, state.cssAliasRules, false));
-	else state.collectedCss.delete(filePath);
+	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;
 }
-function shouldExtractCssForRequest(state, ssr) {
-	return state.isProduction && !ssr;
+//#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;
+		}
+	};
 }
-function clearBuildCaches(state) {
-	state.cache.clear();
-	state.ssrCache.clear();
-	state.collectedCss.clear();
-	state.precompileMetadata.clear();
-	state.pendingHmrUpdateTypes.clear();
-	state.viteResolveCache?.clear();
+/**
+* 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) {
+	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 +1432,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 +1486,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}`);
@@ -1317,10 +1906,10 @@ function isPotentialVizeResolveId(id) {
 function classifyImporterRequest(importer) {
 	return importer ? classifyVitePluginRequest(importer) : null;
 }
-function isPotentialVizeImporter(importer, importerRequest) {
+function isPotentialVizeImporter(importer) {
 	if (importer === void 0) return false;
 	if (importer.startsWith("\0") || importer.startsWith("vize:")) return true;
-	return importerRequest?.isVueSfcPath ?? false;
+	return importer.includes(".vue");
 }
 function shouldCompileVueSfcRequest(request) {
 	if (!request.isVueSfcPath || request.isVueStyleQuery || request.hasMacroQuery || request.hasDefinePageQuery) return false;
@@ -1354,8 +1943,8 @@ async function resolveAliasedVueImport(ctx, state, id, importer, isSsrRequest, h
 	return null;
 }
 async function resolveIdHook(ctx, state, id, importer, options) {
+	if (!isPotentialVizeResolveId(id) && !isPotentialVizeImporter(importer)) return null;
 	const importerRequest = classifyImporterRequest(importer);
-	if (!isPotentialVizeResolveId(id) && !isPotentialVizeImporter(importer, importerRequest)) return null;
 	const isBuild = state.server === null;
 	const isDependencyScan = !!options?.scan;
 	const isSsrRequest = !!options?.ssr || (importerRequest?.isVizeSsrVirtual ?? false) || (importer ? isPluginVisibleSsrVirtualId(importer) : false);
@@ -1785,19 +2374,19 @@ function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions)
 	if (!compiled) return null;
 	for (const watchFile of new Set([realPath, ...compiled.dependencies ?? []])) loadOptions?.addWatchFile?.(watchFile);
 	const hasDelegated = hasDelegatedStyles(compiled);
-	const pendingHmrUpdateType = loadOptions?.ssr ? void 0 : state.pendingHmrUpdateTypes.get(realPath);
-	if (compiled.css && !hasDelegated) compiled = {
-		...compiled,
-		css: resolveCssImports(compiled.css, realPath, state.cssAliasRules, state.server !== null, currentBase)
-	};
-	const generatedOutput = generateOutput(compiled, {
+	const outputOptions = {
 		isProduction: state.isProduction,
 		isDev: state.server !== null && !isSsr,
 		ssr: isSsr,
-		hmrUpdateType: pendingHmrUpdateType,
+		hmrUpdateType: loadOptions?.ssr ? void 0 : state.pendingHmrUpdateTypes.get(realPath),
 		extractCss,
 		filePath: realPath
-	});
+	};
+	if (compiled.css && !hasDelegated && embedsInlineCss(compiled, outputOptions)) compiled = {
+		...compiled,
+		css: resolveCssImports(compiled.css, realPath, state.cssAliasRules, state.server !== null, currentBase)
+	};
+	const generatedOutput = generateOutput(compiled, outputOptions);
 	const normalizedOutput = rewriteImportMetaGlobBase(rewriteStaticAssetUrls(rewriteDynamicTemplateImports(isSsr ? normalizeVueServerRendererImport(generatedOutput) : generatedOutput, state.dynamicImportAliasRules), state.dynamicImportAliasRules), realPath, state.root);
 	if (!loadOptions?.ssr) state.pendingHmrUpdateTypes.delete(realPath);
 	return {
@@ -2138,7 +2727,22 @@ function normalizeVirtualStyleId(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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.302.0",
+  "version": "0.306.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.306.0",
     "oxc-parser": "0.133.0",
     "tinyglobby": "0.2.16",
-    "vize": "0.302.0"
+    "vize": "0.306.0"
   },
   "devDependencies": {
     "@types/node": "25.9.2",