@vizejs/babel-plugin 0.0.0-stage → 0.706.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ubugeeei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,135 @@
-# Temporary Holding Version
+# @vizejs/babel-plugin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Compile Vue single-file components, JSX, and TSX with the shared Vize compiler inside Babel.
+
+```sh
+pnpm add -D @babel/core @vizejs/babel-plugin
+```
+
+The native Vize compiler is a normal package dependency. Babel is the host peer;
+the application supplies its Vue runtime. The current Vapor preview targets
+Vue 3.6.0-rc.11 and its build containing the Vapor runtime APIs. Select that
+build through the application's normal module resolution configuration and
+use `createVaporApp` or `createVaporSSRApp` for the client entry.
+
+The runtime conformance matrix uses Vue 3.5.44 for VDOM. Historical 3.6.0-rc.9
+fixtures remain an unsupported ABI frontier with their failed and reference
+packets retained separately.
+
+```js
+// babel.config.mjs
+export default {
+  plugins: [["@vizejs/babel-plugin", { jsxMode: "vdom" }]],
+  sourceMaps: true,
+};
+```
+
+Use `@babel/preset-typescript` for type stripping and the usual Babel plugins for
+decorators, language targets, or CommonJS output. The plugin enables JSX parsing
+and TSX parsing for `.tsx` filenames. It leaves plain `.ts` parsing to the host.
+
+The same plugin compiles `.vue` files through Babel's parser override. The native
+compiler returns JavaScript before the normal Babel visitor pipeline runs, so module,
+target, and instrumentation plugins continue to work on SFC output. Plain and scoped
+CSS is injected once at runtime by default; server transforms keep the CSS in metadata
+without touching `document`.
+
+## Options
+
+| Option         | Default    | Behavior                                                                                                       |
+| -------------- | ---------- | -------------------------------------------------------------------------------------------------------------- |
+| `jsxMode`      | `"vdom"`   | Default client renderer: `"vdom"` or `"vapor"`. Component mode directives retain their native meaning.         |
+| `ssr`          | `false`    | Generate SSR output for the selected client renderer.                                                          |
+| `jsxCompat`    | `"native"` | Select native or `"babel"` compatibility semantics. Incompatible combinations surface the compiler diagnostic. |
+| `scopedStyles` | `"error"`  | `"metadata"` lets a bundler consume extracted CSS explicitly.                                                  |
+| `sfcStyles`    | `"inject"` | Handle SFC CSS with runtime `"inject"`, metadata-only `"metadata"`, or `"error"`.                              |
+| `root`         | cwd        | Project root used to make SFC scope IDs stable across machines.                                                |
+| `isProduction` | `NODE_ENV` | Enable production SFC output and content-sensitive production scope IDs.                                       |
+
+Keep client and server builds on the same renderer setting. Unsupported native
+source shapes surface as compilation errors.
+
+## Component authoring
+
+Vapor and setup SSR output use component objects. A block arrow keeps setup
+state inside the component; declare props with a named identifier and an inline
+object type:
+
+```tsx
+import { ref } from "vue";
+
+export const Counter = (props: { label: string }) => {
+  const count = ref(0);
+  const increment = () => {
+    count.value++;
+  };
+  return <button onClick={increment}>{props.label + ":" + count.value}</button>;
+};
+```
+
+The preview rejects destructured props in these component objects. Use their
+bindings as JSX component tags or direct exports; calls, callable aliases,
+introspection, and escaping component values require a separate callable
+representation and produce a diagnostic. Nested JSX that an attribute expression
+cannot lower also produces a diagnostic.
+
+VDOM client output supports expression arrows. SSR output for an expression
+functional component is an explicit unsupported role; use a block setup component
+for the paired client/server build.
+
+## Babel composition
+
+The compiler runs in a `pre` hook. It serializes the current AST, including edits
+from earlier `pre` hooks, and compiles that file once. Babel's normal visitors then
+process the generated module. Program edits and the host's TypeScript, decorator,
+and module transformations keep their place in that pipeline.
+
+Files without JSX return before loading the native addon. JSX-producing visitor
+transforms belong in an earlier Babel pass; introducing new JSX after native
+compilation produces an explicit error.
+The final generation boundary also checks for JSX introduced by later `post`
+hooks. That guard returns control to Babel without claiming code generation;
+other generator overrides keep Babel's normal collision rules.
+
+`.vue` files are selected by filename before parsing, so the native compiler is loaded
+for those inputs even though their authored syntax is not JavaScript. External SFC
+blocks, custom blocks, style preprocessors, and CSS `@import` require a bundler adapter
+and fail explicitly in standalone Babel.
+
+Use Babel `overrides`, `only`, and `ignore` to select Vue files in mixed projects.
+An explicit foreign JSX runtime or factory is a configuration error.
+
+## Source maps
+
+Enable Babel `sourceMaps` normally. For JSX, the plugin composes the native map with
+Babel's current-AST map and any upstream input map, then lets Babel's normal
+generator produce the final map. It does not replace the parser or generator.
+A missing requested native map produces an error.
+
+For SFCs, the parser override installs the compiler's structured `.vue` map as Babel's
+input map before ordinary visitors run. Runtime style bootstrap lines are unmapped and
+the authored script/template mappings retain their original `.vue` source.
+
+When calling `transformFromAstSync`, pass the original source to retain its
+source content in the map.
+
+## Extracted styles
+
+Babel does not emit stylesheets. By default, extracted scoped JSX CSS produces
+an error. A bundler can opt in and emit the returned styles:
+
+```js
+import * as babel from "@babel/core";
+import vize from "@vizejs/babel-plugin";
+
+const result = babel.transformSync(source, {
+  filename: "Card.tsx",
+  plugins: [[vize, { scopedStyles: "metadata" }]],
+});
+
+const styles = result.metadata.vize.jsx.scopedStyles;
+// Each entry contains scopeId and already-scoped CSS.
+```
+
+The same metadata contains the configured default mode, SSR flag, native pass
+count, and compiler warnings. Compiler warnings are also emitted as Node warnings.

package/dist/index.cjs

@@ -0,0 +1,405 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_module = require("node:module");
+let convert_source_map = require("convert-source-map");
+convert_source_map = __toESM(convert_source_map, 1);
+let _jridgewell_remapping = require("@jridgewell/remapping");
+_jridgewell_remapping = __toESM(_jridgewell_remapping, 1);
+//#region src/ast.ts
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function hasJsx(ast, keys) {
+	const pending = [ast];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
+		for (const key of keys[node.type] ?? []) {
+			const child = node[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isNode(item)) pending.push(item);
+			} else if (isNode(child)) pending.push(child);
+		}
+	}
+	return false;
+}
+function enableSyntax(filename, parser) {
+	const plugins = parser.plugins ??= [];
+	const has = (name) => plugins.some((p) => (Array.isArray(p) ? p[0] : p) === name);
+	if (/\.tsx$/iu.test(filename) && !has("typescript")) plugins.push("typescript");
+	if (!/\.(?:ts|mts|cts)$/iu.test(filename) && !has("jsx")) plugins.push("jsx");
+}
+/** Explicit foreign runtime selection is a configuration error, never Vue output. */
+function rejectForeignRuntime(ast, plugins, scope) {
+	if (Array.isArray(plugins)) for (const plugin of plugins) {
+		if (typeof plugin !== "object" || plugin === null || !("key" in plugin)) continue;
+		if (typeof plugin.key === "string" && /^(?:@babel\/plugin-)?transform-react-jsx(?:-development|\/development)?$/u.test(plugin.key)) rejectReact();
+	}
+	const body = ast.program.body;
+	if (Array.isArray(body)) for (const node of body) {
+		if (isNode(node) && node.type === "TSImportEqualsDeclaration" && node.importKind !== "type") {
+			const owner = node.moduleReference;
+			if (isNode(owner) && isNode(owner.expression) && foreignName(owner.expression.value)) rejectReact();
+		}
+		if (isNode(node) && node.type === "VariableDeclaration" && !scope.getBinding("require")) {
+			const declarations = node.declarations;
+			if (Array.isArray(declarations)) for (const declaration of declarations) {
+				if (!isNode(declaration) || !isNode(declaration.init)) continue;
+				const call = declaration.init;
+				if (call.type === "CallExpression" && isNode(call.callee) && call.callee.type === "Identifier" && call.callee.name === "require" && Array.isArray(call.arguments) && call.arguments.length === 1 && isNode(call.arguments[0]) && foreignName(call.arguments[0].value)) rejectReact();
+			}
+		}
+		if (!isNode(node) || node.type !== "ImportDeclaration" || node.importKind === "type") continue;
+		const specifiers = node.specifiers;
+		if (Array.isArray(specifiers) && specifiers.length > 0 && specifiers.every((specifier) => isNode(specifier) && specifier.importKind === "type")) continue;
+		const source = node.source;
+		if (isNode(source) && typeof source.value === "string" && foreignName(source.value)) rejectReact();
+	}
+	const comments = ast.comments;
+	if (Array.isArray(comments)) for (const comment of comments) {
+		if (!isNode(comment) || typeof comment.value !== "string") continue;
+		const source = /@jsxImportSource\s+(\S+)/u.exec(comment.value)?.[1];
+		if (source && source !== "vue") throw new Error(`Vize cannot compile the explicitly selected JSX import source: ${source}`);
+		if (/@jsx\s+(\S+)/u.exec(comment.value)?.[1]) throw new Error("Custom JSX factory pragmas are not supported by the native Babel adapter");
+	}
+}
+function foreignName(value) {
+	return typeof value === "string" && /^react(?:\/|$)/u.test(value);
+}
+function rejectReact() {
+	throw new Error("Vize compiles Vue JSX; scope this plugin to Vue files using Babel overrides");
+}
+//#endregion
+//#region src/native.ts
+let compiler;
+/** Keep addon initialization outside the common no-JSX/non-SFC path. */
+function getCompiler() {
+	if (compiler) return compiler;
+	const binding = (0, node_module.createRequire)(typeof __filename === "string" ? __filename : require("url").pathToFileURL(__filename).href)("@vizejs/native");
+	if (typeof binding !== "object" || binding === null || !("compileJsx" in binding) || typeof binding.compileJsx !== "function" || !("compileSfc" in binding) || typeof binding.compileSfc !== "function" || !("generateSfcScopeId" in binding) || typeof binding.generateSfcScopeId !== "function") throw new Error("The installed Vize native binding does not expose the Babel compiler surface; use matching Vize package versions");
+	compiler = binding;
+	return compiler;
+}
+//#endregion
+//#region src/options.ts
+function normalizeOptions(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("Vize Babel options must be an object");
+	for (const key of Object.keys(value)) if (![
+		"jsxMode",
+		"jsxCompat",
+		"ssr",
+		"scopedStyles",
+		"sfcStyles",
+		"root",
+		"isProduction"
+	].includes(key)) throw new TypeError(`Unknown Vize Babel option: ${key}`);
+	const { jsxMode = "vdom", jsxCompat = "native", ssr = false, scopedStyles = "error", sfcStyles = "inject", root = process.cwd(), isProduction = process.env.NODE_ENV === "production" } = value;
+	if (jsxMode !== "vdom" && jsxMode !== "vapor") throw new TypeError("jsxMode must be \"vdom\" or \"vapor\"");
+	if (jsxCompat !== "native" && jsxCompat !== "babel") throw new TypeError("jsxCompat must be \"native\" or \"babel\"");
+	if (typeof ssr !== "boolean") throw new TypeError("ssr must be a boolean");
+	if (scopedStyles !== "error" && scopedStyles !== "metadata") throw new TypeError("scopedStyles must be \"error\" or \"metadata\"");
+	if (sfcStyles !== "inject" && sfcStyles !== "metadata" && sfcStyles !== "error") throw new TypeError("sfcStyles must be \"inject\", \"metadata\", or \"error\"");
+	if (typeof root !== "string" || root.length === 0) throw new TypeError("root must be a non-empty string");
+	if (typeof isProduction !== "boolean") throw new TypeError("isProduction must be a boolean");
+	return {
+		jsxMode,
+		jsxCompat,
+		ssr,
+		scopedStyles,
+		sfcStyles,
+		root,
+		isProduction
+	};
+}
+//#endregion
+//#region src/scopes.ts
+/** Earlier pre hooks can reserve identifiers before adding their declarations. */
+function captureReservations(file) {
+	const names = file.scope.uidsSet ? [...file.scope.uidsSet] : Object.keys(file.scope.uids).filter((name) => file.scope.uids[name]);
+	if (names.length === 0) return void 0;
+	const authoredBindings = new Set(Object.keys(file.scope.bindings));
+	const seen = new Set([file.scope]);
+	file.path.traverse({ Scopable({ scope }) {
+		if (seen.has(scope)) return;
+		seen.add(scope);
+		for (const name of Object.keys(scope.bindings)) authoredBindings.add(name);
+	} });
+	return {
+		names,
+		authoredBindings
+	};
+}
+function restoreReservations(file, reserved) {
+	if (!reserved) return;
+	const names = new Set(reserved.names);
+	for (const name of names) if (file.scope.uidsSet) file.scope.uidsSet.add(name);
+	else file.scope.uids[name] = true;
+	const seen = /* @__PURE__ */ new Set();
+	const restore = (scope) => {
+		if (seen.has(scope)) return;
+		seen.add(scope);
+		for (const name of Object.keys(scope.bindings)) if (names.has(name) && !reserved.authoredBindings.has(name)) scope.rename(name, scope.generateUid(name));
+	};
+	restore(file.scope);
+	file.path.traverse({ Scopable: ({ scope }) => restore(scope) });
+}
+//#endregion
+//#region src/source-map.ts
+function composeInputMap(nativeMap, printedMap) {
+	if (!nativeMap || !printedMap) throw new Error("The native JSX compiler did not provide the requested original-source map");
+	const parsed = JSON.parse(nativeMap);
+	if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || parsed.version !== 3 || !("mappings" in parsed) || typeof parsed.mappings !== "string" || !("sources" in parsed) || !Array.isArray(parsed.sources)) throw new Error("The native JSX compiler returned an invalid source map");
+	const composed = (0, _jridgewell_remapping.default)([parsed, printedMap], () => null);
+	return convert_source_map.default.fromObject(composed);
+}
+//#endregion
+//#region src/sfc.ts
+function isVueSfc(filename) {
+	return /\.vue$/iu.test(filename);
+}
+function compileSfcForBabel(source, filename, parserOptions, parse, options) {
+	const native = getCompiler();
+	const scopeId = native.generateSfcScopeId(filename, options.root, options.isProduction, source);
+	const result = native.compileSfc(source, {
+		filename,
+		mode: "module",
+		sourceMap: true,
+		ssr: options.ssr,
+		vapor: options.jsxMode === "vapor",
+		scopeId: `data-v-${scopeId}`,
+		isProd: options.isProduction,
+		inlineTemplate: options.isProduction && !options.ssr
+	});
+	assertSupported(result, filename, options.sfcStyles);
+	const completed = completeModule(result, scopeId, options.sfcStyles);
+	return {
+		ast: parse(completed.code, {
+			...parserOptions,
+			filename,
+			sourceType: "module"
+		}),
+		code: completed.code,
+		map: completed.map,
+		metadata: {
+			defaultMode: options.jsxMode,
+			ssr: options.ssr,
+			nativePasses: 1,
+			warnings: result.warnings,
+			css: result.css ?? null,
+			styles: result.styles,
+			dependencies: result.dependencies ?? []
+		}
+	};
+}
+function installSfcFileState(file, compiled) {
+	file.code = compiled.code;
+	if (file.opts.sourceMaps) {
+		if (!compiled.map) throw new Error("The native SFC compiler did not provide the requested original-source map");
+		const parsed = JSON.parse(compiled.map);
+		if (!isSourceMap(parsed)) throw new Error("The native SFC compiler returned an invalid source map");
+		const upstream = file.inputMap?.toObject();
+		file.inputMap = upstream ? composeInputMap(compiled.map, upstream) : convert_source_map.default.fromObject(parsed);
+	}
+	const old = file.metadata.vize;
+	file.metadata.vize = {
+		...typeof old === "object" && old !== null ? old : {},
+		sfc: compiled.metadata
+	};
+	for (const warning of compiled.metadata.warnings) process.emitWarning(`[vize] ${warning}`, { type: "VizeSfcWarning" });
+}
+function assertSupported(result, filename, styleMode) {
+	if (result.errors.length > 0) throw new Error(result.errors.join("\n"));
+	if (result.customBlocks.length > 0 || result.macroArtifacts.length > 0) throw new Error(`${filename}: custom blocks and emitted macro artifacts need a bundler adapter and are not supported by standalone Babel`);
+	for (const style of result.styles) {
+		if (style.src) throw new Error(`${filename}: <style src> needs a bundler CSS pipeline and is not supported by standalone Babel`);
+		if (style.lang && style.lang !== "css") throw new Error(`${filename}: <style lang="${style.lang}"> needs a bundler CSS pipeline and is not supported by standalone Babel`);
+		if (style.content.includes("@import")) throw new Error(`${filename}: CSS @import needs a bundler CSS pipeline and is not supported by standalone Babel`);
+	}
+	if (result.css && styleMode === "error") throw new Error(`${filename}: SFC styles require sfcStyles: "inject" or "metadata" in standalone Babel`);
+}
+function completeModule(result, scopeId, styleMode) {
+	let code = result.code;
+	if (result.hasScoped) code = attachScope(code, scopeId);
+	const prefix = result.css && styleMode === "inject" ? styleInjection(result.css, scopeId) : "";
+	return {
+		code: prefix + code,
+		map: shiftMap(result.map, prefix)
+	};
+}
+function attachScope(code, scopeId) {
+	if (/^export default _sfc_main/mu.test(code)) return code.replace(/^export default _sfc_main/mu, `_sfc_main.__scopeId = "data-v-${scopeId}";\nexport default _sfc_main`);
+	if (/^export default /mu.test(code)) return `${code.replace(/^export default /mu, "const _sfc_main = ")}\n_sfc_main.__scopeId = "data-v-${scopeId}";\nexport default _sfc_main;\n`;
+	if (/^export function render\b/mu.test(code)) return `${code}\nconst _sfc_main = { render };\n_sfc_main.__scopeId = "data-v-${scopeId}";\nexport default _sfc_main;\n`;
+	return code;
+}
+function styleInjection(css, scopeId) {
+	return `export const __vize_css__ = ${JSON.stringify(css)};
+const __vize_css_id__ = ${JSON.stringify(`vize-style-${scopeId}`)};
+(function() {
+  if (typeof document !== "undefined") {
+    let style = document.getElementById(__vize_css_id__);
+    if (!style) {
+      style = document.createElement("style");
+      style.id = __vize_css_id__;
+      document.head.appendChild(style);
+    }
+    style.textContent = __vize_css__;
+  }
+})();
+`;
+}
+function shiftMap(mapJson, prefix) {
+	if (!mapJson) return null;
+	if (!prefix) return mapJson;
+	const parsed = JSON.parse(mapJson);
+	if (!isSourceMap(parsed)) return null;
+	const lines = prefix.split("\n").length - 1;
+	return JSON.stringify({
+		...parsed,
+		mappings: ";".repeat(lines) + parsed.mappings
+	});
+}
+function isSourceMap(value) {
+	return typeof value === "object" && value !== null && "version" in value && value.version === 3 && "sources" in value && Array.isArray(value.sources) && "names" in value && Array.isArray(value.names) && "mappings" in value && typeof value.mappings === "string";
+}
+//#endregion
+//#region src/index.ts
+const compiled = Symbol.for("@vizejs/babel-plugin/compiled");
+/** Babel owns the returned hooks; consumers configure the strongly typed options. */
+function vizeBabelPlugin(apiValue, rawOptions = {}) {
+	const api = apiValue;
+	api.assertVersion("^7.29.7 || ^8.0.9");
+	const options = normalizeOptions(rawOptions);
+	const sfcOutputs = /* @__PURE__ */ new WeakMap();
+	const assertComplete = (ast) => {
+		if (hasJsx(ast, api.types.VISITOR_KEYS)) throw new Error("JSX was introduced after the native phase; run JSX-producing transforms in an earlier Babel pass");
+	};
+	return {
+		name: "vize-vue-jsx",
+		manipulateOptions(host, parser) {
+			enableSyntax(host.filename ?? "", parser);
+		},
+		parserOverride(source, parserOptions, parse) {
+			const filename = String(parserOptions.filename ?? parserOptions.sourceFilename ?? parserOptions.sourceFileName ?? "");
+			if (!filename || !isVueSfc(filename)) return void 0;
+			const compiledSfc = compileSfcForBabel(source, filename, parserOptions, parse, options);
+			sfcOutputs.set(compiledSfc.ast, compiledSfc);
+			return compiledSfc.ast;
+		},
+		pre(file) {
+			const compiledSfc = sfcOutputs.get(file.ast);
+			if (compiledSfc) {
+				file.set(compiled, true);
+				installSfcFileState(file, compiledSfc);
+				return;
+			}
+			if (!hasJsx(file.ast, api.types.VISITOR_KEYS)) return;
+			if (file.get(compiled)) throw new Error("JSX was introduced after this file's native compilation pass");
+			rejectForeignRuntime(file.ast, file.opts.plugins, file.scope);
+			const reservations = captureReservations(file);
+			const maps = Boolean(file.opts.sourceMaps);
+			const hostGenerator = file.opts.generatorOpts;
+			const printed = api.transformFromAstSync(file.ast, file.code, {
+				filename: file.opts.filename,
+				sourceFileName: file.opts.sourceFileName,
+				sourceRoot: file.opts.sourceRoot,
+				babelrc: false,
+				configFile: false,
+				plugins: [],
+				presets: [],
+				ast: false,
+				sourceMaps: maps,
+				inputSourceMap: maps ? file.inputMap?.toObject() ?? false : false,
+				comments: file.opts.comments,
+				generatorOpts: {
+					...typeof hostGenerator === "object" && hostGenerator !== null ? hostGenerator : {},
+					sourceMaps: maps
+				}
+			});
+			if (!printed || typeof printed.code !== "string") throw new Error("Babel could not serialize the current JSX AST");
+			const parserPlugins = file.opts.parserOpts?.plugins ?? [];
+			const typescript = /\.(?:tsx|ts|mts|cts)$/iu.test(file.opts.filename ?? "") || parserPlugins.some((p) => (Array.isArray(p) ? p[0] : p) === "typescript");
+			const output = getCompiler().compileJsx(printed.code, {
+				filename: file.opts.filename,
+				lang: typescript ? "tsx" : "jsx",
+				jsxMode: options.jsxMode,
+				jsxCompat: options.jsxCompat,
+				ssr: options.ssr,
+				sourceMap: maps
+			});
+			file.set(compiled, true);
+			if (output.errors.length > 0) throw new Error(output.errors.join("\n"));
+			if (output.scopedStyles.length > 0 && options.scopedStyles === "error") throw new Error("Scoped JSX CSS requires a bundler consumer; set scopedStyles: \"metadata\" and consume file.metadata.vize.jsx.scopedStyles");
+			const generated = api.parseSync(output.code, {
+				filename: file.opts.filename,
+				babelrc: false,
+				configFile: false,
+				plugins: [],
+				presets: [],
+				sourceType: "module",
+				parserOpts: {
+					...file.opts.parserOpts,
+					sourceType: "module"
+				}
+			});
+			if (!generated || hasJsx(generated, api.types.VISITOR_KEYS)) throw new Error("The native JSX compiler did not return a complete JSX-free module");
+			const inputMap = maps ? composeInputMap(output.map, printed.map) : null;
+			file.path.replaceWith(generated.program);
+			for (const key of [
+				"comments",
+				"tokens",
+				"errors",
+				"start",
+				"end",
+				"loc"
+			]) if (key in generated) file.ast[key] = generated[key];
+			else delete file.ast[key];
+			file.scope = file.path.scope;
+			file.scope.crawl();
+			restoreReservations(file, reservations);
+			file.code = output.code;
+			file.inputMap = inputMap;
+			const old = file.metadata.vize;
+			const metadata = {
+				defaultMode: options.jsxMode,
+				ssr: options.ssr,
+				nativePasses: 1,
+				warnings: output.warnings,
+				scopedStyles: output.scopedStyles
+			};
+			file.metadata.vize = {
+				...typeof old === "object" && old !== null ? old : {},
+				jsx: metadata
+			};
+			for (const warning of output.warnings) process.emitWarning(`[vize] ${warning}`, { type: "VizeJsxWarning" });
+		},
+		post(file) {
+			assertComplete(file.ast);
+		},
+		generatorOverride(ast) {
+			assertComplete(ast);
+		}
+	};
+}
+//#endregion
+module.exports = vizeBabelPlugin;

package/dist/index.d.cts

@@ -0,0 +1,41 @@
+import { JsxCompileResultNapi, StyleBlockNapi } from "@vizejs/native";
+
+//#region src/types.d.ts
+/** JSX output defaults; component directive prologues can select another mode. */
+interface VizeBabelOptions {
+  jsxMode?: "vdom" | "vapor";
+  jsxCompat?: "native" | "babel";
+  ssr?: boolean;
+  /** Explicitly hand extracted CSS to a bundler through Babel file metadata. */
+  scopedStyles?: "error" | "metadata";
+  /** How standalone Babel transforms handle Vue SFC style blocks. */
+  sfcStyles?: "inject" | "metadata" | "error";
+  /** Root used to make SFC scope IDs stable across machines. */
+  root?: string;
+  /** Enables production SFC output and content-sensitive production scope IDs. */
+  isProduction?: boolean;
+}
+interface VizeBabelMetadata {
+  defaultMode: "vdom" | "vapor";
+  ssr: boolean;
+  nativePasses: 1;
+  warnings: string[];
+  scopedStyles: JsxCompileResultNapi["scopedStyles"];
+}
+interface VizeBabelSfcMetadata {
+  defaultMode: "vdom" | "vapor";
+  ssr: boolean;
+  nativePasses: 1;
+  warnings: string[];
+  css: string | null;
+  styles: StyleBlockNapi[];
+  dependencies: string[];
+}
+//#endregion
+//#region src/index.d.ts
+/** Babel owns the returned hooks; consumers configure the strongly typed options. */
+declare function vizeBabelPlugin(apiValue: unknown, rawOptions?: VizeBabelOptions): {
+  name: string;
+};
+//#endregion
+export { type VizeBabelMetadata, type VizeBabelOptions, type VizeBabelSfcMetadata, vizeBabelPlugin as default };

package/dist/index.d.mts

@@ -0,0 +1,41 @@
+import { JsxCompileResultNapi, StyleBlockNapi } from "@vizejs/native";
+
+//#region src/types.d.ts
+/** JSX output defaults; component directive prologues can select another mode. */
+interface VizeBabelOptions {
+  jsxMode?: "vdom" | "vapor";
+  jsxCompat?: "native" | "babel";
+  ssr?: boolean;
+  /** Explicitly hand extracted CSS to a bundler through Babel file metadata. */
+  scopedStyles?: "error" | "metadata";
+  /** How standalone Babel transforms handle Vue SFC style blocks. */
+  sfcStyles?: "inject" | "metadata" | "error";
+  /** Root used to make SFC scope IDs stable across machines. */
+  root?: string;
+  /** Enables production SFC output and content-sensitive production scope IDs. */
+  isProduction?: boolean;
+}
+interface VizeBabelMetadata {
+  defaultMode: "vdom" | "vapor";
+  ssr: boolean;
+  nativePasses: 1;
+  warnings: string[];
+  scopedStyles: JsxCompileResultNapi["scopedStyles"];
+}
+interface VizeBabelSfcMetadata {
+  defaultMode: "vdom" | "vapor";
+  ssr: boolean;
+  nativePasses: 1;
+  warnings: string[];
+  css: string | null;
+  styles: StyleBlockNapi[];
+  dependencies: string[];
+}
+//#endregion
+//#region src/index.d.ts
+/** Babel owns the returned hooks; consumers configure the strongly typed options. */
+declare function vizeBabelPlugin(apiValue: unknown, rawOptions?: VizeBabelOptions): {
+  name: string;
+};
+//#endregion
+export { type VizeBabelMetadata, type VizeBabelOptions, type VizeBabelSfcMetadata, vizeBabelPlugin as default };

package/dist/index.mjs

@@ -0,0 +1,381 @@
+import { createRequire } from "node:module";
+import convertSourceMap from "convert-source-map";
+import remapping from "@jridgewell/remapping";
+//#region src/ast.ts
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function hasJsx(ast, keys) {
+	const pending = [ast];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
+		for (const key of keys[node.type] ?? []) {
+			const child = node[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isNode(item)) pending.push(item);
+			} else if (isNode(child)) pending.push(child);
+		}
+	}
+	return false;
+}
+function enableSyntax(filename, parser) {
+	const plugins = parser.plugins ??= [];
+	const has = (name) => plugins.some((p) => (Array.isArray(p) ? p[0] : p) === name);
+	if (/\.tsx$/iu.test(filename) && !has("typescript")) plugins.push("typescript");
+	if (!/\.(?:ts|mts|cts)$/iu.test(filename) && !has("jsx")) plugins.push("jsx");
+}
+/** Explicit foreign runtime selection is a configuration error, never Vue output. */
+function rejectForeignRuntime(ast, plugins, scope) {
+	if (Array.isArray(plugins)) for (const plugin of plugins) {
+		if (typeof plugin !== "object" || plugin === null || !("key" in plugin)) continue;
+		if (typeof plugin.key === "string" && /^(?:@babel\/plugin-)?transform-react-jsx(?:-development|\/development)?$/u.test(plugin.key)) rejectReact();
+	}
+	const body = ast.program.body;
+	if (Array.isArray(body)) for (const node of body) {
+		if (isNode(node) && node.type === "TSImportEqualsDeclaration" && node.importKind !== "type") {
+			const owner = node.moduleReference;
+			if (isNode(owner) && isNode(owner.expression) && foreignName(owner.expression.value)) rejectReact();
+		}
+		if (isNode(node) && node.type === "VariableDeclaration" && !scope.getBinding("require")) {
+			const declarations = node.declarations;
+			if (Array.isArray(declarations)) for (const declaration of declarations) {
+				if (!isNode(declaration) || !isNode(declaration.init)) continue;
+				const call = declaration.init;
+				if (call.type === "CallExpression" && isNode(call.callee) && call.callee.type === "Identifier" && call.callee.name === "require" && Array.isArray(call.arguments) && call.arguments.length === 1 && isNode(call.arguments[0]) && foreignName(call.arguments[0].value)) rejectReact();
+			}
+		}
+		if (!isNode(node) || node.type !== "ImportDeclaration" || node.importKind === "type") continue;
+		const specifiers = node.specifiers;
+		if (Array.isArray(specifiers) && specifiers.length > 0 && specifiers.every((specifier) => isNode(specifier) && specifier.importKind === "type")) continue;
+		const source = node.source;
+		if (isNode(source) && typeof source.value === "string" && foreignName(source.value)) rejectReact();
+	}
+	const comments = ast.comments;
+	if (Array.isArray(comments)) for (const comment of comments) {
+		if (!isNode(comment) || typeof comment.value !== "string") continue;
+		const source = /@jsxImportSource\s+(\S+)/u.exec(comment.value)?.[1];
+		if (source && source !== "vue") throw new Error(`Vize cannot compile the explicitly selected JSX import source: ${source}`);
+		if (/@jsx\s+(\S+)/u.exec(comment.value)?.[1]) throw new Error("Custom JSX factory pragmas are not supported by the native Babel adapter");
+	}
+}
+function foreignName(value) {
+	return typeof value === "string" && /^react(?:\/|$)/u.test(value);
+}
+function rejectReact() {
+	throw new Error("Vize compiles Vue JSX; scope this plugin to Vue files using Babel overrides");
+}
+//#endregion
+//#region src/native.ts
+let compiler;
+/** Keep addon initialization outside the common no-JSX/non-SFC path. */
+function getCompiler() {
+	if (compiler) return compiler;
+	const binding = createRequire(typeof __filename === "string" ? __filename : import.meta.url)("@vizejs/native");
+	if (typeof binding !== "object" || binding === null || !("compileJsx" in binding) || typeof binding.compileJsx !== "function" || !("compileSfc" in binding) || typeof binding.compileSfc !== "function" || !("generateSfcScopeId" in binding) || typeof binding.generateSfcScopeId !== "function") throw new Error("The installed Vize native binding does not expose the Babel compiler surface; use matching Vize package versions");
+	compiler = binding;
+	return compiler;
+}
+//#endregion
+//#region src/options.ts
+function normalizeOptions(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("Vize Babel options must be an object");
+	for (const key of Object.keys(value)) if (![
+		"jsxMode",
+		"jsxCompat",
+		"ssr",
+		"scopedStyles",
+		"sfcStyles",
+		"root",
+		"isProduction"
+	].includes(key)) throw new TypeError(`Unknown Vize Babel option: ${key}`);
+	const { jsxMode = "vdom", jsxCompat = "native", ssr = false, scopedStyles = "error", sfcStyles = "inject", root = process.cwd(), isProduction = process.env.NODE_ENV === "production" } = value;
+	if (jsxMode !== "vdom" && jsxMode !== "vapor") throw new TypeError("jsxMode must be \"vdom\" or \"vapor\"");
+	if (jsxCompat !== "native" && jsxCompat !== "babel") throw new TypeError("jsxCompat must be \"native\" or \"babel\"");
+	if (typeof ssr !== "boolean") throw new TypeError("ssr must be a boolean");
+	if (scopedStyles !== "error" && scopedStyles !== "metadata") throw new TypeError("scopedStyles must be \"error\" or \"metadata\"");
+	if (sfcStyles !== "inject" && sfcStyles !== "metadata" && sfcStyles !== "error") throw new TypeError("sfcStyles must be \"inject\", \"metadata\", or \"error\"");
+	if (typeof root !== "string" || root.length === 0) throw new TypeError("root must be a non-empty string");
+	if (typeof isProduction !== "boolean") throw new TypeError("isProduction must be a boolean");
+	return {
+		jsxMode,
+		jsxCompat,
+		ssr,
+		scopedStyles,
+		sfcStyles,
+		root,
+		isProduction
+	};
+}
+//#endregion
+//#region src/scopes.ts
+/** Earlier pre hooks can reserve identifiers before adding their declarations. */
+function captureReservations(file) {
+	const names = file.scope.uidsSet ? [...file.scope.uidsSet] : Object.keys(file.scope.uids).filter((name) => file.scope.uids[name]);
+	if (names.length === 0) return void 0;
+	const authoredBindings = new Set(Object.keys(file.scope.bindings));
+	const seen = new Set([file.scope]);
+	file.path.traverse({ Scopable({ scope }) {
+		if (seen.has(scope)) return;
+		seen.add(scope);
+		for (const name of Object.keys(scope.bindings)) authoredBindings.add(name);
+	} });
+	return {
+		names,
+		authoredBindings
+	};
+}
+function restoreReservations(file, reserved) {
+	if (!reserved) return;
+	const names = new Set(reserved.names);
+	for (const name of names) if (file.scope.uidsSet) file.scope.uidsSet.add(name);
+	else file.scope.uids[name] = true;
+	const seen = /* @__PURE__ */ new Set();
+	const restore = (scope) => {
+		if (seen.has(scope)) return;
+		seen.add(scope);
+		for (const name of Object.keys(scope.bindings)) if (names.has(name) && !reserved.authoredBindings.has(name)) scope.rename(name, scope.generateUid(name));
+	};
+	restore(file.scope);
+	file.path.traverse({ Scopable: ({ scope }) => restore(scope) });
+}
+//#endregion
+//#region src/source-map.ts
+function composeInputMap(nativeMap, printedMap) {
+	if (!nativeMap || !printedMap) throw new Error("The native JSX compiler did not provide the requested original-source map");
+	const parsed = JSON.parse(nativeMap);
+	if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || parsed.version !== 3 || !("mappings" in parsed) || typeof parsed.mappings !== "string" || !("sources" in parsed) || !Array.isArray(parsed.sources)) throw new Error("The native JSX compiler returned an invalid source map");
+	const composed = remapping([parsed, printedMap], () => null);
+	return convertSourceMap.fromObject(composed);
+}
+//#endregion
+//#region src/sfc.ts
+function isVueSfc(filename) {
+	return /\.vue$/iu.test(filename);
+}
+function compileSfcForBabel(source, filename, parserOptions, parse, options) {
+	const native = getCompiler();
+	const scopeId = native.generateSfcScopeId(filename, options.root, options.isProduction, source);
+	const result = native.compileSfc(source, {
+		filename,
+		mode: "module",
+		sourceMap: true,
+		ssr: options.ssr,
+		vapor: options.jsxMode === "vapor",
+		scopeId: `data-v-${scopeId}`,
+		isProd: options.isProduction,
+		inlineTemplate: options.isProduction && !options.ssr
+	});
+	assertSupported(result, filename, options.sfcStyles);
+	const completed = completeModule(result, scopeId, options.sfcStyles);
+	return {
+		ast: parse(completed.code, {
+			...parserOptions,
+			filename,
+			sourceType: "module"
+		}),
+		code: completed.code,
+		map: completed.map,
+		metadata: {
+			defaultMode: options.jsxMode,
+			ssr: options.ssr,
+			nativePasses: 1,
+			warnings: result.warnings,
+			css: result.css ?? null,
+			styles: result.styles,
+			dependencies: result.dependencies ?? []
+		}
+	};
+}
+function installSfcFileState(file, compiled) {
+	file.code = compiled.code;
+	if (file.opts.sourceMaps) {
+		if (!compiled.map) throw new Error("The native SFC compiler did not provide the requested original-source map");
+		const parsed = JSON.parse(compiled.map);
+		if (!isSourceMap(parsed)) throw new Error("The native SFC compiler returned an invalid source map");
+		const upstream = file.inputMap?.toObject();
+		file.inputMap = upstream ? composeInputMap(compiled.map, upstream) : convertSourceMap.fromObject(parsed);
+	}
+	const old = file.metadata.vize;
+	file.metadata.vize = {
+		...typeof old === "object" && old !== null ? old : {},
+		sfc: compiled.metadata
+	};
+	for (const warning of compiled.metadata.warnings) process.emitWarning(`[vize] ${warning}`, { type: "VizeSfcWarning" });
+}
+function assertSupported(result, filename, styleMode) {
+	if (result.errors.length > 0) throw new Error(result.errors.join("\n"));
+	if (result.customBlocks.length > 0 || result.macroArtifacts.length > 0) throw new Error(`${filename}: custom blocks and emitted macro artifacts need a bundler adapter and are not supported by standalone Babel`);
+	for (const style of result.styles) {
+		if (style.src) throw new Error(`${filename}: <style src> needs a bundler CSS pipeline and is not supported by standalone Babel`);
+		if (style.lang && style.lang !== "css") throw new Error(`${filename}: <style lang="${style.lang}"> needs a bundler CSS pipeline and is not supported by standalone Babel`);
+		if (style.content.includes("@import")) throw new Error(`${filename}: CSS @import needs a bundler CSS pipeline and is not supported by standalone Babel`);
+	}
+	if (result.css && styleMode === "error") throw new Error(`${filename}: SFC styles require sfcStyles: "inject" or "metadata" in standalone Babel`);
+}
+function completeModule(result, scopeId, styleMode) {
+	let code = result.code;
+	if (result.hasScoped) code = attachScope(code, scopeId);
+	const prefix = result.css && styleMode === "inject" ? styleInjection(result.css, scopeId) : "";
+	return {
+		code: prefix + code,
+		map: shiftMap(result.map, prefix)
+	};
+}
+function attachScope(code, scopeId) {
+	if (/^export default _sfc_main/mu.test(code)) return code.replace(/^export default _sfc_main/mu, `_sfc_main.__scopeId = "data-v-${scopeId}";\nexport default _sfc_main`);
+	if (/^export default /mu.test(code)) return `${code.replace(/^export default /mu, "const _sfc_main = ")}\n_sfc_main.__scopeId = "data-v-${scopeId}";\nexport default _sfc_main;\n`;
+	if (/^export function render\b/mu.test(code)) return `${code}\nconst _sfc_main = { render };\n_sfc_main.__scopeId = "data-v-${scopeId}";\nexport default _sfc_main;\n`;
+	return code;
+}
+function styleInjection(css, scopeId) {
+	return `export const __vize_css__ = ${JSON.stringify(css)};
+const __vize_css_id__ = ${JSON.stringify(`vize-style-${scopeId}`)};
+(function() {
+  if (typeof document !== "undefined") {
+    let style = document.getElementById(__vize_css_id__);
+    if (!style) {
+      style = document.createElement("style");
+      style.id = __vize_css_id__;
+      document.head.appendChild(style);
+    }
+    style.textContent = __vize_css__;
+  }
+})();
+`;
+}
+function shiftMap(mapJson, prefix) {
+	if (!mapJson) return null;
+	if (!prefix) return mapJson;
+	const parsed = JSON.parse(mapJson);
+	if (!isSourceMap(parsed)) return null;
+	const lines = prefix.split("\n").length - 1;
+	return JSON.stringify({
+		...parsed,
+		mappings: ";".repeat(lines) + parsed.mappings
+	});
+}
+function isSourceMap(value) {
+	return typeof value === "object" && value !== null && "version" in value && value.version === 3 && "sources" in value && Array.isArray(value.sources) && "names" in value && Array.isArray(value.names) && "mappings" in value && typeof value.mappings === "string";
+}
+//#endregion
+//#region src/index.ts
+const compiled = Symbol.for("@vizejs/babel-plugin/compiled");
+/** Babel owns the returned hooks; consumers configure the strongly typed options. */
+function vizeBabelPlugin(apiValue, rawOptions = {}) {
+	const api = apiValue;
+	api.assertVersion("^7.29.7 || ^8.0.9");
+	const options = normalizeOptions(rawOptions);
+	const sfcOutputs = /* @__PURE__ */ new WeakMap();
+	const assertComplete = (ast) => {
+		if (hasJsx(ast, api.types.VISITOR_KEYS)) throw new Error("JSX was introduced after the native phase; run JSX-producing transforms in an earlier Babel pass");
+	};
+	return {
+		name: "vize-vue-jsx",
+		manipulateOptions(host, parser) {
+			enableSyntax(host.filename ?? "", parser);
+		},
+		parserOverride(source, parserOptions, parse) {
+			const filename = String(parserOptions.filename ?? parserOptions.sourceFilename ?? parserOptions.sourceFileName ?? "");
+			if (!filename || !isVueSfc(filename)) return void 0;
+			const compiledSfc = compileSfcForBabel(source, filename, parserOptions, parse, options);
+			sfcOutputs.set(compiledSfc.ast, compiledSfc);
+			return compiledSfc.ast;
+		},
+		pre(file) {
+			const compiledSfc = sfcOutputs.get(file.ast);
+			if (compiledSfc) {
+				file.set(compiled, true);
+				installSfcFileState(file, compiledSfc);
+				return;
+			}
+			if (!hasJsx(file.ast, api.types.VISITOR_KEYS)) return;
+			if (file.get(compiled)) throw new Error("JSX was introduced after this file's native compilation pass");
+			rejectForeignRuntime(file.ast, file.opts.plugins, file.scope);
+			const reservations = captureReservations(file);
+			const maps = Boolean(file.opts.sourceMaps);
+			const hostGenerator = file.opts.generatorOpts;
+			const printed = api.transformFromAstSync(file.ast, file.code, {
+				filename: file.opts.filename,
+				sourceFileName: file.opts.sourceFileName,
+				sourceRoot: file.opts.sourceRoot,
+				babelrc: false,
+				configFile: false,
+				plugins: [],
+				presets: [],
+				ast: false,
+				sourceMaps: maps,
+				inputSourceMap: maps ? file.inputMap?.toObject() ?? false : false,
+				comments: file.opts.comments,
+				generatorOpts: {
+					...typeof hostGenerator === "object" && hostGenerator !== null ? hostGenerator : {},
+					sourceMaps: maps
+				}
+			});
+			if (!printed || typeof printed.code !== "string") throw new Error("Babel could not serialize the current JSX AST");
+			const parserPlugins = file.opts.parserOpts?.plugins ?? [];
+			const typescript = /\.(?:tsx|ts|mts|cts)$/iu.test(file.opts.filename ?? "") || parserPlugins.some((p) => (Array.isArray(p) ? p[0] : p) === "typescript");
+			const output = getCompiler().compileJsx(printed.code, {
+				filename: file.opts.filename,
+				lang: typescript ? "tsx" : "jsx",
+				jsxMode: options.jsxMode,
+				jsxCompat: options.jsxCompat,
+				ssr: options.ssr,
+				sourceMap: maps
+			});
+			file.set(compiled, true);
+			if (output.errors.length > 0) throw new Error(output.errors.join("\n"));
+			if (output.scopedStyles.length > 0 && options.scopedStyles === "error") throw new Error("Scoped JSX CSS requires a bundler consumer; set scopedStyles: \"metadata\" and consume file.metadata.vize.jsx.scopedStyles");
+			const generated = api.parseSync(output.code, {
+				filename: file.opts.filename,
+				babelrc: false,
+				configFile: false,
+				plugins: [],
+				presets: [],
+				sourceType: "module",
+				parserOpts: {
+					...file.opts.parserOpts,
+					sourceType: "module"
+				}
+			});
+			if (!generated || hasJsx(generated, api.types.VISITOR_KEYS)) throw new Error("The native JSX compiler did not return a complete JSX-free module");
+			const inputMap = maps ? composeInputMap(output.map, printed.map) : null;
+			file.path.replaceWith(generated.program);
+			for (const key of [
+				"comments",
+				"tokens",
+				"errors",
+				"start",
+				"end",
+				"loc"
+			]) if (key in generated) file.ast[key] = generated[key];
+			else delete file.ast[key];
+			file.scope = file.path.scope;
+			file.scope.crawl();
+			restoreReservations(file, reservations);
+			file.code = output.code;
+			file.inputMap = inputMap;
+			const old = file.metadata.vize;
+			const metadata = {
+				defaultMode: options.jsxMode,
+				ssr: options.ssr,
+				nativePasses: 1,
+				warnings: output.warnings,
+				scopedStyles: output.scopedStyles
+			};
+			file.metadata.vize = {
+				...typeof old === "object" && old !== null ? old : {},
+				jsx: metadata
+			};
+			for (const warning of output.warnings) process.emitWarning(`[vize] ${warning}`, { type: "VizeJsxWarning" });
+		},
+		post(file) {
+			assertComplete(file.ast);
+		},
+		generatorOverride(ast) {
+			assertComplete(ast);
+		}
+	};
+}
+//#endregion
+export { vizeBabelPlugin as default };

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@vizejs/babel-plugin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.706.0",
+  "description": "Vue JSX and TSX compilation through the shared Vize compiler",
+  "homepage": "https://github.com/ubugeeei-prod/vize",
+  "bugs": {
+    "url": "https://github.com/ubugeeei-prod/vize/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei-prod/vize",
+    "directory": "npm/babel"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@jridgewell/remapping": "2.3.5",
+    "@vizejs/native": "0.706.0",
+    "convert-source-map": "2.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "8.0.9",
+    "@types/convert-source-map": "2.0.3",
+    "@types/node": "25.9.2",
+    "playwright": "1.62.1",
+    "typescript": "6.0.3",
+    "vite-plus": "0.1.24",
+    "vue": "3.6.0-rc.11"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.29.7 || ^8.0.9"
+  },
+  "engines": {
+    "node": "^22.18.0 || >=24.11.0"
+  },
+  "metadata": {
+    "vize": {
+      "stability": "compatibility-preview",
+      "stabilityDocs": "https://github.com/ubugeeei-prod/vize/blob/main/docs/content/stability.md#package-support-tiers"
+    }
+  },
+  "scripts": {
+    "build": "vp pack",
+    "check": "vp check src vite.config.ts && tsc -p test/tsconfig.json",
+    "test": "node --test test/packed-hosts.test.ts test/runtime-renderers.test.ts test/style-guards.test.ts"
+  }
 }