@vizejs/vite-plugin 0.306.0 → 0.312.0

package/README.md

@@ -181,8 +181,9 @@ interface VizeNativeOptions {
   ssr?: boolean;
 
   /**
-   * Enable source map generation
-   * @default true in development, false in production
+   * Enable source map generation. The emitted map's `sources` names the
+   * authored `.vue` file, not the virtual `.vue.ts` module.
+   * @default true in development, false in production unless `build.sourcemap` is set
    */
   sourceMap?: boolean;
 

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as VizeVueVersion, c as ResolvedVizeConfig, i as VizeOptions, l as UserConfigExport, n as MacroArtifact, o as ConfigEnv, r as VizeCompatibilityOptions, s as LoadConfigOptions, t as CompiledModule, u as VizeConfig } from "./types-x-lq08Y8.mjs";
+import { a as VizeVueVersion, c as ResolvedVizeConfig, i as VizeOptions, l as UserConfigExport, n as MacroArtifact, o as ConfigEnv, r as VizeCompatibilityOptions, s as LoadConfigOptions, t as CompiledModule, u as VizeConfig } from "./types-Cm3dJq25.mjs";
 import { Plugin } from "vite";
 
 //#region src/virtual.d.ts

package/dist/index.mjs

@@ -4,9 +4,9 @@ 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";
@@ -230,6 +230,89 @@ function insertBeforeSfcMainDefaultExport(code, insertion, options = {}) {
 	return `${code.slice(0, exportStart)}${insertion}\n${code.slice(exportStart)}`;
 }
 //#endregion
+//#region src/utils/source-map.ts
+function isSourceMapV3(value) {
+	if (value === null || typeof value !== "object") return false;
+	const map = value;
+	return map.version === 3 && Array.isArray(map.sources) && Array.isArray(map.names) && typeof map.mappings === "string";
+}
+/**
+* Parse a compiler-produced map, or `null` when there is nothing usable.
+*
+* A malformed map is worse than no map — Vite would chain garbage into the
+* bundle's map — so anything that is not a v3 document is dropped.
+*/
+function parseSourceMap(json) {
+	if (!json) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		return null;
+	}
+	return isSourceMapV3(parsed) ? parsed : null;
+}
+function countNewlines(text) {
+	let total = 0;
+	for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) total++;
+	return total;
+}
+/**
+* Insert `count` unmapped generated lines at generated line `atLine`.
+*
+* Returns the map unchanged when the insertion lands past the last mapped line,
+* because nothing after it needs moving.
+*/
+function shiftMappedLines(map, atLine, count) {
+	if (count <= 0) return map;
+	const groups = map.mappings.split(";");
+	if (atLine >= groups.length) return map;
+	const shifted = [
+		...groups.slice(0, atLine),
+		...Array(count).fill(""),
+		...groups.slice(atLine)
+	];
+	return {
+		...map,
+		mappings: shifted.join(";")
+	};
+}
+/**
+* A module's code and the map that describes it, edited together.
+*
+* Every write goes through {@link edit}, so the map is corrected in the same
+* step that changes the code and the two cannot drift.
+*/
+var MappedModule = class {
+	code;
+	map;
+	constructor(code, map) {
+		this.code = code;
+		this.map = map;
+	}
+	/** Replace the module with `next`, realigning the map to the new line layout. */
+	edit(next) {
+		const previous = this.code;
+		this.code = next;
+		if (this.map === null || next === previous) return;
+		const limit = Math.min(previous.length, next.length);
+		let prefix = 0;
+		while (prefix < limit && previous.charCodeAt(prefix) === next.charCodeAt(prefix)) prefix++;
+		let suffix = 0;
+		while (suffix < limit - prefix && previous.charCodeAt(previous.length - 1 - suffix) === next.charCodeAt(next.length - 1 - suffix)) suffix++;
+		const removed = previous.slice(prefix, previous.length - suffix);
+		const addedLines = countNewlines(next.slice(prefix, next.length - suffix)) - countNewlines(removed);
+		if (addedLines === 0) return;
+		if (addedLines < 0) {
+			this.map = null;
+			return;
+		}
+		const editLine = countNewlines(previous.slice(0, prefix));
+		const startsAtLineStart = prefix === 0 || previous.charCodeAt(prefix - 1) === 10;
+		this.map = shiftMappedLines(this.map, startsAtLineStart ? editLine : editLine + 1, addedLines);
+	}
+};
+//#endregion
 //#region src/utils/css.ts
 function scopeCssForPipeline(css, scopeId) {
 	return scopeViteCssForPipeline(css, scopeId);
@@ -433,29 +516,40 @@ function embedsInlineCss(compiled, options) {
 	return !usesStyleImports(compiled, options) && !options.ssr && !!compiled.css && !(options.isProduction && !!options.extractCss);
 }
 function generateOutput(compiled, options) {
+	return generateOutputWithMap(compiled, options).code;
+}
+/**
+* `generateOutput` plus the source map that describes the module it returns.
+*
+* The compiler's map (`compiled.map`) describes `compiled.code`; every rewrite
+* below goes through {@link MappedModule}, which realigns the map to the lines
+* it inserts, so the returned map describes the returned code (#3399). `map` is
+* `null` when the compiler produced none.
+*/
+function generateOutputWithMap(compiled, options) {
 	const { isProduction, isDev, ssr, hmrUpdateType, extractCss, filePath } = options;
-	let output = compiled.code;
-	const moduleInfo = analyzeModuleOutput(output);
+	const emitted = new MappedModule(compiled.code, parseSourceMap(compiled.map));
+	const moduleInfo = compiled.moduleShape ?? analyzeModuleOutput(emitted.code);
 	const hasExportDefault = moduleInfo.hasDefaultExport;
 	const hasNamedRenderExport = moduleInfo.hasNamedRenderExport;
 	const hasNamedSsrRenderExport = moduleInfo.hasNamedSsrRenderExport;
 	const hasSfcMainDefined = moduleInfo.hasSfcMainDefined;
 	if (hasExportDefault && !hasSfcMainDefined) {
-		output = rewriteDefaultExportToSfcMain(output, moduleInfo);
-		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
-		output += "\nexport default _sfc_main;";
+		emitted.edit(rewriteDefaultExportToSfcMain(emitted.code, moduleInfo));
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
 	} else if (hasExportDefault && hasSfcMainDefined) {
-		if (compiled.hasScoped && compiled.scopeId) output = insertBeforeSfcMainDefaultExport(output, `_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`, { moduleInfo });
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(insertBeforeSfcMainDefaultExport(emitted.code, `_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}";`;
-		output += "\n_sfc_main.render = render;";
-		output += "\nexport default _sfc_main;";
+		emitted.edit(`${emitted.code}\nconst _sfc_main = {};`);
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\n_sfc_main.render = render;`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
 	} else if (!hasExportDefault && !hasSfcMainDefined && hasNamedSsrRenderExport) {
-		output += "\nconst _sfc_main = {};";
-		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
-		output += "\n_sfc_main.ssrRender = ssrRender;";
-		output += "\nexport default _sfc_main;";
+		emitted.edit(`${emitted.code}\nconst _sfc_main = {};`);
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\n_sfc_main.ssrRender = ssrRender;`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
 	}
 	if (usesStyleImports(compiled, options)) {
 		const styleImports = [];
@@ -479,7 +573,7 @@ function generateOutput(compiled, options) {
 			}
 		}
 		const allImports = [...styleImports, ...cssModuleImports].join("\n");
-		if (allImports) output = insertAfterStaticImports(output, allImports);
+		if (allImports) emitted.edit(insertAfterStaticImports(emitted.code, allImports));
 		if (cssModuleImports.length > 0) {
 			const moduleBindings = [];
 			for (const block of compiled.styles) if (isCssModule(block)) {
@@ -490,14 +584,17 @@ function generateOutput(compiled, options) {
 				});
 			}
 			const cssModuleSetup = moduleBindings.map((m) => `_sfc_main.__cssModules = _sfc_main.__cssModules || {};\n_sfc_main.__cssModules[${JSON.stringify(m.name)}] = ${m.bindingName};`).join("\n");
-			output = insertBeforeSfcMainDefaultExport(output, cssModuleSetup, { normalizeSemicolon: true });
+			emitted.edit(insertBeforeSfcMainDefaultExport(emitted.code, cssModuleSetup, { normalizeSemicolon: true }));
 		}
-	} else if (!ssr && compiled.css && !(isProduction && extractCss)) output = prependInlineStyleInjection(output, compiled.css, compiled.scopeId);
+	} else if (!ssr && compiled.css && !(isProduction && extractCss)) emitted.edit(prependInlineStyleInjection(emitted.code, compiled.css, compiled.scopeId));
 	if (!isProduction && isDev && hasExportDefault) {
-		const effectiveHmrUpdateType = hmrUpdateType === "template-only" && !supportsTemplateOnlyHmr(output) ? "full-reload" : hmrUpdateType ?? "full-reload";
-		output += generateHmrCode(compiled.scopeId, effectiveHmrUpdateType);
+		const effectiveHmrUpdateType = hmrUpdateType === "template-only" && !supportsTemplateOnlyHmr(emitted.code) ? "full-reload" : hmrUpdateType ?? "full-reload";
+		emitted.edit(`${emitted.code}${generateHmrCode(compiled.scopeId, effectiveHmrUpdateType)}`);
 	}
-	return output;
+	return {
+		code: emitted.code,
+		map: emitted.map
+	};
 }
 const RESOLVED_CSS_MODULE = "\0vize:all-styles.css";
 /** Create a virtual module ID from a real .vue file path */
@@ -651,7 +748,7 @@ function getEnvironmentCache(state, ssr) {
 }
 function getCompileOptionsForRequest(state, ssr) {
 	const options = {
-		sourceMap: state.mergedOptions?.sourceMap ?? !state.isProduction,
+		sourceMap: state.mergedOptions?.sourceMap ?? (!state.isProduction || !!state.viteBuildSourcemap),
 		ssr,
 		vapor: !ssr && (state.mergedOptions?.vapor ?? false),
 		customRenderer: state.mergedOptions?.customRenderer ?? false,
@@ -687,6 +784,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 {
@@ -717,6 +892,7 @@ function buildCompileBatchOptions(options) {
 		includeStyles: true,
 		includeMacroArtifacts: true,
 		includeHashes: true,
+		includeSourceMap: options.sourceMap,
 		...options.mode === void 0 ? {} : { mode: options.mode },
 		...options.templateSyntax === void 0 ? {} : { templateSyntax: options.templateSyntax },
 		...options.runtimeModuleName === void 0 ? {} : { runtimeModuleName: options.runtimeModuleName },
@@ -823,6 +999,7 @@ function compileFile(filePath, cache, options, source, diagnostics) {
 	});
 	const compiled = {
 		code: result.code,
+		...result.map ? { map: result.map } : {},
 		css: result.css,
 		scopeId,
 		hasScoped: result.hasScoped,
@@ -886,6 +1063,7 @@ function compileBatch(files, cache, options) {
 	for (const fileResult of result.results) {
 		if (fileResult.errors.length === 0) cache.set(fileResult.path, {
 			code: fileResult.code,
+			...fileResult.map ? { map: fileResult.map } : {},
 			css: fileResult.css,
 			scopeId: fileResult.scopeId,
 			hasScoped: fileResult.hasScoped,
@@ -961,7 +1139,7 @@ function resolveCompilerIdentity() {
 */
 function computePrecompileCacheKey(compileOptions) {
 	const material = stableStringify({
-		format: 2,
+		format: 3,
 		compiler: resolveCompilerIdentity(),
 		options: compileOptions
 	});
@@ -1080,7 +1258,7 @@ function encodePrecompileManifest(options) {
 	const indexBody = compressBody(Buffer.from(JSON.stringify(index), "utf8"));
 	const payloadBody = compressBody(Buffer.concat(records));
 	const header = Buffer.from(JSON.stringify({
-		format: 2,
+		format: 3,
 		key,
 		codec: hasZstd ? "zstd" : "gzip",
 		index: indexBody.length,
@@ -1156,7 +1334,7 @@ function decodePrecompileManifest(bytes, options) {
 		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 (header.format !== 3 || header.key !== key) return reject("foreign format or key");
 	if (!isByteLength(header.index) || !isByteLength(header.payload)) return reject("unrecognized body lengths");
 	const indexStart = headerEnd + 1;
 	const payloadStart = indexStart + header.index;
@@ -1372,6 +1550,7 @@ function writeManifest(file, container, onDiagnostic) {
 */
 function resolvePrecompileBatchOptions(state) {
 	return {
+		sourceMap: getCompileOptionsForRequest(state, false).sourceMap,
 		ssr: false,
 		vapor: state.mergedOptions.vapor ?? false,
 		mode: state.mergedOptions.mode,
@@ -2386,12 +2565,15 @@ function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions)
 		...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);
+	const emitted = generateOutputWithMap(compiled, outputOptions);
+	const rewritten = new MappedModule(isSsr ? normalizeVueServerRendererImport(emitted.code) : emitted.code, emitted.map);
+	rewritten.edit(rewriteDynamicTemplateImports(rewritten.code, state.dynamicImportAliasRules));
+	rewritten.edit(rewriteStaticAssetUrls(rewritten.code, state.dynamicImportAliasRules));
+	rewritten.edit(rewriteImportMetaGlobBase(rewritten.code, realPath, state.root));
 	if (!loadOptions?.ssr) state.pendingHmrUpdateTypes.delete(realPath);
 	return {
-		code: normalizedOutput,
-		map: null
+		code: rewritten.code,
+		map: rewritten.map
 	};
 }
 function loadDefinePageArtifact(state, realPath, ssr) {
@@ -2539,10 +2721,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) {
@@ -3248,13 +3440,14 @@ 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(),
 		viteResolveCache: /* @__PURE__ */ new Map(),
 		isProduction: false,
+		viteBuildSourcemap: false,
 		root: "",
 		clientViteBase: "/",
 		serverViteBase: "/",
@@ -3293,6 +3486,7 @@ function vize(options = {}) {
 			async configResolved(resolvedConfig) {
 				state.root = options.root ?? resolvedConfig.root;
 				state.isProduction = options.isProduction ?? resolvedConfig.isProduction;
+				state.viteBuildSourcemap = !!resolvedConfig.build?.sourcemap;
 				const isSsrBuild = !!resolvedConfig.build?.ssr;
 				const currentBase = resolvedConfig.command === "serve" ? options.devUrlBase ?? resolvedConfig.base ?? "/" : resolvedConfig.base ?? "/";
 				if (isSsrBuild) state.serverViteBase = currentBase;

package/dist/internal/config-bridge.d.mts

@@ -1,4 +1,4 @@
-import { c as ResolvedVizeConfig } from "../types-x-lq08Y8.mjs";
+import { c as ResolvedVizeConfig } from "../types-Cm3dJq25.mjs";
 import { ResolvedConfig } from "vite";
 
 //#region src/internal/config-bridge.d.ts

package/dist/{types-x-lq08Y8.d.mts → types-Cm3dJq25.d.mts}

@@ -660,6 +660,28 @@ interface ExperimentalPluginOptions extends ExperimentalCompileFlags {
   experimentals?: ExperimentalOptions;
 }
 //#endregion
+//#region src/utils/module-output.d.ts
+type ModuleOutputInfo = {
+  hasDefaultExport: boolean;
+  hasSfcMainDefined: boolean;
+  hasNamedRenderExport: boolean;
+  hasNamedSsrRenderExport: boolean;
+  defaultExportKeywordEnd: number | null;
+  defaultExportStart: number | null;
+  /**
+   * End offset of the whole `export default ...` statement, or `null`.
+   *
+   * Recorded so {@link insertBeforeSfcMainDefaultExport} can reuse the caller's
+   * analysis instead of parsing the module a second time (#3425).
+   */
+  defaultExportEnd: number | null;
+  /**
+   * Whether the default export's declaration is exactly the `_sfc_main`
+   * identifier -- the only shape {@link insertBeforeSfcMainDefaultExport} acts on.
+   */
+  defaultExportIsSfcMain: boolean;
+};
+//#endregion
 //#region src/types.d.ts
 interface MacroArtifact {
   kind: string;
@@ -755,7 +777,10 @@ interface VizeOptions extends ExperimentalPluginOptions {
    */
   isProduction?: boolean;
   ssr?: boolean;
-  /** Enable source map generation */
+  /**
+   * Enable source map generation.
+   * @default development on; production off unless Vite's `build.sourcemap` is set
+   */
   sourceMap?: boolean;
   /**
    * Enable Vapor mode compilation
@@ -845,6 +870,13 @@ interface StyleBlockInfo {
 }
 interface CompiledModule {
   code: string;
+  /**
+   * Source Map v3 document (JSON) describing `code`, when the compiler was
+   * asked for one (#3399). Absent when source maps are off, when the SFC has no
+   * script block, and for the rspack and unplugin builders, which do not request
+   * maps. Persisted with the rest of the module in the pre-compile cache.
+   */
+  map?: string;
   css?: string;
   scopeId: string;
   hasScoped: boolean;
@@ -857,6 +889,13 @@ interface CompiledModule {
   styles?: StyleBlockInfo[];
   /** Files loaded through SFC `src` imports */
   dependencies?: string[];
+  /**
+   * Module shape reported by the native compiler, so `generateOutput` need not
+   * re-parse the emitted module (#3425). Absent for a cache entry written before
+   * the field existed, and for the rspack and unplugin builders, which never set
+   * it — both fall back to parsing.
+   */
+  moduleShape?: ModuleOutputInfo;
 }
 //#endregion
 export { VizeVueVersion as a, ResolvedVizeConfig as c, VizeOptions as i, UserConfigExport as l, MacroArtifact as n, ConfigEnv as o, VizeCompatibilityOptions as r, LoadConfigOptions as s, CompiledModule as t, VizeConfig as u };

package/package.json

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