@vizejs/vite-plugin 0.310.0 → 0.314.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 VizeInspectorOptions, d as ResolvedVizeConfig, f as UserConfigExport, i as VizeOptions, l as ConfigEnv, n as MacroArtifact, o as VizeInspectorLintPlanProvider, p as VizeConfig, r as VizeCompatibilityOptions, s as VizeInspectorLintPlanRequest, t as CompiledModule, u as LoadConfigOptions } from "./types-BU_B_kFs.mjs";
 import { Plugin } from "vite";
 
 //#region src/virtual.d.ts
@@ -40,4 +40,4 @@ declare const __internal: {
   rewriteStaticAssetUrls: typeof rewriteStaticAssetUrls;
 };
 //#endregion
-export { type CompiledModule, type LoadConfigOptions, type MacroArtifact, type ResolvedVizeConfig, type UserConfigExport, VIZE_CONFIG_FILE_ENV, type VizeCompatibilityOptions, type VizeConfig, type VizeOptions, type VizeVueVersion, __internal, rewriteStaticAssetUrls as __internal_rewriteStaticAssetUrls, vize as default, vize, defineConfig, loadConfig, resolveConfigExport, vizeConfigStore };
+export { type CompiledModule, type LoadConfigOptions, type MacroArtifact, type ResolvedVizeConfig, type UserConfigExport, VIZE_CONFIG_FILE_ENV, type VizeCompatibilityOptions, type VizeConfig, type VizeInspectorLintPlanProvider, type VizeInspectorLintPlanRequest, type VizeInspectorOptions, type VizeOptions, type VizeVueVersion, __internal, rewriteStaticAssetUrls as __internal_rewriteStaticAssetUrls, vize as default, vize, defineConfig, loadConfig, resolveConfigExport, vizeConfigStore };

package/dist/index.mjs

@@ -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,
@@ -795,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 },
@@ -901,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,
@@ -964,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,
@@ -1039,7 +1139,7 @@ function resolveCompilerIdentity() {
 */
 function computePrecompileCacheKey(compileOptions) {
 	const material = stableStringify({
-		format: 2,
+		format: 3,
 		compiler: resolveCompilerIdentity(),
 		options: compileOptions
 	});
@@ -1158,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,
@@ -1234,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;
@@ -1450,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,
@@ -2464,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) {
@@ -2992,6 +3096,114 @@ function normalizeCssModuleFilename(filename) {
 	return normalized;
 }
 //#endregion
+//#region src/plugin/inspector-lint-plan.ts
+const VIZE_INSPECTOR_LINT_PLAN_ENDPOINT = "/__vize/inspector/lint-plan";
+const MAX_REQUEST_URL_BYTES = 8 * 1024;
+const MAX_FILE_COUNT = 128;
+const MAX_FILE_BYTES = 4 * 1024;
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+const ALLOWED_QUERY_KEYS = new Set(["file", "fresh"]);
+function installInspectorLintPlanMiddleware(devServer, state) {
+	const provider = state.mergedOptions.inspector?.lintPlan;
+	if (!provider) return;
+	devServer.middlewares.use((req, res, next) => {
+		if (!isInspectorLintPlanRequest(req.url, state.clientViteBase)) {
+			next();
+			return;
+		}
+		handleInspectorLintPlanRequest(req, res, provider, state.logger, state.clientViteBase);
+	});
+}
+function isInspectorLintPlanRequest(reqUrl, base = "/") {
+	if (!reqUrl) return false;
+	try {
+		return new URL(reqUrl, "http://localhost").pathname === resolveInspectorEndpoint(base);
+	} catch {
+		return false;
+	}
+}
+function parseInspectorLintPlanRequest(reqUrl, base = "/") {
+	if (!reqUrl || !isInspectorLintPlanRequest(reqUrl, base)) return null;
+	if (Buffer.byteLength(reqUrl) > MAX_REQUEST_URL_BYTES) return {
+		statusCode: 414,
+		error: "request_uri_too_long"
+	};
+	const url = new URL(reqUrl, "http://localhost");
+	for (const key of url.searchParams.keys()) if (!ALLOWED_QUERY_KEYS.has(key)) return {
+		statusCode: 400,
+		error: "invalid_query"
+	};
+	const freshValues = url.searchParams.getAll("fresh");
+	if (freshValues.length > 1 || freshValues[0] !== void 0 && freshValues[0] !== "1") return {
+		statusCode: 400,
+		error: "invalid_fresh"
+	};
+	const rawFiles = url.searchParams.getAll("file");
+	if (rawFiles.length > MAX_FILE_COUNT) return {
+		statusCode: 413,
+		error: "too_many_files"
+	};
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const file of rawFiles) {
+		if (!isSafeInspectorFile(file)) return {
+			statusCode: 400,
+			error: "invalid_file"
+		};
+		if (!seen.has(file)) {
+			seen.add(file);
+			files.push(file);
+		}
+	}
+	return { request: {
+		files,
+		fresh: freshValues[0] === "1"
+	} };
+}
+async function handleInspectorLintPlanRequest(req, res, provider, logger, base = "/") {
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		res.setHeader("allow", "GET, HEAD");
+		sendJson$1(res, 405, { error: "method_not_allowed" });
+		return;
+	}
+	const parsed = parseInspectorLintPlanRequest(req.url, base);
+	if (!parsed) {
+		sendJson$1(res, 404, { error: "not_found" });
+		return;
+	}
+	if ("error" in parsed) {
+		sendJson$1(res, parsed.statusCode, { error: parsed.error }, req.method === "HEAD");
+		return;
+	}
+	try {
+		sendJson$1(res, 200, await provider(parsed.request), req.method === "HEAD");
+	} catch (error) {
+		logger.error("Failed to build inspector lint plan:", error);
+		sendJson$1(res, 500, { error: "inspector_lint_plan_failed" }, req.method === "HEAD");
+	}
+}
+function resolveInspectorEndpoint(base) {
+	return `${new URL(base, "http://localhost").pathname.replace(/\/+$/, "")}${VIZE_INSPECTOR_LINT_PLAN_ENDPOINT}`;
+}
+function isSafeInspectorFile(file) {
+	if (file.length === 0 || Buffer.byteLength(file) > MAX_FILE_BYTES || file.includes("\0") || file.includes("\\") || path.posix.isAbsolute(file)) return false;
+	return !file.split("/").some((segment) => segment === ".." || segment.length === 0);
+}
+function sendJson$1(res, statusCode, payload, headOnly = false) {
+	let body = JSON.stringify(payload);
+	if (body === void 0) throw new TypeError("Inspector payload is not JSON serializable");
+	if (Buffer.byteLength(body) > MAX_RESPONSE_BYTES) {
+		statusCode = 413;
+		body = JSON.stringify({ error: "inspector_response_too_large" });
+	}
+	res.statusCode = statusCode;
+	res.setHeader("cache-control", "no-store");
+	res.setHeader("content-type", "application/json; charset=utf-8");
+	res.setHeader("content-length", Buffer.byteLength(body));
+	res.setHeader("x-content-type-options", "nosniff");
+	res.end(headOnly ? void 0 : body);
+}
+//#endregion
 //#region src/plugin/dev-middleware.ts
 const VIZE_INSPECTOR_GRAPH_ENDPOINT = "/__vize/inspector/graph";
 const INSPECTOR_SCRIPT_PATTERNS = ["**/*.{js,jsx,ts,tsx}"];
@@ -3000,6 +3212,7 @@ const INSPECTOR_FILE_EXTENSION_RE = /\.(?:vue|[jt]sx?)$/;
 function installDevMiddleware(devServer, state) {
 	installVirtualAssetMiddleware(devServer, state);
 	installInspectorGraphMiddleware(devServer, state);
+	installInspectorLintPlanMiddleware(devServer, state);
 }
 function installVirtualAssetMiddleware(devServer, state) {
 	devServer.middlewares.use((req, _res, next) => {
@@ -3343,6 +3556,7 @@ function vize(options = {}) {
 		pendingHmrUpdateTypes: /* @__PURE__ */ new Map(),
 		viteResolveCache: /* @__PURE__ */ new Map(),
 		isProduction: false,
+		viteBuildSourcemap: false,
 		root: "",
 		clientViteBase: "/",
 		serverViteBase: "/",
@@ -3381,6 +3595,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 { d as ResolvedVizeConfig } from "../types-BU_B_kFs.mjs";
 import { ResolvedConfig } from "vite";
 
 //#region src/internal/config-bridge.d.ts

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

@@ -660,6 +660,41 @@ interface ExperimentalPluginOptions extends ExperimentalCompileFlags {
   experimentals?: ExperimentalOptions;
 }
 //#endregion
+//#region src/inspector-types.d.ts
+interface VizeInspectorLintPlanRequest {
+  /** Project-relative files whose effective lint rules should be explained. */
+  files: string[];
+  /** Ask the integration to rebuild its plan before resolving the files. */
+  fresh: boolean;
+}
+type VizeInspectorLintPlanProvider = (request: VizeInspectorLintPlanRequest) => unknown;
+interface VizeInspectorOptions {
+  /** Optional development-only lint-plan payload provider. */
+  lintPlan?: VizeInspectorLintPlanProvider;
+}
+//#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;
@@ -704,6 +739,8 @@ interface VizeOptions extends ExperimentalPluginOptions {
    * Direct plugin options still take precedence over these values.
    */
   config?: UserConfigExport;
+  /** Development inspector integrations exposed through Vite's dev server. */
+  inspector?: VizeInspectorOptions;
   /**
    * Vue major version for the host project.
    *
@@ -755,7 +792,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 +885,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 +904,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 };
+export { VizeVueVersion as a, VizeInspectorOptions as c, ResolvedVizeConfig as d, UserConfigExport as f, VizeOptions as i, ConfigEnv as l, MacroArtifact as n, VizeInspectorLintPlanProvider as o, VizeConfig as p, VizeCompatibilityOptions as r, VizeInspectorLintPlanRequest as s, CompiledModule as t, LoadConfigOptions as u };

package/package.json

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