@vizejs/vite-plugin 0.303.0 → 0.310.0

package/dist/index.mjs

@@ -4,9 +4,10 @@ import crypto, { createHash } from "node:crypto";
 import * as native from "@vizejs/native";
 import { applyViteDefineReplacements, buildInspectorGraph, chunkVitePrecompileFiles, classifyVitePluginRequest, createViteBareImportBases, createViteBareImportCandidates, createViteVirtualId, detectViteHmrUpdateType, diffVitePrecompileFiles, generateViteHmrCode, hasViteHmrChanges, isViteBareSpecifier, normalizeViteCssModuleFilename, normalizeViteDevMiddlewareUrl, normalizeVitePrecompileBatchSize, normalizeViteRequireBase, normalizeViteResolvedVuePath, resolveViteAliasRequest, resolveViteCssImports, resolveViteRelativeImport, resolveViteVuePath, rewriteViteDynamicTemplateImports, rewriteViteImportMetaGlobBase, rewriteViteStaticAssetUrls, scopeViteCssForPipeline, shouldApplyViteDefineInVirtualModule, splitViteIdQuery, toViteBrowserImportPrefix, transformViteCssVarsForPipeline } from "@vizejs/native";
 import { parseSync } from "oxc-parser";
+import path from "node:path";
 import fs from "node:fs";
 import { glob } from "tinyglobby";
-import 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");
@@ -603,6 +687,84 @@ function clearBuildCaches(state) {
 	state.viteResolveCache?.clear();
 }
 //#endregion
+//#region src/plugin/compiled-module-cache.ts
+/**
+* Compiled-module caches carrying a reverse index from a `src`-imported
+* dependency to the SFCs that pulled it in.
+*
+* Every hot update has to answer "which SFCs own this changed file?" before it
+* can do anything else, and that answer used to come from a full scan of both
+* caches with a `path.resolve` per dependency per cached file. HMR latency then
+* grew with the number of components in the project, on the interactive path,
+* for every save — including saves of ordinary `.vue` files, because the scan
+* runs before the `.vue` fast path.
+*
+* The index is maintained by overriding `set`/`delete`/`clear` rather than by a
+* second structure updated at each call site. `state.cache` is handed to
+* `compileFile` and `compileBatch`, and is also mutated directly from
+* `precompile-run.ts`, `hmr.ts` and `state.ts`; a structure kept in sync by hand
+* across those would drift the first time a new writer appeared. Subclassing
+* puts the bookkeeping where the mutation is.
+*
+* The keys are `path.resolve`d exactly as the previous scan resolved them, so a
+* dependency recorded as a relative path indexes and looks up identically.
+*/
+var CompiledModuleCache = class extends Map {
+	#ownersByDependency = /* @__PURE__ */ new Map();
+	/**
+	* Deliberately takes no entries: `Map`'s constructor would call the
+	* overridden `set` from inside `super()`, before `#ownersByDependency` exists.
+	*/
+	constructor() {
+		super();
+	}
+	set(file, compiled) {
+		this.#unindex(file);
+		super.set(file, compiled);
+		for (const dependency of compiled.dependencies ?? []) {
+			const key = path.resolve(dependency);
+			const owners = this.#ownersByDependency.get(key);
+			if (owners) owners.add(file);
+			else this.#ownersByDependency.set(key, new Set([file]));
+		}
+		return this;
+	}
+	delete(file) {
+		this.#unindex(file);
+		return super.delete(file);
+	}
+	clear() {
+		this.#ownersByDependency.clear();
+		super.clear();
+	}
+	/** The cached SFCs that `src`-import `resolvedDependency`. */
+	ownersOf(resolvedDependency) {
+		const owners = this.#ownersByDependency.get(resolvedDependency);
+		return owners ? [...owners] : [];
+	}
+	#unindex(file) {
+		for (const dependency of super.get(file)?.dependencies ?? []) {
+			const key = path.resolve(dependency);
+			const owners = this.#ownersByDependency.get(key);
+			if (!owners) continue;
+			owners.delete(file);
+			if (owners.size === 0) this.#ownersByDependency.delete(key);
+		}
+	}
+};
+/**
+* Owners of `resolvedDependency` in one cache.
+*
+* Plain `Map`s — the hand-built states in unit tests — keep the original linear
+* scan, so an unindexed cache answers exactly what the indexed one does.
+*/
+function ownersOfDependency(cache, resolvedDependency) {
+	if (cache instanceof CompiledModuleCache) return cache.ownersOf(resolvedDependency);
+	const owners = [];
+	for (const [file, compiled] of cache) if (compiled.dependencies?.some((dependency) => path.resolve(dependency) === resolvedDependency)) owners.push(file);
+	return owners;
+}
+//#endregion
 //#region src/compile-options.ts
 function buildCompileFileOptions(filePath, options) {
 	return {
@@ -819,9 +981,14 @@ function compileBatch(files, cache, options) {
 	}
 	return result;
 }
-/** SHA-256 of the exact source text handed to the compiler. */
+/**
+* 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("hex");
+	return crypto.createHash("sha256").update(source, "utf8").digest("base64url");
 }
 /** Key-independent JSON: object key order must not change the hash. */
 function stableStringify(value) {
@@ -872,13 +1039,241 @@ function resolveCompilerIdentity() {
 */
 function computePrecompileCacheKey(compileOptions) {
 	const material = stableStringify({
-		format: 1,
+		format: 2,
 		compiler: resolveCompilerIdentity(),
 		options: compileOptions
 	});
 	return crypto.createHash("sha256").update(material, "utf8").digest("hex").slice(0, 32);
 }
 //#endregion
+//#region src/plugin/precompile-cache-store.ts
+/**
+* On-disk container for the persistent pre-compile cache.
+*
+* The first format stored the whole manifest as one JSON document, which meant
+* every compiled module's `code` went to disk as a JSON-escaped string: ~87% of
+* the bytes were that one field, and a cold build paid `JSON.stringify` over all
+* of it while a warm build paid `JSON.parse` back. This container splits the
+* two concerns instead:
+*
+* ```text
+* <header JSON>\n<compressed index><compressed payload>
+* ```
+*
+* - The **header** is one line of plain JSON naming the format, the cache key,
+*   the codec, and the exact byte length of the two bodies.
+* - The **index** is a compressed JSON array of `[relativePath, sourceHash,
+*   recordLength]`. Record offsets are *not* stored: they are the running sum of
+*   the lengths, so there is no offset that can point somewhere else.
+* - The **payload** is the records back to back, each one
+*   `<meta JSON>\n<code utf8><css utf8>\n`. `code` and `css` are raw UTF-8, so
+*   the 90% of the manifest that is compiled output is never escaped, parsed, or
+*   re-quoted -- only sliced out.
+*
+* `meta` is `[codeLength, cssLength, everythingElse]`, where `everythingElse` is
+* the compiled module minus `code`/`css` **by rest destructuring**, not by a
+* hand-copied field list. A field added to `CompiledModule` later is therefore
+* carried through automatically instead of being silently dropped.
+*
+* Every structural expectation above is re-checked on read and any failure
+* returns `null`, which the caller treats as "no cache" -- a full recompile.
+* See `decodePrecompileManifest`.
+*/
+/** File extension of the container. Not `.json`: it is a header plus two blobs. */
+const PRECOMPILE_CACHE_EXTENSION = ".vpc";
+const LF = 10;
+const NEWLINE = Buffer.from("\n");
+const EMPTY = Buffer.alloc(0);
+/**
+* Whether `module` may be persisted.
+*
+* Modules assembled from `src` imports depend on sibling files that this cache
+* does not hash, so they are recompiled on every cold start instead.
+*/
+function isPersistablePrecompileModule(module) {
+	return !module.dependencies || module.dependencies.length === 0;
+}
+function isCompiledModule(value) {
+	if (value === null || typeof value !== "object") return false;
+	const module = value;
+	if (typeof module.code !== "string" || typeof module.scopeId !== "string") return false;
+	if (typeof module.hasScoped !== "boolean") return false;
+	if (module.css !== void 0 && typeof module.css !== "string") return false;
+	if (module.styles !== void 0 && !Array.isArray(module.styles)) return false;
+	if (module.macroArtifacts !== void 0 && !Array.isArray(module.macroArtifacts)) return false;
+	return isPersistablePrecompileModule(module);
+}
+/**
+* `zstd` when this Node has it, `gzip` otherwise.
+*
+* The sync zstd bindings arrived in Node 22.15 / 23.8 and this package supports
+* Node >= 22, so the codec is detected rather than assumed. Both codecs carry
+* an integrity check of their own -- zstd with `checksumFlag`, gzip with its
+* trailing CRC32 -- so bit rot inside either body fails decompression instead of
+* being decoded into a plausible-looking module.
+*/
+const hasZstd = typeof zlib.zstdCompressSync === "function" && typeof zlib.zstdDecompressSync === "function";
+const ZSTD_PARAMS = hasZstd ? { params: { [zlib.constants.ZSTD_c_checksumFlag]: 1 } } : void 0;
+function compressBody(body) {
+	return hasZstd ? zlib.zstdCompressSync(body, ZSTD_PARAMS) : zlib.gzipSync(body, { level: 1 });
+}
+/** `null` for an unknown codec, or one this Node cannot read. */
+function decompressBody(codec, body) {
+	if (codec === "zstd") return hasZstd ? zlib.zstdDecompressSync(body) : null;
+	if (codec === "gzip") return zlib.gunzipSync(body);
+	return null;
+}
+/** `<meta JSON>\n<code><css>\n` -- the trailing LF marks the record boundary. */
+function encodeRecord(module) {
+	const { code, css, ...rest } = module;
+	const codeBytes = Buffer.from(code, "utf8");
+	const cssBytes = css === void 0 ? null : Buffer.from(css, "utf8");
+	const meta = Buffer.from(JSON.stringify([
+		codeBytes.length,
+		cssBytes === null ? -1 : cssBytes.length,
+		rest
+	]), "utf8");
+	return Buffer.concat([
+		meta,
+		NEWLINE,
+		codeBytes,
+		cssBytes ?? EMPTY,
+		NEWLINE
+	]);
+}
+/** Serialize the container. Never throws for well-typed entries. */
+function encodePrecompileManifest(options) {
+	const { key, root, entries } = options;
+	const index = [];
+	const records = [];
+	for (const [file, entry] of entries) {
+		const record = encodeRecord(entry.module);
+		index.push([
+			path.relative(root, file),
+			entry.hash,
+			record.length
+		]);
+		records.push(record);
+	}
+	const indexBody = compressBody(Buffer.from(JSON.stringify(index), "utf8"));
+	const payloadBody = compressBody(Buffer.concat(records));
+	const header = Buffer.from(JSON.stringify({
+		format: 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 (cssLength !== -1) module.css = record.toString("utf8", cssStart, cssStart + cssLength);
+	return isCompiledModule(module) ? module : null;
+}
+/**
+* Parse the container, or return `null`.
+*
+* `null` is indistinguishable from having no cache at all, which is exactly the
+* safe outcome: recompile everything. Every gate below fails that way --
+* a missing or unparsable header, a foreign `format` or `key`, a codec this Node
+* cannot read, body lengths that do not account for the file exactly (a
+* truncated or partially written container), a body that fails its own
+* decompression checksum, an index that is not the expected shape, and record
+* lengths that do not sum to the payload. An individual entry whose record does
+* not decode into a valid `CompiledModule` is dropped on its own, as in format 1;
+* because offsets come from the index alone, one bad record cannot shift the
+* others.
+*/
+function decodePrecompileManifest(bytes, options) {
+	const { key, root, onReject } = options;
+	const reject = (reason) => {
+		onReject?.(reason);
+		return null;
+	};
+	const headerEnd = bytes.indexOf(LF);
+	if (headerEnd < 0) return reject("no header");
+	let header;
+	try {
+		header = JSON.parse(bytes.toString("utf8", 0, headerEnd));
+	} catch {
+		return reject("unparsable header");
+	}
+	if (typeof header !== "object" || header === null || Array.isArray(header)) return reject("unrecognized header");
+	if (header.format !== 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 (bodies === null) return reject(`unsupported codec ${JSON.stringify(header.codec)}`);
+	const [indexText, payload] = bodies;
+	let index;
+	try {
+		index = JSON.parse(indexText.toString("utf8"));
+	} catch {
+		return reject("unparsable index");
+	}
+	if (!Array.isArray(index)) return reject("unrecognized index");
+	const entries = /* @__PURE__ */ new Map();
+	let offset = 0;
+	for (const row of index) {
+		if (!isIndexRow(row)) return reject("unrecognized index row");
+		const [relative, hash, length] = row;
+		const end = offset + length;
+		if (end > payload.length) return reject("index overruns payload");
+		const module = decodeRecord(payload.subarray(offset, end));
+		offset = end;
+		if (module !== null) entries.set(path.resolve(root, relative), {
+			hash,
+			module
+		});
+	}
+	if (offset !== payload.length) return reject("payload not fully described by the index");
+	return entries;
+}
+//#endregion
 //#region src/plugin/precompile-cache.ts
 /**
 * Persistent (on-disk) pre-compile cache.
@@ -892,10 +1287,11 @@ function computePrecompileCacheKey(compileOptions) {
 *
 * 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:
+* 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 manifest's own
+*   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>` /
@@ -913,30 +1309,6 @@ function computePrecompileCacheKey(compileOptions) {
 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];
@@ -958,8 +1330,8 @@ 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);
+	const file = path.join(root, PRECOMPILE_CACHE_DIR, `${key}${PRECOMPILE_CACHE_EXTENSION}`);
+	const entries = readManifestEntries(file, key, root, onDiagnostic);
 	let dirty = false;
 	return {
 		file,
@@ -992,51 +1364,64 @@ function openPrecompileCache(options) {
 		},
 		flush() {
 			if (!dirty) return false;
-			if (!writeManifest(file, {
-				format: 1,
-				key,
-				entries: Object.fromEntries(entries)
-			}, onDiagnostic)) 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;
 		}
 	};
 }
 /**
-* Parse the manifest, or return an empty map.
+* 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, onDiagnostic) {
-	const entries = /* @__PURE__ */ new Map();
-	let raw;
+function readManifestEntries(file, key, root, onDiagnostic) {
+	let bytes;
 	try {
-		raw = fs.readFileSync(file, "utf-8");
+		bytes = fs.readFileSync(file);
 	} catch {
-		return entries;
-	}
-	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;
+		return /* @__PURE__ */ new Map();
 	}
-	for (const [filePath, entry] of Object.entries(manifest.entries)) if (isCacheEntry(entry)) entries.set(filePath, entry);
-	return entries;
+	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, manifest, onDiagnostic) {
+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, JSON.stringify(manifest));
+		fs.writeFileSync(temp, container);
 		fs.renameSync(temp, file);
 		return true;
 	} catch (error) {
@@ -1599,10 +1984,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;
@@ -1636,8 +2021,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);
@@ -2067,19 +2452,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 {
@@ -2232,10 +2617,20 @@ async function transformHook(state, code, id, options) {
 //#region src/plugin/hmr.ts
 const VIZE_COMPONENTS_CSS_BASENAME = "vize-components.css";
 const VIZE_COMPONENTS_CSS_FILE = `assets/${VIZE_COMPONENTS_CSS_BASENAME}`;
+/**
+* The cached SFCs that pulled `dependencyFile` in through
+* `<script src>` / `<template src>` / `<style src>`.
+*
+* This runs as the first statement of every hot update, before the `.vue` fast
+* path, so editing an ordinary SFC pays for it too. It used to walk both caches
+* end to end with a `path.resolve` per dependency, which made HMR latency grow
+* with the number of components in the project; the caches now carry a reverse
+* index that answers it in constant time. See `compiled-module-cache.ts`.
+*/
 function getVueFilesDependingOn(state, dependencyFile) {
 	const normalizedDependency = path.resolve(dependencyFile);
 	const owners = /* @__PURE__ */ new Set();
-	for (const cache of [state.cache, state.ssrCache]) for (const [vueFile, compiled] of cache) if (compiled.dependencies?.some((dependency) => path.resolve(dependency) === normalizedDependency)) owners.add(vueFile);
+	for (const cache of [state.cache, state.ssrCache]) for (const vueFile of ownersOfDependency(cache, normalizedDependency)) owners.add(vueFile);
 	return [...owners];
 }
 function unique(values) {
@@ -2420,7 +2815,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);
@@ -2926,8 +3336,8 @@ function resolveCompatibilityOptions(options, compilerConfig = {}) {
 function vize(options = {}) {
 	if (isLegacyVueCompatibilityMode(options)) return [createLegacyVueCompatibilityPlugin(options)];
 	const state = {
-		cache: /* @__PURE__ */ new Map(),
-		ssrCache: /* @__PURE__ */ new Map(),
+		cache: new CompiledModuleCache(),
+		ssrCache: new CompiledModuleCache(),
 		collectedCss: /* @__PURE__ */ new Map(),
 		precompileMetadata: /* @__PURE__ */ new Map(),
 		pendingHmrUpdateTypes: /* @__PURE__ */ new Map(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.303.0",
+  "version": "0.310.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.303.0",
+    "@vizejs/native": "0.310.0",
     "oxc-parser": "0.133.0",
     "tinyglobby": "0.2.16",
-    "vize": "0.303.0"
+    "vize": "0.310.0"
   },
   "devDependencies": {
     "@types/node": "25.9.2",